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