composer/hwc_buffer_allocator.cpp - LeafOS-Project/android_hardware_qcom_display - Gitiles

 /*
  * Copyright (c) 2015-2020, 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
  * met:
  *  * Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *  * Redistributions in binary form must reproduce the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer in the documentation and/or other materials provided
  *    with the distribution.
  *  * Neither the name of The Linux Foundation nor the names of its
  *    contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <gralloc_priv.h>

 #include <core/buffer_allocator.h>
 #include <utils/constants.h>
 #include <utils/debug.h>

 #include "gr_utils.h"
 #include "hwc_buffer_allocator.h"
 #include "hwc_debugger.h"
 #include "hwc_layers.h"

 #define __CLASS__ "HWCBufferAllocator"

 using android::hardware::graphics::mapper::V2_0::Error;
 using MapperV3Error = android::hardware::graphics::mapper::V3_0::Error;
 using android::hardware::graphics::mapper::V2_0::BufferDescriptor;
 using MapperV3BufferDescriptor = android::hardware::graphics::mapper::V3_0::BufferDescriptor;
 using android::hardware::hidl_handle;
 using android::hardware::hidl_vec;

 namespace sdm {

 DisplayError HWCBufferAllocator::GetGrallocInstance() {
   // Lazy initialization of gralloc HALs
   if (mapper_V3_ != nullptr || mapper_V2_ != nullptr || allocator_V3_ != nullptr ||
       allocator_V2_ != nullptr) {
     return kErrorNone;
   }

   allocator_V3_ = IAllocatorV3::getService();
   if (allocator_V3_ == nullptr) {
     allocator_V2_ = IAllocatorV2::getService();
     if (allocator_V2_ == nullptr) {
       DLOGE("Unable to get allocator");
       return kErrorCriticalResource;
     }
   }

   mapper_V3_ = IMapperV3::getService();
   if (mapper_V3_ == nullptr) {
     mapper_V2_ = IMapperV2::getService();
     if (mapper_V2_ == nullptr) {
       DLOGE("Unable to get mapper");
       return kErrorCriticalResource;
     }
   }

   return kErrorNone;
 }

 DisplayError HWCBufferAllocator::AllocateBuffer(BufferInfo *buffer_info) {
   auto err = GetGrallocInstance();
   if (err != kErrorNone) {
     return err;
   }
   const BufferConfig &buffer_config = buffer_info->buffer_config;
   AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
   int format;
   uint64_t alloc_flags = 0;
   int error = SetBufferInfo(buffer_config.format, &format, &alloc_flags);
   if (error != 0) {
     return kErrorParameters;
   }

   if (buffer_config.secure) {
     alloc_flags |= BufferUsage::PROTECTED;
   }

   if (buffer_config.secure_camera) {
     alloc_flags |= BufferUsage::CAMERA_OUTPUT;
   }

   if (!buffer_config.cache) {
     // Allocate uncached buffers
     alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
   }

   if (buffer_config.gfx_client) {
     alloc_flags |= BufferUsage::GPU_TEXTURE;
   }

   alloc_flags |= BufferUsage::COMPOSER_OVERLAY;

   const native_handle_t *buf = nullptr;

   if (mapper_V3_ != nullptr) {
     IMapperV3::BufferDescriptorInfo descriptor_info;
     descriptor_info.width = buffer_config.width;
     descriptor_info.height = buffer_config.height;
     descriptor_info.layerCount = 1;
     descriptor_info.format =
         static_cast<android::hardware::graphics::common::V1_2::PixelFormat>(format);
     descriptor_info.usage = alloc_flags;

     auto hidl_err = MapperV3Error::NONE;

     auto descriptor = BufferDescriptor();
     mapper_V3_->createDescriptor(descriptor_info, [&](const auto &_error, const auto &_descriptor) {
       hidl_err = _error;
       if (hidl_err != MapperV3Error::NONE) {
         return;
       }
       descriptor = _descriptor;
     });

     if (hidl_err != MapperV3Error::NONE) {
       DLOGE("Failed to create descriptor");
       return kErrorMemory;
     }

     hidl_handle raw_handle = nullptr;

     allocator_V3_->allocate(descriptor, 1,
                             [&](const auto &_error, const auto &_stride, const auto &_buffers) {
                               hidl_err = _error;
                               if (hidl_err != MapperV3Error::NONE) {
                                 return;
                               }
                               raw_handle = _buffers[0];
                             });

     if (hidl_err != MapperV3Error::NONE) {
       DLOGE("Failed to allocate buffer");
       return kErrorMemory;
     }

     mapper_V3_->importBuffer(raw_handle, [&](const auto &_error, const auto &_buffer) {
       hidl_err = _error;
       if (hidl_err != MapperV3Error::NONE) {
         return;
       }
       buf = static_cast<const native_handle_t *>(_buffer);
     });

     if (hidl_err != MapperV3Error::NONE) {
       DLOGE("Failed to import buffer into HWC");
       return kErrorMemory;
     }
   } else {
     IMapperV2::BufferDescriptorInfo descriptor_info;
     descriptor_info.width = buffer_config.width;
     descriptor_info.height = buffer_config.height;
     descriptor_info.layerCount = 1;
     descriptor_info.format =
         static_cast<android::hardware::graphics::common::V1_0::PixelFormat>(format);
     descriptor_info.usage = alloc_flags;

     auto hidl_err = Error::NONE;

     auto descriptor = BufferDescriptor();
     mapper_V2_->createDescriptor(descriptor_info, [&](const auto &_error, const auto &_descriptor) {
       hidl_err = _error;
       if (hidl_err != Error::NONE) {
         return;
       }
       descriptor = _descriptor;
     });

     if (hidl_err != Error::NONE) {
       DLOGE("Failed to create descriptor");
       return kErrorMemory;
     }

     hidl_handle raw_handle = nullptr;

     allocator_V2_->allocate(descriptor, 1,
                             [&](const auto &_error, const auto &_stride, const auto &_buffers) {
                               hidl_err = _error;
                               if (hidl_err != Error::NONE) {
                                 return;
                               }
                               raw_handle = _buffers[0];
                             });

     if (hidl_err != Error::NONE) {
       DLOGE("Failed to allocate buffer");
       return kErrorMemory;
     }

     mapper_V2_->importBuffer(raw_handle, [&](const auto &_error, const auto &_buffer) {
       hidl_err = _error;
       if (hidl_err != Error::NONE) {
         return;
       }
       buf = static_cast<const native_handle_t *>(_buffer);
     });

     if (hidl_err != Error::NONE) {
       DLOGE("Failed to import buffer into HWC");
       return kErrorMemory;
     }
   }

   private_handle_t *hnd = nullptr;
   hnd = (private_handle_t *)buf;  // NOLINT
   alloc_buffer_info->fd = hnd->fd;
   alloc_buffer_info->stride = UINT32(hnd->width);
   alloc_buffer_info->aligned_width = UINT32(hnd->width);
   alloc_buffer_info->aligned_height = UINT32(hnd->height);
   alloc_buffer_info->size = hnd->size;
   alloc_buffer_info->id = hnd->id;
   alloc_buffer_info->format = HWCLayer::GetSDMFormat(hnd->format, hnd->flags);

   buffer_info->private_data = reinterpret_cast<void *>(hnd);
   return kErrorNone;
 }

 DisplayError HWCBufferAllocator::FreeBuffer(BufferInfo *buffer_info) {
   DisplayError err = kErrorNone;
   auto hnd = reinterpret_cast<void *>(buffer_info->private_data);
   if (mapper_V3_ != nullptr) {
     mapper_V3_->freeBuffer(hnd);
   } else {
     mapper_V2_->freeBuffer(hnd);
   }
   AllocatedBufferInfo &alloc_buffer_info = buffer_info->alloc_buffer_info;

   alloc_buffer_info.fd = -1;
   alloc_buffer_info.stride = 0;
   alloc_buffer_info.size = 0;
   buffer_info->private_data = NULL;
   return err;
 }

 void HWCBufferAllocator::GetCustomWidthAndHeight(const private_handle_t *handle, int *width,
                                                  int *height) {
   *width = handle->width;
   *height = handle->height;
   gralloc::GetCustomDimensions(const_cast<private_handle_t *>(handle), width, height);
 }

 void HWCBufferAllocator::GetAlignedWidthAndHeight(int width, int height, int format,
                                                   uint32_t alloc_type, int *aligned_width,
                                                   int *aligned_height) {
   uint64_t usage = 0;
   if (alloc_type & GRALLOC_USAGE_HW_FB) {
     usage |= BufferUsage::COMPOSER_CLIENT_TARGET;
   }
   if (alloc_type & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) {
     usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
   }
   uint32_t aligned_w = UINT(width);
   uint32_t aligned_h = UINT(height);
   gralloc::BufferInfo info(width, height, format, usage);
   gralloc::GetAlignedWidthAndHeight(info, &aligned_w, &aligned_h);
   *aligned_width = INT(aligned_w);
   *aligned_height = INT(aligned_h);
 }

 uint32_t HWCBufferAllocator::GetBufferSize(BufferInfo *buffer_info) {
   const BufferConfig &buffer_config = buffer_info->buffer_config;
   uint64_t alloc_flags = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP;

   int width = INT(buffer_config.width);
   int height = INT(buffer_config.height);
   int format;

   if (buffer_config.secure) {
     alloc_flags |= INT(GRALLOC_USAGE_PROTECTED);
   }

   if (!buffer_config.cache) {
     // Allocate uncached buffers
     alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
   }

   if (SetBufferInfo(buffer_config.format, &format, &alloc_flags) < 0) {
     return 0;
   }

   uint32_t aligned_width = 0, aligned_height = 0, buffer_size = 0;
   gralloc::BufferInfo info(width, height, format, alloc_flags);
   int ret = GetBufferSizeAndDimensions(info, &buffer_size, &aligned_width, &aligned_height);
   if (ret < 0) {
     return 0;
   }
   return buffer_size;
 }

 int HWCBufferAllocator::SetBufferInfo(LayerBufferFormat format, int *target, uint64_t *flags) {
   switch (format) {
     case kFormatRGBA8888:
       *target = HAL_PIXEL_FORMAT_RGBA_8888;
       break;
     case kFormatRGBX8888:
       *target = HAL_PIXEL_FORMAT_RGBX_8888;
       break;
     case kFormatRGB888:
       *target = HAL_PIXEL_FORMAT_RGB_888;
       break;
     case kFormatRGB565:
       *target = HAL_PIXEL_FORMAT_RGB_565;
       break;
     case kFormatBGR565:
       *target = HAL_PIXEL_FORMAT_BGR_565;
       break;
     case kFormatBGR888:
       *target = HAL_PIXEL_FORMAT_BGR_888;
       break;
     case kFormatBGRA8888:
       *target = HAL_PIXEL_FORMAT_BGRA_8888;
       break;
     case kFormatYCrCb420PlanarStride16:
       *target = HAL_PIXEL_FORMAT_YV12;
       break;
     case kFormatYCrCb420SemiPlanar:
       *target = HAL_PIXEL_FORMAT_YCrCb_420_SP;
       break;
     case kFormatYCbCr420SemiPlanar:
       *target = HAL_PIXEL_FORMAT_YCbCr_420_SP;
       break;
     case kFormatYCbCr422H2V1Packed:
       *target = HAL_PIXEL_FORMAT_YCbCr_422_I;
       break;
     case kFormatCbYCrY422H2V1Packed:
       *target = HAL_PIXEL_FORMAT_CbYCrY_422_I;
       break;
     case kFormatYCbCr422H2V1SemiPlanar:
       *target = HAL_PIXEL_FORMAT_YCbCr_422_SP;
       break;
     case kFormatYCbCr420SemiPlanarVenus:
       *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;
       break;
     case kFormatYCrCb420SemiPlanarVenus:
       *target = HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS;
       break;
     case kFormatYCbCr420SPVenusUbwc:
     case kFormatYCbCr420SPVenusTile:
       *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
       *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
       break;
     case kFormatRGBA5551:
       *target = HAL_PIXEL_FORMAT_RGBA_5551;
       break;
     case kFormatRGBA4444:
       *target = HAL_PIXEL_FORMAT_RGBA_4444;
       break;
     case kFormatRGBA1010102:
       *target = HAL_PIXEL_FORMAT_RGBA_1010102;
       break;
     case kFormatARGB2101010:
       *target = HAL_PIXEL_FORMAT_ARGB_2101010;
       break;
     case kFormatRGBX1010102:
       *target = HAL_PIXEL_FORMAT_RGBX_1010102;
       break;
     case kFormatXRGB2101010:
       *target = HAL_PIXEL_FORMAT_XRGB_2101010;
       break;
     case kFormatBGRA1010102:
       *target = HAL_PIXEL_FORMAT_BGRA_1010102;
       break;
     case kFormatABGR2101010:
       *target = HAL_PIXEL_FORMAT_ABGR_2101010;
       break;
     case kFormatBGRX1010102:
       *target = HAL_PIXEL_FORMAT_BGRX_1010102;
       break;
     case kFormatXBGR2101010:
       *target = HAL_PIXEL_FORMAT_XBGR_2101010;
       break;
     case kFormatYCbCr420P010:
       *target = HAL_PIXEL_FORMAT_YCbCr_420_P010;
       break;
     case kFormatYCbCr420TP10Ubwc:
     case kFormatYCbCr420TP10Tile:
       *target = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;
       *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
       break;
     case kFormatYCbCr420P010Ubwc:
     case kFormatYCbCr420P010Tile:
       *target = HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC;
       *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
       break;
     case kFormatYCbCr420P010Venus:
       *target = HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS;
       break;
     case kFormatRGBA8888Ubwc:
       *target = HAL_PIXEL_FORMAT_RGBA_8888;
       *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
       break;
     case kFormatRGBX8888Ubwc:
       *target = HAL_PIXEL_FORMAT_RGBX_8888;
       *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
       break;
     case kFormatBGR565Ubwc:
       *target = HAL_PIXEL_FORMAT_BGR_565;
       *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
       break;
     case kFormatRGBA1010102Ubwc:
       *target = HAL_PIXEL_FORMAT_RGBA_1010102;
       *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
       break;
     case kFormatRGBX1010102Ubwc:
       *target = HAL_PIXEL_FORMAT_RGBX_1010102;
       *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
       break;
     default:
       DLOGW("Unsupported format = 0x%x", format);
       return -EINVAL;
   }
   return 0;
 }

 DisplayError HWCBufferAllocator::GetAllocatedBufferInfo(
     const BufferConfig &buffer_config, AllocatedBufferInfo *allocated_buffer_info) {
   // TODO(user): This API should pass the buffer_info of the already allocated buffer
   // The private_data can then be typecast to the private_handle and used directly.
   uint64_t alloc_flags = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP;

   int width = INT(buffer_config.width);
   int height = INT(buffer_config.height);
   int format;

   if (buffer_config.secure) {
     alloc_flags |= INT(GRALLOC_USAGE_PROTECTED);
   }

   if (!buffer_config.cache) {
     // Allocate uncached buffers
     alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
   }

   if (SetBufferInfo(buffer_config.format, &format, &alloc_flags) < 0) {
     return kErrorParameters;
   }

   uint32_t aligned_width = 0, aligned_height = 0, buffer_size = 0;
   gralloc::BufferInfo info(width, height, format, alloc_flags);
   int ret = GetBufferSizeAndDimensions(info, &buffer_size, &aligned_width, &aligned_height);
   if (ret < 0) {
     return kErrorParameters;
   }
   allocated_buffer_info->stride = UINT32(aligned_width);
   allocated_buffer_info->aligned_width = UINT32(aligned_width);
   allocated_buffer_info->aligned_height = UINT32(aligned_height);
   allocated_buffer_info->size = UINT32(buffer_size);

   return kErrorNone;
 }

 DisplayError HWCBufferAllocator::GetBufferLayout(const AllocatedBufferInfo &buf_info,
                                                  uint32_t stride[4], uint32_t offset[4],
                                                  uint32_t *num_planes) {
   // TODO(user): Transition APIs to not need a private handle
   private_handle_t hnd(-1, 0, 0, 0, 0, 0, 0);
   int format = HAL_PIXEL_FORMAT_RGBA_8888;
   uint64_t flags = 0;

   SetBufferInfo(buf_info.format, &format, &flags);
   // Setup only the required stuff, skip rest
   hnd.format = format;
   hnd.width = INT32(buf_info.aligned_width);
   hnd.height = INT32(buf_info.aligned_height);
   if (flags & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) {
     hnd.flags = private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
   }

   int ret = gralloc::GetBufferLayout(&hnd, stride, offset, num_planes);
   if (ret < 0) {
     DLOGE("GetBufferLayout failed");
     return kErrorParameters;
   }

   return kErrorNone;
 }

 DisplayError HWCBufferAllocator::MapBuffer(const private_handle_t *handle,
                                            shared_ptr<Fence> acquire_fence) {
   auto err = GetGrallocInstance();
   if (err != kErrorNone) {
     return err;
   }

   Fence::ScopedRef scoped_ref;
   NATIVE_HANDLE_DECLARE_STORAGE(acquire_fence_storage, 1, 0);
   hidl_handle acquire_fence_handle;
   if (acquire_fence) {
     auto h = native_handle_init(acquire_fence_storage, 1, 0);
     h->data[0] = scoped_ref.Get(acquire_fence);
     acquire_fence_handle = h;
   }

   auto hnd = const_cast<private_handle_t *>(handle);
   void *buffer_ptr = NULL;
   if (mapper_V3_ != nullptr) {
     const IMapperV3::Rect access_region = {.left = 0, .top = 0, .width = 0, .height = 0};
     mapper_V3_->lock(
         reinterpret_cast<void *>(hnd), (uint64_t)BufferUsage::CPU_READ_OFTEN, access_region,
         acquire_fence_handle,
         [&](const auto &_error, const auto &_buffer, const auto &_bpp, const auto &_stride) {
           if (_error == MapperV3Error::NONE) {
             buffer_ptr = _buffer;
           }
         });
   } else {
     const IMapperV2::Rect access_region = {.left = 0, .top = 0, .width = 0, .height = 0};
     mapper_V2_->lock(reinterpret_cast<void *>(hnd), (uint64_t)BufferUsage::CPU_READ_OFTEN,
                      access_region, acquire_fence_handle,
                      [&](const auto &_error, const auto &_buffer) {
                        if (_error == Error::NONE) {
                          buffer_ptr = _buffer;
                        }
                      });
   }
   if (!buffer_ptr) {
     return kErrorUndefined;
   }
   return kErrorNone;
 }

 DisplayError HWCBufferAllocator::UnmapBuffer(const private_handle_t *handle, int *release_fence) {
   DisplayError err = kErrorNone;
   *release_fence = -1;
   auto hnd = const_cast<private_handle_t *>(handle);
   if (mapper_V3_ != nullptr) {
     mapper_V3_->unlock(reinterpret_cast<void *>(hnd),
                        [&](const auto &_error, const auto &_release_fence) {
                          if (_error != MapperV3Error::NONE) {
                            err = kErrorUndefined;
                          }
                        });
   } else {
     mapper_V2_->unlock(reinterpret_cast<void *>(hnd),
                        [&](const auto &_error, const auto &_release_fence) {
                          if (_error != Error::NONE) {
                            err = kErrorUndefined;
                          }
                        });
   }
   return err;
 }

 }  // namespace sdm
	/*
	* Copyright (c) 2015-2020, 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
	* met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials provided
	* with the distribution.
	* * Neither the name of The Linux Foundation nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
	* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <gralloc_priv.h>

	#include <core/buffer_allocator.h>
	#include <utils/constants.h>
	#include <utils/debug.h>

	#include "gr_utils.h"
	#include "hwc_buffer_allocator.h"
	#include "hwc_debugger.h"
	#include "hwc_layers.h"

	#define __CLASS__ "HWCBufferAllocator"

	using android::hardware::graphics::mapper::V2_0::Error;
	using MapperV3Error = android::hardware::graphics::mapper::V3_0::Error;
	using android::hardware::graphics::mapper::V2_0::BufferDescriptor;
	using MapperV3BufferDescriptor = android::hardware::graphics::mapper::V3_0::BufferDescriptor;
	using android::hardware::hidl_handle;
	using android::hardware::hidl_vec;

	namespace sdm {

	DisplayError HWCBufferAllocator::GetGrallocInstance() {
	// Lazy initialization of gralloc HALs
	if (mapper_V3_ != nullptr \|\| mapper_V2_ != nullptr \|\| allocator_V3_ != nullptr \|\|
	allocator_V2_ != nullptr) {
	return kErrorNone;
	}

	allocator_V3_ = IAllocatorV3::getService();
	if (allocator_V3_ == nullptr) {
	allocator_V2_ = IAllocatorV2::getService();
	if (allocator_V2_ == nullptr) {
	DLOGE("Unable to get allocator");
	return kErrorCriticalResource;
	}
	}

	mapper_V3_ = IMapperV3::getService();
	if (mapper_V3_ == nullptr) {
	mapper_V2_ = IMapperV2::getService();
	if (mapper_V2_ == nullptr) {
	DLOGE("Unable to get mapper");
	return kErrorCriticalResource;
	}
	}

	return kErrorNone;
	}

	DisplayError HWCBufferAllocator::AllocateBuffer(BufferInfo *buffer_info) {
	auto err = GetGrallocInstance();
	if (err != kErrorNone) {
	return err;
	}
	const BufferConfig &buffer_config = buffer_info->buffer_config;
	AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
	int format;
	uint64_t alloc_flags = 0;
	int error = SetBufferInfo(buffer_config.format, &format, &alloc_flags);
	if (error != 0) {
	return kErrorParameters;
	}

	if (buffer_config.secure) {
	alloc_flags \|= BufferUsage::PROTECTED;
	}

	if (buffer_config.secure_camera) {
	alloc_flags \|= BufferUsage::CAMERA_OUTPUT;
	}

	if (!buffer_config.cache) {
	// Allocate uncached buffers
	alloc_flags \|= GRALLOC_USAGE_PRIVATE_UNCACHED;
	}

	if (buffer_config.gfx_client) {
	alloc_flags \|= BufferUsage::GPU_TEXTURE;
	}

	alloc_flags \|= BufferUsage::COMPOSER_OVERLAY;

	const native_handle_t *buf = nullptr;

	if (mapper_V3_ != nullptr) {
	IMapperV3::BufferDescriptorInfo descriptor_info;
	descriptor_info.width = buffer_config.width;
	descriptor_info.height = buffer_config.height;
	descriptor_info.layerCount = 1;
	descriptor_info.format =
	static_cast<android::hardware::graphics::common::V1_2::PixelFormat>(format);
	descriptor_info.usage = alloc_flags;

	auto hidl_err = MapperV3Error::NONE;

	auto descriptor = BufferDescriptor();
	mapper_V3_->createDescriptor(descriptor_info, [&](const auto &_error, const auto &_descriptor) {
	hidl_err = _error;
	if (hidl_err != MapperV3Error::NONE) {
	return;
	}
	descriptor = _descriptor;
	});

	if (hidl_err != MapperV3Error::NONE) {
	DLOGE("Failed to create descriptor");
	return kErrorMemory;
	}

	hidl_handle raw_handle = nullptr;

	allocator_V3_->allocate(descriptor, 1,
	[&](const auto &_error, const auto &_stride, const auto &_buffers) {
	hidl_err = _error;
	if (hidl_err != MapperV3Error::NONE) {
	return;
	}
	raw_handle = _buffers[0];
	});

	if (hidl_err != MapperV3Error::NONE) {
	DLOGE("Failed to allocate buffer");
	return kErrorMemory;
	}

	mapper_V3_->importBuffer(raw_handle, [&](const auto &_error, const auto &_buffer) {
	hidl_err = _error;
	if (hidl_err != MapperV3Error::NONE) {
	return;
	}
	buf = static_cast<const native_handle_t *>(_buffer);
	});

	if (hidl_err != MapperV3Error::NONE) {
	DLOGE("Failed to import buffer into HWC");
	return kErrorMemory;
	}
	} else {
	IMapperV2::BufferDescriptorInfo descriptor_info;
	descriptor_info.width = buffer_config.width;
	descriptor_info.height = buffer_config.height;
	descriptor_info.layerCount = 1;
	descriptor_info.format =
	static_cast<android::hardware::graphics::common::V1_0::PixelFormat>(format);
	descriptor_info.usage = alloc_flags;

	auto hidl_err = Error::NONE;

	auto descriptor = BufferDescriptor();
	mapper_V2_->createDescriptor(descriptor_info, [&](const auto &_error, const auto &_descriptor) {
	hidl_err = _error;
	if (hidl_err != Error::NONE) {
	return;
	}
	descriptor = _descriptor;
	});

	if (hidl_err != Error::NONE) {
	DLOGE("Failed to create descriptor");
	return kErrorMemory;
	}

	hidl_handle raw_handle = nullptr;

	allocator_V2_->allocate(descriptor, 1,
	[&](const auto &_error, const auto &_stride, const auto &_buffers) {
	hidl_err = _error;
	if (hidl_err != Error::NONE) {
	return;
	}
	raw_handle = _buffers[0];
	});

	if (hidl_err != Error::NONE) {
	DLOGE("Failed to allocate buffer");
	return kErrorMemory;
	}

	mapper_V2_->importBuffer(raw_handle, [&](const auto &_error, const auto &_buffer) {
	hidl_err = _error;
	if (hidl_err != Error::NONE) {
	return;
	}
	buf = static_cast<const native_handle_t *>(_buffer);
	});

	if (hidl_err != Error::NONE) {
	DLOGE("Failed to import buffer into HWC");
	return kErrorMemory;
	}
	}

	private_handle_t *hnd = nullptr;
	hnd = (private_handle_t *)buf; // NOLINT
	alloc_buffer_info->fd = hnd->fd;
	alloc_buffer_info->stride = UINT32(hnd->width);
	alloc_buffer_info->aligned_width = UINT32(hnd->width);
	alloc_buffer_info->aligned_height = UINT32(hnd->height);
	alloc_buffer_info->size = hnd->size;
	alloc_buffer_info->id = hnd->id;
	alloc_buffer_info->format = HWCLayer::GetSDMFormat(hnd->format, hnd->flags);

	buffer_info->private_data = reinterpret_cast<void *>(hnd);
	return kErrorNone;
	}

	DisplayError HWCBufferAllocator::FreeBuffer(BufferInfo *buffer_info) {
	DisplayError err = kErrorNone;
	auto hnd = reinterpret_cast<void *>(buffer_info->private_data);
	if (mapper_V3_ != nullptr) {
	mapper_V3_->freeBuffer(hnd);
	} else {
	mapper_V2_->freeBuffer(hnd);
	}
	AllocatedBufferInfo &alloc_buffer_info = buffer_info->alloc_buffer_info;

	alloc_buffer_info.fd = -1;
	alloc_buffer_info.stride = 0;
	alloc_buffer_info.size = 0;
	buffer_info->private_data = NULL;
	return err;
	}

	void HWCBufferAllocator::GetCustomWidthAndHeight(const private_handle_t handle, int width,
	int *height) {
	*width = handle->width;
	*height = handle->height;
	gralloc::GetCustomDimensions(const_cast<private_handle_t *>(handle), width, height);
	}

	void HWCBufferAllocator::GetAlignedWidthAndHeight(int width, int height, int format,
	uint32_t alloc_type, int *aligned_width,
	int *aligned_height) {
	uint64_t usage = 0;
	if (alloc_type & GRALLOC_USAGE_HW_FB) {
	usage \|= BufferUsage::COMPOSER_CLIENT_TARGET;
	}
	if (alloc_type & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) {
	usage \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	}
	uint32_t aligned_w = UINT(width);
	uint32_t aligned_h = UINT(height);
	gralloc::BufferInfo info(width, height, format, usage);
	gralloc::GetAlignedWidthAndHeight(info, &aligned_w, &aligned_h);
	*aligned_width = INT(aligned_w);
	*aligned_height = INT(aligned_h);
	}

	uint32_t HWCBufferAllocator::GetBufferSize(BufferInfo *buffer_info) {
	const BufferConfig &buffer_config = buffer_info->buffer_config;
	uint64_t alloc_flags = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP;

	int width = INT(buffer_config.width);
	int height = INT(buffer_config.height);
	int format;

	if (buffer_config.secure) {
	alloc_flags \|= INT(GRALLOC_USAGE_PROTECTED);
	}

	if (!buffer_config.cache) {
	// Allocate uncached buffers
	alloc_flags \|= GRALLOC_USAGE_PRIVATE_UNCACHED;
	}

	if (SetBufferInfo(buffer_config.format, &format, &alloc_flags) < 0) {
	return 0;
	}

	uint32_t aligned_width = 0, aligned_height = 0, buffer_size = 0;
	gralloc::BufferInfo info(width, height, format, alloc_flags);
	int ret = GetBufferSizeAndDimensions(info, &buffer_size, &aligned_width, &aligned_height);
	if (ret < 0) {
	return 0;
	}
	return buffer_size;
	}

	int HWCBufferAllocator::SetBufferInfo(LayerBufferFormat format, int target, uint64_t flags) {
	switch (format) {
	case kFormatRGBA8888:
	*target = HAL_PIXEL_FORMAT_RGBA_8888;
	break;
	case kFormatRGBX8888:
	*target = HAL_PIXEL_FORMAT_RGBX_8888;
	break;
	case kFormatRGB888:
	*target = HAL_PIXEL_FORMAT_RGB_888;
	break;
	case kFormatRGB565:
	*target = HAL_PIXEL_FORMAT_RGB_565;
	break;
	case kFormatBGR565:
	*target = HAL_PIXEL_FORMAT_BGR_565;
	break;
	case kFormatBGR888:
	*target = HAL_PIXEL_FORMAT_BGR_888;
	break;
	case kFormatBGRA8888:
	*target = HAL_PIXEL_FORMAT_BGRA_8888;
	break;
	case kFormatYCrCb420PlanarStride16:
	*target = HAL_PIXEL_FORMAT_YV12;
	break;
	case kFormatYCrCb420SemiPlanar:
	*target = HAL_PIXEL_FORMAT_YCrCb_420_SP;
	break;
	case kFormatYCbCr420SemiPlanar:
	*target = HAL_PIXEL_FORMAT_YCbCr_420_SP;
	break;
	case kFormatYCbCr422H2V1Packed:
	*target = HAL_PIXEL_FORMAT_YCbCr_422_I;
	break;
	case kFormatCbYCrY422H2V1Packed:
	*target = HAL_PIXEL_FORMAT_CbYCrY_422_I;
	break;
	case kFormatYCbCr422H2V1SemiPlanar:
	*target = HAL_PIXEL_FORMAT_YCbCr_422_SP;
	break;
	case kFormatYCbCr420SemiPlanarVenus:
	*target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;
	break;
	case kFormatYCrCb420SemiPlanarVenus:
	*target = HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS;
	break;
	case kFormatYCbCr420SPVenusUbwc:
	case kFormatYCbCr420SPVenusTile:
	*target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
	*flags \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	break;
	case kFormatRGBA5551:
	*target = HAL_PIXEL_FORMAT_RGBA_5551;
	break;
	case kFormatRGBA4444:
	*target = HAL_PIXEL_FORMAT_RGBA_4444;
	break;
	case kFormatRGBA1010102:
	*target = HAL_PIXEL_FORMAT_RGBA_1010102;
	break;
	case kFormatARGB2101010:
	*target = HAL_PIXEL_FORMAT_ARGB_2101010;
	break;
	case kFormatRGBX1010102:
	*target = HAL_PIXEL_FORMAT_RGBX_1010102;
	break;
	case kFormatXRGB2101010:
	*target = HAL_PIXEL_FORMAT_XRGB_2101010;
	break;
	case kFormatBGRA1010102:
	*target = HAL_PIXEL_FORMAT_BGRA_1010102;
	break;
	case kFormatABGR2101010:
	*target = HAL_PIXEL_FORMAT_ABGR_2101010;
	break;
	case kFormatBGRX1010102:
	*target = HAL_PIXEL_FORMAT_BGRX_1010102;
	break;
	case kFormatXBGR2101010:
	*target = HAL_PIXEL_FORMAT_XBGR_2101010;
	break;
	case kFormatYCbCr420P010:
	*target = HAL_PIXEL_FORMAT_YCbCr_420_P010;
	break;
	case kFormatYCbCr420TP10Ubwc:
	case kFormatYCbCr420TP10Tile:
	*target = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;
	*flags \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	break;
	case kFormatYCbCr420P010Ubwc:
	case kFormatYCbCr420P010Tile:
	*target = HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC;
	*flags \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	break;
	case kFormatYCbCr420P010Venus:
	*target = HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS;
	break;
	case kFormatRGBA8888Ubwc:
	*target = HAL_PIXEL_FORMAT_RGBA_8888;
	*flags \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	break;
	case kFormatRGBX8888Ubwc:
	*target = HAL_PIXEL_FORMAT_RGBX_8888;
	*flags \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	break;
	case kFormatBGR565Ubwc:
	*target = HAL_PIXEL_FORMAT_BGR_565;
	*flags \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	break;
	case kFormatRGBA1010102Ubwc:
	*target = HAL_PIXEL_FORMAT_RGBA_1010102;
	*flags \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	break;
	case kFormatRGBX1010102Ubwc:
	*target = HAL_PIXEL_FORMAT_RGBX_1010102;
	*flags \|= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
	break;
	default:
	DLOGW("Unsupported format = 0x%x", format);
	return -EINVAL;
	}
	return 0;
	}

	DisplayError HWCBufferAllocator::GetAllocatedBufferInfo(
	const BufferConfig &buffer_config, AllocatedBufferInfo *allocated_buffer_info) {
	// TODO(user): This API should pass the buffer_info of the already allocated buffer
	// The private_data can then be typecast to the private_handle and used directly.
	uint64_t alloc_flags = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP;

	int width = INT(buffer_config.width);
	int height = INT(buffer_config.height);
	int format;

	if (buffer_config.secure) {
	alloc_flags \|= INT(GRALLOC_USAGE_PROTECTED);
	}

	if (!buffer_config.cache) {
	// Allocate uncached buffers
	alloc_flags \|= GRALLOC_USAGE_PRIVATE_UNCACHED;
	}

	if (SetBufferInfo(buffer_config.format, &format, &alloc_flags) < 0) {
	return kErrorParameters;
	}

	uint32_t aligned_width = 0, aligned_height = 0, buffer_size = 0;
	gralloc::BufferInfo info(width, height, format, alloc_flags);
	int ret = GetBufferSizeAndDimensions(info, &buffer_size, &aligned_width, &aligned_height);
	if (ret < 0) {
	return kErrorParameters;
	}
	allocated_buffer_info->stride = UINT32(aligned_width);
	allocated_buffer_info->aligned_width = UINT32(aligned_width);
	allocated_buffer_info->aligned_height = UINT32(aligned_height);
	allocated_buffer_info->size = UINT32(buffer_size);

	return kErrorNone;
	}

	DisplayError HWCBufferAllocator::GetBufferLayout(const AllocatedBufferInfo &buf_info,
	uint32_t stride[4], uint32_t offset[4],
	uint32_t *num_planes) {
	// TODO(user): Transition APIs to not need a private handle
	private_handle_t hnd(-1, 0, 0, 0, 0, 0, 0);
	int format = HAL_PIXEL_FORMAT_RGBA_8888;
	uint64_t flags = 0;

	SetBufferInfo(buf_info.format, &format, &flags);
	// Setup only the required stuff, skip rest
	hnd.format = format;
	hnd.width = INT32(buf_info.aligned_width);
	hnd.height = INT32(buf_info.aligned_height);
	if (flags & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) {
	hnd.flags = private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
	}

	int ret = gralloc::GetBufferLayout(&hnd, stride, offset, num_planes);
	if (ret < 0) {
	DLOGE("GetBufferLayout failed");
	return kErrorParameters;
	}

	return kErrorNone;
	}

	DisplayError HWCBufferAllocator::MapBuffer(const private_handle_t *handle,
	shared_ptr<Fence> acquire_fence) {
	auto err = GetGrallocInstance();
	if (err != kErrorNone) {
	return err;
	}

	Fence::ScopedRef scoped_ref;
	NATIVE_HANDLE_DECLARE_STORAGE(acquire_fence_storage, 1, 0);
	hidl_handle acquire_fence_handle;
	if (acquire_fence) {
	auto h = native_handle_init(acquire_fence_storage, 1, 0);
	h->data[0] = scoped_ref.Get(acquire_fence);
	acquire_fence_handle = h;
	}

	auto hnd = const_cast<private_handle_t *>(handle);
	void *buffer_ptr = NULL;
	if (mapper_V3_ != nullptr) {
	const IMapperV3::Rect access_region = {.left = 0, .top = 0, .width = 0, .height = 0};
	mapper_V3_->lock(
	reinterpret_cast<void *>(hnd), (uint64_t)BufferUsage::CPU_READ_OFTEN, access_region,
	acquire_fence_handle,
	[&](const auto &_error, const auto &_buffer, const auto &_bpp, const auto &_stride) {
	if (_error == MapperV3Error::NONE) {
	buffer_ptr = _buffer;
	}
	});
	} else {
	const IMapperV2::Rect access_region = {.left = 0, .top = 0, .width = 0, .height = 0};
	mapper_V2_->lock(reinterpret_cast<void *>(hnd), (uint64_t)BufferUsage::CPU_READ_OFTEN,
	access_region, acquire_fence_handle,
	[&](const auto &_error, const auto &_buffer) {
	if (_error == Error::NONE) {
	buffer_ptr = _buffer;
	}
	});
	}
	if (!buffer_ptr) {
	return kErrorUndefined;
	}
	return kErrorNone;
	}

	DisplayError HWCBufferAllocator::UnmapBuffer(const private_handle_t handle, int release_fence) {
	DisplayError err = kErrorNone;
	*release_fence = -1;
	auto hnd = const_cast<private_handle_t *>(handle);
	if (mapper_V3_ != nullptr) {
	mapper_V3_->unlock(reinterpret_cast<void *>(hnd),
	[&](const auto &_error, const auto &_release_fence) {
	if (_error != MapperV3Error::NONE) {
	err = kErrorUndefined;
	}
	});
	} else {
	mapper_V2_->unlock(reinterpret_cast<void *>(hnd),
	[&](const auto &_error, const auto &_release_fence) {
	if (_error != Error::NONE) {
	err = kErrorUndefined;
	}
	});
	}
	return err;
	}

	} // namespace sdm