diff --git a/gralloc/Android.mk b/gralloc/Android.mk
index 9ad44e5..ee37c1f 100644
--- a/gralloc/Android.mk
+++ b/gralloc/Android.mk
@@ -49,6 +49,9 @@
 LOCAL_SHARED_LIBRARIES        := $(common_libs) libqdMetaData libdl libgrallocutils libion \
                                   android.hardware.graphics.mapper@2.1
 LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdgralloc\" -Wno-sign-conversion
+ifeq ($(ENABLE_HYP),true)
+LOCAL_CFLAGS += -DHYPERVISOR
+endif
 LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
 LOCAL_SRC_FILES               := gr_allocator.cpp gr_buf_mgr.cpp gr_ion_alloc.cpp
 include $(BUILD_SHARED_LIBRARY)
diff --git a/gralloc/QtiMapperExtensions.cpp b/gralloc/QtiMapperExtensions.cpp
index 56b747b..33cd23d 100644
--- a/gralloc/QtiMapperExtensions.cpp
+++ b/gralloc/QtiMapperExtensions.cpp
@@ -342,11 +342,53 @@
 Return<void> QtiMapperExtensions::getFormatLayout(int32_t format, uint64_t usage, int32_t flags,
                                                   int32_t width, int32_t height,
                                                   getFormatLayout_cb hidl_cb) {
-  ALOGD_IF(DEBUG, "%s: Input parameters - wxh: %dx%d usage: 0x%" PRIu64 " format: %d flags: %d",
-           __FUNCTION__, width, height, usage, format, flags);
+  ALOGD_IF(DEBUG, "%s: Input parameters - wxh: %dx%d usage: 0x%" PRIu64 " format: %d", __FUNCTION__,
+           width, height, usage, format);
   auto err = Error::NONE;
   hidl_vec<PlaneLayout> plane_info;
+  unsigned int alignedw = 0, alignedh = 0;
+  int plane_count = 0;
   uint64_t size = 0;
+  int custom_format = gralloc::GetImplDefinedFormat(usage, format);
+  BufferInfo info(width, height, custom_format, usage);
+  gralloc::GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
+  size = gralloc::GetSize(info, alignedw, alignedh);
+  gralloc::PlaneLayoutInfo plane_layout[8] = {};
+  ALOGD_IF(DEBUG, "%s: Aligned width and height - wxh: %ux%u custom_format = %d", __FUNCTION__,
+           alignedw, alignedh, custom_format);
+  if (gralloc::IsYuvFormat(custom_format)) {
+    gralloc::GetYUVPlaneInfo(info, custom_format, alignedw, alignedh, flags, &plane_count,
+                             plane_layout);
+  } else if (gralloc::IsUncompressedRGBFormat(custom_format) ||
+             gralloc::IsCompressedRGBFormat(custom_format)) {
+    gralloc::GetRGBPlaneInfo(info, custom_format, alignedw, alignedh, flags, &plane_count,
+                             plane_layout);
+  } else {
+    err = Error::BAD_BUFFER;
+    hidl_cb(err, size, plane_info);
+    return Void();
+  }
+  ALOGD_IF(DEBUG, "%s: Number of plane - %d, custom_format - %d", __FUNCTION__, plane_count,
+           custom_format);
+  plane_info.resize(plane_count);
+  for (int i = 0; i < plane_count; i++) {
+    plane_info[i].component = plane_layout[i].component;
+    plane_info[i].h_subsampling = plane_layout[i].h_subsampling;
+    plane_info[i].v_subsampling = plane_layout[i].v_subsampling;
+    plane_info[i].offset = plane_layout[i].offset;
+    plane_info[i].pixel_increment = plane_layout[i].step;
+    plane_info[i].stride = plane_layout[i].stride;
+    plane_info[i].stride_bytes = plane_layout[i].stride_bytes;
+    plane_info[i].scanlines = plane_layout[i].scanlines;
+    plane_info[i].size = plane_layout[i].size;
+    ALOGD_IF(DEBUG, "%s: plane info: component - %d", __FUNCTION__, plane_info[i].component);
+    ALOGD_IF(DEBUG, "h_subsampling - %u, v_subsampling - %u, offset - %u, pixel_increment - %d",
+             plane_info[i].h_subsampling, plane_info[i].v_subsampling, plane_info[i].offset,
+             plane_info[i].pixel_increment);
+    ALOGD_IF(DEBUG, "stride_pixel - %d, stride_bytes - %d, scanlines - %d, size - %u",
+             plane_info[i].stride, plane_info[i].stride_bytes, plane_info[i].scanlines,
+             plane_info[i].size);
+  }
   hidl_cb(err, size, plane_info);
   return Void();
 }
diff --git a/gralloc/gr_allocator.cpp b/gralloc/gr_allocator.cpp
index fc53168..6421157 100644
--- a/gralloc/gr_allocator.cpp
+++ b/gralloc/gr_allocator.cpp
@@ -66,7 +66,11 @@
 #define ION_SC_FLAGS ION_SECURE
 #define ION_SC_PREVIEW_FLAGS ION_SECURE
 #else  // MASTER_SIDE_CP
+#ifdef HYPERVISOR
+#define CP_HEAP_ID ION_SECURE_DISPLAY_HEAP_ID
+#else
 #define CP_HEAP_ID ION_SECURE_HEAP_ID
+#endif
 #define SD_HEAP_ID ION_SECURE_DISPLAY_HEAP_ID
 #define ION_CP_FLAGS (ION_SECURE | ION_FLAG_CP_PIXEL)
 #define ION_SD_FLAGS (ION_SECURE | ION_FLAG_CP_SEC_DISPLAY)
diff --git a/gralloc/gr_utils.cpp b/gralloc/gr_utils.cpp
index 656ddec..6eb414e 100644
--- a/gralloc/gr_utils.cpp
+++ b/gralloc/gr_utils.cpp
@@ -360,14 +360,16 @@
   return 0;
 }
 
