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)