libhwcutils/ExynosHWCUtils.cpp

   1 #include "ExynosHWCUtils.h"
   2 #include "ExynosHWCDebug.h"
   3
   4 int hwcDebug;
   5
   6 uint32_t hwcApiVersion(const hwc_composer_device_1_t* hwc) {
   7     uint32_t hwcVersion = hwc->common.version;
   8     return hwcVersion & HARDWARE_API_VERSION_2_MAJ_MIN_MASK;
   9 }
  10
  11 uint32_t hwcHeaderVersion(const hwc_composer_device_1_t* hwc) {
  12     uint32_t hwcVersion = hwc->common.version;
  13     return hwcVersion & HARDWARE_API_VERSION_2_HEADER_MASK;
  14 }
  15
  16 bool hwcHasApiVersion(const hwc_composer_device_1_t* hwc,
  17         uint32_t version) {
  18     return hwcApiVersion(hwc) >= (version & HARDWARE_API_VERSION_2_MAJ_MIN_MASK);
  19 }
  20 void dumpHandle(private_handle_t *h)
  21 {
  22     ALOGV("\t\tformat = %d, width = %u, height = %u, stride = %u, vstride = %u",
  23             h->format, h->width, h->height, h->stride, h->vstride);
  24 }
  25
  26 void dumpHandle(uint32_t type, private_handle_t *h)
  27 {
  28     HDEBUGLOGD(type, "\t\tformat = %d, width = %u, height = %u, stride = %u, vstride = %u",
  29             h->format, h->width, h->height, h->stride, h->vstride);
  30 }
  31
  32 void dumpLayer(hwc_layer_1_t const *l)
  33 {
  34     ALOGV("\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, "
  35             "{%7.1f,%7.1f,%7.1f,%7.1f}, {%d,%d,%d,%d}",
  36             l->compositionType, l->flags, l->handle, l->transform,
  37             l->blending,
  38             l->sourceCropf.left,
  39             l->sourceCropf.top,
  40             l->sourceCropf.right,
  41             l->sourceCropf.bottom,
  42             l->displayFrame.left,
  43             l->displayFrame.top,
  44             l->displayFrame.right,
  45             l->displayFrame.bottom);
  46
  47     if(l->handle && !(l->flags & HWC_SKIP_LAYER))
  48         dumpHandle(private_handle_t::dynamicCast(l->handle));
  49 }
  50
  51 void dumpLayer(uint32_t type, hwc_layer_1_t const *l)
  52 {
  53     HDEBUGLOGD(type, "\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, "
  54             "{%7.1f,%7.1f,%7.1f,%7.1f}, {%d,%d,%d,%d}",
  55             l->compositionType, l->flags, l->handle, l->transform,
  56             l->blending,
  57             l->sourceCropf.left,
  58             l->sourceCropf.top,
  59             l->sourceCropf.right,
  60             l->sourceCropf.bottom,
  61             l->displayFrame.left,
  62             l->displayFrame.top,
  63             l->displayFrame.right,
  64             l->displayFrame.bottom);
  65
  66     if(l->handle && !(l->flags & HWC_SKIP_LAYER))
  67         dumpHandle(type, private_handle_t::dynamicCast(l->handle));
  68 }
  69
  70 void dumpMPPImage(exynos_mpp_img &c)
  71 {
  72     ALOGV("\tx = %u, y = %u, w = %u, h = %u, fw = %u, fh = %u",
  73             c.x, c.y, c.w, c.h, c.fw, c.fh);
  74     ALOGV("\tf = %u", c.format);
  75     ALOGV("\taddr = {%lu, %lu, %lu}, rot = %u, cacheable = %u, drmMode = %u",
  76             c.yaddr, c.uaddr, c.vaddr, c.rot, c.cacheable, c.drmMode);
  77     ALOGV("\tnarrowRgb = %u, acquireFenceFd = %d, releaseFenceFd = %d, mem_type = %u",
  78             c.narrowRgb, c.acquireFenceFd, c.releaseFenceFd, c.mem_type);
  79 }
  80
  81 void dumpMPPImage(uint32_t type, exynos_mpp_img &c)
  82 {
  83     HDEBUGLOGD(type, "\tx = %u, y = %u, w = %u, h = %u, fw = %u, fh = %u",
  84             c.x, c.y, c.w, c.h, c.fw, c.fh);
  85     HDEBUGLOGD(type, "\tf = %u", c.format);
  86     HDEBUGLOGD(type, "\taddr = {%lu, %lu, %lu}, rot = %u, cacheable = %u, drmMode = %u",
  87             c.yaddr, c.uaddr, c.vaddr, c.rot, c.cacheable, c.drmMode);
  88     HDEBUGLOGD(type, "\tnarrowRgb = %u, acquireFenceFd = %d, releaseFenceFd = %d, mem_type = %u",
  89             c.narrowRgb, c.acquireFenceFd, c.releaseFenceFd, c.mem_type);
  90 }
  91
  92 #ifndef USES_FIMC
  93 void dumpBlendMPPImage(struct SrcBlendInfo &c)
  94 {
  95     ALOGV("\tblop = %d, srcblendfmt = %u, srcblendpremulti = %u\n",
  96         c.blop, c.srcblendfmt, c.srcblendpremulti);
  97     ALOGV("\tx = %u, y = %u, w = %u, h = %u, fw = %u\n",
  98         c.srcblendhpos, c.srcblendvpos, c.srcblendwidth,
  99         c.srcblendheight, c.srcblendstride);
 100     ALOGV("\tglobalalpha = %d, tglobalalpha.val = %u, cscspec = %d, cscspec.space = %u, cscspec.wide = %u\n",
 101         c.globalalpha.enable, c.globalalpha.val, c.cscspec.enable,
 102         c.cscspec.space, c.cscspec.wide);
 103 }
 104 void dumpBlendMPPImage(uint32_t type, struct SrcBlendInfo &c)
 105 {
 106     HDEBUGLOGD(type, "\tblop = %d, srcblendfmt = %u, srcblendpremulti = %u\n",
 107         c.blop, c.srcblendfmt, c.srcblendpremulti);
 108     HDEBUGLOGD(type, "\tx = %u, y = %u, w = %u, h = %u, fw = %u\n",
 109         c.srcblendhpos, c.srcblendvpos, c.srcblendwidth,
 110         c.srcblendheight, c.srcblendstride);
 111     HDEBUGLOGD(type, "\tglobalalpha = %d, tglobalalpha.val = %u, cscspec = %d, cscspec.space = %u, cscspec.wide = %u\n",
 112         c.globalalpha.enable, c.globalalpha.val, c.cscspec.enable,
 113         c.cscspec.space, c.cscspec.wide);
 114 }
 115 #endif
 116
 117 bool isDstCropWidthAligned(int dest_w)
 118 {
 119     int dst_crop_w_alignement;
 120
 121    /* GSC's dst crop size should be aligned 128Bytes */
 122     dst_crop_w_alignement = GSC_DST_CROP_W_ALIGNMENT_RGB888;
 123
 124     return (dest_w % dst_crop_w_alignement) == 0;
 125 }
 126
 127 bool isTransformed(const hwc_layer_1_t &layer)
 128 {
 129     return layer.transform != 0;
 130 }
 131
 132 bool isRotated(const hwc_layer_1_t &layer)
 133 {
 134     return (layer.transform & HAL_TRANSFORM_ROT_90) ||
 135             (layer.transform & HAL_TRANSFORM_ROT_180);
 136 }
 137
 138 bool isScaled(const hwc_layer_1_t &layer)
 139 {
 140     return WIDTH(layer.displayFrame) != WIDTH(layer.sourceCropf) ||
 141             HEIGHT(layer.displayFrame) != HEIGHT(layer.sourceCropf);
 142 }
 143
 144 bool isFormatRgb(int format)
 145 {
 146     switch (format) {
 147     case HAL_PIXEL_FORMAT_RGBA_8888:
 148     case HAL_PIXEL_FORMAT_RGBX_8888:
 149     case HAL_PIXEL_FORMAT_RGB_888:
 150     case HAL_PIXEL_FORMAT_RGB_565:
 151     case HAL_PIXEL_FORMAT_BGRA_8888:
 152 #ifdef EXYNOS_SUPPORT_BGRX_8888
 153     case HAL_PIXEL_FORMAT_BGRX_8888:
 154 #endif
 155         return true;
 156
 157     default:
 158         return false;
 159     }
 160 }
 161
 162 bool isFormatYUV420(int format)
 163 {
 164     switch (format) {
 165     case HAL_PIXEL_FORMAT_EXYNOS_YV12_M:
 166     case HAL_PIXEL_FORMAT_YV12:
 167     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_P_M:
 168     case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M:
 169     case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL:
 170     case HAL_PIXEL_FORMAT_YCrCb_420_SP:
 171     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M:
 172     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_PRIV:
 173     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_TILED:
 174     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_PN:
 175     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN:
 176     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN_TILED:
 177     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_S10B:
 178     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN_S10B:
 179         return true;
 180     default:
 181         return false;
 182     }
 183 }
 184
 185 bool isFormatYUV422(int __unused format)
 186 {
 187     // Might add support later
 188     return false;
 189 }
 190
 191 bool isFormatYCrCb(int format)
 192 {
 193     return format == HAL_PIXEL_FORMAT_EXYNOS_YV12_M;
 194 }
 195
 196 uint8_t formatToBpp(int format)
 197 {
 198     switch (format) {
 199     case HAL_PIXEL_FORMAT_RGBA_8888:
 200     case HAL_PIXEL_FORMAT_RGBX_8888:
 201     case HAL_PIXEL_FORMAT_BGRA_8888:
 202 #ifdef EXYNOS_SUPPORT_BGRX_8888
 203     case HAL_PIXEL_FORMAT_BGRX_8888:
 204 #endif
 205         return 32;
 206     case HAL_PIXEL_FORMAT_RGB_565:
 207         return 16;
 208     case HAL_PIXEL_FORMAT_EXYNOS_YV12_M:
 209     case HAL_PIXEL_FORMAT_YV12:
 210     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_P_M:
 211     case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M:
 212     case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL:
 213     case HAL_PIXEL_FORMAT_YCrCb_420_SP:
 214     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M:
 215     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_PRIV:
 216     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_TILED:
 217     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_PN:
 218     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN:
 219     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN_TILED:
 220     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M_S10B:
 221     case HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SPN_S10B:
 222         return 12;
 223     default:
 224         ALOGW("unrecognized pixel format %u", format);
 225         return 0;
 226     }
 227 }
 228
 229 int getDrmMode(int flags)
 230 {
 231     if (flags & GRALLOC_USAGE_PROTECTED) {
 232         if (flags & GRALLOC_USAGE_PRIVATE_NONSECURE)
 233             return NORMAL_DRM;
 234         else
 235             return SECURE_DRM;
 236     } else {
 237         return NO_DRM;
 238     }
 239 }
 240
 241 int halFormatToV4L2Format(int format)
 242 {
 243 #ifdef EXYNOS_SUPPORT_BGRX_8888
 244     if (format == HAL_PIXEL_FORMAT_BGRX_8888)
 245         return HAL_PIXEL_FORMAT_2_V4L2_PIX(HAL_PIXEL_FORMAT_RGBX_8888);
 246     else
 247 #endif
 248         return HAL_PIXEL_FORMAT_2_V4L2_PIX(format);
 249 }
 250
 251 bool isOffscreen(hwc_layer_1_t &layer, int xres, int yres)
 252 {
 253     return layer.displayFrame.left < 0 ||
 254         layer.displayFrame.top < 0 ||
 255         layer.displayFrame.right > xres ||
 256         layer.displayFrame.bottom > yres;
 257 }
 258
 259 bool isSrcCropFloat(hwc_frect &frect)
 260 {
 261     return (frect.left != (int)frect.left) ||
 262         (frect.top != (int)frect.top) ||
 263         (frect.right != (int)frect.right) ||
 264         (frect.bottom != (int)frect.bottom);
 265 }
 266
 267 bool isFloat(float f)
 268 {
 269     return (f != floorf(f));
 270 }
 271
 272 bool isUHD(const hwc_layer_1_t &layer)
 273 {
 274     return (WIDTH(layer.sourceCropf) >= UHD_WIDTH &&
 275             HEIGHT(layer.sourceCropf) >= UHD_HEIGHT);
 276 }
 277
 278 bool isFullRangeColor(const hwc_layer_1_t &layer)
 279 {
 280     private_handle_t *handle = private_handle_t::dynamicCast(layer.handle);
 281     return (handle->format == HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL);
 282 }
 283
 284 bool isCompressed(const hwc_layer_1_t &layer)
 285 {
 286     if (layer.handle) {
 287         private_handle_t *handle = private_handle_t::dynamicCast(layer.handle);
 288         if (handle->internal_format & ((uint64_t)(1) << 32))
 289             return true;
 290     }
 291     return false;
 292 }
 293
 294 bool compareYuvLayerConfig(int videoLayers, uint32_t index,
 295         hwc_layer_1_t &layer,
 296         video_layer_config *pre_src_data, video_layer_config *pre_dst_data)
 297 {
 298     private_handle_t *src_handle = private_handle_t::dynamicCast(layer.handle);
 299     bool reconfigure = 1;
 300
 301     video_layer_config new_src_cfg, new_dst_cfg;
 302     memset(&new_src_cfg, 0, sizeof(new_src_cfg));
 303     memset(&new_dst_cfg, 0, sizeof(new_dst_cfg));
 304
 305     new_src_cfg.x = (int)layer.sourceCropf.left;
 306     new_src_cfg.y = (int)layer.sourceCropf.top;
 307     new_src_cfg.w = WIDTH(layer.sourceCropf);
 308     new_src_cfg.fw = src_handle->stride;
 309     new_src_cfg.h = HEIGHT(layer.sourceCropf);
 310     new_src_cfg.fh = src_handle->vstride;
 311     new_src_cfg.format = src_handle->format;
 312     new_src_cfg.drmMode = !!(getDrmMode(src_handle->flags) == SECURE_DRM);
 313     new_src_cfg.index = index;
 314
 315     new_dst_cfg.x = layer.displayFrame.left;
 316     new_dst_cfg.y = layer.displayFrame.top;
 317     new_dst_cfg.w = WIDTH(layer.displayFrame);
 318     new_dst_cfg.h = HEIGHT(layer.displayFrame);
 319     new_dst_cfg.rot = layer.transform;
 320     new_dst_cfg.drmMode = new_src_cfg.drmMode;
 321
 322     /* check to save previous yuv layer configration */
 323     if (pre_src_data && pre_dst_data) {
 324          reconfigure = yuvConfigChanged(new_src_cfg, pre_src_data[videoLayers]) ||
 325             yuvConfigChanged(new_dst_cfg, pre_dst_data[videoLayers]);
 326     } else {
 327         ALOGE("Invalid parameter");
 328         return reconfigure;
 329     }
 330
 331     memcpy(&pre_src_data[videoLayers], &new_src_cfg, sizeof(new_src_cfg));
 332     memcpy(&pre_dst_data[videoLayers], &new_dst_cfg, sizeof(new_dst_cfg));
 333
 334     return reconfigure;
 335
 336 }
 337
 338 size_t getRequiredPixels(hwc_layer_1_t &layer, int xres, int yres)
 339 {
 340     uint32_t w = WIDTH(layer.displayFrame);
 341     uint32_t h = HEIGHT(layer.displayFrame);
 342     if (layer.displayFrame.left < 0) {
 343         unsigned int crop = -layer.displayFrame.left;
 344         w -= crop;
 345     }
 346
 347     if (layer.displayFrame.right > xres) {
 348         unsigned int crop = layer.displayFrame.right - xres;
 349         w -= crop;
 350     }
 351
 352     if (layer.displayFrame.top < 0) {
 353         unsigned int crop = -layer.displayFrame.top;
 354         h -= crop;
 355     }
 356
 357     if (layer.displayFrame.bottom > yres) {
 358         int crop = layer.displayFrame.bottom - yres;
 359         h -= crop;
 360     }
 361     return w*h;
 362 }
 363
 364 /* OFF_Screen to ON_Screen changes */
 365 void recalculateDisplayFrame(hwc_layer_1_t &layer, int xres, int yres)
 366 {
 367     uint32_t x, y;
 368     uint32_t w = WIDTH(layer.displayFrame);
 369     uint32_t h = HEIGHT(layer.displayFrame);
 370
 371     if (layer.displayFrame.left < 0) {
 372         unsigned int crop = -layer.displayFrame.left;
 373         ALOGV("layer off left side of screen; cropping %u pixels from left edge",
 374                 crop);
 375         HDEBUGLOGD(eDebugDefault, "layer off left side of screen; cropping %u pixels from left edge",
 376                 crop);
 377         x = 0;
 378         w -= crop;
 379     } else {
 380         x = layer.displayFrame.left;
 381     }
 382
 383     if (layer.displayFrame.right > xres) {
 384         unsigned int crop = layer.displayFrame.right - xres;
 385         ALOGV("layer off right side of screen; cropping %u pixels from right edge",
 386                 crop);
 387         HDEBUGLOGD(eDebugDefault, "layer off right side of screen; cropping %u pixels from right edge",
 388                 crop);
 389         w -= crop;
 390     }
 391
 392     if (layer.displayFrame.top < 0) {
 393         unsigned int crop = -layer.displayFrame.top;
 394         ALOGV("layer off top side of screen; cropping %u pixels from top edge",
 395                 crop);
 396         HDEBUGLOGD(eDebugDefault, "layer off top side of screen; cropping %u pixels from top edge",
 397                 crop);
 398         y = 0;
 399         h -= crop;
 400     } else {
 401         y = layer.displayFrame.top;
 402     }
 403
 404     if (layer.displayFrame.bottom > yres) {
 405         int crop = layer.displayFrame.bottom - yres;
 406         ALOGV("layer off bottom side of screen; cropping %u pixels from bottom edge",
 407                 crop);
 408         HDEBUGLOGD(eDebugDefault, "layer off bottom side of screen; cropping %u pixels from bottom edge",
 409                 crop);
 410         h -= crop;
 411     }
 412
 413     layer.displayFrame.left = x;
 414     layer.displayFrame.top = y;
 415     layer.displayFrame.right = w + x;
 416     layer.displayFrame.bottom = h + y;
 417 }
 418
 419 int getS3DFormat(int preset)
 420 {
 421     switch (preset) {
 422 #ifndef HDMI_INCAPABLE
 423     case V4L2_DV_720P60_SB_HALF:
 424     case V4L2_DV_720P50_SB_HALF:
 425     case V4L2_DV_1080P60_SB_HALF:
 426     case V4L2_DV_1080P30_SB_HALF:
 427         return S3D_SBS;
 428     case V4L2_DV_720P60_TB:
 429     case V4L2_DV_720P50_TB:
 430     case V4L2_DV_1080P60_TB:
 431     case V4L2_DV_1080P30_TB:
 432         return S3D_TB;
 433 #endif
 434     default:
 435         return S3D_ERROR;
 436     }
 437 }
 438
 439 void adjustRect(hwc_rect_t &rect, int32_t width, int32_t height)
 440 {
 441     if (rect.left < 0)
 442         rect.left = 0;
 443     if (rect.left > width)
 444         rect.left = width;
 445     if (rect.top < 0)
 446         rect.top = 0;
 447     if (rect.top > height)
 448         rect.top = height;
 449     if (rect.right < rect.left)
 450         rect.right = rect.left;
 451     if (rect.right > width)
 452         rect.right = width;
 453     if (rect.bottom < rect.top)
 454         rect.bottom = rect.top;
 455     if (rect.bottom > height)
 456         rect.bottom = height;
 457 }