Merge "sdm: Remove duplicate bit clock rates."
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__