overlayMdp.cpp revision 4e6cb925345e033b317e21138c616d0499647a37 
1/*
2* Copyright (C) 2008 The Android Open Source Project
3* Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
4*
5* Licensed under the Apache License, Version 2.0 (the "License");
6* you may not use this file except in compliance with the License.
7* You may obtain a copy of the License at
8*
9*      http://www.apache.org/licenses/LICENSE-2.0
10*
11* Unless required by applicable law or agreed to in writing, software
12* distributed under the License is distributed on an "AS IS" BASIS,
13* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14* See the License for the specific language governing permissions and
15* limitations under the License.
16*/
17
18#include <math.h>
19#include <mdp_version.h>
20#include "overlayUtils.h"
21#include "overlayMdp.h"
22#include "mdp_version.h"
23
24#define HSIC_SETTINGS_DEBUG 0
25
26using namespace qdutils;
27
28static inline bool isEqual(float f1, float f2) {
29        return ((int)(f1*100) == (int)(f2*100)) ? true : false;
30}
31
32namespace ovutils = overlay::utils;
33namespace overlay {
34
35bool MdpCtrl::init(uint32_t fbnum) {
36    // FD init
37    if(!utils::openDev(mFd, fbnum,
38                Res::fbPath, O_RDWR)){
39        ALOGE("Ctrl failed to init fbnum=%d", fbnum);
40        return false;
41    }
42    return true;
43}
44
45void MdpCtrl::reset() {
46    utils::memset0(mOVInfo);
47    utils::memset0(mLkgo);
48    mOVInfo.id = MSMFB_NEW_REQUEST;
49    mLkgo.id = MSMFB_NEW_REQUEST;
50    mOrientation = utils::OVERLAY_TRANSFORM_0;
51    mDownscale = 0;
52    mForceSet = false;
53#ifdef USES_POST_PROCESSING
54    mPPChanged = false;
55    memset(&mParams, 0, sizeof(struct compute_params));
56    mParams.params.conv_params.order = hsic_order_hsc_i;
57    mParams.params.conv_params.interface = interface_rec601;
58    mParams.params.conv_params.cc_matrix[0][0] = 1;
59    mParams.params.conv_params.cc_matrix[1][1] = 1;
60    mParams.params.conv_params.cc_matrix[2][2] = 1;
61#endif
62}
63
64bool MdpCtrl::close() {
65    bool result = true;
66    if(MSMFB_NEW_REQUEST != static_cast<int>(mOVInfo.id)) {
67        if(!mdp_wrapper::unsetOverlay(mFd.getFD(), mOVInfo.id)) {
68            ALOGE("MdpCtrl close error in unset");
69            result = false;
70        }
71    }
72#ifdef USES_POST_PROCESSING
73    /* free allocated memory in PP */
74    if (mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data)
75            free(mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data);
76#endif
77    reset();
78
79    if(!mFd.close()) {
80        result = false;
81    }
82
83    return result;
84}
85
86void MdpCtrl::setSource(const utils::PipeArgs& args) {
87    setSrcWhf(args.whf);
88
89    //TODO These are hardcoded. Can be moved out of setSource.
90    mOVInfo.transp_mask = 0xffffffff;
91
92    //TODO These calls should ideally be a part of setPipeParams API
93    setFlags(args.mdpFlags);
94    setZ(args.zorder);
95    setIsFg(args.isFg);
96    setPlaneAlpha(args.planeAlpha);
97    setBlending(args.blending);
98}
99
100void MdpCtrl::setCrop(const utils::Dim& d) {
101    setSrcRectDim(d);
102}
103
104void MdpCtrl::setPosition(const overlay::utils::Dim& d) {
105    setDstRectDim(d);
106}
107
108void MdpCtrl::setTransform(const utils::eTransform& orient) {
109    int rot = utils::getMdpOrient(orient);
110    setUserData(rot);
111    mOrientation = static_cast<utils::eTransform>(rot);
112}
113
114void MdpCtrl::doTransform() {
115    setRotationFlags();
116    utils::Whf whf = getSrcWhf();
117    utils::Dim dim = getSrcRectDim();
118    utils::preRotateSource(mOrientation, whf, dim);
119    setSrcWhf(whf);
120    setSrcRectDim(dim);
121}
122
123void MdpCtrl::doDownscale() {
124    int mdpVersion = MDPVersion::getInstance().getMDPVersion();
125    if(mdpVersion < MDSS_V5) {
126        mOVInfo.src_rect.x >>= mDownscale;
127        mOVInfo.src_rect.y >>= mDownscale;
128        mOVInfo.src_rect.w >>= mDownscale;
129        mOVInfo.src_rect.h >>= mDownscale;
130    } else if(MDPVersion::getInstance().supportsDecimation()) {
131        //Decimation + MDP Downscale
132        mOVInfo.horz_deci = 0;
133        mOVInfo.vert_deci = 0;
134        int minHorDeci = 0;
135        if(mOVInfo.src_rect.w > 2048) {
136            //If the client sends us something > what a layer mixer supports
137            //then it means it doesn't want to use split-pipe but wants us to
138            //decimate. A minimum decimation of 2 will ensure that the width is
139            //always within layer mixer limits.
140            minHorDeci = 2;
141        }
142
143        float horDscale = 0.0f;
144        float verDscale = 0.0f;
145
146        utils::getDecimationFactor(mOVInfo.src_rect.w, mOVInfo.src_rect.h,
147                mOVInfo.dst_rect.w, mOVInfo.dst_rect.h, horDscale, verDscale);
148
149        if(horDscale < minHorDeci)
150            horDscale = minHorDeci;
151
152        if((int)horDscale)
153            mOVInfo.horz_deci = (int)log2f(horDscale);
154
155        if((int)verDscale)
156            mOVInfo.vert_deci = (int)log2f(verDscale);
157    }
158}
159
160bool MdpCtrl::set() {
161    int mdpVersion = MDPVersion::getInstance().getMDPVersion();
162    //deferred calcs, so APIs could be called in any order.
163    doTransform();
164    utils::Whf whf = getSrcWhf();
165    if(utils::isYuv(whf.format)) {
166        utils::normalizeCrop(mOVInfo.src_rect.x, mOVInfo.src_rect.w);
167        utils::normalizeCrop(mOVInfo.src_rect.y, mOVInfo.src_rect.h);
168        if(mdpVersion < MDSS_V5) {
169            utils::even_floor(mOVInfo.dst_rect.w);
170            utils::even_floor(mOVInfo.dst_rect.h);
171        } else if (mOVInfo.flags & MDP_DEINTERLACE) {
172            // For interlaced, crop.h should be 4-aligned
173            if (!(mOVInfo.flags & MDP_SOURCE_ROTATED_90) &&
174                (mOVInfo.src_rect.h % 4))
175                mOVInfo.src_rect.h = utils::aligndown(mOVInfo.src_rect.h, 4);
176        }
177    } else {
178        if (mdpVersion >= MDSS_V5) {
179            // Check for 1-pixel down-scaling
180            if (mOVInfo.src_rect.w - mOVInfo.dst_rect.w == 1)
181                mOVInfo.src_rect.w -= 1;
182            if (mOVInfo.src_rect.h - mOVInfo.dst_rect.h == 1)
183                mOVInfo.src_rect.h -= 1;
184        }
185    }
186
187    doDownscale();
188
189    if(this->ovChanged() || mForceSet) {
190        mForceSet = false;
191        if(!mdp_wrapper::setOverlay(mFd.getFD(), mOVInfo)) {
192            ALOGE("MdpCtrl failed to setOverlay, restoring last known "
193                  "good ov info");
194            mdp_wrapper::dump("== Bad OVInfo is: ", mOVInfo);
195            mdp_wrapper::dump("== Last good known OVInfo is: ", mLkgo);
196            this->restore();
197            return false;
198        }
199        this->save();
200    }
201
202    return true;
203}
204
205bool MdpCtrl::get() {
206    mdp_overlay ov;
207    ov.id = mOVInfo.id;
208    if (!mdp_wrapper::getOverlay(mFd.getFD(), ov)) {
209        ALOGE("MdpCtrl get failed");
210        return false;
211    }
212    mOVInfo = ov;
213    return true;
214}
215
216//Update src format based on rotator's destination format.
217void MdpCtrl::updateSrcFormat(const uint32_t& rotDestFmt) {
218    utils::Whf whf = getSrcWhf();
219    whf.format =  rotDestFmt;
220    setSrcWhf(whf);
221}
222
223void MdpCtrl::dump() const {
224    ALOGE("== Dump MdpCtrl start ==");
225    mFd.dump();
226    mdp_wrapper::dump("mOVInfo", mOVInfo);
227    ALOGE("== Dump MdpCtrl end ==");
228}
229
230void MdpCtrl::getDump(char *buf, size_t len) {
231    ovutils::getDump(buf, len, "Ctrl", mOVInfo);
232}
233
234void MdpData::dump() const {
235    ALOGE("== Dump MdpData start ==");
236    mFd.dump();
237    mdp_wrapper::dump("mOvData", mOvData);
238    ALOGE("== Dump MdpData end ==");
239}
240
241void MdpData::getDump(char *buf, size_t len) {
242    ovutils::getDump(buf, len, "Data", mOvData);
243}
244
245void MdpCtrl3D::dump() const {
246    ALOGE("== Dump MdpCtrl start ==");
247    mFd.dump();
248    ALOGE("== Dump MdpCtrl end ==");
249}
250
251bool MdpCtrl::setVisualParams(const MetaData_t& data) {
252    bool needUpdate = false;
253#ifdef USES_POST_PROCESSING
254    /* calculate the data */
255    if (data.operation & PP_PARAM_HSIC) {
256        if (mParams.params.pa_params.hue != data.hsicData.hue) {
257            ALOGD_IF(HSIC_SETTINGS_DEBUG,
258                "Hue has changed from %d to %d",
259                mParams.params.pa_params.hue,data.hsicData.hue);
260            needUpdate = true;
261        }
262
263        if (!isEqual(mParams.params.pa_params.sat,
264            data.hsicData.saturation)) {
265            ALOGD_IF(HSIC_SETTINGS_DEBUG,
266                "Saturation has changed from %f to %f",
267                mParams.params.pa_params.sat,
268                data.hsicData.saturation);
269            needUpdate = true;
270        }
271
272        if (mParams.params.pa_params.intensity != data.hsicData.intensity) {
273            ALOGD_IF(HSIC_SETTINGS_DEBUG,
274                "Intensity has changed from %d to %d",
275                mParams.params.pa_params.intensity,
276                data.hsicData.intensity);
277            needUpdate = true;
278        }
279
280        if (!isEqual(mParams.params.pa_params.contrast,
281            data.hsicData.contrast)) {
282            ALOGD_IF(HSIC_SETTINGS_DEBUG,
283                "Contrast has changed from %f to %f",
284                mParams.params.pa_params.contrast,
285                data.hsicData.contrast);
286            needUpdate = true;
287        }
288
289        if (needUpdate) {
290            mParams.params.pa_params.hue = data.hsicData.hue;
291            mParams.params.pa_params.sat = data.hsicData.saturation;
292            mParams.params.pa_params.intensity = data.hsicData.intensity;
293            mParams.params.pa_params.contrast = data.hsicData.contrast;
294            mParams.params.pa_params.ops = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
295            mParams.operation |= PP_OP_PA;
296        }
297    }
298
299    if (data.operation & PP_PARAM_SHARP2) {
300        if (mParams.params.sharp_params.strength != data.Sharp2Data.strength) {
301            needUpdate = true;
302        }
303        if (mParams.params.sharp_params.edge_thr != data.Sharp2Data.edge_thr) {
304            needUpdate = true;
305        }
306        if (mParams.params.sharp_params.smooth_thr !=
307                data.Sharp2Data.smooth_thr) {
308            needUpdate = true;
309        }
310        if (mParams.params.sharp_params.noise_thr !=
311                data.Sharp2Data.noise_thr) {
312            needUpdate = true;
313        }
314
315        if (needUpdate) {
316            mParams.params.sharp_params.strength = data.Sharp2Data.strength;
317            mParams.params.sharp_params.edge_thr = data.Sharp2Data.edge_thr;
318            mParams.params.sharp_params.smooth_thr =
319                data.Sharp2Data.smooth_thr;
320            mParams.params.sharp_params.noise_thr = data.Sharp2Data.noise_thr;
321            mParams.params.sharp_params.ops =
322                MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
323            mParams.operation |= PP_OP_SHARP;
324        }
325    }
326
327    if (data.operation & PP_PARAM_IGC) {
328        if (mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data == NULL){
329            uint32_t *igcData
330                = (uint32_t *)malloc(2 * MAX_IGC_LUT_ENTRIES * sizeof(uint32_t));
331            if (!igcData) {
332                ALOGE("IGC storage allocated failed");
333                return false;
334            }
335            mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data = igcData;
336            mOVInfo.overlay_pp_cfg.igc_cfg.c2_data
337                = igcData + MAX_IGC_LUT_ENTRIES;
338        }
339
340        memcpy(mParams.params.igc_lut_params.c0,
341            data.igcData.c0, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
342        memcpy(mParams.params.igc_lut_params.c1,
343            data.igcData.c1, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
344        memcpy(mParams.params.igc_lut_params.c2,
345            data.igcData.c2, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
346
347        mParams.params.igc_lut_params.ops
348            = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
349        mParams.operation |= PP_OP_IGC;
350        needUpdate = true;
351    }
352
353    if (data.operation & PP_PARAM_VID_INTFC) {
354        mParams.params.conv_params.interface =
355            (interface_type) data.video_interface;
356        needUpdate = true;
357    }
358
359    if (needUpdate) {
360        display_pp_compute_params(&mParams, &mOVInfo.overlay_pp_cfg);
361        mPPChanged = true;
362    }
363#endif
364    return true;
365}
366
367} // overlay
368