1 /*
2 * Copyright (c) 2011-2013, 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 #ifndef OVERLAY_UTILS_H
31 #define OVERLAY_UTILS_H
32
33 #include <cutils/log.h> // ALOGE, etc
34 #include <errno.h>
35 #include <fcntl.h> // open, O_RDWR, etc
36 #include <hardware/hardware.h>
37 #include <hardware/gralloc.h> // buffer_handle_t
38 #include <linux/msm_mdp.h> // flags
39 #include <linux/msm_rotator.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <sys/stat.h>
44 #include <sys/types.h>
45 #include <utils/Log.h>
46 #include "gralloc_priv.h" //for interlace
47
48 // Older platforms do not support Venus.
49 #ifndef VENUS_COLOR_FORMAT
50 #define MDP_Y_CBCR_H2V2_VENUS MDP_IMGTYPE_LIMIT
51 #endif
52
53 /*
54 *
55 * Collection of utilities functions/structs/enums etc...
56 *
57 * */
58
59 // comment that out if you want to remove asserts
60 // or put it as -D in Android.mk. your choice.
61 #define OVERLAY_HAS_ASSERT
62
63 #ifdef OVERLAY_HAS_ASSERT
64 # define OVASSERT(x, ...) if(!(x)) { ALOGE(__VA_ARGS__); abort(); }
65 #else
66 # define OVASSERT(x, ...) ALOGE_IF(!(x), __VA_ARGS__)
67 #endif // OVERLAY_HAS_ASSERT
68
69 #define DEBUG_OVERLAY 0
70 #define PROFILE_OVERLAY 0
71
72 #ifndef MDSS_MDP_RIGHT_MIXER
73 #define MDSS_MDP_RIGHT_MIXER 0x100
74 #endif
75
76 #ifndef MDP_OV_PIPE_FORCE_DMA
77 #define MDP_OV_PIPE_FORCE_DMA 0x4000
78 #endif
79
80 #define FB_DEVICE_TEMPLATE "/dev/graphics/fb%u"
81
82 namespace overlay {
83
84 // fwd
85 class Overlay;
86 class OvFD;
87
88 /* helper function to open by using fbnum */
89 bool open(OvFD& fd, uint32_t fbnum, const char* const dev,
90 int flags = O_RDWR);
91
92 namespace utils {
93 struct Whf;
94 struct Dim;
95
setBit(uint32_t x,uint32_t mask)96 inline uint32_t setBit(uint32_t x, uint32_t mask) {
97 return (x | mask);
98 }
99
clrBit(uint32_t x,uint32_t mask)100 inline uint32_t clrBit(uint32_t x, uint32_t mask) {
101 return (x & ~mask);
102 }
103
104 /* Utility class to help avoid copying instances by making the copy ctor
105 * and assignment operator private
106 *
107 * Usage:
108 * class SomeClass : utils::NoCopy {...};
109 */
110 class NoCopy {
111 protected:
NoCopy()112 NoCopy(){}
~NoCopy()113 ~NoCopy() {}
114 private:
115 NoCopy(const NoCopy&);
116 const NoCopy& operator=(const NoCopy&);
117 };
118
119
120 /* 3D related utils, defines etc...
121 * The compound format passed to the overlay is
122 * ABCCC where A is the input 3D format
123 * B is the output 3D format
124 * CCC is the color format e.g YCbCr420SP YCrCb420SP etc */
125 enum { SHIFT_OUT_3D = 12,
126 SHIFT_TOT_3D = 16 };
127 enum { INPUT_3D_MASK = 0xFFFF0000,
128 OUTPUT_3D_MASK = 0x0000FFFF };
129 enum { BARRIER_LAND = 1,
130 BARRIER_PORT = 2 };
131
format3D(uint32_t x)132 inline uint32_t format3D(uint32_t x) { return x & 0xFF000; }
format3DOutput(uint32_t x)133 inline uint32_t format3DOutput(uint32_t x) {
134 return (x & 0xF000) >> SHIFT_OUT_3D; }
format3DInput(uint32_t x)135 inline uint32_t format3DInput(uint32_t x) { return x & 0xF0000; }
136
137 bool isHDMIConnected ();
138 bool is3DTV();
139 bool isPanel3D();
140 bool usePanel3D();
141 bool send3DInfoPacket (uint32_t fmt);
142 bool enableBarrier (uint32_t orientation);
143 uint32_t getS3DFormat(uint32_t fmt);
144 bool isMdssRotator();
145 void normalizeCrop(uint32_t& xy, uint32_t& wh);
146
147 template <int CHAN>
148 bool getPositionS3D(const Whf& whf, Dim& out);
149
150 template <int CHAN>
151 bool getCropS3D(const Dim& in, Dim& out, uint32_t fmt);
152
153 template <class Type>
154 void swapWidthHeight(Type& width, Type& height);
155
156 struct Dim {
DimDim157 Dim () : x(0), y(0),
158 w(0), h(0),
159 o(0) {}
DimDim160 Dim(uint32_t _x, uint32_t _y, uint32_t _w, uint32_t _h) :
161 x(_x), y(_y),
162 w(_w), h(_h) {}
DimDim163 Dim(uint32_t _x, uint32_t _y, uint32_t _w, uint32_t _h, uint32_t _o) :
164 x(_x), y(_y),
165 w(_w), h(_h),
166 o(_o) {}
checkDim167 bool check(uint32_t _w, uint32_t _h) const {
168 return (x+w <= _w && y+h <= _h);
169
170 }
171
172 bool operator==(const Dim& d) const {
173 return d.x == x && d.y == y &&
174 d.w == w && d.h == h &&
175 d.o == o;
176 }
177
178 bool operator!=(const Dim& d) const {
179 return !operator==(d);
180 }
181
182 void dump() const;
183 uint32_t x;
184 uint32_t y;
185 uint32_t w;
186 uint32_t h;
187 uint32_t o;
188 };
189
190 // TODO have Whfz
191
192 struct Whf {
WhfWhf193 Whf() : w(0), h(0), format(0), size(0) {}
WhfWhf194 Whf(uint32_t wi, uint32_t he, uint32_t f) :
195 w(wi), h(he), format(f), size(0) {}
WhfWhf196 Whf(uint32_t wi, uint32_t he, uint32_t f, uint32_t s) :
197 w(wi), h(he), format(f), size(s) {}
198 // FIXME not comparing size at the moment
199 bool operator==(const Whf& whf) const {
200 return whf.w == w && whf.h == h &&
201 whf.format == format;
202 }
203 bool operator!=(const Whf& whf) const {
204 return !operator==(whf);
205 }
206 void dump() const;
207 uint32_t w;
208 uint32_t h;
209 uint32_t format;
210 uint32_t size;
211 };
212
213 enum { MAX_PATH_LEN = 256 };
214
215 enum { DEFAULT_PLANE_ALPHA = 0xFF };
216
217 /**
218 * Rotator flags: not to be confused with orientation flags.
219 * Usually, you want to open the rotator to make sure it is
220 * ready for business.
221 * */
222 enum eRotFlags {
223 ROT_FLAGS_NONE = 0,
224 //Use rotator for 0 rotation. It is used anyway for others.
225 ROT_0_ENABLED = 1 << 0,
226 //Enable rotator downscale optimization for hardware bugs not handled in
227 //driver. If downscale optimizatation is required,
228 //then rotator will be used even if its 0 rotation case.
229 ROT_DOWNSCALE_ENABLED = 1 << 1,
230 ROT_PREROTATED = 1 << 2,
231 };
232
233 enum eRotDownscale {
234 ROT_DS_NONE = 0,
235 ROT_DS_HALF = 1,
236 ROT_DS_FOURTH = 2,
237 ROT_DS_EIGHTH = 3,
238 };
239
240 /* The values for is_fg flag for control alpha and transp
241 * IS_FG_OFF means is_fg = 0
242 * IS_FG_SET means is_fg = 1
243 */
244 enum eIsFg {
245 IS_FG_OFF = 0,
246 IS_FG_SET = 1
247 };
248
249 /*
250 * Various mdp flags like PIPE SHARE, DEINTERLACE etc...
251 * kernel/common/linux/msm_mdp.h
252 * INTERLACE_MASK: hardware/qcom/display/libgralloc/badger/fb_priv.h
253 * */
254 enum eMdpFlags {
255 OV_MDP_FLAGS_NONE = 0,
256 OV_MDP_PIPE_SHARE = MDP_OV_PIPE_SHARE,
257 OV_MDP_PIPE_FORCE_DMA = MDP_OV_PIPE_FORCE_DMA,
258 OV_MDP_DEINTERLACE = MDP_DEINTERLACE,
259 OV_MDP_SECURE_OVERLAY_SESSION = MDP_SECURE_OVERLAY_SESSION,
260 OV_MDP_SOURCE_ROTATED_90 = MDP_SOURCE_ROTATED_90,
261 OV_MDP_BACKEND_COMPOSITION = MDP_BACKEND_COMPOSITION,
262 OV_MDP_BLEND_FG_PREMULT = MDP_BLEND_FG_PREMULT,
263 OV_MDP_FLIP_H = MDP_FLIP_LR,
264 OV_MDP_FLIP_V = MDP_FLIP_UD,
265 OV_MDSS_MDP_RIGHT_MIXER = MDSS_MDP_RIGHT_MIXER,
266 OV_MDP_PP_EN = MDP_OVERLAY_PP_CFG_EN,
267 OV_MDSS_MDP_BWC_EN = MDP_BWC_EN,
268 };
269
270 enum eZorder {
271 ZORDER_0 = 0,
272 ZORDER_1,
273 ZORDER_2,
274 ZORDER_3,
275 Z_SYSTEM_ALLOC = 0xFFFF
276 };
277
278 enum eMdpPipeType {
279 OV_MDP_PIPE_RGB = 0,
280 OV_MDP_PIPE_VG,
281 OV_MDP_PIPE_DMA,
282 OV_MDP_PIPE_ANY, //Any
283 };
284
285 // Identify destination pipes
286 // TODO Names useless, replace with int and change all interfaces
287 enum eDest {
288 OV_P0 = 0,
289 OV_P1,
290 OV_P2,
291 OV_P3,
292 OV_P4,
293 OV_P5,
294 OV_P6,
295 OV_P7,
296 OV_P8,
297 OV_P9,
298 OV_INVALID,
299 OV_MAX = OV_INVALID,
300 };
301
302 /* Used when a buffer is split over 2 pipes and sent to display */
303 enum {
304 OV_LEFT_SPLIT = 0,
305 OV_RIGHT_SPLIT,
306 };
307
308 /* values for copybit_set_parameter(OVERLAY_TRANSFORM) */
309 enum eTransform {
310 /* No rot */
311 OVERLAY_TRANSFORM_0 = 0x0,
312 /* flip source image horizontally 0x1 */
313 OVERLAY_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H,
314 /* flip source image vertically 0x2 */
315 OVERLAY_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V,
316 /* rotate source image 180 degrees
317 * It is basically bit-or-ed H | V == 0x3 */
318 OVERLAY_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180,
319 /* rotate source image 90 degrees 0x4 */
320 OVERLAY_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90,
321 /* rotate source image 90 degrees and flip horizontally 0x5 */
322 OVERLAY_TRANSFORM_ROT_90_FLIP_H = HAL_TRANSFORM_ROT_90 |
323 HAL_TRANSFORM_FLIP_H,
324 /* rotate source image 90 degrees and flip vertically 0x6 */
325 OVERLAY_TRANSFORM_ROT_90_FLIP_V = HAL_TRANSFORM_ROT_90 |
326 HAL_TRANSFORM_FLIP_V,
327 /* rotate source image 270 degrees
328 * Basically 180 | 90 == 0x7 */
329 OVERLAY_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270,
330 /* rotate invalid like in Transform.h */
331 OVERLAY_TRANSFORM_INV = 0x80
332 };
333
334 enum eBlending {
335 OVERLAY_BLENDING_UNDEFINED = 0x0,
336 /* No blending */
337 OVERLAY_BLENDING_OPAQUE,
338 /* src.rgb + dst.rgb*(1-src_alpha) */
339 OVERLAY_BLENDING_PREMULT,
340 /* src.rgb * src_alpha + dst.rgb (1 - src_alpha) */
341 OVERLAY_BLENDING_COVERAGE,
342 };
343
344 // Used to consolidate pipe params
345 struct PipeArgs {
PipeArgsPipeArgs346 PipeArgs() : mdpFlags(OV_MDP_FLAGS_NONE),
347 zorder(Z_SYSTEM_ALLOC),
348 isFg(IS_FG_OFF),
349 rotFlags(ROT_FLAGS_NONE),
350 planeAlpha(DEFAULT_PLANE_ALPHA),
351 blending(OVERLAY_BLENDING_COVERAGE){
352 }
353
PipeArgsPipeArgs354 PipeArgs(eMdpFlags f, Whf _whf,
355 eZorder z, eIsFg fg, eRotFlags r,
356 int pA, eBlending b) :
357 mdpFlags(f),
358 whf(_whf),
359 zorder(z),
360 isFg(fg),
361 rotFlags(r),
362 planeAlpha(pA),
363 blending(b){
364 }
365
366 eMdpFlags mdpFlags; // for mdp_overlay flags
367 Whf whf;
368 eZorder zorder; // stage number
369 eIsFg isFg; // control alpha & transp
370 eRotFlags rotFlags;
371 int planeAlpha;
372 eBlending blending;
373 };
374
375 // Cannot use HW_OVERLAY_MAGNIFICATION_LIMIT, since at the time
376 // of integration, HW_OVERLAY_MAGNIFICATION_LIMIT was a define
377 enum { HW_OV_MAGNIFICATION_LIMIT = 20,
378 HW_OV_MINIFICATION_LIMIT = 8
379 };
380
setMdpFlags(eMdpFlags & f,eMdpFlags v)381 inline void setMdpFlags(eMdpFlags& f, eMdpFlags v) {
382 f = static_cast<eMdpFlags>(setBit(f, v));
383 }
384
clearMdpFlags(eMdpFlags & f,eMdpFlags v)385 inline void clearMdpFlags(eMdpFlags& f, eMdpFlags v) {
386 f = static_cast<eMdpFlags>(clrBit(f, v));
387 }
388
389 enum { FB0, FB1, FB2 };
390
391 struct ScreenInfo {
ScreenInfoScreenInfo392 ScreenInfo() : mFBWidth(0),
393 mFBHeight(0),
394 mFBbpp(0),
395 mFBystride(0) {}
396 void dump(const char* const s) const;
397 uint32_t mFBWidth;
398 uint32_t mFBHeight;
399 uint32_t mFBbpp;
400 uint32_t mFBystride;
401 };
402
403 int getMdpFormat(int format);
404 int getHALFormat(int mdpFormat);
405 int getDownscaleFactor(const int& src_w, const int& src_h,
406 const int& dst_w, const int& dst_h);
407 void getDecimationFactor(const int& src_w, const int& src_h,
408 const int& dst_w, const int& dst_h, uint8_t& horzDeci,
409 uint8_t& vertDeci);
410
411 /* flip is upside down and such. V, H flip
412 * rotation is 90, 180 etc
413 * It returns MDP related enum/define that match rot+flip*/
414 int getMdpOrient(eTransform rotation);
415 const char* getFormatString(int format);
416
417 template <class T>
memset0(T & t)418 inline void memset0(T& t) { ::memset(&t, 0, sizeof(T)); }
419
swap(T & a,T & b)420 template <class T> inline void swap ( T& a, T& b )
421 {
422 T c(a); a=b; b=c;
423 }
424
alignup(int value,int a)425 inline int alignup(int value, int a) {
426 //if align = 0, return the value. Else, do alignment.
427 return a ? ((((value - 1) / a) + 1) * a) : value;
428 }
429
aligndown(int value,int a)430 inline int aligndown(int value, int a) {
431 //if align = 0, return the value. Else, do alignment.
432 return a ? ((value) & ~(a-1)) : value;
433 }
434
435 // FIXME that align should replace the upper one.
align(int value,int a)436 inline int align(int value, int a) {
437 //if align = 0, return the value. Else, do alignment.
438 return a ? ((value + (a-1)) & ~(a-1)) : value;
439 }
440
441 enum eRotOutFmt {
442 ROT_OUT_FMT_DEFAULT,
443 ROT_OUT_FMT_Y_CRCB_H2V2
444 };
445
446 template <int ROT_OUT_FMT> struct RotOutFmt;
447
448 // FIXME, taken from gralloc_priv.h. Need to
449 // put it back as soon as overlay takes place of the old one
450 /* possible formats for 3D content*/
451 enum {
452 HAL_NO_3D = 0x0000,
453 HAL_3D_IN_SIDE_BY_SIDE_L_R = 0x10000,
454 HAL_3D_IN_TOP_BOTTOM = 0x20000,
455 HAL_3D_IN_INTERLEAVE = 0x40000,
456 HAL_3D_IN_SIDE_BY_SIDE_R_L = 0x80000,
457 HAL_3D_OUT_SIDE_BY_SIDE = 0x1000,
458 HAL_3D_OUT_TOP_BOTTOM = 0x2000,
459 HAL_3D_OUT_INTERLEAVE = 0x4000,
460 HAL_3D_OUT_MONOSCOPIC = 0x8000
461 };
462
463 enum { HAL_3D_OUT_SBS_MASK =
464 HAL_3D_OUT_SIDE_BY_SIDE >> overlay::utils::SHIFT_OUT_3D,
465 HAL_3D_OUT_TOP_BOT_MASK =
466 HAL_3D_OUT_TOP_BOTTOM >> overlay::utils::SHIFT_OUT_3D,
467 HAL_3D_OUT_INTERL_MASK =
468 HAL_3D_OUT_INTERLEAVE >> overlay::utils::SHIFT_OUT_3D,
469 HAL_3D_OUT_MONOS_MASK =
470 HAL_3D_OUT_MONOSCOPIC >> overlay::utils::SHIFT_OUT_3D
471 };
472
473
isYuv(uint32_t format)474 inline bool isYuv(uint32_t format) {
475 switch(format){
476 case MDP_Y_CBCR_H2V1:
477 case MDP_Y_CBCR_H2V2:
478 case MDP_Y_CRCB_H2V2:
479 case MDP_Y_CRCB_H1V1:
480 case MDP_Y_CRCB_H2V1:
481 case MDP_Y_CRCB_H2V2_TILE:
482 case MDP_Y_CBCR_H2V2_TILE:
483 case MDP_Y_CR_CB_H2V2:
484 case MDP_Y_CR_CB_GH2V2:
485 case MDP_Y_CBCR_H2V2_VENUS:
486 return true;
487 default:
488 return false;
489 }
490 return false;
491 }
492
isRgb(uint32_t format)493 inline bool isRgb(uint32_t format) {
494 switch(format) {
495 case MDP_RGBA_8888:
496 case MDP_BGRA_8888:
497 case MDP_RGBX_8888:
498 case MDP_RGB_565:
499 return true;
500 default:
501 return false;
502 }
503 return false;
504 }
505
getFormatString(int format)506 inline const char* getFormatString(int format){
507 #define STR(f) #f;
508 static const char* formats[MDP_IMGTYPE_LIMIT + 1] = {0};
509 formats[MDP_RGB_565] = STR(MDP_RGB_565);
510 formats[MDP_XRGB_8888] = STR(MDP_XRGB_8888);
511 formats[MDP_Y_CBCR_H2V2] = STR(MDP_Y_CBCR_H2V2);
512 formats[MDP_Y_CBCR_H2V2_ADRENO] = STR(MDP_Y_CBCR_H2V2_ADRENO);
513 formats[MDP_ARGB_8888] = STR(MDP_ARGB_8888);
514 formats[MDP_RGB_888] = STR(MDP_RGB_888);
515 formats[MDP_Y_CRCB_H2V2] = STR(MDP_Y_CRCB_H2V2);
516 formats[MDP_YCRYCB_H2V1] = STR(MDP_YCRYCB_H2V1);
517 formats[MDP_CBYCRY_H2V1] = STR(MDP_CBYCRY_H2V1);
518 formats[MDP_Y_CRCB_H2V1] = STR(MDP_Y_CRCB_H2V1);
519 formats[MDP_Y_CBCR_H2V1] = STR(MDP_Y_CBCR_H2V1);
520 formats[MDP_Y_CRCB_H1V2] = STR(MDP_Y_CRCB_H1V2);
521 formats[MDP_Y_CBCR_H1V2] = STR(MDP_Y_CBCR_H1V2);
522 formats[MDP_RGBA_8888] = STR(MDP_RGBA_8888);
523 formats[MDP_BGRA_8888] = STR(MDP_BGRA_8888);
524 formats[MDP_RGBX_8888] = STR(MDP_RGBX_8888);
525 formats[MDP_Y_CRCB_H2V2_TILE] = STR(MDP_Y_CRCB_H2V2_TILE);
526 formats[MDP_Y_CBCR_H2V2_TILE] = STR(MDP_Y_CBCR_H2V2_TILE);
527 formats[MDP_Y_CR_CB_H2V2] = STR(MDP_Y_CR_CB_H2V2);
528 formats[MDP_Y_CR_CB_GH2V2] = STR(MDP_Y_CR_CB_GH2V2);
529 formats[MDP_Y_CB_CR_H2V2] = STR(MDP_Y_CB_CR_H2V2);
530 formats[MDP_Y_CRCB_H1V1] = STR(MDP_Y_CRCB_H1V1);
531 formats[MDP_Y_CBCR_H1V1] = STR(MDP_Y_CBCR_H1V1);
532 formats[MDP_YCRCB_H1V1] = STR(MDP_YCRCB_H1V1);
533 formats[MDP_YCBCR_H1V1] = STR(MDP_YCBCR_H1V1);
534 formats[MDP_BGR_565] = STR(MDP_BGR_565);
535 formats[MDP_BGR_888] = STR(MDP_BGR_888);
536 formats[MDP_Y_CBCR_H2V2_VENUS] = STR(MDP_Y_CBCR_H2V2_VENUS);
537 formats[MDP_BGRX_8888] = STR(MDP_BGRX_8888);
538 formats[MDP_IMGTYPE_LIMIT] = STR(MDP_IMGTYPE_LIMIT);
539
540 if(format < 0 || format >= MDP_IMGTYPE_LIMIT) {
541 ALOGE("%s wrong fmt %d", __FUNCTION__, format);
542 return "Unsupported format";
543 }
544 if(formats[format] == 0) {
545 ALOGE("%s: table missing format %d from header", __FUNCTION__, format);
546 return "";
547 }
548 return formats[format];
549 }
550
dump()551 inline void Whf::dump() const {
552 ALOGE("== Dump WHF w=%d h=%d f=%d s=%d start/end ==",
553 w, h, format, size);
554 }
555
dump()556 inline void Dim::dump() const {
557 ALOGE("== Dump Dim x=%d y=%d w=%d h=%d start/end ==", x, y, w, h);
558 }
559
560 // FB0
561 template <int CHAN>
getPositionS3DImpl(const Whf & whf)562 inline Dim getPositionS3DImpl(const Whf& whf)
563 {
564 switch (whf.format & OUTPUT_3D_MASK)
565 {
566 case HAL_3D_OUT_SBS_MASK:
567 // x, y, w, h
568 return Dim(0, 0, whf.w/2, whf.h);
569 case HAL_3D_OUT_TOP_BOT_MASK:
570 return Dim(0, 0, whf.w, whf.h/2);
571 case HAL_3D_OUT_MONOS_MASK:
572 return Dim();
573 case HAL_3D_OUT_INTERL_MASK:
574 // FIXME error?
575 ALOGE("%s HAL_3D_OUT_INTERLEAVE_MASK", __FUNCTION__);
576 return Dim();
577 default:
578 ALOGE("%s Unsupported 3D output format %d", __FUNCTION__,
579 whf.format);
580 }
581 return Dim();
582 }
583
584 template <>
585 inline Dim getPositionS3DImpl<utils::OV_RIGHT_SPLIT>(const Whf& whf)
586 {
587 switch (whf.format & OUTPUT_3D_MASK)
588 {
589 case HAL_3D_OUT_SBS_MASK:
590 return Dim(whf.w/2, 0, whf.w/2, whf.h);
591 case HAL_3D_OUT_TOP_BOT_MASK:
592 return Dim(0, whf.h/2, whf.w, whf.h/2);
593 case HAL_3D_OUT_MONOS_MASK:
594 return Dim(0, 0, whf.w, whf.h);
595 case HAL_3D_OUT_INTERL_MASK:
596 // FIXME error?
597 ALOGE("%s HAL_3D_OUT_INTERLEAVE_MASK", __FUNCTION__);
598 return Dim();
599 default:
600 ALOGE("%s Unsupported 3D output format %d", __FUNCTION__,
601 whf.format);
602 }
603 return Dim();
604 }
605
606 template <int CHAN>
getPositionS3D(const Whf & whf,Dim & out)607 inline bool getPositionS3D(const Whf& whf, Dim& out) {
608 out = getPositionS3DImpl<CHAN>(whf);
609 return (out != Dim());
610 }
611
612 template <int CHAN>
getCropS3DImpl(const Dim & in,uint32_t fmt)613 inline Dim getCropS3DImpl(const Dim& in, uint32_t fmt) {
614 switch (fmt & INPUT_3D_MASK)
615 {
616 case HAL_3D_IN_SIDE_BY_SIDE_L_R:
617 return Dim(0, 0, in.w/2, in.h);
618 case HAL_3D_IN_SIDE_BY_SIDE_R_L:
619 return Dim(in.w/2, 0, in.w/2, in.h);
620 case HAL_3D_IN_TOP_BOTTOM:
621 return Dim(0, 0, in.w, in.h/2);
622 case HAL_3D_IN_INTERLEAVE:
623 ALOGE("%s HAL_3D_IN_INTERLEAVE", __FUNCTION__);
624 break;
625 default:
626 ALOGE("%s Unsupported 3D format %d", __FUNCTION__, fmt);
627 break;
628 }
629 return Dim();
630 }
631
632 template <>
633 inline Dim getCropS3DImpl<utils::OV_RIGHT_SPLIT>(const Dim& in, uint32_t fmt) {
634 switch (fmt & INPUT_3D_MASK)
635 {
636 case HAL_3D_IN_SIDE_BY_SIDE_L_R:
637 return Dim(in.w/2, 0, in.w/2, in.h);
638 case HAL_3D_IN_SIDE_BY_SIDE_R_L:
639 return Dim(0, 0, in.w/2, in.h);
640 case HAL_3D_IN_TOP_BOTTOM:
641 return Dim(0, in.h/2, in.w, in.h/2);
642 case HAL_3D_IN_INTERLEAVE:
643 ALOGE("%s HAL_3D_IN_INTERLEAVE", __FUNCTION__);
644 break;
645 default:
646 ALOGE("%s Unsupported 3D format %d", __FUNCTION__, fmt);
647 break;
648 }
649 return Dim();
650 }
651
652 template <int CHAN>
getCropS3D(const Dim & in,Dim & out,uint32_t fmt)653 inline bool getCropS3D(const Dim& in, Dim& out, uint32_t fmt)
654 {
655 out = getCropS3DImpl<CHAN>(in, fmt);
656 return (out != Dim());
657 }
658
659 template <class Type>
swapWidthHeight(Type & width,Type & height)660 void swapWidthHeight(Type& width, Type& height) {
661 Type tmp = width;
662 width = height;
663 height = tmp;
664 }
665
dump(const char * const s)666 inline void ScreenInfo::dump(const char* const s) const {
667 ALOGE("== Dump %s ScreenInfo w=%d h=%d"
668 " bpp=%d stride=%d start/end ==",
669 s, mFBWidth, mFBHeight, mFBbpp, mFBystride);
670 }
671
openDev(OvFD & fd,int fbnum,const char * const devpath,int flags)672 inline bool openDev(OvFD& fd, int fbnum,
673 const char* const devpath, int flags) {
674 return overlay::open(fd, fbnum, devpath, flags);
675 }
676
677 template <class T>
even_ceil(T & value)678 inline void even_ceil(T& value) {
679 if(value & 1)
680 value++;
681 }
682
683 template <class T>
even_floor(T & value)684 inline void even_floor(T& value) {
685 if(value & 1)
686 value--;
687 }
688
689 void preRotateSource(const eTransform& tr, Whf& whf, Dim& srcCrop);
690 void getDump(char *buf, size_t len, const char *prefix, const mdp_overlay& ov);
691 void getDump(char *buf, size_t len, const char *prefix, const msmfb_img& ov);
692 void getDump(char *buf, size_t len, const char *prefix, const mdp_rect& ov);
693 void getDump(char *buf, size_t len, const char *prefix,
694 const msmfb_overlay_data& ov);
695 void getDump(char *buf, size_t len, const char *prefix, const msmfb_data& ov);
696 void getDump(char *buf, size_t len, const char *prefix,
697 const msm_rotator_img_info& ov);
698 void getDump(char *buf, size_t len, const char *prefix,
699 const msm_rotator_data_info& ov);
700
701 } // namespace utils ends
702
703 //--------------------Class Res stuff (namespace overlay only) -----------
704
705 class Res {
706 public:
707 // /dev/graphics/fb%u
708 static const char* const fbPath;
709 // /dev/msm_rotator
710 static const char* const rotPath;
711 // /sys/class/graphics/fb1/format_3d
712 static const char* const format3DFile;
713 // /sys/class/graphics/fb1/3d_present
714 static const char* const edid3dInfoFile;
715 // /sys/devices/platform/mipi_novatek.0/enable_3d_barrier
716 static const char* const barrierFile;
717 };
718
719
720 //--------------------Class OvFD stuff (namespace overlay only) -----------
721
722 /*
723 * Holds one FD
724 * Dtor will NOT close the underlying FD.
725 * That enables us to copy that object around
726 * */
727 class OvFD {
728 public:
729 /* Ctor */
730 explicit OvFD();
731
732 /* dtor will NOT close the underlying FD */
733 ~OvFD();
734
735 /* Open fd using the path given by dev.
736 * return false in failure */
737 bool open(const char* const dev,
738 int flags = O_RDWR);
739
740 /* populate path */
741 void setPath(const char* const dev);
742
743 /* Close fd if we have a valid fd. */
744 bool close();
745
746 /* returns underlying fd.*/
747 int getFD() const;
748
749 /* returns true if fd is valid */
750 bool valid() const;
751
752 /* like operator= */
753 void copy(int fd);
754
755 /* dump the state of the instance */
756 void dump() const;
757 private:
758 /* helper enum for determine valid/invalid fd */
759 enum { INVAL = -1 };
760
761 /* actual os fd */
762 int mFD;
763
764 /* path, for debugging */
765 char mPath[utils::MAX_PATH_LEN];
766 };
767
768 //-------------------Inlines--------------------------
769
open(OvFD & fd,uint32_t fbnum,const char * const dev,int flags)770 inline bool open(OvFD& fd, uint32_t fbnum, const char* const dev, int flags)
771 {
772 char dev_name[64] = {0};
773 snprintf(dev_name, sizeof(dev_name), dev, fbnum);
774 return fd.open(dev_name, flags);
775 }
776
OvFD()777 inline OvFD::OvFD() : mFD (INVAL) {
778 mPath[0] = 0;
779 }
780
~OvFD()781 inline OvFD::~OvFD() {
782 //no op since copy() can be used to share fd, in 3d cases.
783 }
784
open(const char * const dev,int flags)785 inline bool OvFD::open(const char* const dev, int flags)
786 {
787 mFD = ::open(dev, flags, 0);
788 if (mFD < 0) {
789 // FIXME errno, strerror in bionic?
790 ALOGE("Cant open device %s err=%d", dev, errno);
791 return false;
792 }
793 setPath(dev);
794 return true;
795 }
796
setPath(const char * const dev)797 inline void OvFD::setPath(const char* const dev)
798 {
799 ::strncpy(mPath, dev, utils::MAX_PATH_LEN);
800 }
801
close()802 inline bool OvFD::close()
803 {
804 int ret = 0;
805 if(valid()) {
806 ret = ::close(mFD);
807 mFD = INVAL;
808 }
809 return (ret == 0);
810 }
811
valid()812 inline bool OvFD::valid() const
813 {
814 return (mFD != INVAL);
815 }
816
getFD()817 inline int OvFD::getFD() const { return mFD; }
818
copy(int fd)819 inline void OvFD::copy(int fd) {
820 mFD = fd;
821 }
822
dump()823 inline void OvFD::dump() const
824 {
825 ALOGE("== Dump OvFD fd=%d path=%s start/end ==",
826 mFD, mPath);
827 }
828
829 //--------------- class OvFD stuff ends ---------------------
830
831 } // overlay
832
833
834 #endif // OVERLAY_UTILS_H
835