blob: 24e9227b1755d7d7990ff0f11d039f605294c85d [file] [log] [blame]
/*
* Copyright (c) 2015-2018, 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"
#define __CLASS__ "HWCBufferAllocator"
using android::hardware::graphics::common::V1_0::PixelFormat;
using android::hardware::graphics::mapper::V2_0::BufferDescriptor;
using android::hardware::graphics::mapper::V2_0::Error;
using android::hardware::hidl_handle;
using android::hardware::hidl_vec;
namespace sdm {
DisplayError HWCBufferAllocator::GetGrallocInstance() {
// Lazy initialization of gralloc HALs
if (mapper_ != nullptr || allocator_ != nullptr) {
return kErrorNone;
}
allocator_ = IAllocator::getService();
mapper_ = IMapper::getService();
if (mapper_ == nullptr || allocator_ == nullptr) {
DLOGE("Unable to get mapper or allocator");
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;
IMapper::BufferDescriptorInfo descriptor_info;
descriptor_info.width = buffer_config.width;
descriptor_info.height = buffer_config.height;
descriptor_info.layerCount = 1;
descriptor_info.format = static_cast<PixelFormat>(format);
descriptor_info.usage = alloc_flags;
auto descriptor = BufferDescriptor();
auto hidl_err = Error::NONE;
mapper_->createDescriptor(descriptor_info, [&](const auto &_error, const auto &_descriptor) {
hidl_err = _error;
descriptor = _descriptor;
});
if (hidl_err != Error::NONE) {
DLOGE("Failed to create descriptor");
return kErrorMemory;
}
hidl_handle raw_handle = nullptr;
private_handle_t *hnd = nullptr;
allocator_->allocate(descriptor, 1,
[&](const auto &_error, const auto &_stride, const auto &_buffers) {
hidl_err = _error;
raw_handle = _buffers[0];
});
if (hidl_err != Error::NONE) {
DLOGE("Failed to allocate buffer");
return kErrorMemory;
}
const native_handle_t *buf = nullptr;
mapper_->importBuffer(raw_handle, [&](const auto &_error, const auto &_buffer) {
hidl_err = _error;
buf = static_cast<const native_handle_t *>(_buffer);
});
if (hidl_err != Error::NONE) {
DLOGE("Failed to import buffer into HWC");
return kErrorMemory;
}
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;
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);
mapper_->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);
GetBufferSizeAndDimensions(info, &buffer_size, &aligned_width, &aligned_height);
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:
*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:
*target = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;
*flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
break;
case kFormatYCbCr420P010Ubwc:
*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:
DLOGE("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);
GetBufferSizeAndDimensions(info, &buffer_size, &aligned_width, &aligned_height);
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, int acquire_fence) {
auto err = GetGrallocInstance();
if (err != kErrorNone) {
return err;
}
void *buffer_ptr = NULL;
const IMapper::Rect access_region = {.left = 0, .top = 0, .width = 0, .height = 0};
NATIVE_HANDLE_DECLARE_STORAGE(acquire_fence_storage, 1, 0);
hidl_handle acquire_fence_handle;
if (acquire_fence >= 0) {
auto h = native_handle_init(acquire_fence_storage, 1, 0);
h->data[0] = acquire_fence;
acquire_fence_handle = h;
}
auto hnd = const_cast<private_handle_t *>(handle);
mapper_->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);
mapper_->unlock(reinterpret_cast<void *>(hnd),
[&](const auto &_error, const auto &_release_fence) {
if (_error != Error::NONE) {
err = kErrorUndefined;
}
});
return err;
}
} // namespace sdm