overlayUtils.cpp revision 4a84a77c6de89fc12b727bf41661aa2314dfba8f 
1/*
2* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
3*
4* Redistribution and use in source and binary forms, with or without
5* modification, are permitted provided that the following conditions are
6* met:
7*    * Redistributions of source code must retain the above copyright
8*      notice, this list of conditions and the following disclaimer.
9*    * Redistributions in binary form must reproduce the above
10*      copyright notice, this list of conditions and the following
11*      disclaimer in the documentation and/or other materials provided
12*      with the distribution.
13*    * Neither the name of The Linux Foundation nor the names of its
14*      contributors may be used to endorse or promote products derived
15*      from this software without specific prior written permission.
16*
17* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28*/
29
30#include <stdlib.h>
31#include <math.h>
32#include <utils/Log.h>
33#include <linux/msm_mdp.h>
34#include <cutils/properties.h>
35#include "gralloc_priv.h"
36#include "overlayUtils.h"
37#include "mdpWrapper.h"
38#include "mdp_version.h"
39#include <hardware/hwcomposer_defs.h>
40
41// just a helper static thingy
42namespace {
43struct IOFile {
44    IOFile(const char* s, const char* mode) : fp(0) {
45        fp = ::fopen(s, mode);
46        if(!fp) {
47            ALOGE("Failed open %s", s);
48        }
49    }
50    template <class T>
51            size_t read(T& r, size_t elem) {
52                if(fp) {
53                    return ::fread(&r, sizeof(T), elem, fp);
54                }
55                return 0;
56            }
57    size_t write(const char* s, uint32_t val) {
58        if(fp) {
59            return ::fprintf(fp, s, val);
60        }
61        return 0;
62    }
63    bool valid() const { return fp != 0; }
64    ~IOFile() {
65        if(fp) ::fclose(fp);
66        fp=0;
67    }
68    FILE* fp;
69};
70}
71
72namespace overlay {
73
74//----------From class Res ------------------------------
75const char* const Res::fbPath = "/dev/graphics/fb%u";
76const char* const Res::rotPath = "/dev/msm_rotator";
77//--------------------------------------------------------
78
79
80
81namespace utils {
82
83//--------------------------------------------------------
84//Refer to graphics.h, gralloc_priv.h, msm_mdp.h
85int getMdpFormat(int format) {
86    switch (format) {
87        //From graphics.h
88        case HAL_PIXEL_FORMAT_RGBA_8888 :
89            return MDP_RGBA_8888;
90        case HAL_PIXEL_FORMAT_RGBX_8888:
91            return MDP_RGBX_8888;
92        case HAL_PIXEL_FORMAT_RGB_888:
93            return MDP_RGB_888;
94        case HAL_PIXEL_FORMAT_RGB_565:
95            return MDP_RGB_565;
96        case HAL_PIXEL_FORMAT_BGRA_8888:
97            return MDP_BGRA_8888;
98        case HAL_PIXEL_FORMAT_BGRX_8888:
99            return MDP_BGRX_8888;
100        case HAL_PIXEL_FORMAT_YV12:
101            return MDP_Y_CR_CB_GH2V2;
102        case HAL_PIXEL_FORMAT_YCbCr_422_SP:
103            return MDP_Y_CBCR_H2V1;
104        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
105            return MDP_Y_CRCB_H2V2;
106
107        //From gralloc_priv.h
108        case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
109            return MDP_Y_CBCR_H2V2_TILE;
110        case HAL_PIXEL_FORMAT_YCbCr_420_SP:
111            return MDP_Y_CBCR_H2V2;
112        case HAL_PIXEL_FORMAT_YCrCb_422_SP:
113            return MDP_Y_CRCB_H2V1;
114        case HAL_PIXEL_FORMAT_YCbCr_422_I:
115            return MDP_YCBYCR_H2V1;
116        case HAL_PIXEL_FORMAT_YCrCb_422_I:
117            return MDP_YCRYCB_H2V1;
118        case HAL_PIXEL_FORMAT_YCbCr_444_SP:
119            return MDP_Y_CBCR_H1V1;
120        case HAL_PIXEL_FORMAT_YCrCb_444_SP:
121            return MDP_Y_CRCB_H1V1;
122        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
123        case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
124            //NV12 encodeable format maps to the venus format on
125            //B-Family targets
126            return MDP_Y_CBCR_H2V2_VENUS;
127        default:
128            //Unsupported by MDP
129            //---graphics.h--------
130            //HAL_PIXEL_FORMAT_RGBA_5551
131            //HAL_PIXEL_FORMAT_RGBA_4444
132            //---gralloc_priv.h-----
133            //HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO    = 0x7FA30C01
134            //HAL_PIXEL_FORMAT_R_8                    = 0x10D
135            //HAL_PIXEL_FORMAT_RG_88                  = 0x10E
136            ALOGE("%s: Unsupported HAL format = 0x%x", __func__, format);
137            return -1;
138    }
139    // not reached
140    return -1;
141}
142
143// This function returns corresponding tile format
144// MDSS support following RGB tile formats
145//  32 bit formats
146//  16 bit formats
147int getMdpFormat(int format, bool tileEnabled)
148{
149    if(!tileEnabled) {
150        return getMdpFormat(format);
151    }
152    switch (format) {
153        case HAL_PIXEL_FORMAT_RGBA_8888 :
154            return MDP_RGBA_8888_TILE;
155        case HAL_PIXEL_FORMAT_RGBX_8888:
156            return MDP_RGBX_8888_TILE;
157        case HAL_PIXEL_FORMAT_RGB_565:
158            return MDP_RGB_565_TILE;
159        case HAL_PIXEL_FORMAT_BGRA_8888:
160            return MDP_BGRA_8888_TILE;
161        case HAL_PIXEL_FORMAT_BGRX_8888:
162            return MDP_BGRX_8888_TILE;
163        default:
164            return getMdpFormat(format);
165    }
166}
167
168
169
170//Takes mdp format as input and translates to equivalent HAL format
171//Refer to graphics.h, gralloc_priv.h, msm_mdp.h for formats.
172int getHALFormat(int mdpFormat) {
173    switch (mdpFormat) {
174        //From graphics.h
175        case MDP_RGBA_8888:
176            return HAL_PIXEL_FORMAT_RGBA_8888;
177        case MDP_RGBX_8888:
178            return HAL_PIXEL_FORMAT_RGBX_8888;
179        case MDP_RGB_888:
180            return HAL_PIXEL_FORMAT_RGB_888;
181        case MDP_RGB_565:
182            return HAL_PIXEL_FORMAT_RGB_565;
183        case MDP_BGRA_8888:
184            return HAL_PIXEL_FORMAT_BGRA_8888;
185        case MDP_Y_CR_CB_GH2V2:
186            return HAL_PIXEL_FORMAT_YV12;
187        case MDP_Y_CBCR_H2V1:
188            return HAL_PIXEL_FORMAT_YCbCr_422_SP;
189        case MDP_Y_CRCB_H2V2:
190            return HAL_PIXEL_FORMAT_YCrCb_420_SP;
191
192        //From gralloc_priv.h
193        case MDP_Y_CBCR_H2V2_TILE:
194            return HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED;
195        case MDP_Y_CBCR_H2V2:
196            return HAL_PIXEL_FORMAT_YCbCr_420_SP;
197        case MDP_Y_CRCB_H2V1:
198            return HAL_PIXEL_FORMAT_YCrCb_422_SP;
199        case MDP_YCBYCR_H2V1:
200            return HAL_PIXEL_FORMAT_YCbCr_422_I;
201        case MDP_YCRYCB_H2V1:
202            return HAL_PIXEL_FORMAT_YCrCb_422_I;
203         case MDP_Y_CBCR_H1V1:
204            return HAL_PIXEL_FORMAT_YCbCr_444_SP;
205        case MDP_Y_CRCB_H1V1:
206            return HAL_PIXEL_FORMAT_YCrCb_444_SP;
207        case MDP_Y_CBCR_H2V2_VENUS:
208            return HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;
209        default:
210            ALOGE("%s: Unsupported MDP format = 0x%x", __func__, mdpFormat);
211            return -1;
212    }
213    // not reached
214    return -1;
215}
216
217int getMdpOrient(eTransform rotation) {
218    int retTrans = 0;
219    bool trans90 = false;
220    int mdpVersion = qdutils::MDPVersion::getInstance().getMDPVersion();
221    bool aFamily = (mdpVersion < qdutils::MDSS_V5);
222
223    ALOGD_IF(DEBUG_OVERLAY, "%s: In rotation = %d", __FUNCTION__, rotation);
224    if(rotation & OVERLAY_TRANSFORM_ROT_90) {
225        retTrans |= MDP_ROT_90;
226        trans90 = true;
227    }
228
229    if(rotation & OVERLAY_TRANSFORM_FLIP_H) {
230        if(trans90 && aFamily) {
231            //Swap for a-family, since its driver does 90 first
232            retTrans |= MDP_FLIP_UD;
233        } else {
234            retTrans |= MDP_FLIP_LR;
235        }
236    }
237
238    if(rotation & OVERLAY_TRANSFORM_FLIP_V) {
239        if(trans90 && aFamily) {
240            //Swap for a-family, since its driver does 90 first
241            retTrans |= MDP_FLIP_LR;
242        } else {
243            retTrans |= MDP_FLIP_UD;
244        }
245    }
246
247    ALOGD_IF(DEBUG_OVERLAY, "%s: Out rotation = %d", __FUNCTION__, retTrans);
248    return retTrans;
249}
250
251int getDownscaleFactor(const int& src_w, const int& src_h,
252        const int& dst_w, const int& dst_h) {
253    int dscale_factor = utils::ROT_DS_NONE;
254    // We need this check to engage the rotator whenever possible to assist MDP
255    // in performing video downscale.
256    // This saves bandwidth and avoids causing the driver to make too many panel
257    // -mode switches between BLT (writeback) and non-BLT (Direct) modes.
258    // Use-case: Video playback [with downscaling and rotation].
259    if (dst_w && dst_h)
260    {
261        float fDscale =  (float)(src_w * src_h) / (float)(dst_w * dst_h);
262        uint32_t dscale = (int)sqrtf(fDscale);
263
264        if(dscale < 2) {
265            // Down-scale to > 50% of orig.
266            dscale_factor = utils::ROT_DS_NONE;
267        } else if(dscale < 4) {
268            // Down-scale to between > 25% to <= 50% of orig.
269            dscale_factor = utils::ROT_DS_HALF;
270        } else if(dscale < 8) {
271            // Down-scale to between > 12.5% to <= 25% of orig.
272            dscale_factor = utils::ROT_DS_FOURTH;
273        } else {
274            // Down-scale to <= 12.5% of orig.
275            dscale_factor = utils::ROT_DS_EIGHTH;
276        }
277    }
278    return dscale_factor;
279}
280
281void getDecimationFactor(const int& src_w, const int& src_h,
282        const int& dst_w, const int& dst_h, uint8_t& horzDeci,
283        uint8_t& vertDeci) {
284    horzDeci = 0;
285    vertDeci = 0;
286    float horDscale = ceilf((float)src_w / (float)dst_w);
287    float verDscale = ceilf((float)src_h / (float)dst_h);
288
289    //Next power of 2, if not already
290    horDscale = powf(2.0f, ceilf(log2f(horDscale)));
291    verDscale = powf(2.0f, ceilf(log2f(verDscale)));
292
293    //Since MDP can do 1/4 dscale and has better quality, split the task
294    //between decimator and MDP downscale
295    horDscale /= 4.0f;
296    verDscale /= 4.0f;
297
298    if((int)horDscale)
299        horzDeci = (uint8_t)log2f(horDscale);
300
301    if((int)verDscale)
302        vertDeci = (uint8_t)log2f(verDscale);
303
304    if(src_w > 2048) {
305        //If the client sends us something > what a layer mixer supports
306        //then it means it doesn't want to use split-pipe but wants us to
307        //decimate. A minimum decimation of 2 will ensure that the width is
308        //always within layer mixer limits.
309        if(horzDeci < 2)
310            horzDeci = 2;
311    }
312}
313
314static inline int compute(const uint32_t& x, const uint32_t& y,
315        const uint32_t& z) {
316    return x - ( y + z );
317}
318
319void preRotateSource(const eTransform& tr, Whf& whf, Dim& srcCrop) {
320    if(tr & OVERLAY_TRANSFORM_FLIP_H) {
321        srcCrop.x = compute(whf.w, srcCrop.x, srcCrop.w);
322    }
323    if(tr & OVERLAY_TRANSFORM_FLIP_V) {
324        srcCrop.y = compute(whf.h, srcCrop.y, srcCrop.h);
325    }
326    if(tr & OVERLAY_TRANSFORM_ROT_90) {
327        int tmp = srcCrop.x;
328        srcCrop.x = compute(whf.h,
329                srcCrop.y,
330                srcCrop.h);
331        srcCrop.y = tmp;
332        swap(whf.w, whf.h);
333        swap(srcCrop.w, srcCrop.h);
334    }
335}
336
337void getDump(char *buf, size_t len, const char *prefix,
338        const mdp_overlay& ov) {
339    char str[256] = {'\0'};
340    snprintf(str, 256,
341            "%s id=%d z=%d fg=%d alpha=%d mask=%d flags=0x%x H.Deci=%d,"
342            "V.Deci=%d\n",
343            prefix, ov.id, ov.z_order, ov.is_fg, ov.alpha,
344            ov.transp_mask, ov.flags, ov.horz_deci, ov.vert_deci);
345    strlcat(buf, str, len);
346    getDump(buf, len, "\tsrc", ov.src);
347    getDump(buf, len, "\tsrc_rect", ov.src_rect);
348    getDump(buf, len, "\tdst_rect", ov.dst_rect);
349}
350
351void getDump(char *buf, size_t len, const char *prefix,
352        const msmfb_img& ov) {
353    char str_src[256] = {'\0'};
354    snprintf(str_src, 256,
355            "%s w=%d h=%d format=%d %s\n",
356            prefix, ov.width, ov.height, ov.format,
357            overlay::utils::getFormatString(ov.format));
358    strlcat(buf, str_src, len);
359}
360
361void getDump(char *buf, size_t len, const char *prefix,
362        const mdp_rect& ov) {
363    char str_rect[256] = {'\0'};
364    snprintf(str_rect, 256,
365            "%s x=%d y=%d w=%d h=%d\n",
366            prefix, ov.x, ov.y, ov.w, ov.h);
367    strlcat(buf, str_rect, len);
368}
369
370void getDump(char *buf, size_t len, const char *prefix,
371        const msmfb_overlay_data& ov) {
372    char str[256] = {'\0'};
373    snprintf(str, 256,
374            "%s id=%d\n",
375            prefix, ov.id);
376    strlcat(buf, str, len);
377    getDump(buf, len, "\tdata", ov.data);
378}
379
380void getDump(char *buf, size_t len, const char *prefix,
381        const msmfb_data& ov) {
382    char str_data[256] = {'\0'};
383    snprintf(str_data, 256,
384            "%s offset=%d memid=%d id=%d flags=0x%x\n",
385            prefix, ov.offset, ov.memory_id, ov.id, ov.flags);
386    strlcat(buf, str_data, len);
387}
388
389void getDump(char *buf, size_t len, const char *prefix,
390        const msm_rotator_img_info& rot) {
391    char str[256] = {'\0'};
392    snprintf(str, 256, "%s sessid=%u rot=%d, enable=%d downscale=%d\n",
393            prefix, rot.session_id, rot.rotations, rot.enable,
394            rot.downscale_ratio);
395    strlcat(buf, str, len);
396    getDump(buf, len, "\tsrc", rot.src);
397    getDump(buf, len, "\tdst", rot.dst);
398    getDump(buf, len, "\tsrc_rect", rot.src_rect);
399}
400
401void getDump(char *buf, size_t len, const char *prefix,
402        const msm_rotator_data_info& rot) {
403    char str[256] = {'\0'};
404    snprintf(str, 256,
405            "%s sessid=%u\n",
406            prefix, rot.session_id);
407    strlcat(buf, str, len);
408    getDump(buf, len, "\tsrc", rot.src);
409    getDump(buf, len, "\tdst", rot.dst);
410}
411
412//Helper to even out x,w and y,h pairs
413//x,y are always evened to ceil and w,h are evened to floor
414void normalizeCrop(uint32_t& xy, uint32_t& wh) {
415    if(xy & 1) {
416        even_ceil(xy);
417        if(wh & 1)
418            even_floor(wh);
419        else
420            wh -= 2;
421    } else {
422        even_floor(wh);
423    }
424}
425
426} // utils
427
428} // overlay
429