Merge remote-tracking branch 'goog/qcom/release/LA.UM.7.3.9.08.00.00.385.323' into merge-au323

Bug: 79173695
Change-Id: I4dad9fa602d813a208f80f365fff142006244653

8 files changed, 178 insertions, 15 deletions

diff --git a/gralloc/QtiMapper.cpp b/gralloc/QtiMapper.cpp
index 490cf947..80655361 100644
--- a/gralloc/QtiMapper.cpp
+++ b/gralloc/QtiMapper.cpp
@@ -52,7 +52,7 @@ QtiMapper::QtiMapper() {
 
 bool QtiMapper::ValidDescriptor(const BufferDescriptorInfo_2_1 &bd) {
   if (bd.width == 0 || bd.height == 0 || (static_cast<int32_t>(bd.format) <= 0) ||
-      bd.layerCount != 1) {
+      bd.layerCount <= 0) {
     return false;
   }
 
diff --git a/gralloc/gr_adreno_info.cpp b/gralloc/gr_adreno_info.cpp
index 2098b615..051f965e 100644
--- a/gralloc/gr_adreno_info.cpp
+++ b/gralloc/gr_adreno_info.cpp
@@ -68,6 +68,12 @@ AdrenoMemInfo::AdrenoMemInfo() {
         ::dlsym(libadreno_utils_, "isUBWCSupportedByGpu");
     *reinterpret_cast<void **>(&LINK_adreno_get_gpu_pixel_alignment) =
         ::dlsym(libadreno_utils_, "get_gpu_pixel_alignment");
+    *reinterpret_cast<void **>(&LINK_adreno_get_metadata_blob_size) =
+        ::dlsym(libadreno_utils_, "adreno_get_metadata_blob_size");
+    *reinterpret_cast<void **>(&LINK_adreno_init_memory_layout) =
+        ::dlsym(libadreno_utils_, "adreno_init_memory_layout");
+    *reinterpret_cast<void **>(&LINK_adreno_get_aligned_gpu_buffer_size) =
+        ::dlsym(libadreno_utils_, "adreno_get_aligned_gpu_buffer_size");
   } else {
     ALOGE(" Failed to load libadreno_utils.so");
   }
@@ -182,7 +188,7 @@ ADRENOPIXELFORMAT AdrenoMemInfo::GetGpuPixelFormat(int hal_format) {
     case HAL_PIXEL_FORMAT_RGBX_8888:
       return ADRENO_PIXELFORMAT_R8G8B8X8;
     case HAL_PIXEL_FORMAT_BGRA_8888:
-      return ADRENO_PIXELFORMAT_B8G8R8A8;
+      return ADRENO_PIXELFORMAT_B8G8R8A8_UNORM;
     case HAL_PIXEL_FORMAT_RGB_888:
       return ADRENO_PIXELFORMAT_R8G8B8;
     case HAL_PIXEL_FORMAT_RGB_565:
@@ -201,7 +207,6 @@ ADRENOPIXELFORMAT AdrenoMemInfo::GetGpuPixelFormat(int hal_format) {
        return ADRENO_PIXELFORMAT_A2B10G10R10_UNORM;
     case HAL_PIXEL_FORMAT_RGBA_FP16:
        return ADRENO_PIXELFORMAT_R16G16B16A16_FLOAT;
-
     case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
       return ADRENO_PIXELFORMAT_NV12;
     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
@@ -213,6 +218,18 @@ ADRENOPIXELFORMAT AdrenoMemInfo::GetGpuPixelFormat(int hal_format) {
     case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
     case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
       return ADRENO_PIXELFORMAT_P010;
+    case HAL_PIXEL_FORMAT_DEPTH_16:
+      return ADRENO_PIXELFORMAT_D16_UNORM;
+    case HAL_PIXEL_FORMAT_DEPTH_24:
+      return ADRENO_PIXELFORMAT_D24_UNORM;
+    case HAL_PIXEL_FORMAT_DEPTH_24_STENCIL_8:
+      return ADRENO_PIXELFORMAT_D24_UNORM_S8_UINT;
+    case HAL_PIXEL_FORMAT_DEPTH_32F:
+      return ADRENO_PIXELFORMAT_D32_FLOAT;
+    case HAL_PIXEL_FORMAT_DEPTH_32F_STENCIL_8:
+      return ADRENO_PIXELFORMAT_D32_FLOAT_X24S8_UINT;
+    case HAL_PIXEL_FORMAT_STENCIL_8:
+      return ADRENO_PIXELFORMAT_S8_UINT;
     default:
       ALOGE("%s: No map for format: 0x%x", __FUNCTION__, hal_format);
       break;
@@ -221,4 +238,34 @@ ADRENOPIXELFORMAT AdrenoMemInfo::GetGpuPixelFormat(int hal_format) {
   return ADRENO_PIXELFORMAT_UNKNOWN;
 }
 
+uint32_t AdrenoMemInfo::AdrenoGetMetadataBlobSize() {
+  if (LINK_adreno_get_metadata_blob_size) {
+    return LINK_adreno_get_metadata_blob_size();
+  }
+  return 0;
+}
+
+int AdrenoMemInfo::AdrenoInitMemoryLayout(void *metadata_blob, int width, int height, int depth,
+  int format, int num_samples, int isUBWC, uint64_t usage, uint32_t num_planes) {
+  if (LINK_adreno_init_memory_layout) {
+    surface_tile_mode_t tile_mode = static_cast<surface_tile_mode_t> (isUBWC);
+    return LINK_adreno_init_memory_layout(metadata_blob, width, height, depth,
+                                          GetGpuPixelFormat(format), num_samples,
+                                          tile_mode, usage, num_planes);
+  }
+  return -1;
+}
+
+uint32_t AdrenoMemInfo::AdrenoGetAlignedGpuBufferSize(void *metadata_blob) {
+  if (LINK_adreno_get_aligned_gpu_buffer_size) {
+    return LINK_adreno_get_aligned_gpu_buffer_size(metadata_blob);
+  }
+  return -1;
+}
+
+bool AdrenoMemInfo::AdrenoSizeAPIAvaliable() {
+  return (LINK_adreno_get_metadata_blob_size && LINK_adreno_init_memory_layout &&
+          LINK_adreno_get_aligned_gpu_buffer_size);
+}
+
 }  // namespace gralloc
diff --git a/gralloc/gr_adreno_info.h b/gralloc/gr_adreno_info.h
index b85e7c1d..eec7da49 100644
--- a/gralloc/gr_adreno_info.h
+++ b/gralloc/gr_adreno_info.h
@@ -41,8 +41,12 @@ typedef enum {
   ADRENO_PIXELFORMAT_R10G10B10A2_UNORM = 24,  // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
   ADRENO_PIXELFORMAT_R8G8B8A8 = 28,
   ADRENO_PIXELFORMAT_R8G8B8A8_SRGB = 29,
+  ADRENO_PIXELFORMAT_D32_FLOAT = 40,
+  ADRENO_PIXELFORMAT_D24_UNORM_S8_UINT = 45,
+  ADRENO_PIXELFORMAT_D16_UNORM = 55,
   ADRENO_PIXELFORMAT_B5G6R5 = 85,
   ADRENO_PIXELFORMAT_B5G5R5A1 = 86,
+  ADRENO_PIXELFORMAT_B8G8R8A8_UNORM = 87,
   ADRENO_PIXELFORMAT_B8G8R8A8 = 90,
   ADRENO_PIXELFORMAT_B8G8R8A8_SRGB = 91,
   ADRENO_PIXELFORMAT_B8G8R8X8_SRGB = 93,
@@ -59,6 +63,9 @@ typedef enum {
   ADRENO_PIXELFORMAT_A2B10G10R10_UNORM = 532,
   // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
   ADRENO_PIXELFORMAT_R10G10B10X2_UNORM = 537,
+  ADRENO_PIXELFORMAT_D24_UNORM = 549,
+  ADRENO_PIXELFORMAT_D32_FLOAT_X24S8_UINT = 551,
+  ADRENO_PIXELFORMAT_S8_UINT = 552,
   // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
   ADRENO_PIXELFORMAT_R5G6B5 = 610,    //  RGBA version of B5G6R5
   ADRENO_PIXELFORMAT_R5G5B5A1 = 611,  //  RGBA version of B5G5R5A1
@@ -70,6 +77,11 @@ typedef enum {
   ADRENO_PIXELFORMAT_TP10 = 654,      // YUV 4:2:0 planar 10 bits/comp (2 planes)
 } ADRENOPIXELFORMAT;
 
+typedef enum {
+  SURFACE_TILE_MODE_DISABLE    = 0x0,    // used for linear surface
+  SURFACE_TILE_MODE_ENABLE     = 0x1     // used for tiled surface
+} surface_tile_mode_t;
+
 class AdrenoMemInfo {
  public:
   /*
@@ -119,6 +131,32 @@ class AdrenoMemInfo {
    */
   ADRENOPIXELFORMAT GetGpuPixelFormat(int hal_format);
 
+  /*
+   * Function to get graphics metadata blob size
+   * @return graphics metadata size
+   */
+  uint32_t AdrenoGetMetadataBlobSize();
+
+  /*
+   * Function to populate the graphics metadata blob
+   * @return 1 : Successful
+   *         2 : Unsuccessful
+   */
+  int AdrenoInitMemoryLayout(void *metadata_blob, int width, int height, int depth, int format,
+                             int num_samples, int isUBWC, uint64_t usage, uint32_t num_planes);
+  /*
+   * Function to get buffer size for based on graphcis metadata
+   * @return buffer size
+   */
+  uint32_t AdrenoGetAlignedGpuBufferSize(void *metadata_blob);
+
+  /*
+   * Function to check if adreno size calculation APIs are avaliable
+   * @return true  : Avaliable
+   *         false : Unavaliable
+  */
+  bool AdrenoSizeAPIAvaliable();
+
   static AdrenoMemInfo *GetInstance();
 
  private:
@@ -142,6 +180,12 @@ class AdrenoMemInfo {
   int (*LINK_adreno_isUBWCSupportedByGpu)(ADRENOPIXELFORMAT format) = NULL;
   unsigned int (*LINK_adreno_get_gpu_pixel_alignment)() = NULL;
 
+  uint32_t (*LINK_adreno_get_metadata_blob_size)() = NULL;
+  int (*LINK_adreno_init_memory_layout)(void* metadata_blob, int width, int height, int depth,
+       ADRENOPIXELFORMAT format, int num_samples, surface_tile_mode_t tile_mode,
+       uint64_t usage, uint32_t num_planes) = NULL;
+  uint32_t (*LINK_adreno_get_aligned_gpu_buffer_size)(void* metadata_blob) = NULL;
+
   bool gfx_ubwc_disable_ = false;
   void *libadreno_utils_ = NULL;
 
diff --git a/gralloc/gr_buf_mgr.cpp b/gralloc/gr_buf_mgr.cpp
index fadc8f0c..0b6567da 100644
--- a/gralloc/gr_buf_mgr.cpp
+++ b/gralloc/gr_buf_mgr.cpp
@@ -296,10 +296,10 @@ int BufferManager::GetHandleFlags(int format, uint64_t usage) {
 }
 
 int BufferManager::GetBufferType(int inputFormat) {
-  int buffer_type = BUFFER_TYPE_VIDEO;
-  if (IsUncompressedRGBFormat(inputFormat)) {
-    // RGB formats
-    buffer_type = BUFFER_TYPE_UI;
+  int buffer_type = BUFFER_TYPE_UI;
+  if (IsYuvFormat(inputFormat)) {
+    // Video format
+    buffer_type = BUFFER_TYPE_VIDEO;
   }
 
   return buffer_type;
@@ -321,9 +321,18 @@ Error BufferManager::AllocateBuffer(const BufferDescriptor &descriptor, buffer_h
   int buffer_type = GetBufferType(format);
   BufferInfo info = GetBufferInfo(descriptor);
   info.format = format;
-  GetBufferSizeAndDimensions(info, &size, &alignedw, &alignedh);
-  size = (bufferSize >= size) ? bufferSize : size;
 
+  bool use_adreno_for_size = false;
+  GraphicsMetadata graphics_metadata = {};
+
+  use_adreno_for_size = ((buffer_type != BUFFER_TYPE_VIDEO) && GetAdrenoSizeAPIStatus());
+  if (use_adreno_for_size) {
+    GetGpuResourceSizeAndDimensions(info, &size, &alignedw, &alignedh, &graphics_metadata);
+  } else {
+    GetBufferSizeAndDimensions(info, &size, &alignedw, &alignedh);
+  }
+
+  size = (bufferSize >= size) ? bufferSize : size;
   int err = 0;
   int flags = 0;
   auto page_size = UINT(getpagesize());
@@ -367,6 +376,11 @@ Error BufferManager::AllocateBuffer(const BufferDescriptor &descriptor, buffer_h
 
   ColorSpace_t colorSpace = ITU_R_601;
   setMetaData(hnd, UPDATE_COLOR_SPACE, reinterpret_cast<void *>(&colorSpace));
+
+  if (use_adreno_for_size) {
+    setMetaData(hnd, SET_GRAPHICS_METADATA, reinterpret_cast<void *>(&graphics_metadata));
+  }
+
   *handle = hnd;
   RegisterHandleLocked(hnd, data.ion_handle, e_data.ion_handle);
   ALOGD_IF(DEBUG, "Allocated buffer handle: %p id: %" PRIu64, hnd, hnd->id);
diff --git a/gralloc/gr_device_impl.cpp b/gralloc/gr_device_impl.cpp
index a26ea81b..61ec38bb 100644
--- a/gralloc/gr_device_impl.cpp
+++ b/gralloc/gr_device_impl.cpp
@@ -510,7 +510,7 @@ gralloc1_error_t GrallocImpl::ReleaseBuffer(gralloc1_device_t *device, buffer_ha
 
 gralloc1_error_t GrallocImpl::GetFlexLayout(const private_handle_t *hnd,
                                             struct android_flex_layout *layout) {
-  if (!IsYuvFormat(hnd)) {
+  if (!IsYuvFormat(hnd->format)) {
     return GRALLOC1_ERROR_UNSUPPORTED;
   }
 
@@ -560,7 +560,7 @@ gralloc1_error_t GrallocImpl::GetNumFlexPlanes(gralloc1_device_t *device, buffer
   gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
   if (status == GRALLOC1_ERROR_NONE) {
     const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-    if (!IsYuvFormat(hnd)) {
+    if (!IsYuvFormat(hnd->format)) {
       status = GRALLOC1_ERROR_UNSUPPORTED;
     } else {
       *out_num_planes = 3;
@@ -847,6 +847,21 @@ static gralloc1_error_t Perform(int operation, va_list args) {
       }
     } break;
 
+    case GRALLOC_MODULE_PERFORM_GET_GRAPHICS_METADATA: {
+      private_handle_t* hnd = va_arg(args, private_handle_t *);
+
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      void* graphic_metadata = va_arg(args, void*);
+
+      if (getMetaData(hnd, GET_GRAPHICS_METADATA, graphic_metadata) != 0) {
+        graphic_metadata = NULL;
+        return GRALLOC1_ERROR_UNSUPPORTED;
+      }
+    } break;
+
     default:
       break;
   }
diff --git a/gralloc/gr_utils.cpp b/gralloc/gr_utils.cpp
index 7801005b..5e83941d 100644
--- a/gralloc/gr_utils.cpp
+++ b/gralloc/gr_utils.cpp
@@ -32,7 +32,6 @@
 
 #include "gr_adreno_info.h"
 #include "gr_utils.h"
-#include "qdMetaData.h"
 
 #define ASTC_BLOCK_SIZE 16
 
@@ -42,8 +41,8 @@
 
 namespace gralloc {
 
-bool IsYuvFormat(const private_handle_t *hnd) {
-  switch (hnd->format) {
+bool IsYuvFormat(int format) {
+  switch (format) {
     case HAL_PIXEL_FORMAT_YCbCr_420_SP:
     case HAL_PIXEL_FORMAT_YCbCr_422_SP:
     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
@@ -64,6 +63,9 @@ bool IsYuvFormat(const private_handle_t *hnd) {
     case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
     case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
     case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
+    // Below formats used by camera and VR
+    case HAL_PIXEL_FORMAT_BLOB:
+    case HAL_PIXEL_FORMAT_RAW_OPAQUE:
       return true;
     default:
       return false;
@@ -944,4 +946,39 @@ int GetBufferLayout(private_handle_t *hnd, uint32_t stride[4], uint32_t offset[4
   return 0;
 }
 
+void GetGpuResourceSizeAndDimensions(const BufferInfo &info, unsigned int *size,
+                                     unsigned int *alignedw, unsigned int *alignedh,
+                                     GraphicsMetadata *graphics_metadata) {
+  GetAlignedWidthAndHeight(info, alignedw, alignedh);
+  AdrenoMemInfo* adreno_mem_info = AdrenoMemInfo::GetInstance();
+  graphics_metadata->size = adreno_mem_info->AdrenoGetMetadataBlobSize();
+  uint64_t adreno_usage = info.usage;
+  // If gralloc disables UBWC based on any of the checks,
+  // we pass modified usage flag to adreno to convey this.
+  int is_ubwc_enabled = IsUBwcEnabled(info.format, info.usage);
+  if (!is_ubwc_enabled) {
+    adreno_usage &= ~(GRALLOC_USAGE_PRIVATE_ALLOC_UBWC);
+  }
+
+  // Call adreno api for populating metadata blob
+  int ret = adreno_mem_info->AdrenoInitMemoryLayout(graphics_metadata->data, info.width,
+                                                    info.height, 1, info.format, 1,
+                                                    is_ubwc_enabled, adreno_usage, 1);
+  if (ret != 0) {
+    ALOGE("%s Graphics metadata init failed", __FUNCTION__);
+    *size = 0;
+    return;
+  }
+  // Call adreno api with the metadata blob to get buffer size
+  *size = adreno_mem_info->AdrenoGetAlignedGpuBufferSize(graphics_metadata->data);
+}
+
+bool GetAdrenoSizeAPIStatus() {
+  AdrenoMemInfo* adreno_mem_info = AdrenoMemInfo::GetInstance();
+  if (adreno_mem_info) {
+    return adreno_mem_info->AdrenoSizeAPIAvaliable();
+  }
+  return false;
+}
+
 }  // namespace gralloc
diff --git a/gralloc/gr_utils.h b/gralloc/gr_utils.h
index 783453ff..fa628717 100644
--- a/gralloc/gr_utils.h
+++ b/gralloc/gr_utils.h
@@ -32,6 +32,7 @@
 
 #include <android/hardware/graphics/common/1.1/types.h>
 #include "gralloc_priv.h"
+#include "qdMetaData.h"
 
 #define SZ_2M 0x200000
 #define SZ_1M 0x100000
@@ -67,7 +68,7 @@ inline Type1 ALIGN(Type1 x, Type2 align) {
   return (Type1)((x + (Type1)align - 1) & ~((Type1)align - 1));
 }
 
-bool IsYuvFormat(const private_handle_t *hnd);
+bool IsYuvFormat(int format);
 bool IsCompressedRGBFormat(int format);
 bool IsUncompressedRGBFormat(int format);
 uint32_t GetBppForUncompressedRGB(int format);
@@ -102,6 +103,10 @@ int GetBufferLayout(private_handle_t *hnd, uint32_t stride[4], uint32_t offset[4
                     uint32_t *num_planes);
 uint32_t GetDataAlignment(int format, uint64_t usage);
 
+void GetGpuResourceSizeAndDimensions(const BufferInfo &info, unsigned int *size,
+                                     unsigned int *alignedw, unsigned int *alignedh,
+                                     GraphicsMetadata *graphics_metadata);
+bool GetAdrenoSizeAPIStatus();
 }  // namespace gralloc
 
 #endif  // __GR_UTILS_H__
diff --git a/gralloc/gralloc_priv.h b/gralloc/gralloc_priv.h
index 235f6984..be53d8bb 100644
--- a/gralloc/gralloc_priv.h
+++ b/gralloc/gralloc_priv.h
@@ -92,6 +92,7 @@ inline int roundUpToPageSize(int x) {
 #define GRALLOC_MODULE_PERFORM_SET_SINGLE_BUFFER_MODE 13
 #define GRALLOC1_MODULE_PERFORM_GET_BUFFER_SIZE_AND_DIMENSIONS 14
 #define GRALLOC1_MODULE_PERFORM_GET_INTERLACE_FLAG 15
+#define GRALLOC_MODULE_PERFORM_GET_GRAPHICS_METADATA 16
 
 // OEM specific HAL formats
 #define HAL_PIXEL_FORMAT_RGBA_5551 6