-void GetYuvUbwcSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, int color_format,
-                           struct android_ycbcr *ycbcr) {
+void GetYuvUbwcSPPlaneInfo(uint32_t width, uint32_t height, int color_format,
+                           PlaneLayoutInfo *plane_info) {
   // UBWC buffer has these 4 planes in the following sequence:
-  // Y_Meta_Plane, Y_Plane, UV_Meta_Plane, UV_Plane
+  // Y_Plane, UV_Plane, Y_Meta_Plane, UV_Meta_Plane
   unsigned int y_meta_stride, y_meta_height, y_meta_size;
   unsigned int y_stride, y_height, y_size;
   unsigned int c_meta_stride, c_meta_height, c_meta_size;
   unsigned int alignment = 4096;
+  unsigned int c_stride, c_height, c_size;
+  uint64_t yOffset, cOffset, yMetaOffset, cMetaOffset;
 
   y_meta_stride = VENUS_Y_META_STRIDE(color_format, INT(width));
   y_meta_height = VENUS_Y_META_SCANLINES(color_format, INT(height));
@@ -381,47 +383,148 @@
   c_meta_height = VENUS_UV_META_SCANLINES(color_format, INT(height));
   c_meta_size = ALIGN((c_meta_stride * c_meta_height), alignment);
 
-  ycbcr->y = reinterpret_cast<void *>(base + y_meta_size);
-  ycbcr->cb = reinterpret_cast<void *>(base + y_meta_size + y_size + c_meta_size);
-  ycbcr->cr = reinterpret_cast<void *>(base + y_meta_size + y_size + c_meta_size + 1);
-  ycbcr->ystride = y_stride;
-  ycbcr->cstride = VENUS_UV_STRIDE(color_format, INT(width));
+  c_stride = VENUS_UV_STRIDE(color_format, INT(width));
+  c_height = VENUS_UV_SCANLINES(color_format, INT(height));
+  c_size = ALIGN((c_stride * c_height), alignment);
+
+  yMetaOffset = 0;
+  yOffset = y_meta_size;
+  cMetaOffset = y_meta_size + y_size;
+  cOffset = y_meta_size + y_size + c_meta_size;
+
+  plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
+  plane_info[0].offset = (uint32_t)yOffset;
+  plane_info[0].stride = static_cast<int32_t>(UINT(width));
+  plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
+  plane_info[0].scanlines = static_cast<int32_t>(y_height);
+  plane_info[0].size = static_cast<uint32_t>(y_size);
+
+  plane_info[1].component = (PlaneComponent)(PLANE_COMPONENT_Cb | PLANE_COMPONENT_Cr);
+  plane_info[1].offset = (uint32_t)cOffset;
+  plane_info[1].stride = static_cast<int32_t>(UINT(width));
+  plane_info[1].stride_bytes = static_cast<int32_t>(c_stride);
+  plane_info[1].scanlines = static_cast<int32_t>(c_height);
+  plane_info[1].size = static_cast<uint32_t>(c_size);
+
+  plane_info[2].component = (PlaneComponent)(PLANE_COMPONENT_META | PLANE_COMPONENT_Y);
+  plane_info[2].offset = (uint32_t)yMetaOffset;
+  plane_info[2].stride = static_cast<int32_t>(UINT(width));
+  plane_info[2].stride_bytes = static_cast<int32_t>(y_meta_stride);
+  plane_info[2].scanlines = static_cast<int32_t>(y_meta_height);
+  plane_info[2].size = static_cast<uint32_t>(y_meta_size);
+
+  plane_info[3].component =
+      (PlaneComponent)(PLANE_COMPONENT_META | PLANE_COMPONENT_Cb | PLANE_COMPONENT_Cr);
+  plane_info[3].offset = (uint32_t)cMetaOffset;
+  plane_info[3].stride = static_cast<int32_t>(UINT(width));
+  plane_info[3].stride_bytes = static_cast<int32_t>(c_meta_stride);
+  plane_info[3].scanlines = static_cast<int32_t>(c_meta_height);
+  plane_info[3].size = static_cast<uint32_t>(c_meta_size);
 }
 
-void GetYuvUbwcInterlacedSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height,
-                                     int color_format, struct android_ycbcr ycbcr[2]) {
-  unsigned int uv_stride, uv_height, uv_size;
-  unsigned int alignment = 4096;
-  uint64_t field_base;
-
+// This API gets information about 8 planes (Y_Plane, UV_Plane, Y_Meta_Plane, UV_Meta_Plane,
+// Y_Plane, UV_Plane, Y_Meta_Plane, UV_Meta_Plane) and it stores the
+// information in PlaneLayoutInfo array.
+void GetYuvUbwcInterlacedSPPlaneInfo(uint32_t width, uint32_t height,
+                                     PlaneLayoutInfo plane_info[8]) {
   // UBWC interlaced has top-bottom field layout with each field as
-  // 4-plane NV12_UBWC with width = image_width & height = image_height / 2.
-  // Client passed ycbcr argument is ptr to struct android_ycbcr[2].
+  // 8-plane (including meta plane also) NV12_UBWC with width = image_width
+  // & height = image_height / 2.
+  // Client passed plane_info argument is ptr to struct PlaneLayoutInfo[8].
   // Plane info to be filled for each field separately.
   height = (height + 1) >> 1;
-  uv_stride = VENUS_UV_STRIDE(color_format, INT(width));
-  uv_height = VENUS_UV_SCANLINES(color_format, INT(height));
-  uv_size = ALIGN((uv_stride * uv_height), alignment);
 
-  field_base = base;
-  GetYuvUbwcSPPlaneInfo(field_base, width, height, COLOR_FMT_NV12_UBWC, &ycbcr[0]);
+  GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_NV12_UBWC, &plane_info[0]);
 
-  memset(ycbcr[1].reserved, 0, sizeof(ycbcr[1].reserved));
-  field_base = reinterpret_cast<uint64_t>(ycbcr[0].cb) + uv_size;
-  GetYuvUbwcSPPlaneInfo(field_base, width, height, COLOR_FMT_NV12_UBWC, &ycbcr[1]);
+  GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_NV12_UBWC, &plane_info[4]);
 }
 
