overlayUtils.cpp revision 6e146950e61327d425750c1de36bfd70d526acad 
1/*
2* Copyright (c) 2011-2012, 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 <utils/Log.h>
32#include <linux/msm_mdp.h>
33#include <cutils/properties.h>
34#include "gralloc_priv.h"
35#include "fb_priv.h"
36#include "overlayUtils.h"
37#include "mdpWrapper.h"
38#include "mdp_version.h"
39
40// just a helper static thingy
41namespace {
42struct IOFile {
43    IOFile(const char* s, const char* mode) : fp(0) {
44        fp = ::fopen(s, mode);
45        if(!fp) {
46            ALOGE("Failed open %s", s);
47        }
48    }
49    template <class T>
50            size_t read(T& r, size_t elem) {
51                if(fp) {
52                    return ::fread(&r, sizeof(T), elem, fp);
53                }
54                return 0;
55            }
56    size_t write(const char* s, uint32_t val) {
57        if(fp) {
58            return ::fprintf(fp, s, val);
59        }
60        return 0;
61    }
62    bool valid() const { return fp != 0; }
63    ~IOFile() {
64        if(fp) ::fclose(fp);
65        fp=0;
66    }
67    FILE* fp;
68};
69}
70
71namespace overlay {
72
73//----------From class Res ------------------------------
74const char* const Res::fbPath = "/dev/graphics/fb%u";
75const char* const Res::rotPath = "/dev/msm_rotator";
76const char* const Res::format3DFile =
77        "/sys/class/graphics/fb1/format_3d";
78const char* const Res::edid3dInfoFile =
79        "/sys/class/graphics/fb1/3d_present";
80const char* const Res::barrierFile =
81        "/sys/devices/platform/mipi_novatek.0/enable_3d_barrier";
82//--------------------------------------------------------
83
84
85
86namespace utils {
87
88//--------------------------------------------------------
89//Refer to graphics.h, gralloc_priv.h, msm_mdp.h
90int getMdpFormat(int format) {
91    switch (format) {
92        //From graphics.h
93        case HAL_PIXEL_FORMAT_RGBA_8888 :
94            return MDP_RGBA_8888;
95        case HAL_PIXEL_FORMAT_RGBX_8888:
96            return MDP_RGBX_8888;
97        case HAL_PIXEL_FORMAT_RGB_888:
98            return MDP_RGB_888;
99        case HAL_PIXEL_FORMAT_RGB_565:
100            return MDP_RGB_565;
101        case HAL_PIXEL_FORMAT_BGRA_8888:
102            return MDP_BGRA_8888;
103        case HAL_PIXEL_FORMAT_YV12:
104            return MDP_Y_CR_CB_GH2V2;
105        case HAL_PIXEL_FORMAT_YCbCr_422_SP:
106            return MDP_Y_CBCR_H2V1;
107        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
108            return MDP_Y_CRCB_H2V2;
109
110        //From gralloc_priv.h
111        case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
112            return MDP_Y_CBCR_H2V2_TILE;
113        case HAL_PIXEL_FORMAT_YCbCr_420_SP:
114            return MDP_Y_CBCR_H2V2;
115        case HAL_PIXEL_FORMAT_YCrCb_422_SP:
116            return MDP_Y_CRCB_H2V1;
117        case HAL_PIXEL_FORMAT_YCbCr_444_SP:
118            return MDP_Y_CBCR_H1V1;
119        case HAL_PIXEL_FORMAT_YCrCb_444_SP:
120            return MDP_Y_CRCB_H1V1;
121        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
122            return MDP_Y_CBCR_H2V2_VENUS;
123        default:
124            //Unsupported by MDP
125            //---graphics.h--------
126            //HAL_PIXEL_FORMAT_RGBA_5551
127            //HAL_PIXEL_FORMAT_RGBA_4444
128            //HAL_PIXEL_FORMAT_YCbCr_422_I
129            //---gralloc_priv.h-----
130            //HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO    = 0x7FA30C01
131            //HAL_PIXEL_FORMAT_R_8                    = 0x10D
132            //HAL_PIXEL_FORMAT_RG_88                  = 0x10E
133            ALOGE("%s: Unsupported HAL format = 0x%x", __func__, format);
134            return -1;
135    }
136    // not reached
137    return -1;
138}
139
140//Takes mdp format as input and translates to equivalent HAL format
141//Refer to graphics.h, gralloc_priv.h, msm_mdp.h for formats.
142int getHALFormat(int mdpFormat) {
143    switch (mdpFormat) {
144        //From graphics.h
145        case MDP_RGBA_8888:
146            return HAL_PIXEL_FORMAT_RGBA_8888;
147        case MDP_RGBX_8888:
148            return HAL_PIXEL_FORMAT_RGBX_8888;
149        case MDP_RGB_888:
150            return HAL_PIXEL_FORMAT_RGB_888;
151        case MDP_RGB_565:
152            return HAL_PIXEL_FORMAT_RGB_565;
153        case MDP_BGRA_8888:
154            return HAL_PIXEL_FORMAT_BGRA_8888;
155        case MDP_Y_CR_CB_GH2V2:
156            return HAL_PIXEL_FORMAT_YV12;
157        case MDP_Y_CBCR_H2V1:
158            return HAL_PIXEL_FORMAT_YCbCr_422_SP;
159        case MDP_Y_CRCB_H2V2:
160            return HAL_PIXEL_FORMAT_YCrCb_420_SP;
161
162        //From gralloc_priv.h
163        case MDP_Y_CBCR_H2V2_TILE:
164            return HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED;
165        case MDP_Y_CBCR_H2V2:
166            return HAL_PIXEL_FORMAT_YCbCr_420_SP;
167        case MDP_Y_CRCB_H2V1:
168            return HAL_PIXEL_FORMAT_YCrCb_422_SP;
169        case MDP_Y_CBCR_H1V1:
170            return HAL_PIXEL_FORMAT_YCbCr_444_SP;
171        case MDP_Y_CRCB_H1V1:
172            return HAL_PIXEL_FORMAT_YCrCb_444_SP;
173        case MDP_Y_CBCR_H2V2_VENUS:
174            return HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;
175        default:
176            ALOGE("%s: Unsupported MDP format = 0x%x", __func__, mdpFormat);
177            return -1;
178    }
179    // not reached
180    return -1;
181}
182
183int getDownscaleFactor(const int& src_w, const int& src_h,
184        const int& dst_w, const int& dst_h) {
185    int dscale_factor = utils::ROT_DS_NONE;
186    // We need this check to engage the rotator whenever possible to assist MDP
187    // in performing video downscale.
188    // This saves bandwidth and avoids causing the driver to make too many panel
189    // -mode switches between BLT (writeback) and non-BLT (Direct) modes.
190    // Use-case: Video playback [with downscaling and rotation].
191    if (dst_w && dst_h)
192    {
193        uint32_t dscale = (src_w * src_h) / (dst_w * dst_h);
194        if(dscale < 2) {
195            // Down-scale to > 50% of orig.
196            dscale_factor = utils::ROT_DS_NONE;
197        } else if(dscale < 4) {
198            // Down-scale to between > 25% to <= 50% of orig.
199            dscale_factor = utils::ROT_DS_HALF;
200        } else if(dscale < 8) {
201            // Down-scale to between > 12.5% to <= 25% of orig.
202            dscale_factor = utils::ROT_DS_FOURTH;
203        } else {
204            // Down-scale to <= 12.5% of orig.
205            dscale_factor = utils::ROT_DS_EIGHTH;
206        }
207    }
208    return dscale_factor;
209}
210
211static inline int compute(const uint32_t& x, const uint32_t& y,
212        const uint32_t& z) {
213    return x - ( y + z );
214}
215
216void preRotateSource(eTransform& tr, Whf& whf, Dim& srcCrop) {
217    if(tr & OVERLAY_TRANSFORM_FLIP_H) {
218        srcCrop.x = compute(whf.w, srcCrop.x, srcCrop.w);
219    }
220    if(tr & OVERLAY_TRANSFORM_FLIP_V) {
221        srcCrop.y = compute(whf.h, srcCrop.y, srcCrop.h);
222    }
223    if(tr & OVERLAY_TRANSFORM_ROT_90) {
224        int tmp = srcCrop.x;
225        srcCrop.x = compute(whf.h,
226                srcCrop.y,
227                srcCrop.h);
228        srcCrop.y = tmp;
229        swap(whf.w, whf.h);
230        swap(srcCrop.w, srcCrop.h);
231    }
232    tr = OVERLAY_TRANSFORM_0;
233}
234
235bool is3DTV() {
236    char is3DTV = '0';
237    IOFile fp(Res::edid3dInfoFile, "r");
238    (void)fp.read(is3DTV, 1);
239    ALOGI("3DTV EDID flag: %d", is3DTV);
240    return (is3DTV == '0') ? false : true;
241}
242
243bool isPanel3D() {
244    OvFD fd;
245    if(!overlay::open(fd, 0 /*fb*/, Res::fbPath)){
246        ALOGE("isPanel3D Can't open framebuffer 0");
247        return false;
248    }
249    fb_fix_screeninfo finfo;
250    if(!mdp_wrapper::getFScreenInfo(fd.getFD(), finfo)) {
251        ALOGE("isPanel3D read fb0 failed");
252    }
253    fd.close();
254    return (FB_TYPE_3D_PANEL == finfo.type) ? true : false;
255}
256
257bool usePanel3D() {
258    if(!isPanel3D())
259        return false;
260    char value[PROPERTY_VALUE_MAX];
261    property_get("persist.user.panel3D", value, "0");
262    int usePanel3D = atoi(value);
263    return usePanel3D ? true : false;
264}
265
266bool send3DInfoPacket (uint32_t format3D) {
267    IOFile fp(Res::format3DFile, "wb");
268    (void)fp.write("%d", format3D);
269    if(!fp.valid()) {
270        ALOGE("send3DInfoPacket: no sysfs entry for setting 3d mode");
271        return false;
272    }
273    return true;
274}
275
276bool enableBarrier (uint32_t orientation) {
277    IOFile fp(Res::barrierFile, "wb");
278    (void)fp.write("%d", orientation);
279    if(!fp.valid()) {
280        ALOGE("enableBarrier no sysfs entry for "
281                "enabling barriers on 3D panel");
282        return false;
283    }
284    return true;
285}
286
287uint32_t getS3DFormat(uint32_t fmt) {
288    // The S3D is part of the HAL_PIXEL_FORMAT_YV12 value. Add
289    // an explicit check for the format
290    if (fmt == HAL_PIXEL_FORMAT_YV12) {
291        return 0;
292    }
293    uint32_t fmt3D = format3D(fmt);
294    uint32_t fIn3D = format3DInput(fmt3D); // MSB 2 bytes - inp
295    uint32_t fOut3D = format3DOutput(fmt3D); // LSB 2 bytes - out
296    fmt3D = fIn3D | fOut3D;
297    if (!fIn3D) {
298        fmt3D |= fOut3D << SHIFT_TOT_3D; //Set the input format
299    }
300    if (!fOut3D) {
301        switch (fIn3D) {
302            case HAL_3D_IN_SIDE_BY_SIDE_L_R:
303            case HAL_3D_IN_SIDE_BY_SIDE_R_L:
304                // For all side by side formats, set the output
305                // format as Side-by-Side i.e 0x1
306                fmt3D |= HAL_3D_IN_SIDE_BY_SIDE_L_R >> SHIFT_TOT_3D;
307                break;
308            default:
309                fmt3D |= fIn3D >> SHIFT_TOT_3D; //Set the output format
310        }
311    }
312    return fmt3D;
313}
314
315bool isMdssRotator() {
316    int mdpVersion = qdutils::MDPVersion::getInstance().getMDPVersion();
317    return (mdpVersion >= qdutils::MDSS_V5);
318}
319
320void getDump(char *buf, size_t len, const char *prefix,
321        const mdp_overlay& ov) {
322    char str[256] = {'\0'};
323    snprintf(str, 256,
324            "%s id=%d z=%d fg=%d alpha=%d mask=%d flags=0x%x\n",
325            prefix, ov.id, ov.z_order, ov.is_fg, ov.alpha,
326            ov.transp_mask, ov.flags);
327    strncat(buf, str, strlen(str));
328    getDump(buf, len, "\tsrc(msmfb_img)", ov.src);
329    getDump(buf, len, "\tsrc_rect(mdp_rect)", ov.src_rect);
330    getDump(buf, len, "\tdst_rect(mdp_rect)", ov.dst_rect);
331}
332
333void getDump(char *buf, size_t len, const char *prefix,
334        const msmfb_img& ov) {
335    char str_src[256] = {'\0'};
336    snprintf(str_src, 256,
337            "%s w=%d h=%d format=%d %s\n",
338            prefix, ov.width, ov.height, ov.format,
339            overlay::utils::getFormatString(ov.format));
340    strncat(buf, str_src, strlen(str_src));
341}
342
343void getDump(char *buf, size_t len, const char *prefix,
344        const mdp_rect& ov) {
345    char str_rect[256] = {'\0'};
346    snprintf(str_rect, 256,
347            "%s x=%d y=%d w=%d h=%d\n",
348            prefix, ov.x, ov.y, ov.w, ov.h);
349    strncat(buf, str_rect, strlen(str_rect));
350}
351
352void getDump(char *buf, size_t len, const char *prefix,
353        const msmfb_overlay_data& ov) {
354    char str[256] = {'\0'};
355    snprintf(str, 256,
356            "%s id=%d\n",
357            prefix, ov.id);
358    strncat(buf, str, strlen(str));
359    getDump(buf, len, "\tdata(msmfb_data)", ov.data);
360}
361
362void getDump(char *buf, size_t len, const char *prefix,
363        const msmfb_data& ov) {
364    char str_data[256] = {'\0'};
365    snprintf(str_data, 256,
366            "%s offset=%d memid=%d id=%d flags=0x%x priv=%d\n",
367            prefix, ov.offset, ov.memory_id, ov.id, ov.flags,
368            ov.priv);
369    strncat(buf, str_data, strlen(str_data));
370}
371
372void getDump(char *buf, size_t len, const char *prefix,
373        const msm_rotator_img_info& rot) {
374    char str[256] = {'\0'};
375    snprintf(str, 256, "%s sessid=%u rot=%d, enable=%d downscale=%d\n",
376            prefix, rot.session_id, rot.rotations, rot.enable,
377            rot.downscale_ratio);
378    strncat(buf, str, strlen(str));
379    getDump(buf, len, "\tsrc", rot.src);
380    getDump(buf, len, "\tdst", rot.dst);
381    getDump(buf, len, "\tsrc_rect", rot.src_rect);
382}
383
384void getDump(char *buf, size_t len, const char *prefix,
385        const msm_rotator_data_info& rot) {
386    char str[256] = {'\0'};
387    snprintf(str, 256,
388            "%s sessid=%u verkey=%d\n",
389            prefix, rot.session_id, rot.version_key);
390    strncat(buf, str, strlen(str));
391    getDump(buf, len, "\tsrc", rot.src);
392    getDump(buf, len, "\tdst", rot.dst);
393    getDump(buf, len, "\tsrc_chroma", rot.src_chroma);
394    getDump(buf, len, "\tdst_chroma", rot.dst_chroma);
395}
396
397} // utils
398
399} // overlay
400