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