-void GetYuvSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, uint32_t bpp,
-                       struct android_ycbcr *ycbcr) {
-  unsigned int ystride, cstride;
+// This API gets information about 2 planes (Y_Plane & UV_Plane)
+void GetYuvSPPlaneInfo(const BufferInfo &info, int format, uint32_t width, uint32_t height,
+                       uint32_t bpp, PlaneLayoutInfo *plane_info) {
+  int unaligned_width = info.width;
+  int unaligned_height = info.height;
+  unsigned int y_stride = 0, y_height = 0, y_size = 0;
+  unsigned int c_stride = 0, c_height = 0, c_size = 0;
+  uint64_t yOffset, cOffset;
 
-  ystride = cstride = UINT(width) * bpp;
-  ycbcr->y = reinterpret_cast<void *>(base);
-  ycbcr->cb = reinterpret_cast<void *>(base + ystride * UINT(height));
-  ycbcr->cr = reinterpret_cast<void *>(base + ystride * UINT(height) + 1);
-  ycbcr->ystride = ystride;
-  ycbcr->cstride = cstride;
-  ycbcr->chroma_step = 2 * bpp;
+  y_stride = c_stride = UINT(width) * bpp;
+  y_height = INT(height);
+  y_size = y_stride * y_height;
+  switch (format) {
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+      c_size = (width * height) / 2 + 1;
+      c_height = height >> 1;
+      break;
+    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+    case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+      if (unaligned_width & 1) {
+        ALOGE("width is odd for the YUV422_SP format");
+        return;
+      }
+      c_size = width * height;
+      c_height = height;
+      break;
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
+    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
+      c_height = VENUS_UV_SCANLINES(COLOR_FMT_NV12, height);
+      c_size = c_stride * c_height;
+      break;
+    case HAL_PIXEL_FORMAT_NV12_HEIF:
+      c_height = VENUS_UV_SCANLINES(COLOR_FMT_NV12_512, height);
+      c_size = c_stride * c_height;
+      break;
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
+      y_size = ALIGN(width * height, 4096);
+      c_size = ALIGN(2 * ALIGN(unaligned_width / 2, 32) * ALIGN(unaligned_height / 2, 32), 4096);
+      break;
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
+      c_height = VENUS_UV_SCANLINES(COLOR_FMT_NV21, height);
+      c_size = c_stride * c_height;
+      break;
+    case HAL_PIXEL_FORMAT_NV21_ZSL:
+      c_size = (width * height) / 2;
+      c_height = height >> 1;
+      break;
+    case HAL_PIXEL_FORMAT_RAW16:
+    case HAL_PIXEL_FORMAT_Y16:
+      c_size = width * height;
+      c_height = height;
+      break;
+    case HAL_PIXEL_FORMAT_RAW10:
+      c_size = 0;
+      break;
+    case HAL_PIXEL_FORMAT_RAW8:
+    case HAL_PIXEL_FORMAT_Y8:
+      c_size = 0;
+      break;
+    case HAL_PIXEL_FORMAT_YCbCr_420_P010:
+      c_size = (width * height) + 1;
+      c_height = height;
+      break;
+    default:
+      break;
+  }
+
+  yOffset = 0;
+  cOffset = y_size;
+
+  plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
+  plane_info[0].offset = (uint32_t)yOffset;
+  plane_info[0].step = 1;
+  plane_info[0].stride = static_cast<int32_t>(UINT(width));
+  plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
+  plane_info[0].scanlines = static_cast<int32_t>(y_height);
+  plane_info[0].size = static_cast<uint32_t>(y_size);
+
+  plane_info[1].component = (PlaneComponent)(PLANE_COMPONENT_Cb | PLANE_COMPONENT_Cr);
+  plane_info[1].offset = (uint32_t)cOffset;
+  plane_info[1].step = 2 * bpp;
+  plane_info[1].stride = static_cast<int32_t>(UINT(width));
+  plane_info[1].stride_bytes = static_cast<int32_t>(c_stride);
+  plane_info[1].scanlines = static_cast<int32_t>(c_height);
+  plane_info[1].size = static_cast<uint32_t>(c_size);
 }
 
 int GetYUVPlaneInfo(const private_handle_t *hnd, struct android_ycbcr ycbcr[2]) {
@@ -430,8 +533,11 @@
   uint32_t height = UINT(hnd->height);
   int format = hnd->format;
   uint64_t usage = hnd->usage;
-  unsigned int ystride, cstride;
-  bool interlaced = false;
+  int32_t interlaced = 0;
+  int plane_count = 0;
+  int unaligned_width = INT(hnd->unaligned_width);
+  int unaligned_height = INT(hnd->unaligned_height);
+  BufferInfo info(unaligned_width, unaligned_height, format, usage);
 
   memset(ycbcr->reserved, 0, sizeof(ycbcr->reserved));
 
@@ -452,102 +558,45 @@
   int interlace_flag = 0;
   if (getMetaData(const_cast<private_handle_t *>(hnd), GET_PP_PARAM_INTERLACED, &interlace_flag) ==
       0) {
-    interlaced = interlace_flag;
+    if (interlace_flag) {
+      interlaced = LAYOUT_INTERLACED_FLAG;
+    }
   }
 
+  PlaneLayoutInfo plane_info[8] = {};
   // Get the chroma offsets from the handle width/height. We take advantage
   // of the fact the width _is_ the stride
-  switch (format) {
-    // Semiplanar
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
-    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-    case HAL_PIXEL_FORMAT_NV12_HEIF:
-      // Same as YCbCr_420_SP_VENUS
-      GetYuvSPPlaneInfo(hnd->base, width, height, 1, ycbcr);
-      break;
-
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
-      if (!interlaced) {
-        GetYuvUbwcSPPlaneInfo(hnd->base, width, height, COLOR_FMT_NV12_UBWC, ycbcr);
-      } else {
-        GetYuvUbwcInterlacedSPPlaneInfo(hnd->base, width, height, COLOR_FMT_NV12_UBWC, ycbcr);
+  err = GetYUVPlaneInfo(info, format, width, height, interlaced, &plane_count, plane_info);
+  if (err == 0) {
+    if (interlaced && format == HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC) {
+      CopyPlaneLayoutInfotoAndroidYcbcr(hnd->base, plane_count, &plane_info[0], &ycbcr[0]);
+      unsigned int uv_stride, uv_height, uv_size;
+      unsigned int alignment = 4096;
+      uint64_t field_base;
+      height = (height + 1) >> 1;
+      uv_stride = VENUS_UV_STRIDE(COLOR_FMT_NV12_UBWC, INT(width));
+      uv_height = VENUS_UV_SCANLINES(COLOR_FMT_NV12_UBWC, INT(height));
+      uv_size = ALIGN((uv_stride * uv_height), alignment);
+      field_base = hnd->base + plane_info[1].offset + uv_size;
+      memset(ycbcr[1].reserved, 0, sizeof(ycbcr[1].reserved));
+      CopyPlaneLayoutInfotoAndroidYcbcr(field_base, plane_count, &plane_info[4], &ycbcr[1]);
+    } else {
+      CopyPlaneLayoutInfotoAndroidYcbcr(hnd->base, plane_count, plane_info, ycbcr);
+      switch (format) {
+        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+        case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+        case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
+        case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
+        case HAL_PIXEL_FORMAT_NV21_ZSL:
+        case HAL_PIXEL_FORMAT_RAW16:
+        case HAL_PIXEL_FORMAT_Y16:
+        case HAL_PIXEL_FORMAT_RAW10:
+        case HAL_PIXEL_FORMAT_RAW8:
+        case HAL_PIXEL_FORMAT_Y8:
+          std::swap(ycbcr->cb, ycbcr->cr);
       }
-      ycbcr->chroma_step = 2;
-      break;
-
-    case HAL_PIXEL_FORMAT_YCbCr_420_P010:
-      GetYuvSPPlaneInfo(hnd->base, width, height, 2, ycbcr);
-      break;
-
-    case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
-      GetYuvUbwcSPPlaneInfo(hnd->base, width, height, COLOR_FMT_NV12_BPP10_UBWC, ycbcr);
-      ycbcr->chroma_step = 3;
-      break;
-
-    case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
-      GetYuvUbwcSPPlaneInfo(hnd->base, width, height, COLOR_FMT_P010_UBWC, ycbcr);
-      ycbcr->chroma_step = 4;
-      break;
-
-    case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
-      ystride = VENUS_Y_STRIDE(COLOR_FMT_P010, width);
-      cstride = VENUS_UV_STRIDE(COLOR_FMT_P010, width);
-      ycbcr->y = reinterpret_cast<void *>(hnd->base);
-      ycbcr->cb =
-          reinterpret_cast<void *>(hnd->base + ystride * VENUS_Y_SCANLINES(COLOR_FMT_P010, height));
-      ycbcr->cr = reinterpret_cast<void *>(hnd->base +
-                                           ystride * VENUS_Y_SCANLINES(COLOR_FMT_P010, height) + 1);
-      ycbcr->ystride = ystride;
-      ycbcr->cstride = cstride;
-      ycbcr->chroma_step = 4;
-      break;
-
-    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
-    case HAL_PIXEL_FORMAT_YCrCb_422_SP:
-    case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
-    case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
-    case HAL_PIXEL_FORMAT_NV21_ZSL:
-    case HAL_PIXEL_FORMAT_RAW16:
-    case HAL_PIXEL_FORMAT_Y16:
-    case HAL_PIXEL_FORMAT_RAW10:
-    case HAL_PIXEL_FORMAT_RAW8:
-    case HAL_PIXEL_FORMAT_Y8:
-      GetYuvSPPlaneInfo(hnd->base, width, height, 1, ycbcr);
-      std::swap(ycbcr->cb, ycbcr->cr);
-      break;
-
-      // Planar
-    case HAL_PIXEL_FORMAT_YV12:
-      ystride = width;
-      cstride = ALIGN(width / 2, 16);
-      ycbcr->y = reinterpret_cast<void *>(hnd->base);
-      ycbcr->cr = reinterpret_cast<void *>(hnd->base + ystride * height);
-      ycbcr->cb = reinterpret_cast<void *>(hnd->base + ystride * height + cstride * height / 2);
-      ycbcr->ystride = ystride;
-      ycbcr->cstride = cstride;
-      ycbcr->chroma_step = 1;
-      break;
-    case HAL_PIXEL_FORMAT_CbYCrY_422_I:
-      ystride = width * 2;
-      cstride = 0;
-      ycbcr->y = reinterpret_cast<void *>(hnd->base);
-      ycbcr->cr = NULL;
-      ycbcr->cb = NULL;
-      ycbcr->ystride = ystride;
-      ycbcr->cstride = 0;
-      ycbcr->chroma_step = 0;
-      break;
-      // Unsupported formats
-    case HAL_PIXEL_FORMAT_YCbCr_422_I:
-    case HAL_PIXEL_FORMAT_YCrCb_422_I:
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
-    default:
-      ALOGD("%s: Invalid format passed: 0x%x", __FUNCTION__, format);
-      err = -EINVAL;
+    }
   }
-
   return err;
 }
 
@@ -745,6 +794,28 @@
   return size;
 }
 
+unsigned int GetRgbMetaSize(int format, uint32_t width, uint32_t height, uint64_t usage) {
+  unsigned int meta_size = 0;
+  if (!IsUBwcEnabled(format, usage)) {
+    return meta_size;
+  }
+  uint32_t bpp = GetBppForUncompressedRGB(format);
+  switch (format) {
+    case HAL_PIXEL_FORMAT_BGR_565:
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+    case HAL_PIXEL_FORMAT_RGBA_1010102:
+    case HAL_PIXEL_FORMAT_RGBX_1010102:
+    case HAL_PIXEL_FORMAT_RGBA_FP16:
+      meta_size = GetRgbUBwcMetaBufferSize(width, height, bpp);
+      break;
+    default:
+      ALOGE("%s:Unsupported RGB format: 0x%x", __FUNCTION__, format);
+      break;
+  }
+  return meta_size;
+}
+
 int GetRgbDataAddress(private_handle_t *hnd, void **rgb_data) {
   int err = 0;
 
@@ -758,22 +829,8 @@
     *rgb_data = reinterpret_cast<void *>(hnd->base);
     return err;
   }
+  unsigned int meta_size = GetRgbMetaSize(hnd->format, hnd->width, hnd->height, hnd->usage);
 
-  unsigned int meta_size = 0;
-  uint32_t bpp = GetBppForUncompressedRGB(hnd->format);
-  switch (hnd->format) {
-    case HAL_PIXEL_FORMAT_BGR_565:
-    case HAL_PIXEL_FORMAT_RGBA_8888:
-    case HAL_PIXEL_FORMAT_RGBX_8888:
-    case HAL_PIXEL_FORMAT_RGBA_1010102:
-    case HAL_PIXEL_FORMAT_RGBX_1010102:
-      meta_size = GetRgbUBwcMetaBufferSize(hnd->width, hnd->height, bpp);
-      break;
-    default:
-      ALOGE("%s:Unsupported RGB format: 0x%x", __FUNCTION__, hnd->format);
-      err = -EINVAL;
-      break;
-  }
   *rgb_data = reinterpret_cast<void *>(hnd->base + meta_size);
 
   return err;
@@ -1217,4 +1274,338 @@
   return IsYuvFormat(inputFormat) ? BUFFER_TYPE_VIDEO : BUFFER_TYPE_UI;
 }
 
+int GetYUVPlaneInfo(const BufferInfo &info, int32_t format, int32_t width, int32_t height,
+                    int32_t flags, int *plane_count, PlaneLayoutInfo *plane_info) {
+  int err = 0;
+  unsigned int y_stride, c_stride, y_height, c_height, y_size, c_size;
+  uint64_t yOffset, cOffset, crOffset, cbOffset;
+  int h_subsampling = 0, v_subsampling = 0;
+  switch (format) {
+    // Semiplanar
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
+    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
+    case HAL_PIXEL_FORMAT_NV12_HEIF:  // Same as YCbCr_420_SP_VENUS
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+    case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
+    case HAL_PIXEL_FORMAT_NV21_ZSL:
+    case HAL_PIXEL_FORMAT_RAW16:
+    case HAL_PIXEL_FORMAT_Y16:
+    case HAL_PIXEL_FORMAT_RAW10:
+    case HAL_PIXEL_FORMAT_RAW8:
+    case HAL_PIXEL_FORMAT_Y8:
+      *plane_count = 2;
+      GetYuvSPPlaneInfo(info, format, width, height, 1, plane_info);
+      GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
+      plane_info[0].h_subsampling = 0;
+      plane_info[0].v_subsampling = 0;
+      plane_info[1].h_subsampling = h_subsampling;
+      plane_info[1].v_subsampling = v_subsampling;
+      break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
+      GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
+      if (flags & LAYOUT_INTERLACED_FLAG) {
+        *plane_count = 8;
+        GetYuvUbwcInterlacedSPPlaneInfo(width, height, plane_info);
+        plane_info[0].step = plane_info[4].step = 1;
+        plane_info[1].step = plane_info[5].step = 2;
+        plane_info[0].h_subsampling = plane_info[4].h_subsampling = 0;
+        plane_info[0].v_subsampling = plane_info[4].v_subsampling = 0;
+        plane_info[1].h_subsampling = plane_info[5].h_subsampling = h_subsampling;
+        plane_info[1].v_subsampling = plane_info[5].v_subsampling = v_subsampling;
+        plane_info[2].h_subsampling = plane_info[3].h_subsampling = 0;
+        plane_info[2].v_subsampling = plane_info[3].v_subsampling = 0;
+        plane_info[2].step = plane_info[3].step = 0;
+        plane_info[6].h_subsampling = plane_info[7].h_subsampling = 0;
+        plane_info[6].v_subsampling = plane_info[7].v_subsampling = 0;
+        plane_info[6].step = plane_info[7].step = 0;
+      } else {
+        *plane_count = 4;
+        GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_NV12_UBWC, plane_info);
+        plane_info[0].h_subsampling = 0;
+        plane_info[0].v_subsampling = 0;
+        plane_info[0].step = 1;
+        plane_info[1].h_subsampling = h_subsampling;
+        plane_info[1].v_subsampling = v_subsampling;
+        plane_info[1].step = 2;
+        plane_info[2].h_subsampling = plane_info[3].h_subsampling = 0;
+        plane_info[2].v_subsampling = plane_info[3].v_subsampling = 0;
+        plane_info[2].step = plane_info[3].step = 0;
+      }
+      break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_420_P010:
+      *plane_count = 2;
+      GetYuvSPPlaneInfo(info, format, width, height, 2, plane_info);
+      GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
+      plane_info[0].h_subsampling = 0;
+      plane_info[0].v_subsampling = 0;
+      plane_info[1].h_subsampling = h_subsampling;
+      plane_info[1].v_subsampling = v_subsampling;
+      break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
+      *plane_count = 4;
+      GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_NV12_BPP10_UBWC, plane_info);
+      GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
+      plane_info[0].h_subsampling = 0;
+      plane_info[0].v_subsampling = 0;
+      plane_info[1].step = 1;
+      plane_info[1].h_subsampling = h_subsampling;
+      plane_info[1].v_subsampling = v_subsampling;
+      plane_info[1].step = 3;
+      plane_info[2].h_subsampling = plane_info[3].h_subsampling = 0;
+      plane_info[2].v_subsampling = plane_info[3].v_subsampling = 0;
+      plane_info[2].step = plane_info[3].step = 0;
+      break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
+      *plane_count = 4;
+      GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_P010_UBWC, plane_info);
+      GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
+      plane_info[0].h_subsampling = 0;
+      plane_info[0].v_subsampling = 0;
+      plane_info[1].step = 1;
+      plane_info[1].h_subsampling = h_subsampling;
+      plane_info[1].v_subsampling = v_subsampling;
+      plane_info[1].step = 4;
+      plane_info[2].h_subsampling = plane_info[3].h_subsampling = 0;
+      plane_info[2].v_subsampling = plane_info[3].v_subsampling = 0;
+      plane_info[2].step = plane_info[3].step = 0;
+      break;
+
+    case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
+      *plane_count = 2;
+      y_stride = VENUS_Y_STRIDE(COLOR_FMT_P010, width);
+      c_stride = VENUS_UV_STRIDE(COLOR_FMT_P010, width);
+      y_height = VENUS_Y_SCANLINES(COLOR_FMT_P010, height);
+      y_size = y_stride * y_height;
+      yOffset = 0;
+      cOffset = y_size;
+      c_height = VENUS_UV_SCANLINES(COLOR_FMT_P010, INT(height));
+      c_size = c_stride * c_height;
+      GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
+
+      plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
+      plane_info[0].offset = (uint32_t)yOffset;
+      plane_info[0].stride = static_cast<int32_t>(UINT(width));
+      plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
+      plane_info[0].scanlines = static_cast<int32_t>(y_height);
+      plane_info[0].size = static_cast<uint32_t>(y_size);
+      plane_info[0].step = 1;
+      plane_info[0].h_subsampling = 0;
+      plane_info[0].v_subsampling = 0;
+
+      plane_info[1].component = (PlaneComponent)(PLANE_COMPONENT_Cb | PLANE_COMPONENT_Cr);
+      plane_info[1].offset = (uint32_t)cOffset;
+      plane_info[1].stride = static_cast<int32_t>(UINT(width));
+      plane_info[1].stride_bytes = static_cast<int32_t>(c_stride);
+      plane_info[1].scanlines = static_cast<int32_t>(c_height);
+      plane_info[1].size = static_cast<uint32_t>(c_size);
+      plane_info[1].step = 4;
+      plane_info[1].h_subsampling = h_subsampling;
+      plane_info[1].v_subsampling = v_subsampling;
+      break;
+
+      // Planar
+    case HAL_PIXEL_FORMAT_YV12:
+      if ((info.width & 1) || (info.height & 1)) {
+        ALOGE("w or h is odd for the YV12 format");
+        err = -EINVAL;
+        return err;
+      }
+      *plane_count = 3;
+      y_stride = width;
+      c_stride = ALIGN(width / 2, 16);
+      y_height = UINT(height);
+      y_size = (y_stride * y_height);
+      height = height >> 1;
+      c_height = UINT(height);
+      c_size = (c_stride * c_height);
+      yOffset = 0;
+      crOffset = y_size;
+      cbOffset = (y_size + c_size);
+      GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
+
+      plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
+      plane_info[0].offset = (uint32_t)yOffset;
+      plane_info[0].stride = static_cast<int32_t>(UINT(width));
+      plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
+      plane_info[0].scanlines = static_cast<int32_t>(y_height);
+      plane_info[0].size = static_cast<uint32_t>(y_size);
+      plane_info[0].step = 1;
+      plane_info[0].h_subsampling = 0;
+      plane_info[0].v_subsampling = 0;
+
+      plane_info[1].component = (PlaneComponent)PLANE_COMPONENT_Cb;
+      plane_info[1].offset = (uint32_t)cbOffset;
+      plane_info[2].component = (PlaneComponent)PLANE_COMPONENT_Cr;
+      plane_info[2].offset = (uint32_t)crOffset;
+      for (int i = 1; i < 3; i++) {
+        plane_info[i].stride = static_cast<int32_t>(UINT(width));
+        plane_info[i].stride_bytes = static_cast<int32_t>(c_stride);
+        plane_info[i].scanlines = static_cast<int32_t>(c_height);
+        plane_info[i].size = static_cast<uint32_t>(c_size);
+        plane_info[i].step = 1;
+        plane_info[i].h_subsampling = h_subsampling;
+        plane_info[i].v_subsampling = v_subsampling;
+      }
+      break;
+    case HAL_PIXEL_FORMAT_CbYCrY_422_I:
+      if (info.width & 1) {
+        ALOGE("width is odd for the YUV422_SP format");
+        err = -EINVAL;
+        return err;
+      }
+      *plane_count = 1;
+      y_stride = width * 2;
+      y_height = UINT(height);
+      y_size = y_stride * y_height;
+      yOffset = 0;
+      plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
+      plane_info[0].offset = (uint32_t)yOffset;
+      plane_info[0].stride = static_cast<int32_t>(UINT(width));
+      plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
+      plane_info[0].scanlines = static_cast<int32_t>(y_height);
+      plane_info[0].size = static_cast<uint32_t>(y_size);
+      plane_info[0].step = 1;
+      plane_info[0].h_subsampling = 0;
+      plane_info[0].v_subsampling = 0;
+      break;
+
+      // Unsupported formats
+    case HAL_PIXEL_FORMAT_YCbCr_422_I:
+    case HAL_PIXEL_FORMAT_YCrCb_422_I:
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
+    default:
+      *plane_count = 0;
+      ALOGD("%s: Invalid format passed: 0x%x", __FUNCTION__, format);
+      err = -EINVAL;
+  }
+  return err;
+}
+
+void GetYuvSubSamplingFactor(int32_t format, int *h_subsampling, int *v_subsampling) {
+  switch (format) {
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+    case HAL_PIXEL_FORMAT_YCbCr_420_P010:
+    case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
+    case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
+    case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
+    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:  // Same as YCbCr_420_SP_VENUS
+    case HAL_PIXEL_FORMAT_NV21_ZSL:
+    case HAL_PIXEL_FORMAT_YV12:
+      *h_subsampling = 1;
+      *v_subsampling = 1;
+      break;
+    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+    case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+    case HAL_PIXEL_FORMAT_CbYCrY_422_I:
+      *h_subsampling = 1;
+      *v_subsampling = 0;
+      break;
+    case HAL_PIXEL_FORMAT_RAW16:
+    case HAL_PIXEL_FORMAT_Y16:
+    case HAL_PIXEL_FORMAT_RAW12:
+    case HAL_PIXEL_FORMAT_RAW10:
+    case HAL_PIXEL_FORMAT_Y8:
+    case HAL_PIXEL_FORMAT_BLOB:
+    case HAL_PIXEL_FORMAT_RAW_OPAQUE:
+    case HAL_PIXEL_FORMAT_NV12_HEIF:
+    default:
+      *h_subsampling = 0;
+      *v_subsampling = 0;
+      break;
+  }
+}
+
+void CopyPlaneLayoutInfotoAndroidYcbcr(uint64_t base, int plane_count, PlaneLayoutInfo *plane_info,
+                                       struct android_ycbcr *ycbcr) {
+  ycbcr->y = reinterpret_cast<void *>(base + plane_info[0].offset);
+  ycbcr->ystride = plane_info[0].stride_bytes;
+  if (plane_count == 1) {
+    ycbcr->cb = NULL;
+    ycbcr->cr = NULL;
+    ycbcr->cstride = 0;
+    ycbcr->chroma_step = 0;
+  } else if (plane_count == 2 || plane_count == 4 || plane_count == 8) {
+    /* For YUV semiplanar :-
+     *   - In progressive & linear case plane count is 2 and plane_info[0] will
+     *     contain info about Y plane and plane_info[1] will contain info about UV plane.
+     *   - In progressive & compressed case plane count is 4 then plane_info[0] will
+     *     contain info about Y plane and plane_info[1] will contain info about UV plane.
+     *     Remaining two plane (plane_info[2] & plane_info[3]) contain info about the
+     *     Y_Meta_Plane and UV_Meta_Plane.
+     *   - In interlaced & compressed case plane count is 8 then plane_info[0], plane_info[1],
+     *     plane_info[4] & plane_info[5] will contain info about Y_plane, UV_plane, Y_plane
+     *     & UV_plane. Remaining plane will contain info about the meta planes. As in this case
+     *     this API is called twice through GetYUVPlaneInfo() with address of plane_info[0] &
+     *     plane_info[4], so this will calculate the information accordingly and will fill the
+     *     ycbcr structure with interlaced plane info only.
+     */
+    ycbcr->cb = reinterpret_cast<void *>(base + plane_info[1].offset);
+    ycbcr->cr = reinterpret_cast<void *>(base + plane_info[1].offset + 1);
+    ycbcr->cstride = plane_info[1].stride_bytes;
+    ycbcr->chroma_step = plane_info[1].step;
+  } else if (plane_count == 3) {
+    /* For YUV planar :-
+     * Plane size is 3 and plane_info[0], plane_info[1], plane_info[2] will
+     * contain info about y_plane, cb_plane and cr_plane accordingly.
+     */
+    ycbcr->cb = reinterpret_cast<void *>(base + plane_info[1].offset);
+    ycbcr->cr = reinterpret_cast<void *>(base + plane_info[2].offset);
+    ycbcr->cstride = plane_info[1].stride_bytes;
+    ycbcr->chroma_step = plane_info[1].step;
+  }
+}
+
+bool HasAlphaComponent(int32_t format) {
+  switch (format) {
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+    case HAL_PIXEL_FORMAT_RGBA_5551:
+    case HAL_PIXEL_FORMAT_RGBA_4444:
+    case HAL_PIXEL_FORMAT_RGBA_1010102:
+    case HAL_PIXEL_FORMAT_ARGB_2101010:
+    case HAL_PIXEL_FORMAT_BGRA_1010102:
+    case HAL_PIXEL_FORMAT_ABGR_2101010:
+    case HAL_PIXEL_FORMAT_RGBA_FP16:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void GetRGBPlaneInfo(const BufferInfo &info, int32_t format, int32_t width, int32_t height,
+                     int32_t /* flags */, int *plane_count, PlaneLayoutInfo *plane_info) {
+  uint64_t usage = info.usage;
+  *plane_count = 1;
+  uint32_t bpp = 0;
+  if (IsUncompressedRGBFormat(format)) {
+    bpp = GetBppForUncompressedRGB(format);
+  }
+  plane_info->component =
+      (PlaneComponent)(PLANE_COMPONENT_R | PLANE_COMPONENT_G | PLANE_COMPONENT_B);
+  if (HasAlphaComponent(format)) {
+    plane_info->component = (PlaneComponent)(plane_info->component | PLANE_COMPONENT_A);
+  }
+  plane_info->size = GetSize(info, width, height);
+  plane_info->step = bpp;
+  plane_info->offset = GetRgbMetaSize(format, width, height, usage);
+  plane_info->h_subsampling = 0;
+  plane_info->v_subsampling = 0;
+  plane_info->stride = width;
+  plane_info->stride_bytes = width * plane_info->step;
+  plane_info->scanlines = height;
+}
+
 }  // namespace gralloc
diff --git a/gralloc/gr_utils.h b/gralloc/gr_utils.h
index 309b8a7..39d7e9b 100644
--- a/gralloc/gr_utils.h
+++ b/gralloc/gr_utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2016,2018, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2016,2018-2019, The Linux Foundation. All rights reserved.
 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -68,6 +68,63 @@
   return (Type1)((x + (Type1)align - 1) & ~((Type1)align - 1));
 }
 
