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 #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 #ifndef MDSS_MDP_DUAL_PIPE
81 #define MDSS_MDP_DUAL_PIPE 0x200
82 #endif
83
84 #define FB_DEVICE_TEMPLATE "/dev/graphics/fb%u"
85
86 namespace overlay {
87
88 // fwd
89 class Overlay;
90 class OvFD;
91
92 /* helper function to open by using fbnum */
93 bool open(OvFD& fd, uint32_t fbnum, const char* const dev,
94 int flags = O_RDWR);
95
96 namespace utils {
97 struct Whf;
98 struct Dim;
99
setBit(uint32_t x,uint32_t mask)100 inline uint32_t setBit(uint32_t x, uint32_t mask) {
101 return (x | mask);
102 }
103
clrBit(uint32_t x,uint32_t mask)104 inline uint32_t clrBit(uint32_t x, uint32_t mask) {
105 return (x & ~mask);
106 }
107
108 /* Utility class to help avoid copying instances by making the copy ctor
109 * and assignment operator private
110 *
111 * Usage:
112 * class SomeClass : utils::NoCopy {...};
113 */
114 class NoCopy {
115 protected:
NoCopy()116 NoCopy(){}
~NoCopy()117 ~NoCopy() {}
118 private:
119 NoCopy(const NoCopy&);
120 const NoCopy& operator=(const NoCopy&);
121 };
122
123 bool isMdssRotator();
124 void normalizeCrop(uint32_t& xy, uint32_t& wh);
125
126 template <class Type>
127 void swapWidthHeight(Type& width, Type& height);
128
129 struct Dim {
DimDim130 Dim () : x(0), y(0),
131 w(0), h(0),
132 o(0) {}
DimDim133 Dim(uint32_t _x, uint32_t _y, uint32_t _w, uint32_t _h) :
134 x(_x), y(_y),
135 w(_w), h(_h) {}
DimDim136 Dim(uint32_t _x, uint32_t _y, uint32_t _w, uint32_t _h, uint32_t _o) :
137 x(_x), y(_y),
138 w(_w), h(_h),
139 o(_o) {}
checkDim140 bool check(uint32_t _w, uint32_t _h) const {
141 return (x+w <= _w && y+h <= _h);
142
143 }
144
145 bool operator==(const Dim& d) const {
146 return d.x == x && d.y == y &&
147 d.w == w && d.h == h &&
148 d.o == o;
149 }
150
151 bool operator!=(const Dim& d) const {
152 return !operator==(d);
153 }
154
155 void dump() const;
156 uint32_t x;
157 uint32_t y;
158 uint32_t w;
159 uint32_t h;
160 uint32_t o;
161 };
162
163 // TODO have Whfz
164
165 struct Whf {
WhfWhf166 Whf() : w(0), h(0), format(0), size(0) {}
WhfWhf167 Whf(uint32_t wi, uint32_t he, uint32_t f) :
168 w(wi), h(he), format(f), size(0) {}
WhfWhf169 Whf(uint32_t wi, uint32_t he, uint32_t f, uint32_t s) :
170 w(wi), h(he), format(f), size(s) {}
171 // FIXME not comparing size at the moment
172 bool operator==(const Whf& whf) const {
173 return whf.w == w && whf.h == h &&
174 whf.format == format;
175 }
176 bool operator!=(const Whf& whf) const {
177 return !operator==(whf);
178 }
179 void dump() const;
180 uint32_t w;
181 uint32_t h;
182 uint32_t format;
183 uint32_t size;
184 };
185
186 enum { MAX_PATH_LEN = 256 };
187
188 enum { DEFAULT_PLANE_ALPHA = 0xFF };
189
190 /**
191 * Rotator flags: not to be confused with orientation flags.
192 * Usually, you want to open the rotator to make sure it is
193 * ready for business.
194 * */
195 enum eRotFlags {
196 ROT_FLAGS_NONE = 0,
197 //Use rotator for 0 rotation. It is used anyway for others.
198 ROT_0_ENABLED = 1 << 0,
199 //Enable rotator downscale optimization for hardware bugs not handled in
200 //driver. If downscale optimizatation is required,
201 //then rotator will be used even if its 0 rotation case.
202 ROT_DOWNSCALE_ENABLED = 1 << 1,
203 ROT_PREROTATED = 1 << 2,
204 };
205
206 enum eRotDownscale {
207 ROT_DS_NONE = 0,
208 ROT_DS_HALF = 1,
209 ROT_DS_FOURTH = 2,
210 ROT_DS_EIGHTH = 3,
211 };
212
213 /*
214 * Various mdp flags like PIPE SHARE, DEINTERLACE etc...
215 * kernel/common/linux/msm_mdp.h
216 * INTERLACE_MASK: hardware/qcom/display/libgralloc/badger/fb_priv.h
217 * */
218 enum eMdpFlags {
219 OV_MDP_FLAGS_NONE = 0,
220 OV_MDP_PIPE_SHARE = MDP_OV_PIPE_SHARE,
221 OV_MDP_PIPE_FORCE_DMA = MDP_OV_PIPE_FORCE_DMA,
222 OV_MDP_DEINTERLACE = MDP_DEINTERLACE,
223 OV_MDP_SECURE_OVERLAY_SESSION = MDP_SECURE_OVERLAY_SESSION,
224 OV_MDP_SECURE_DISPLAY_OVERLAY_SESSION = MDP_SECURE_DISPLAY_OVERLAY_SESSION,
225 OV_MDP_SOURCE_ROTATED_90 = MDP_SOURCE_ROTATED_90,
226 OV_MDP_BLEND_FG_PREMULT = MDP_BLEND_FG_PREMULT,
227 OV_MDP_FLIP_H = MDP_FLIP_LR,
228 OV_MDP_FLIP_V = MDP_FLIP_UD,
229 OV_MDSS_MDP_RIGHT_MIXER = MDSS_MDP_RIGHT_MIXER,
230 OV_MDP_PP_EN = MDP_OVERLAY_PP_CFG_EN,
231 OV_MDSS_MDP_BWC_EN = MDP_BWC_EN,
232 OV_MDSS_MDP_DUAL_PIPE = MDSS_MDP_DUAL_PIPE,
233 OV_MDP_SOLID_FILL = MDP_SOLID_FILL,
234 OV_MDP_SMP_FORCE_ALLOC = MDP_SMP_FORCE_ALLOC,
235 };
236
237 enum eZorder {
238 ZORDER_0 = 0,
239 ZORDER_1,
240 ZORDER_2,
241 ZORDER_3,
242 ZORDER_4,
243 ZORDER_5,
244 ZORDER_6,
245 Z_SYSTEM_ALLOC = 0xFFFF
246 };
247
248 enum eMdpPipeType {
249 OV_MDP_PIPE_RGB = 0,
250 OV_MDP_PIPE_VG,
251 OV_MDP_PIPE_DMA,
252 OV_MDP_PIPE_ANY, //Any
253 };
254
255 // Identify destination pipes
256 // TODO Names useless, replace with int and change all interfaces
257 enum eDest {
258 OV_P0 = 0,
259 OV_P1,
260 OV_P2,
261 OV_P3,
262 OV_P4,
263 OV_P5,
264 OV_P6,
265 OV_P7,
266 OV_P8,
267 OV_P9,
268 OV_INVALID,
269 OV_MAX = OV_INVALID,
270 };
271
272 /* Used when a buffer is split over 2 pipes and sent to display */
273 enum {
274 OV_LEFT_SPLIT = 0,
275 OV_RIGHT_SPLIT,
276 };
277
278 /* values for copybit_set_parameter(OVERLAY_TRANSFORM) */
279 enum eTransform {
280 /* No rot */
281 OVERLAY_TRANSFORM_0 = 0x0,
282 /* flip source image horizontally 0x1 */
283 OVERLAY_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H,
284 /* flip source image vertically 0x2 */
285 OVERLAY_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V,
286 /* rotate source image 180 degrees
287 * It is basically bit-or-ed H | V == 0x3 */
288 OVERLAY_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180,
289 /* rotate source image 90 degrees 0x4 */
290 OVERLAY_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90,
291 /* rotate source image 90 degrees and flip horizontally 0x5 */
292 OVERLAY_TRANSFORM_ROT_90_FLIP_H = HAL_TRANSFORM_ROT_90 |
293 HAL_TRANSFORM_FLIP_H,
294 /* rotate source image 90 degrees and flip vertically 0x6 */
295 OVERLAY_TRANSFORM_ROT_90_FLIP_V = HAL_TRANSFORM_ROT_90 |
296 HAL_TRANSFORM_FLIP_V,
297 /* rotate source image 270 degrees
298 * Basically 180 | 90 == 0x7 */
299 OVERLAY_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270,
300 /* rotate invalid like in Transform.h */
301 OVERLAY_TRANSFORM_INV = 0x80
302 };
303
304 enum eBlending {
305 OVERLAY_BLENDING_UNDEFINED = 0x0,
306 /* No blending */
307 OVERLAY_BLENDING_OPAQUE,
308 /* src.rgb + dst.rgb*(1-src_alpha) */
309 OVERLAY_BLENDING_PREMULT,
310 /* src.rgb * src_alpha + dst.rgb (1 - src_alpha) */
311 OVERLAY_BLENDING_COVERAGE,
312 };
313
314 // Used to consolidate pipe params
315 struct PipeArgs {
PipeArgsPipeArgs316 PipeArgs() : mdpFlags(OV_MDP_FLAGS_NONE),
317 zorder(Z_SYSTEM_ALLOC),
318 rotFlags(ROT_FLAGS_NONE),
319 planeAlpha(DEFAULT_PLANE_ALPHA),
320 blending(OVERLAY_BLENDING_COVERAGE){
321 }
322
323 PipeArgs(eMdpFlags f, Whf _whf,
324 eZorder z, eRotFlags r,
325 int pA = DEFAULT_PLANE_ALPHA, eBlending b = OVERLAY_BLENDING_COVERAGE) :
mdpFlagsPipeArgs326 mdpFlags(f),
327 whf(_whf),
328 zorder(z),
329 rotFlags(r),
330 planeAlpha(pA),
331 blending(b){
332 }
333
334 eMdpFlags mdpFlags; // for mdp_overlay flags
335 Whf whf;
336 eZorder zorder; // stage number
337 eRotFlags rotFlags;
338 int planeAlpha;
339 eBlending blending;
340 };
341
342 // Cannot use HW_OVERLAY_MAGNIFICATION_LIMIT, since at the time
343 // of integration, HW_OVERLAY_MAGNIFICATION_LIMIT was a define
344 enum { HW_OV_MAGNIFICATION_LIMIT = 20,
345 HW_OV_MINIFICATION_LIMIT = 8
346 };
347
setMdpFlags(eMdpFlags & f,eMdpFlags v)348 inline void setMdpFlags(eMdpFlags& f, eMdpFlags v) {
349 f = static_cast<eMdpFlags>(setBit(f, v));
350 }
351
clearMdpFlags(eMdpFlags & f,eMdpFlags v)352 inline void clearMdpFlags(eMdpFlags& f, eMdpFlags v) {
353 f = static_cast<eMdpFlags>(clrBit(f, v));
354 }
355
356 enum { FB0, FB1, FB2 };
357
358 struct ScreenInfo {
ScreenInfoScreenInfo359 ScreenInfo() : mFBWidth(0),
360 mFBHeight(0),
361 mFBbpp(0),
362 mFBystride(0) {}
363 void dump(const char* const s) const;
364 uint32_t mFBWidth;
365 uint32_t mFBHeight;
366 uint32_t mFBbpp;
367 uint32_t mFBystride;
368 };
369
370 int getMdpFormat(int format);
371 int getMdpFormat(int format, int flags);
372 int getHALFormat(int mdpFormat);
373 void getDecimationFactor(const int& src_w, const int& src_h,
374 const int& dst_w, const int& dst_h, uint8_t& horzDeci,
375 uint8_t& vertDeci);
376
377 /* flip is upside down and such. V, H flip
378 * rotation is 90, 180 etc
379 * It returns MDP related enum/define that match rot+flip*/
380 int getMdpOrient(eTransform rotation);
381 const char* getFormatString(int format);
382
383 template <class T>
memset0(T & t)384 inline void memset0(T& t) { ::memset(&t, 0, sizeof(t)); }
385
swap(T & a,T & b)386 template <class T> inline void swap ( T& a, T& b )
387 {
388 T c(a); a=b; b=c;
389 }
390
max(T a,T b)391 template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; }
392
min(T a,T b)393 template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
394
alignup(int value,int a)395 inline int alignup(int value, int a) {
396 //if align = 0, return the value. Else, do alignment.
397 return a ? ((((value - 1) / a) + 1) * a) : value;
398 }
399
aligndown(int value,int a)400 inline int aligndown(int value, int a) {
401 //if align = 0, return the value. Else, do alignment.
402 return a ? ((value) & ~(a-1)) : value;
403 }
404
405 // FIXME that align should replace the upper one.
align(int value,int a)406 inline int align(int value, int a) {
407 //if align = 0, return the value. Else, do alignment.
408 return a ? ((value + (a-1)) & ~(a-1)) : value;
409 }
410
isYuv(uint32_t format)411 inline bool isYuv(uint32_t format) {
412 switch(format){
413 case MDP_Y_CBCR_H2V1:
414 case MDP_Y_CBCR_H2V2:
415 case MDP_Y_CRCB_H2V2:
416 case MDP_Y_CRCB_H1V1:
417 case MDP_Y_CRCB_H2V1:
418 case MDP_Y_CRCB_H2V2_TILE:
419 case MDP_Y_CBCR_H2V2_TILE:
420 case MDP_Y_CR_CB_H2V2:
421 case MDP_Y_CR_CB_GH2V2:
422 case MDP_Y_CBCR_H2V2_VENUS:
423 case MDP_YCBYCR_H2V1:
424 case MDP_YCRYCB_H2V1:
425 return true;
426 default:
427 return false;
428 }
429 return false;
430 }
431
isRgb(uint32_t format)432 inline bool isRgb(uint32_t format) {
433 switch(format) {
434 case MDP_RGBA_8888:
435 case MDP_BGRA_8888:
436 case MDP_RGBX_8888:
437 case MDP_RGB_565:
438 case MDP_RGBA_4444:
439 case MDP_RGBA_5551:
440 return true;
441 default:
442 return false;
443 }
444 return false;
445 }
446
getFormatString(int format)447 inline const char* getFormatString(int format){
448 #define STR(f) #f;
449 static const char* formats[MDP_IMGTYPE_LIMIT + 1] = {0};
450 formats[MDP_RGB_565] = STR(MDP_RGB_565);
451 formats[MDP_RGBA_5551] = STR(MDP_RGBA_5551);
452 formats[MDP_RGBA_4444] = STR(MDP_RGBA_4444);
453 formats[MDP_XRGB_8888] = STR(MDP_XRGB_8888);
454 formats[MDP_Y_CBCR_H2V2] = STR(MDP_Y_CBCR_H2V2);
455 formats[MDP_Y_CBCR_H2V2_ADRENO] = STR(MDP_Y_CBCR_H2V2_ADRENO);
456 formats[MDP_ARGB_8888] = STR(MDP_ARGB_8888);
457 formats[MDP_RGB_888] = STR(MDP_RGB_888);
458 formats[MDP_Y_CRCB_H2V2] = STR(MDP_Y_CRCB_H2V2);
459 formats[MDP_YCBYCR_H2V1] = STR(MDP_YCBYCR_H2V1);
460 formats[MDP_YCRYCB_H2V1] = STR(MDP_YCRYCB_H2V1);
461 formats[MDP_CBYCRY_H2V1] = STR(MDP_CBYCRY_H2V1);
462 formats[MDP_Y_CRCB_H2V1] = STR(MDP_Y_CRCB_H2V1);
463 formats[MDP_Y_CBCR_H2V1] = STR(MDP_Y_CBCR_H2V1);
464 formats[MDP_Y_CRCB_H1V2] = STR(MDP_Y_CRCB_H1V2);
465 formats[MDP_Y_CBCR_H1V2] = STR(MDP_Y_CBCR_H1V2);
466 formats[MDP_RGBA_8888] = STR(MDP_RGBA_8888);
467 formats[MDP_BGRA_8888] = STR(MDP_BGRA_8888);
468 formats[MDP_RGBX_8888] = STR(MDP_RGBX_8888);
469 formats[MDP_Y_CRCB_H2V2_TILE] = STR(MDP_Y_CRCB_H2V2_TILE);
470 formats[MDP_Y_CBCR_H2V2_TILE] = STR(MDP_Y_CBCR_H2V2_TILE);
471 formats[MDP_Y_CR_CB_H2V2] = STR(MDP_Y_CR_CB_H2V2);
472 formats[MDP_Y_CR_CB_GH2V2] = STR(MDP_Y_CR_CB_GH2V2);
473 formats[MDP_Y_CB_CR_H2V2] = STR(MDP_Y_CB_CR_H2V2);
474 formats[MDP_Y_CRCB_H1V1] = STR(MDP_Y_CRCB_H1V1);
475 formats[MDP_Y_CBCR_H1V1] = STR(MDP_Y_CBCR_H1V1);
476 formats[MDP_YCRCB_H1V1] = STR(MDP_YCRCB_H1V1);
477 formats[MDP_YCBCR_H1V1] = STR(MDP_YCBCR_H1V1);
478 formats[MDP_BGR_565] = STR(MDP_BGR_565);
479 formats[MDP_BGR_888] = STR(MDP_BGR_888);
480 formats[MDP_Y_CBCR_H2V2_VENUS] = STR(MDP_Y_CBCR_H2V2_VENUS);
481 formats[MDP_BGRX_8888] = STR(MDP_BGRX_8888);
482 formats[MDP_RGBA_8888_TILE] = STR(MDP_RGBA_8888_TILE);
483 formats[MDP_ARGB_8888_TILE] = STR(MDP_ARGB_8888_TILE);
484 formats[MDP_ABGR_8888_TILE] = STR(MDP_ABGR_8888_TILE);
485 formats[MDP_BGRA_8888_TILE] = STR(MDP_BGRA_8888_TILE);
486 formats[MDP_RGBX_8888_TILE] = STR(MDP_RGBX_8888_TILE);
487 formats[MDP_XRGB_8888_TILE] = STR(MDP_XRGB_8888_TILE);
488 formats[MDP_XBGR_8888_TILE] = STR(MDP_XBGR_8888_TILE);
489 formats[MDP_BGRX_8888_TILE] = STR(MDP_BGRX_8888_TILE);
490 formats[MDP_RGB_565_TILE] = STR(MDP_RGB_565_TILE);
491 formats[MDP_IMGTYPE_LIMIT] = STR(MDP_IMGTYPE_LIMIT);
492
493 if(format < 0 || format >= MDP_IMGTYPE_LIMIT) {
494 ALOGE("%s wrong fmt %d", __FUNCTION__, format);
495 return "Unsupported format";
496 }
497 if(formats[format] == 0) {
498 ALOGE("%s: table missing format %d from header", __FUNCTION__, format);
499 return "";
500 }
501 return formats[format];
502 }
503
dump()504 inline void Whf::dump() const {
505 ALOGE("== Dump WHF w=%d h=%d f=%d s=%d start/end ==",
506 w, h, format, size);
507 }
508
dump()509 inline void Dim::dump() const {
510 ALOGE("== Dump Dim x=%d y=%d w=%d h=%d start/end ==", x, y, w, h);
511 }
512
513 template <class Type>
swapWidthHeight(Type & width,Type & height)514 void swapWidthHeight(Type& width, Type& height) {
515 Type tmp = width;
516 width = height;
517 height = tmp;
518 }
519
dump(const char * const s)520 inline void ScreenInfo::dump(const char* const s) const {
521 ALOGE("== Dump %s ScreenInfo w=%d h=%d"
522 " bpp=%d stride=%d start/end ==",
523 s, mFBWidth, mFBHeight, mFBbpp, mFBystride);
524 }
525
openDev(OvFD & fd,int fbnum,const char * const devpath,int flags)526 inline bool openDev(OvFD& fd, int fbnum,
527 const char* const devpath, int flags) {
528 return overlay::open(fd, fbnum, devpath, flags);
529 }
530
531 template <class T>
even_ceil(T & value)532 inline void even_ceil(T& value) {
533 if(value & 1)
534 value++;
535 }
536
537 template <class T>
even_floor(T & value)538 inline void even_floor(T& value) {
539 if(value & 1)
540 value--;
541 }
542
543 /* Prerotation adjusts crop co-ordinates to the new transformed values within
544 * destination buffer. This is necessary only when the entire buffer is rotated
545 * irrespective of crop (A-family). If only the crop portion of the buffer is
546 * rotated into a destination buffer matching the size of crop, we don't need to
547 * use this helper (B-family).
548 * @Deprecated as of now, retained for the case where a full buffer needs
549 * transform and also as a reference.
550 */
551 void preRotateSource(const eTransform& tr, Whf& whf, Dim& srcCrop);
552 void getDump(char *buf, size_t len, const char *prefix, const mdp_overlay& ov);
553 void getDump(char *buf, size_t len, const char *prefix, const msmfb_img& ov);
554 void getDump(char *buf, size_t len, const char *prefix, const mdp_rect& ov);
555 void getDump(char *buf, size_t len, const char *prefix,
556 const msmfb_overlay_data& ov);
557 void getDump(char *buf, size_t len, const char *prefix, const msmfb_data& ov);
558 void getDump(char *buf, size_t len, const char *prefix,
559 const msm_rotator_img_info& ov);
560 void getDump(char *buf, size_t len, const char *prefix,
561 const msm_rotator_data_info& ov);
562
563 } // namespace utils ends
564
565 //--------------------Class Res stuff (namespace overlay only) -----------
566
567 class Res {
568 public:
569 // /dev/graphics/fb%u
570 static const char* const fbPath;
571 // /dev/msm_rotator
572 static const char* const rotPath;
573 };
574
575
576 //--------------------Class OvFD stuff (namespace overlay only) -----------
577
578 /*
579 * Holds one FD
580 * Dtor will NOT close the underlying FD.
581 * That enables us to copy that object around
582 * */
583 class OvFD {
584 public:
585 /* Ctor */
586 explicit OvFD();
587
588 /* dtor will NOT close the underlying FD */
589 ~OvFD();
590
591 /* Open fd using the path given by dev.
592 * return false in failure */
593 bool open(const char* const dev,
594 int flags = O_RDWR);
595
596 /* populate path */
597 void setPath(const char* const dev);
598
599 /* Close fd if we have a valid fd. */
600 bool close();
601
602 /* returns underlying fd.*/
603 int getFD() const;
604
605 /* returns true if fd is valid */
606 bool valid() const;
607
608 /* like operator= */
609 void copy(int fd);
610
611 /* dump the state of the instance */
612 void dump() const;
613 private:
614 /* helper enum for determine valid/invalid fd */
615 enum { INVAL = -1 };
616
617 /* actual os fd */
618 int mFD;
619
620 /* path, for debugging */
621 char mPath[utils::MAX_PATH_LEN];
622 };
623
624 //-------------------Inlines--------------------------
625
open(OvFD & fd,uint32_t fbnum,const char * const dev,int flags)626 inline bool open(OvFD& fd, uint32_t fbnum, const char* const dev, int flags)
627 {
628 char dev_name[64] = {0};
629 snprintf(dev_name, sizeof(dev_name), dev, fbnum);
630 return fd.open(dev_name, flags);
631 }
632
OvFD()633 inline OvFD::OvFD() : mFD (INVAL) {
634 mPath[0] = 0;
635 }
636
~OvFD()637 inline OvFD::~OvFD() {
638 //no op since copy() can be used to share fd, in 3d cases.
639 }
640
open(const char * const dev,int flags)641 inline bool OvFD::open(const char* const dev, int flags)
642 {
643 mFD = ::open(dev, flags, 0);
644 if (mFD < 0) {
645 // FIXME errno, strerror in bionic?
646 ALOGE("Cant open device %s err=%d", dev, errno);
647 return false;
648 }
649 setPath(dev);
650 return true;
651 }
652
setPath(const char * const dev)653 inline void OvFD::setPath(const char* const dev)
654 {
655 ::strlcpy(mPath, dev, sizeof(mPath));
656 }
657
close()658 inline bool OvFD::close()
659 {
660 int ret = 0;
661 if(valid()) {
662 ret = ::close(mFD);
663 mFD = INVAL;
664 }
665 return (ret == 0);
666 }
667
valid()668 inline bool OvFD::valid() const
669 {
670 return (mFD != INVAL);
671 }
672
getFD()673 inline int OvFD::getFD() const { return mFD; }
674
copy(int fd)675 inline void OvFD::copy(int fd) {
676 mFD = fd;
677 }
678
dump()679 inline void OvFD::dump() const
680 {
681 ALOGE("== Dump OvFD fd=%d path=%s start/end ==",
682 mFD, mPath);
683 }
684
685 //--------------- class OvFD stuff ends ---------------------
686
687 } // overlay
688
689
690 #endif // OVERLAY_UTILS_H
691