From 2a24a30904821360ed9116ff2fde598ed6c3bc6f Mon Sep 17 00:00:00 2001 From: Marissa Wall Date: Mon, 25 Nov 2019 11:19:18 -0800 Subject: [PATCH] gralloc: move codec2 to GraphicBufferAllocator/Mapper libui's GraphicBufferAllocator/Mapper already wrap the different gralloc functions and hide the details from the caller. There is no reason C2AllocatorGralloc needs to directly talk to gralloc. This patch updates C2AllocatorGralloc to use libui. Bug: 145139476 Test: Cherry pick ag/9741096 and run android.media.cts.MediaMetadataRetrieverTest#testThumbnailVP9Hdr Change-Id: I41e106ea8faad02b1eb4d20557dda3ecb1aeedec --- media/codec2/vndk/Android.bp | 7 +- media/codec2/vndk/C2AllocatorGralloc.cpp | 947 ++++------------------- 2 files changed, 137 insertions(+), 817 deletions(-) diff --git a/media/codec2/vndk/Android.bp b/media/codec2/vndk/Android.bp index e0b3939af6..071bb746f3 100644 --- a/media/codec2/vndk/Android.bp +++ b/media/codec2/vndk/Android.bp @@ -50,13 +50,8 @@ cc_library_shared { ], shared_libs: [ - "android.hardware.graphics.allocator@2.0", - "android.hardware.graphics.allocator@3.0", - "android.hardware.graphics.allocator@4.0", "android.hardware.graphics.bufferqueue@2.0", - "android.hardware.graphics.mapper@2.0", - "android.hardware.graphics.mapper@3.0", - "android.hardware.graphics.mapper@4.0", + "android.hardware.graphics.common@1.2", "android.hardware.media.bufferpool@2.0", "libbase", "libcutils", diff --git a/media/codec2/vndk/C2AllocatorGralloc.cpp b/media/codec2/vndk/C2AllocatorGralloc.cpp index 78ac35507f..3ac3d89fe4 100644 --- a/media/codec2/vndk/C2AllocatorGralloc.cpp +++ b/media/codec2/vndk/C2AllocatorGralloc.cpp @@ -18,19 +18,21 @@ #define LOG_TAG "C2AllocatorGralloc" #include -#include -#include -#include -#include -#include -#include +#include + +#include #include #include +#include +#include #include #include #include +using ::android::hardware::hidl_handle; +using PixelFormat4 = ::android::hardware::graphics::common::V1_2::PixelFormat; + namespace android { namespace /* unnamed */ { @@ -63,82 +65,9 @@ uint64_t C2AndroidMemoryUsage::asGrallocUsage() const { (expected & PASSTHROUGH_USAGE_MASK)); } -using ::android::hardware::hidl_handle; -using ::android::hardware::hidl_vec; -using ::android::hardware::graphics::common::V1_0::BufferUsage; -using PixelFormat2 = ::android::hardware::graphics::common::V1_0::PixelFormat; -using PixelFormat3 = ::android::hardware::graphics::common::V1_2::PixelFormat; -using PixelFormat4 = ::android::hardware::graphics::common::V1_2::PixelFormat; - -using IAllocator2 = ::android::hardware::graphics::allocator::V2_0::IAllocator; -using BufferDescriptor2 = ::android::hardware::graphics::mapper::V2_0::BufferDescriptor; -using Error2 = ::android::hardware::graphics::mapper::V2_0::Error; -using IMapper2 = ::android::hardware::graphics::mapper::V2_0::IMapper; - -using IAllocator3 = ::android::hardware::graphics::allocator::V3_0::IAllocator; -using BufferDescriptor3 = ::android::hardware::graphics::mapper::V3_0::BufferDescriptor; -using Error3 = ::android::hardware::graphics::mapper::V3_0::Error; -using IMapper3 = ::android::hardware::graphics::mapper::V3_0::IMapper; - -using IAllocator4 = ::android::hardware::graphics::allocator::V4_0::IAllocator; -using BufferDescriptor4 = ::android::hardware::graphics::mapper::V4_0::BufferDescriptor; -using Error4 = ::android::hardware::graphics::mapper::V4_0::Error; -using IMapper4 = ::android::hardware::graphics::mapper::V4_0::IMapper; - namespace /* unnamed */ { -struct BufferDescriptorInfo2 { - IMapper2::BufferDescriptorInfo mapperInfo; - uint32_t stride; -}; - -struct BufferDescriptorInfo3 { - IMapper3::BufferDescriptorInfo mapperInfo; - uint32_t stride; -}; - -struct BufferDescriptorInfo4 { - IMapper4::BufferDescriptorInfo mapperInfo; - uint32_t stride; -}; - /* ===================================== GRALLOC ALLOCATION ==================================== */ -c2_status_t maperr2error(Error2 maperr) { - switch (maperr) { - case Error2::NONE: return C2_OK; - case Error2::BAD_DESCRIPTOR: return C2_BAD_VALUE; - case Error2::BAD_BUFFER: return C2_BAD_VALUE; - case Error2::BAD_VALUE: return C2_BAD_VALUE; - case Error2::NO_RESOURCES: return C2_NO_MEMORY; - case Error2::UNSUPPORTED: return C2_CANNOT_DO; - } - return C2_CORRUPTED; -} - -c2_status_t maperr2error(Error3 maperr) { - switch (maperr) { - case Error3::NONE: return C2_OK; - case Error3::BAD_DESCRIPTOR: return C2_BAD_VALUE; - case Error3::BAD_BUFFER: return C2_BAD_VALUE; - case Error3::BAD_VALUE: return C2_BAD_VALUE; - case Error3::NO_RESOURCES: return C2_NO_MEMORY; - case Error3::UNSUPPORTED: return C2_CANNOT_DO; - } - return C2_CORRUPTED; -} - -c2_status_t maperr2error(Error4 maperr) { - switch (maperr) { - case Error4::NONE: return C2_OK; - case Error4::BAD_DESCRIPTOR: return C2_BAD_VALUE; - case Error4::BAD_BUFFER: return C2_BAD_VALUE; - case Error4::BAD_VALUE: return C2_BAD_VALUE; - case Error4::NO_RESOURCES: return C2_NO_MEMORY; - case Error4::UNSUPPORTED: return C2_CANNOT_DO; - } - return C2_CORRUPTED; -} - bool native_handle_is_invalid(const native_handle_t *const handle) { // perform basic validation of a native handle if (handle == nullptr) { @@ -334,21 +263,11 @@ public: // internal methods // |handle| will be moved. + C2AllocationGralloc( - const BufferDescriptorInfo2 &info, - const sp &mapper, - hidl_handle &hidlHandle, - const C2HandleGralloc *const handle, - C2Allocator::id_t allocatorId); - C2AllocationGralloc( - const BufferDescriptorInfo3 &info, - const sp &mapper, - hidl_handle &hidlHandle, - const C2HandleGralloc *const handle, - C2Allocator::id_t allocatorId); - C2AllocationGralloc( - const BufferDescriptorInfo4 &info, - const sp &mapper, + uint32_t width, uint32_t height, + uint32_t format, uint32_t layerCount, + uint64_t grallocUsage, uint32_t stride, hidl_handle &hidlHandle, const C2HandleGralloc *const handle, C2Allocator::id_t allocatorId); @@ -356,12 +275,12 @@ public: c2_status_t status() const; private: - const BufferDescriptorInfo2 mInfo2{}; - const sp mMapper2{nullptr}; - const BufferDescriptorInfo3 mInfo3{}; - const sp mMapper3{nullptr}; - const BufferDescriptorInfo4 mInfo4{}; - const sp mMapper4{nullptr}; + const uint32_t mWidth; + const uint32_t mHeight; + const uint32_t mFormat; + const uint32_t mLayerCount; + const uint64_t mGrallocUsage; + const uint32_t mStride; const hidl_handle mHidlHandle; const C2HandleGralloc *mHandle; buffer_handle_t mBuffer; @@ -372,48 +291,19 @@ private: }; C2AllocationGralloc::C2AllocationGralloc( - const BufferDescriptorInfo2 &info, - const sp &mapper, + uint32_t width, uint32_t height, + uint32_t format, uint32_t layerCount, + uint64_t grallocUsage, uint32_t stride, hidl_handle &hidlHandle, const C2HandleGralloc *const handle, C2Allocator::id_t allocatorId) - : C2GraphicAllocation(info.mapperInfo.width, info.mapperInfo.height), - mInfo2(info), - mMapper2(mapper), - mHidlHandle(std::move(hidlHandle)), - mHandle(handle), - mBuffer(nullptr), - mLockedHandle(nullptr), - mLocked(false), - mAllocatorId(allocatorId) { -} - -C2AllocationGralloc::C2AllocationGralloc( - const BufferDescriptorInfo3 &info, - const sp &mapper, - hidl_handle &hidlHandle, - const C2HandleGralloc *const handle, - C2Allocator::id_t allocatorId) - : C2GraphicAllocation(info.mapperInfo.width, info.mapperInfo.height), - mInfo3(info), - mMapper3(mapper), - mHidlHandle(std::move(hidlHandle)), - mHandle(handle), - mBuffer(nullptr), - mLockedHandle(nullptr), - mLocked(false), - mAllocatorId(allocatorId) { -} - -C2AllocationGralloc::C2AllocationGralloc( - const BufferDescriptorInfo4 &info, - const sp &mapper, - hidl_handle &hidlHandle, - const C2HandleGralloc *const handle, - C2Allocator::id_t allocatorId) - : C2GraphicAllocation(info.mapperInfo.width, info.mapperInfo.height), - mInfo4(info), - mMapper4(mapper), + : C2GraphicAllocation(width, height), + mWidth(width), + mHeight(height), + mFormat(format), + mLayerCount(layerCount), + mGrallocUsage(grallocUsage), + mStride(stride), mHidlHandle(std::move(hidlHandle)), mHandle(handle), mBuffer(nullptr), @@ -429,23 +319,10 @@ C2AllocationGralloc::~C2AllocationGralloc() { unmap(addr, C2Rect(), nullptr); } if (mBuffer) { - if (mMapper2) { - if (!mMapper2->freeBuffer(const_cast( - mBuffer)).isOk()) { - ALOGE("failed transaction: freeBuffer"); - } - } else if (mMapper3) { - if (!mMapper3->freeBuffer(const_cast( - mBuffer)).isOk()) { - ALOGE("failed transaction: freeBuffer"); - } - } else { - if (!mMapper4->freeBuffer(const_cast( - mBuffer)).isOk()) { - ALOGE("failed transaction: freeBuffer"); - } + status_t err = GraphicBufferMapper::get().freeBuffer(mBuffer); + if (err) { + ALOGE("failed transaction: freeBuffer"); } - } if (mHandle) { native_handle_delete( @@ -466,7 +343,7 @@ c2_status_t C2AllocationGralloc::map( (long long)usage.expected, (long long)grallocUsage); // TODO - (void) fence; + (void)fence; std::lock_guard lock(mMappedLock); if (mBuffer && mLocked) { @@ -478,45 +355,13 @@ c2_status_t C2AllocationGralloc::map( return C2_BAD_VALUE; } - c2_status_t err = C2_OK; if (!mBuffer) { - if (mMapper2) { - if (!mMapper2->importBuffer( - mHidlHandle, [&err, this](const auto &maperr, const auto &buffer) { - err = maperr2error(maperr); - if (err == C2_OK) { - mBuffer = static_cast(buffer); - } - }).isOk()) { - ALOGE("failed transaction: importBuffer"); - return C2_CORRUPTED; - } - } else if (mMapper3) { - if (!mMapper3->importBuffer( - mHidlHandle, [&err, this](const auto &maperr, const auto &buffer) { - err = maperr2error(maperr); - if (err == C2_OK) { - mBuffer = static_cast(buffer); - } - }).isOk()) { - ALOGE("failed transaction: importBuffer (@3.0)"); - return C2_CORRUPTED; - } - } else { - if (!mMapper4->importBuffer( - mHidlHandle, [&err, this](const auto &maperr, const auto &buffer) { - err = maperr2error(maperr); - if (err == C2_OK) { - mBuffer = static_cast(buffer); - } - }).isOk()) { - ALOGE("failed transaction: importBuffer (@4.0)"); - return C2_CORRUPTED; - } - } - if (err != C2_OK) { - ALOGD("importBuffer failed: %d", err); - return err; + status_t err = GraphicBufferMapper::get().importBuffer( + mHidlHandle.getNativeHandle(), mWidth, mHeight, mLayerCount, + mFormat, mGrallocUsage, mStride, &mBuffer); + if (err) { + ALOGE("failed transaction: importBuffer"); + return C2_CORRUPTED; } if (mBuffer == nullptr) { ALOGD("importBuffer returned null buffer"); @@ -528,96 +373,26 @@ c2_status_t C2AllocationGralloc::map( if (mHandle) { mHandle->getIgbpData(&generation, &igbp_id, &igbp_slot); } - if (mMapper2) { - mLockedHandle = C2HandleGralloc::WrapAndMoveNativeHandle( - mBuffer, mInfo2.mapperInfo.width, mInfo2.mapperInfo.height, - (uint32_t)mInfo2.mapperInfo.format, mInfo2.mapperInfo.usage, - mInfo2.stride, generation, igbp_id, igbp_slot); - } else if (mMapper3) { - mLockedHandle = C2HandleGralloc::WrapAndMoveNativeHandle( - mBuffer, mInfo3.mapperInfo.width, mInfo3.mapperInfo.height, - (uint32_t)mInfo3.mapperInfo.format, mInfo3.mapperInfo.usage, - mInfo3.stride, generation, igbp_id, igbp_slot); - } else { - mLockedHandle = C2HandleGralloc::WrapAndMoveNativeHandle( - mBuffer, mInfo4.mapperInfo.width, mInfo4.mapperInfo.height, - (uint32_t)mInfo4.mapperInfo.format, mInfo4.mapperInfo.usage, - mInfo4.stride, generation, igbp_id, igbp_slot); - } - } - PixelFormat4 format; - if (mMapper2) { - format = PixelFormat4(mInfo2.mapperInfo.format); - } else if (mMapper3) { - format = PixelFormat4(mInfo3.mapperInfo.format); - } else { - format = PixelFormat4(mInfo4.mapperInfo.format); + mLockedHandle = C2HandleGralloc::WrapAndMoveNativeHandle( + mBuffer, mWidth, mHeight, mFormat, mGrallocUsage, + mStride, generation, igbp_id, igbp_slot); } - switch (format) { - case PixelFormat4::RGBA_1010102: { + switch (mFormat) { + case static_cast(PixelFormat4::RGBA_1010102): { // TRICKY: this is used for media as YUV444 in the case when it is queued directly to a // Surface. In all other cases it is RGBA. We don't know which case it is here, so // default to YUV for now. void *pointer = nullptr; - if (mMapper2) { - if (!mMapper2->lock( - const_cast(mBuffer), - grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto &maperr, const auto &mapPointer) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - }).isOk()) { - ALOGE("failed transaction: lock(RGBA_1010102)"); - return C2_CORRUPTED; - } - } else if (mMapper3) { - if (!mMapper3->lock( - const_cast(mBuffer), - grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto &maperr, const auto &mapPointer, - int32_t bytesPerPixel, int32_t bytesPerStride) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - (void)bytesPerPixel; - (void)bytesPerStride; - }).isOk()) { - ALOGE("failed transaction: lock(RGBA_1010102) (@3.0)"); - return C2_CORRUPTED; - } - } else { - if (!mMapper4->lock( - const_cast(mBuffer), - grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto &maperr, const auto &mapPointer) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - }).isOk()) { - ALOGE("failed transaction: lock(RGBA_1010102) (@4.0)"); - return C2_CORRUPTED; - } - } - if (err != C2_OK) { - ALOGD("lock failed: %d", err); - return err; + // TODO: fence + status_t err = GraphicBufferMapper::get().lock( + const_cast(mBuffer), grallocUsage, + { (int32_t)rect.left, (int32_t)rect.top, + (int32_t)rect.width, (int32_t)rect.height }, + &pointer); + if (err) { + ALOGE("failed transaction: lock(RGBA_1010102)"); + return C2_CORRUPTED; } // treat as 32-bit values addr[C2PlanarLayout::PLANE_Y] = (uint8_t *)pointer; @@ -627,18 +402,10 @@ c2_status_t C2AllocationGralloc::map( layout->type = C2PlanarLayout::TYPE_YUVA; layout->numPlanes = 4; layout->rootPlanes = 1; - int32_t stride; - if (mMapper2) { - stride = int32_t(mInfo2.stride); - } else if (mMapper3) { - stride = int32_t(mInfo3.stride); - } else { - stride = int32_t(mInfo4.stride); - } layout->planes[C2PlanarLayout::PLANE_Y] = { C2PlaneInfo::CHANNEL_Y, // channel 4, // colInc - 4 * stride, // rowInc + static_cast(4 * mStride), // rowInc 1, // mColSampling 1, // mRowSampling 32, // allocatedDepth @@ -651,7 +418,7 @@ c2_status_t C2AllocationGralloc::map( layout->planes[C2PlanarLayout::PLANE_U] = { C2PlaneInfo::CHANNEL_CB, // channel 4, // colInc - 4 * stride, // rowInc + static_cast(4 * mStride), // rowInc 1, // mColSampling 1, // mRowSampling 32, // allocatedDepth @@ -664,7 +431,7 @@ c2_status_t C2AllocationGralloc::map( layout->planes[C2PlanarLayout::PLANE_V] = { C2PlaneInfo::CHANNEL_CR, // channel 4, // colInc - 4 * stride, // rowInc + static_cast(4 * mStride), // rowInc 1, // mColSampling 1, // mRowSampling 32, // allocatedDepth @@ -677,7 +444,7 @@ c2_status_t C2AllocationGralloc::map( layout->planes[C2PlanarLayout::PLANE_A] = { C2PlaneInfo::CHANNEL_A, // channel 4, // colInc - 4 * stride, // rowInc + static_cast(4 * mStride), // rowInc 1, // mColSampling 1, // mRowSampling 32, // allocatedDepth @@ -690,69 +457,20 @@ c2_status_t C2AllocationGralloc::map( break; } - case PixelFormat4::RGBA_8888: + case static_cast(PixelFormat4::RGBA_8888): // TODO: alpha channel // fall-through - case PixelFormat4::RGBX_8888: { + case static_cast(PixelFormat4::RGBX_8888): { void *pointer = nullptr; - if (mMapper2) { - if (!mMapper2->lock( - const_cast(mBuffer), - grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto &maperr, const auto &mapPointer) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - }).isOk()) { - ALOGE("failed transaction: lock(RGBA_8888)"); - return C2_CORRUPTED; - } - } else if (mMapper3) { - if (!mMapper3->lock( - const_cast(mBuffer), - grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto &maperr, const auto &mapPointer, - int32_t bytesPerPixel, int32_t bytesPerStride) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - (void)bytesPerPixel; - (void)bytesPerStride; - }).isOk()) { - ALOGE("failed transaction: lock(RGBA_8888) (@3.0)"); - return C2_CORRUPTED; - } - } else { - if (!mMapper4->lock( - const_cast(mBuffer), - grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto &maperr, const auto &mapPointer) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - }).isOk()) { - ALOGE("failed transaction: lock(RGBA_8888) (@4.0)"); - return C2_CORRUPTED; - } - } - if (err != C2_OK) { - ALOGD("lock failed: %d", err); - return err; + // TODO: fence + status_t err = GraphicBufferMapper::get().lock( + const_cast(mBuffer), grallocUsage, + { (int32_t)rect.left, (int32_t)rect.top, + (int32_t)rect.width, (int32_t)rect.height }, + &pointer); + if (err) { + ALOGE("failed transaction: lock(RGBA_8888)"); + return C2_CORRUPTED; } addr[C2PlanarLayout::PLANE_R] = (uint8_t *)pointer; addr[C2PlanarLayout::PLANE_G] = (uint8_t *)pointer + 1; @@ -760,18 +478,10 @@ c2_status_t C2AllocationGralloc::map( layout->type = C2PlanarLayout::TYPE_RGB; layout->numPlanes = 3; layout->rootPlanes = 1; - int32_t stride; - if (mMapper2) { - stride = int32_t(mInfo2.stride); - } else if (mMapper3) { - stride = int32_t(mInfo3.stride); - } else { - stride = int32_t(mInfo4.stride); - } layout->planes[C2PlanarLayout::PLANE_R] = { C2PlaneInfo::CHANNEL_R, // channel 4, // colInc - 4 * stride, // rowInc + static_cast(4 * mStride), // rowInc 1, // mColSampling 1, // mRowSampling 8, // allocatedDepth @@ -784,7 +494,7 @@ c2_status_t C2AllocationGralloc::map( layout->planes[C2PlanarLayout::PLANE_G] = { C2PlaneInfo::CHANNEL_G, // channel 4, // colInc - 4 * stride, // rowInc + static_cast(4 * mStride), // rowInc 1, // mColSampling 1, // mRowSampling 8, // allocatedDepth @@ -797,7 +507,7 @@ c2_status_t C2AllocationGralloc::map( layout->planes[C2PlanarLayout::PLANE_B] = { C2PlaneInfo::CHANNEL_B, // channel 4, // colInc - 4 * stride, // rowInc + static_cast(4 * mStride), // rowInc 1, // mColSampling 1, // mRowSampling 8, // allocatedDepth @@ -810,142 +520,23 @@ c2_status_t C2AllocationGralloc::map( break; } - case PixelFormat4::BLOB: { - void* pointer = nullptr; - if (mMapper2) { - if (!mMapper2->lock(const_cast(mBuffer), grallocUsage, - {(int32_t)rect.left, (int32_t)rect.top, (int32_t)rect.width, - (int32_t)rect.height}, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto& maperr, const auto& mapPointer) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - }).isOk()) { - ALOGE("failed transaction: lock(BLOB)"); - return C2_CORRUPTED; - } - } else if (mMapper3) { - if (!mMapper3->lock( - const_cast(mBuffer), - grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto &maperr, const auto &mapPointer, - int32_t bytesPerPixel, int32_t bytesPerStride) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - (void)bytesPerPixel; - (void)bytesPerStride; - }).isOk()) { - ALOGE("failed transaction: lock(BLOB) (@3.0)"); - return C2_CORRUPTED; - } - } else { - if (!mMapper4->lock( - const_cast(mBuffer), - grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &pointer](const auto &maperr, const auto &mapPointer) { - err = maperr2error(maperr); - if (err == C2_OK) { - pointer = mapPointer; - } - }).isOk()) { - ALOGE("failed transaction: lock(BLOB) (@4.0)"); - return C2_CORRUPTED; - } - } - if (err != C2_OK) { - ALOGD("lock failed: %d", err); - return err; - } - - *addr = static_cast(pointer); - break; - } - - case PixelFormat4::YCBCR_420_888: + case static_cast(PixelFormat4::YCBCR_420_888): // fall-through - case PixelFormat4::YV12: + case static_cast(PixelFormat4::YV12): // fall-through default: { - struct YCbCrLayout { - void* y; - void* cb; - void* cr; - uint32_t yStride; - uint32_t cStride; - uint32_t chromaStep; - }; - YCbCrLayout ycbcrLayout; - if (mMapper2) { - if (!mMapper2->lockYCbCr( - const_cast(mBuffer), grallocUsage, - { (int32_t)rect.left, (int32_t)rect.top, - (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &ycbcrLayout](const auto &maperr, const auto &mapLayout) { - err = maperr2error(maperr); - if (err == C2_OK) { - ycbcrLayout = YCbCrLayout{ - mapLayout.y, - mapLayout.cb, - mapLayout.cr, - mapLayout.yStride, - mapLayout.cStride, - mapLayout.chromaStep}; - } - }).isOk()) { - ALOGE("failed transaction: lockYCbCr"); - return C2_CORRUPTED; - } - } else if (mMapper3) { - if (!mMapper3->lockYCbCr( - const_cast(mBuffer), grallocUsage, + android_ycbcr ycbcrLayout; + + status_t err = GraphicBufferMapper::get().lockYCbCr( + const_cast(mBuffer), grallocUsage, { (int32_t)rect.left, (int32_t)rect.top, (int32_t)rect.width, (int32_t)rect.height }, - // TODO: fence - hidl_handle(), - [&err, &ycbcrLayout](const auto &maperr, const auto &mapLayout) { - err = maperr2error(maperr); - if (err == C2_OK) { - ycbcrLayout = YCbCrLayout{ - mapLayout.y, - mapLayout.cb, - mapLayout.cr, - mapLayout.yStride, - mapLayout.cStride, - mapLayout.chromaStep}; - } - }).isOk()) { - ALOGE("failed transaction: lockYCbCr (@3.0)"); - return C2_CORRUPTED; - } - } else { - // No device currently supports IMapper 4.0 so it is safe to just return an error - // code here. - // - // This will be supported by a combination of lock and BufferMetadata getters. - // We are going to refactor all the IAllocator/IMapper versioning code into a - // shared library. We will then add the IMapper 4.0 lockYCbCr support then. - ALOGE("failed transaction: lockYCbCr (@4.0)"); + &ycbcrLayout); + if (err) { + ALOGE("failed transaction: lockYCbCr"); return C2_CORRUPTED; } - if (err != C2_OK) { - ALOGD("lockYCbCr failed: %d", err); - return err; - } + addr[C2PlanarLayout::PLANE_Y] = (uint8_t *)ycbcrLayout.y; addr[C2PlanarLayout::PLANE_U] = (uint8_t *)ycbcrLayout.cb; addr[C2PlanarLayout::PLANE_V] = (uint8_t *)ycbcrLayout.cr; @@ -955,7 +546,7 @@ c2_status_t C2AllocationGralloc::map( layout->planes[C2PlanarLayout::PLANE_Y] = { C2PlaneInfo::CHANNEL_Y, // channel 1, // colInc - (int32_t)ycbcrLayout.yStride, // rowInc + (int32_t)ycbcrLayout.ystride, // rowInc 1, // mColSampling 1, // mRowSampling 8, // allocatedDepth @@ -967,8 +558,8 @@ c2_status_t C2AllocationGralloc::map( }; layout->planes[C2PlanarLayout::PLANE_U] = { C2PlaneInfo::CHANNEL_CB, // channel - (int32_t)ycbcrLayout.chromaStep, // colInc - (int32_t)ycbcrLayout.cStride, // rowInc + (int32_t)ycbcrLayout.chroma_step, // colInc + (int32_t)ycbcrLayout.cstride, // rowInc 2, // mColSampling 2, // mRowSampling 8, // allocatedDepth @@ -980,8 +571,8 @@ c2_status_t C2AllocationGralloc::map( }; layout->planes[C2PlanarLayout::PLANE_V] = { C2PlaneInfo::CHANNEL_CR, // channel - (int32_t)ycbcrLayout.chromaStep, // colInc - (int32_t)ycbcrLayout.cStride, // rowInc + (int32_t)ycbcrLayout.chroma_step, // colInc + (int32_t)ycbcrLayout.cstride, // rowInc 2, // mColSampling 2, // mRowSampling 8, // allocatedDepth @@ -993,11 +584,11 @@ c2_status_t C2AllocationGralloc::map( }; // handle interleaved formats intptr_t uvOffset = addr[C2PlanarLayout::PLANE_V] - addr[C2PlanarLayout::PLANE_U]; - if (uvOffset > 0 && uvOffset < (intptr_t)ycbcrLayout.chromaStep) { + if (uvOffset > 0 && uvOffset < (intptr_t)ycbcrLayout.chroma_step) { layout->rootPlanes = 2; layout->planes[C2PlanarLayout::PLANE_V].rootIx = C2PlanarLayout::PLANE_U; layout->planes[C2PlanarLayout::PLANE_V].offset = uvOffset; - } else if (uvOffset < 0 && uvOffset > -(intptr_t)ycbcrLayout.chromaStep) { + } else if (uvOffset < 0 && uvOffset > -(intptr_t)ycbcrLayout.chroma_step) { layout->rootPlanes = 2; layout->planes[C2PlanarLayout::PLANE_U].rootIx = C2PlanarLayout::PLANE_V; layout->planes[C2PlanarLayout::PLANE_U].offset = -uvOffset; @@ -1015,59 +606,18 @@ c2_status_t C2AllocationGralloc::unmap( // TODO: check addr and size, use fence (void)addr; (void)rect; + (void)fence; std::lock_guard lock(mMappedLock); - c2_status_t err = C2_OK; - if (mMapper2) { - if (!mMapper2->unlock( - const_cast(mBuffer), - [&err, &fence](const auto &maperr, const auto &releaseFence) { - // TODO - (void) fence; - (void) releaseFence; - err = maperr2error(maperr); - if (err == C2_OK) { - // TODO: fence - } - }).isOk()) { - ALOGE("failed transaction: unlock"); - return C2_CORRUPTED; - } - } else if (mMapper3) { - if (!mMapper3->unlock( - const_cast(mBuffer), - [&err, &fence](const auto &maperr, const auto &releaseFence) { - // TODO - (void) fence; - (void) releaseFence; - err = maperr2error(maperr); - if (err == C2_OK) { - // TODO: fence - } - }).isOk()) { - ALOGE("failed transaction: unlock (@3.0)"); - return C2_CORRUPTED; - } - } else { - if (!mMapper4->unlock( - const_cast(mBuffer), - [&err, &fence](const auto &maperr, const auto &releaseFence) { - // TODO - (void) fence; - (void) releaseFence; - err = maperr2error(maperr); - if (err == C2_OK) { - // TODO: fence - } - }).isOk()) { - ALOGE("failed transaction: unlock (@4.0)"); - return C2_CORRUPTED; - } + // TODO: fence + status_t err = GraphicBufferMapper::get().unlock(mBuffer); + if (err) { + ALOGE("failed transaction: unlock"); + return C2_CORRUPTED; } - if (err == C2_OK) { - mLocked = false; - } - return err; + + mLocked = false; + return C2_OK; } bool C2AllocationGralloc::equals(const std::shared_ptr &other) const { @@ -1104,12 +654,6 @@ public: private: std::shared_ptr mTraits; c2_status_t mInit; - sp mAllocator2; - sp mMapper2; - sp mAllocator3; - sp mMapper3; - sp mAllocator4; - sp mMapper4; const bool mBufferQueue; }; @@ -1127,27 +671,6 @@ C2AllocatorGralloc::Impl::Impl(id_t id, bool bufferQueue) C2MemoryUsage minUsage = { 0, 0 }, maxUsage = { ~(uint64_t)0, ~(uint64_t)0 }; Traits traits = { "android.allocator.gralloc", id, C2Allocator::GRAPHIC, minUsage, maxUsage }; mTraits = std::make_shared(traits); - - // gralloc allocator is a singleton, so all objects share a global service - mAllocator4 = IAllocator4::getService(); - mMapper4 = IMapper4::getService(); - if (!mAllocator4 || !mMapper4) { - mAllocator4 = nullptr; - mMapper4 = nullptr; - mAllocator3 = IAllocator3::getService(); - mMapper3 = IMapper3::getService(); - if (!mAllocator3 || !mMapper3) { - mAllocator3 = nullptr; - mMapper3 = nullptr; - mAllocator2 = IAllocator2::getService(); - mMapper2 = IMapper2::getService(); - if (!mAllocator2 || !mMapper2) { - mAllocator2 = nullptr; - mMapper2 = nullptr; - mInit = C2_CORRUPTED; - } - } - } } c2_status_t C2AllocatorGralloc::Impl::newGraphicAllocation( @@ -1157,257 +680,59 @@ c2_status_t C2AllocatorGralloc::Impl::newGraphicAllocation( ALOGV("allocating buffer with usage %#llx => %#llx", (long long)usage.expected, (long long)grallocUsage); - c2_status_t err = C2_OK; - hidl_handle buffer{}; - - if (mMapper2) { - BufferDescriptorInfo2 info = { - { - width, - height, - 1u, // layerCount - PixelFormat2(format), - grallocUsage, - }, - 0u, // stride placeholder - }; - BufferDescriptor2 desc; - if (!mMapper2->createDescriptor( - info.mapperInfo, [&err, &desc](const auto &maperr, const auto &descriptor) { - err = maperr2error(maperr); - if (err == C2_OK) { - desc = descriptor; - } - }).isOk()) { - ALOGE("failed transaction: createDescriptor"); - return C2_CORRUPTED; - } - if (err != C2_OK) { - return err; - } - - // IAllocator shares IMapper error codes. - if (!mAllocator2->allocate( - desc, - 1u, - [&err, &buffer, &info](const auto &maperr, const auto &stride, auto &buffers) { - err = maperr2error(maperr); - if (err != C2_OK) { - return; - } - if (buffers.size() != 1u) { - err = C2_CORRUPTED; - return; - } - info.stride = stride; - buffer = buffers[0]; - }).isOk()) { - ALOGE("failed transaction: allocate"); - return C2_CORRUPTED; - } - if (err != C2_OK) { - return err; - } - allocation->reset(new C2AllocationGralloc( - info, mMapper2, buffer, - C2HandleGralloc::WrapAndMoveNativeHandle( - buffer.getNativeHandle(), - width, height, - format, grallocUsage, info.stride, - 0, 0, mBufferQueue ? ~0 : 0), - mTraits->id)); - return C2_OK; - } else if (mMapper3) { - BufferDescriptorInfo3 info = { - { - width, - height, - 1u, // layerCount - PixelFormat4(format), - grallocUsage, - }, - 0u, // stride placeholder - }; - BufferDescriptor3 desc; - if (!mMapper3->createDescriptor( - info.mapperInfo, [&err, &desc](const auto &maperr, const auto &descriptor) { - err = maperr2error(maperr); - if (err == C2_OK) { - desc = descriptor; - } - }).isOk()) { - ALOGE("failed transaction: createDescriptor"); - return C2_CORRUPTED; - } - if (err != C2_OK) { - return err; - } + buffer_handle_t buffer; - // IAllocator shares IMapper error codes. - if (!mAllocator3->allocate( - desc, - 1u, - [&err, &buffer, &info](const auto &maperr, const auto &stride, auto &buffers) { - err = maperr2error(maperr); - if (err != C2_OK) { - return; - } - if (buffers.size() != 1u) { - err = C2_CORRUPTED; - return; - } - info.stride = stride; - buffer = buffers[0]; - }).isOk()) { - ALOGE("failed transaction: allocate"); - return C2_CORRUPTED; - } - if (err != C2_OK) { - return err; - } - allocation->reset(new C2AllocationGralloc( - info, mMapper3, buffer, - C2HandleGralloc::WrapAndMoveNativeHandle( - buffer.getNativeHandle(), - width, height, - format, grallocUsage, info.stride, - 0, 0, mBufferQueue ? ~0 : 0), - mTraits->id)); - return C2_OK; - } else { - BufferDescriptorInfo4 info = { - { - "C2GrallocAllocation", - width, - height, - 1u, // layerCount - PixelFormat4(format), - grallocUsage, - }, - 0u, // stride placeholder - }; - BufferDescriptor4 desc; - if (!mMapper4->createDescriptor( - info.mapperInfo, [&err, &desc](const auto &maperr, const auto &descriptor) { - err = maperr2error(maperr); - if (err == C2_OK) { - desc = descriptor; - } - }).isOk()) { - ALOGE("failed transaction: createDescriptor"); - return C2_CORRUPTED; - } - if (err != C2_OK) { - return err; - } + uint32_t stride = 0; - // IAllocator shares IMapper error codes. - if (!mAllocator4->allocate( - desc, - 1u, - [&err, &buffer, &info](const auto &maperr, const auto &stride, auto &buffers) { - err = maperr2error(maperr); - if (err != C2_OK) { - return; - } - if (buffers.size() != 1u) { - err = C2_CORRUPTED; - return; - } - info.stride = stride; - buffer = buffers[0]; - }).isOk()) { - ALOGE("failed transaction: allocate"); - return C2_CORRUPTED; - } - if (err != C2_OK) { - return err; - } - allocation->reset(new C2AllocationGralloc( - info, mMapper4, buffer, - C2HandleGralloc::WrapAndMoveNativeHandle( - buffer.getNativeHandle(), - width, height, - format, grallocUsage, info.stride, - 0, 0, mBufferQueue ? ~0 : 0), - mTraits->id)); - return C2_OK; + status_t err = GraphicBufferAllocator::get().allocateRawHandle(width, height, format, + 1u /* layer count */, grallocUsage, &buffer, &stride, "C2GrallocAllocation"); + if (err) { + ALOGE("failed transaction: allocate"); + return C2_CORRUPTED; } + + hidl_handle hidlHandle; + hidlHandle.setTo(const_cast(buffer), true); + + allocation->reset(new C2AllocationGralloc( + width, height, format, 1u /* layer count */, grallocUsage, stride, hidlHandle, + C2HandleGralloc::WrapAndMoveNativeHandle( + hidlHandle, width, height, + format, grallocUsage, stride, + 0, 0, mBufferQueue ? ~0 : 0), + mTraits->id)); + return C2_OK; } c2_status_t C2AllocatorGralloc::Impl::priorGraphicAllocation( const C2Handle *handle, std::shared_ptr *allocation) { - if (mMapper2) { - BufferDescriptorInfo2 info; - info.mapperInfo.layerCount = 1u; - uint32_t generation; - uint64_t igbp_id; - uint32_t igbp_slot; - const C2HandleGralloc *grallocHandle = C2HandleGralloc::Import( - handle, - &info.mapperInfo.width, &info.mapperInfo.height, - (uint32_t *)&info.mapperInfo.format, - (uint64_t *)&info.mapperInfo.usage, - &info.stride, - &generation, &igbp_id, &igbp_slot); - if (grallocHandle == nullptr) { - return C2_BAD_VALUE; - } - hidl_handle hidlHandle; - hidlHandle.setTo(C2HandleGralloc::UnwrapNativeHandle(grallocHandle), true); - - allocation->reset(new C2AllocationGralloc( - info, mMapper2, hidlHandle, grallocHandle, mTraits->id)); - return C2_OK; - } else if (mMapper3) { - BufferDescriptorInfo3 info; - info.mapperInfo.layerCount = 1u; - uint32_t generation; - uint64_t igbp_id; - uint32_t igbp_slot; - const C2HandleGralloc *grallocHandle = C2HandleGralloc::Import( - handle, - &info.mapperInfo.width, &info.mapperInfo.height, - (uint32_t *)&info.mapperInfo.format, - (uint64_t *)&info.mapperInfo.usage, - &info.stride, - &generation, &igbp_id, &igbp_slot); - if (grallocHandle == nullptr) { - return C2_BAD_VALUE; - } + uint32_t generation; + uint64_t igbp_id; + uint32_t igbp_slot; - hidl_handle hidlHandle; - hidlHandle.setTo(C2HandleGralloc::UnwrapNativeHandle(grallocHandle), true); + uint32_t width; + uint32_t height; + uint32_t format; + uint32_t layerCount = 1; + uint64_t grallocUsage; + uint32_t stride; - allocation->reset(new C2AllocationGralloc( - info, mMapper3, hidlHandle, grallocHandle, mTraits->id)); - return C2_OK; - } else { - BufferDescriptorInfo4 info; - info.mapperInfo.layerCount = 1u; - uint32_t generation; - uint64_t igbp_id; - uint32_t igbp_slot; - const C2HandleGralloc *grallocHandle = C2HandleGralloc::Import( - handle, - &info.mapperInfo.width, &info.mapperInfo.height, - (uint32_t *)&info.mapperInfo.format, - (uint64_t *)&info.mapperInfo.usage, - &info.stride, - &generation, &igbp_id, &igbp_slot); - if (grallocHandle == nullptr) { - return C2_BAD_VALUE; - } + const C2HandleGralloc *grallocHandle = C2HandleGralloc::Import( + handle, &width, &height, &format, &grallocUsage, &stride, + &generation, &igbp_id, &igbp_slot); + if (grallocHandle == nullptr) { + return C2_BAD_VALUE; + } - hidl_handle hidlHandle; - hidlHandle.setTo(C2HandleGralloc::UnwrapNativeHandle(grallocHandle), true); + hidl_handle hidlHandle; + hidlHandle.setTo(C2HandleGralloc::UnwrapNativeHandle(grallocHandle), true); - allocation->reset(new C2AllocationGralloc( - info, mMapper4, hidlHandle, grallocHandle, mTraits->id)); - return C2_OK; - } + allocation->reset(new C2AllocationGralloc( + width, height, format, layerCount, + grallocUsage, stride, hidlHandle, grallocHandle, mTraits->id)); + return C2_OK; } C2AllocatorGralloc::C2AllocatorGralloc(id_t id, bool bufferQueue)