+enum PlaneComponent {
+  /* luma */
+  PLANE_COMPONENT_Y = 1 << 0,
+  /* chroma blue */
+  PLANE_COMPONENT_Cb = 1 << 1,
+  /* chroma red */
+  PLANE_COMPONENT_Cr = 1 << 2,
+
+  /* red */
+  PLANE_COMPONENT_R = 1 << 10,
+  /* green */
+  PLANE_COMPONENT_G = 1 << 11,
+  /* blue */
+  PLANE_COMPONENT_B = 1 << 12,
+
+  /* alpha */
+  PLANE_COMPONENT_A = 1 << 20,
+
+  /* raw data plane */
+  PLANE_COMPONENT_RAW = 1 << 30,
+
+  /* meta information plane */
+  PLANE_COMPONENT_META = 1 << 31,
+};
+
+struct PlaneLayoutInfo {
+  /** Components represented the type of plane. */
+  PlaneComponent component;
+
+  /** horizontal subsampling. Must be a positive power of 2. */
+  uint32_t h_subsampling;
+
+  /** vertical subsampling. Must be a positive power of 2. */
+  uint32_t v_subsampling;
+
+  /** offset to the first byte of the top-left pixel of the plane
+   *  and it is calculated from the start of the buffer.
+   *  Add base of the handle with offset to get the first byte of the plane.
+   */
+  uint32_t offset;
+
+  /** step is the distance in bytes from one pixel value to the next. */
+  int32_t step;
+
+  /** stride of the plane in pixels */
+  int32_t stride;
+
+  /** stride of the plane in in bytes */
+  int32_t stride_bytes;
+
+  /** plane height or vertical stride */
+  int32_t scanlines;
+
+  /** size of the plane in bytes */
+  uint32_t size;
+};
+
 bool IsYuvFormat(int format);
 bool IsCompressedRGBFormat(int format);
 bool IsUncompressedRGBFormat(int format);
@@ -85,6 +142,14 @@
 void GetAlignedWidthAndHeight(const BufferInfo &d, unsigned int *aligned_w,
                               unsigned int *aligned_h);
 int GetYUVPlaneInfo(const private_handle_t *hnd, struct android_ycbcr ycbcr[2]);
+int GetYUVPlaneInfo(const BufferInfo &info, int32_t format, int32_t width, int32_t height,
+                    int32_t flags, int *plane_count, PlaneLayoutInfo plane_info[8]);
+void GetRGBPlaneInfo(const BufferInfo &info, int32_t format, int32_t width, int32_t height,
+                     int32_t flags, int *plane_count, PlaneLayoutInfo *plane_info);
+unsigned int GetRgbMetaSize(int format, uint32_t width, uint32_t height, uint64_t usage);
+void GetYuvSubSamplingFactor(int32_t format, int *h_subsampling, int *v_subsampling);
+void CopyPlaneLayoutInfotoAndroidYcbcr(uint64_t base, int plane_count, PlaneLayoutInfo *plane_info,
+                                       struct android_ycbcr *ycbcr);
 int GetRgbDataAddress(private_handle_t *hnd, void **rgb_data);
 bool IsUBwcFormat(int format);
 bool IsUBwcSupported(int format);
@@ -92,12 +157,12 @@
 bool IsUBwcEnabled(int format, uint64_t usage);
 void GetYuvUBwcWidthAndHeight(int width, int height, int format, unsigned int *aligned_w,
                               unsigned int *aligned_h);
-void GetYuvSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, uint32_t bpp,
-                       struct android_ycbcr *ycbcr);
-void GetYuvUbwcSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, int color_format,
-                           struct android_ycbcr *ycbcr);
-void GetYuvUbwcInterlacedSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height,
-                                     int color_format, struct android_ycbcr ycbcr[2]);
+void GetYuvSPPlaneInfo(const BufferInfo &info, int format, uint32_t width, uint32_t height,
+                       uint32_t bpp, PlaneLayoutInfo *plane_info);
+void GetYuvUbwcSPPlaneInfo(uint32_t width, uint32_t height, int color_format,
+                           PlaneLayoutInfo *plane_info);
+void GetYuvUbwcInterlacedSPPlaneInfo(uint32_t width, uint32_t height,
+                                     PlaneLayoutInfo plane_info[8]);
 void GetRgbUBwcBlockSize(uint32_t bpp, int *block_width, int *block_height);
 unsigned int GetRgbUBwcMetaBufferSize(int width, int height, uint32_t bpp);
 unsigned int GetUBwcSize(int width, int height, int format, unsigned int alignedw,
@@ -116,6 +181,7 @@
 int GetCustomFormatFlags(int format, uint64_t usage, int *custom_format, uint64_t *priv_flags);
 int GetBufferType(int inputFormat);
 bool IsGPUFlagSupported(uint64_t usage);
+bool HasAlphaComponent(int32_t format);
 }  // namespace gralloc
 
 #endif  // __GR_UTILS_H__