| // Copyright 2020 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "C2VdaBqBlockPool" |
| |
| #include <v4l2_codec2/plugin_store/C2VdaBqBlockPool.h> |
| |
| #include <errno.h> |
| |
| #include <chrono> |
| #include <mutex> |
| #include <thread> |
| |
| #include <C2AllocatorGralloc.h> |
| #include <C2BlockInternal.h> |
| #include <android/hardware/graphics/bufferqueue/2.0/IGraphicBufferProducer.h> |
| #include <android/hardware/graphics/bufferqueue/2.0/IProducerListener.h> |
| #include <base/callback.h> |
| #include <log/log.h> |
| #include <system/window.h> |
| #include <types.h> |
| #include <ui/BufferQueueDefs.h> |
| |
| #include <v4l2_codec2/plugin_store/V4L2AllocatorId.h> |
| |
| namespace android { |
| namespace { |
| |
| // The wait time for acquire fence in milliseconds. |
| constexpr int kFenceWaitTimeMs = 10; |
| // The timeout limit of acquiring lock of timed_mutex in milliseconds. |
| constexpr std::chrono::milliseconds kTimedMutexTimeoutMs = std::chrono::milliseconds(500); |
| |
| } // namespace |
| |
| using namespace std::chrono_literals; |
| |
| using ::android::C2AndroidMemoryUsage; |
| using ::android::Fence; |
| using ::android::GraphicBuffer; |
| using ::android::sp; |
| using ::android::status_t; |
| using ::android::BufferQueueDefs::BUFFER_NEEDS_REALLOCATION; |
| using ::android::BufferQueueDefs::NUM_BUFFER_SLOTS; |
| using ::android::BufferQueueDefs::RELEASE_ALL_BUFFERS; |
| using ::android::hardware::hidl_handle; |
| using ::android::hardware::Return; |
| |
| using HBuffer = ::android::hardware::graphics::common::V1_2::HardwareBuffer; |
| using HStatus = ::android::hardware::graphics::bufferqueue::V2_0::Status; |
| using HGraphicBufferProducer = |
| ::android::hardware::graphics::bufferqueue::V2_0::IGraphicBufferProducer; |
| using HProducerListener = ::android::hardware::graphics::bufferqueue::V2_0::IProducerListener; |
| using HConnectionType = hardware::graphics::bufferqueue::V2_0::ConnectionType; |
| using HQueueBufferOutput = |
| ::android::hardware::graphics::bufferqueue::V2_0::IGraphicBufferProducer::QueueBufferOutput; |
| |
| using ::android::hardware::graphics::bufferqueue::V2_0::utils::b2h; |
| using ::android::hardware::graphics::bufferqueue::V2_0::utils::h2b; |
| using ::android::hardware::graphics::bufferqueue::V2_0::utils::HFenceWrapper; |
| |
| static c2_status_t asC2Error(int32_t err) { |
| switch (err) { |
| case android::NO_ERROR: |
| return C2_OK; |
| case android::NO_INIT: |
| return C2_NO_INIT; |
| case android::BAD_VALUE: |
| return C2_BAD_VALUE; |
| case android::TIMED_OUT: |
| return C2_TIMED_OUT; |
| case android::WOULD_BLOCK: |
| return C2_BLOCKING; |
| case android::NO_MEMORY: |
| return C2_NO_MEMORY; |
| } |
| return C2_CORRUPTED; |
| } |
| |
| class H2BGraphicBufferProducer { |
| public: |
| explicit H2BGraphicBufferProducer(sp<HGraphicBufferProducer> base) : mBase(base) {} |
| ~H2BGraphicBufferProducer() = default; |
| |
| status_t requestBuffer(int slot, sp<GraphicBuffer>* buf) { |
| bool converted = false; |
| status_t status = UNKNOWN_ERROR; |
| Return<void> transResult = mBase->requestBuffer( |
| slot, [&converted, &status, buf](HStatus hStatus, HBuffer const& hBuffer, |
| uint32_t generationNumber) { |
| converted = h2b(hStatus, &status) && h2b(hBuffer, buf); |
| if (*buf) { |
| (*buf)->setGenerationNumber(generationNumber); |
| } |
| }); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!converted) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| if (status != android::NO_ERROR) { |
| ALOGE("%s() failed: %d", __func__, status); |
| } |
| return status; |
| } |
| |
| status_t setMaxDequeuedBufferCount(int maxDequeuedBuffers) { |
| status_t status = UNKNOWN_ERROR; |
| Return<HStatus> transResult = |
| mBase->setMaxDequeuedBufferCount(static_cast<int32_t>(maxDequeuedBuffers)); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!h2b(static_cast<HStatus>(transResult), &status)) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| if (status != android::NO_ERROR) { |
| ALOGE("%s() failed: %d", __func__, status); |
| } |
| return status; |
| } |
| |
| status_t dequeueBuffer(uint32_t width, uint32_t height, uint32_t pixelFormat, |
| C2AndroidMemoryUsage androidUsage, int* slot, sp<Fence>* fence) { |
| using Input = HGraphicBufferProducer::DequeueBufferInput; |
| using Output = HGraphicBufferProducer::DequeueBufferOutput; |
| Input input{width, height, pixelFormat, androidUsage.asGrallocUsage()}; |
| |
| bool converted = false; |
| status_t status = UNKNOWN_ERROR; |
| Return<void> transResult = mBase->dequeueBuffer( |
| input, [&converted, &status, &slot, &fence](HStatus hStatus, int32_t hSlot, |
| Output const& hOutput) { |
| converted = h2b(hStatus, &status); |
| if (!converted || status != android::NO_ERROR) { |
| return; |
| } |
| |
| *slot = hSlot; |
| if (hOutput.bufferNeedsReallocation) { |
| status = BUFFER_NEEDS_REALLOCATION; |
| } |
| converted = h2b(hOutput.fence, fence); |
| }); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!converted) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| if (status != android::NO_ERROR && status != BUFFER_NEEDS_REALLOCATION && |
| status != android::TIMED_OUT) { |
| ALOGE("%s() failed: %d", __func__, status); |
| } |
| return status; |
| } |
| |
| status_t detachBuffer(int slot) { |
| status_t status = UNKNOWN_ERROR; |
| Return<HStatus> transResult = mBase->detachBuffer(static_cast<int32_t>(slot)); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!h2b(static_cast<HStatus>(transResult), &status)) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| if (status != android::NO_ERROR) { |
| ALOGE("%s() failed: %d", __func__, status); |
| } |
| return status; |
| } |
| |
| status_t attachBuffer(const sp<GraphicBuffer>& buffer, int* outSlot) { |
| HBuffer hBuffer; |
| uint32_t hGenerationNumber; |
| if (!b2h(buffer, &hBuffer, &hGenerationNumber)) { |
| ALOGE("%s: invalid input buffer.", __func__); |
| return BAD_VALUE; |
| } |
| |
| bool converted = false; |
| status_t status = UNKNOWN_ERROR; |
| Return<void> transResult = mBase->attachBuffer( |
| hBuffer, hGenerationNumber, |
| [&converted, &status, outSlot](HStatus hStatus, int32_t hSlot, |
| bool releaseAllBuffers) { |
| converted = h2b(hStatus, &status); |
| *outSlot = static_cast<int>(hSlot); |
| if (converted && releaseAllBuffers && status == android::NO_ERROR) { |
| status = RELEASE_ALL_BUFFERS; |
| } |
| }); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!converted) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| if (status != android::NO_ERROR) { |
| ALOGE("%s() failed: %d", __func__, status); |
| } |
| return status; |
| } |
| |
| status_t cancelBuffer(int slot, const sp<Fence>& fence) { |
| HFenceWrapper hFenceWrapper; |
| if (!b2h(fence, &hFenceWrapper)) { |
| ALOGE("%s(): corrupted input fence.", __func__); |
| return UNKNOWN_ERROR; |
| } |
| |
| status_t status = UNKNOWN_ERROR; |
| Return<HStatus> transResult = |
| mBase->cancelBuffer(static_cast<int32_t>(slot), hFenceWrapper.getHandle()); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!h2b(static_cast<HStatus>(transResult), &status)) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| if (status != android::NO_ERROR) { |
| ALOGE("%s() failed: %d", __func__, status); |
| } |
| return status; |
| } |
| |
| int query(int what, int* value) { |
| int result = 0; |
| Return<void> transResult = |
| mBase->query(static_cast<int32_t>(what), [&result, value](int32_t r, int32_t v) { |
| result = static_cast<int>(r); |
| *value = static_cast<int>(v); |
| }); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| return result; |
| } |
| |
| status_t allowAllocation(bool allow) { |
| status_t status = UNKNOWN_ERROR; |
| Return<HStatus> transResult = mBase->allowAllocation(allow); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!h2b(static_cast<HStatus>(transResult), &status)) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| if (status != android::NO_ERROR) { |
| ALOGW("%s() failed: %d", __func__, status); |
| } |
| return status; |
| } |
| |
| status_t getUniqueId(uint64_t* outId) const { |
| Return<uint64_t> transResult = mBase->getUniqueId(); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| |
| *outId = static_cast<uint64_t>(transResult); |
| return android::NO_ERROR; |
| } |
| |
| // android::IProducerListener cannot be depended by vendor library, so we use HProducerListener |
| // directly. |
| status_t connect(sp<HProducerListener> const& hListener, int32_t api, |
| bool producerControlledByApp) { |
| bool converted = false; |
| status_t status = UNKNOWN_ERROR; |
| // hack(b/146409777): We pass self-defined api, so we don't use b2h() here. |
| Return<void> transResult = mBase->connect( |
| hListener, static_cast<HConnectionType>(api), producerControlledByApp, |
| [&converted, &status](HStatus hStatus, HQueueBufferOutput const& /* hOutput */) { |
| converted = h2b(hStatus, &status); |
| }); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!converted) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| return status; |
| } |
| |
| status_t setDequeueTimeout(nsecs_t timeout) { |
| status_t status = UNKNOWN_ERROR; |
| Return<HStatus> transResult = mBase->setDequeueTimeout(static_cast<int64_t>(timeout)); |
| |
| if (!transResult.isOk()) { |
| ALOGE("%s(): transaction failed: %s", __func__, transResult.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| if (!h2b(static_cast<HStatus>(transResult), &status)) { |
| ALOGE("%s(): corrupted transaction.", __func__); |
| return FAILED_TRANSACTION; |
| } |
| return status; |
| } |
| |
| private: |
| const sp<HGraphicBufferProducer> mBase; |
| }; |
| |
| // This class is used to notify the listener when a certain event happens. |
| class EventNotifier : public virtual android::RefBase { |
| public: |
| class Listener { |
| public: |
| virtual ~Listener() = default; |
| |
| // Called by EventNotifier when a certain event happens. |
| virtual void onEventNotified() = 0; |
| }; |
| |
| explicit EventNotifier(const std::shared_ptr<Listener>& listener) : mListener(listener) {} |
| virtual ~EventNotifier() = default; |
| |
| protected: |
| void notify() { |
| ALOGV("%s()", __func__); |
| std::shared_ptr<Listener> listener = mListener.lock(); |
| if (listener) { |
| listener->onEventNotified(); |
| } |
| } |
| |
| std::weak_ptr<Listener> mListener; |
| }; |
| |
| // Notifies the listener when the connected IGBP releases buffers. |
| class BufferReleasedNotifier : public EventNotifier, public HProducerListener { |
| public: |
| using EventNotifier::EventNotifier; |
| ~BufferReleasedNotifier() override = default; |
| |
| // HProducerListener implementation |
| Return<void> onBuffersReleased(uint32_t count) override { |
| ALOGV("%s(%u)", __func__, count); |
| if (count > 0) { |
| notify(); |
| } |
| return {}; |
| } |
| }; |
| |
| /** |
| * BlockPoolData implementation for C2VdaBqBlockPool. The life cycle of this object should be as |
| * long as its accompanied C2GraphicBlock. |
| * |
| * When C2VdaBqBlockPoolData is created, |mShared| is false, and the owner of the accompanied |
| * C2GraphicBlock is the component that called fetchGraphicBlock(). If this is released before |
| * sharing, the destructor will call detachBuffer() to BufferQueue to free the slot. |
| * |
| * When the accompanied C2GraphicBlock is going to share to client from component, component should |
| * call MarkBlockPoolDataAsShared() to set |mShared| to true, and then this will be released after |
| * the transition of C2GraphicBlock across HIDL interface. At this time, the destructor will not |
| * call detachBuffer(). |
| */ |
| struct C2VdaBqBlockPoolData : public _C2BlockPoolData { |
| // This type should be a different value than what _C2BlockPoolData::type_t has defined. |
| static constexpr int kTypeVdaBufferQueue = TYPE_BUFFERQUEUE + 256; |
| |
| C2VdaBqBlockPoolData(uint64_t producerId, int32_t slotId, |
| const std::shared_ptr<C2VdaBqBlockPool::Impl>& pool); |
| C2VdaBqBlockPoolData() = delete; |
| |
| // If |mShared| is false, call detach buffer to BufferQueue via |mPool| |
| virtual ~C2VdaBqBlockPoolData() override; |
| |
| type_t getType() const override { return static_cast<type_t>(kTypeVdaBufferQueue); } |
| |
| bool mShared = false; // whether is shared from component to client. |
| const uint64_t mProducerId; |
| const int32_t mSlotId; |
| const std::shared_ptr<C2VdaBqBlockPool::Impl> mPool; |
| }; |
| |
| c2_status_t MarkBlockPoolDataAsShared(const C2ConstGraphicBlock& sharedBlock) { |
| std::shared_ptr<_C2BlockPoolData> data = _C2BlockFactory::GetGraphicBlockPoolData(sharedBlock); |
| if (!data || data->getType() != C2VdaBqBlockPoolData::kTypeVdaBufferQueue) { |
| // Skip this functtion if |sharedBlock| is not fetched from C2VdaBqBlockPool. |
| return C2_OMITTED; |
| } |
| const std::shared_ptr<C2VdaBqBlockPoolData> poolData = |
| std::static_pointer_cast<C2VdaBqBlockPoolData>(data); |
| if (poolData->mShared) { |
| ALOGE("C2VdaBqBlockPoolData(id=%" PRIu64 ", slot=%d) is already marked as shared...", |
| poolData->mProducerId, poolData->mSlotId); |
| return C2_BAD_STATE; |
| } |
| poolData->mShared = true; |
| return C2_OK; |
| } |
| |
| // static |
| std::optional<uint32_t> C2VdaBqBlockPool::getBufferIdFromGraphicBlock(const C2Block2D& block) { |
| uint32_t width, height, format, stride, igbp_slot, generation; |
| uint64_t usage, igbp_id; |
| android::_UnwrapNativeCodec2GrallocMetadata(block.handle(), &width, &height, &format, &usage, |
| &stride, &generation, &igbp_id, &igbp_slot); |
| ALOGV("Unwrap Metadata: igbp[%" PRIu64 ", %u] (%u*%u, fmt %#x, usage %" PRIx64 ", stride %u)", |
| igbp_id, igbp_slot, width, height, format, usage, stride); |
| return igbp_slot; |
| } |
| |
| class C2VdaBqBlockPool::Impl : public std::enable_shared_from_this<C2VdaBqBlockPool::Impl>, |
| public EventNotifier::Listener { |
| public: |
| using HGraphicBufferProducer = C2VdaBqBlockPool::HGraphicBufferProducer; |
| |
| explicit Impl(const std::shared_ptr<C2Allocator>& allocator); |
| // TODO: should we detach buffers on producer if any on destructor? |
| ~Impl() = default; |
| |
| // EventNotifier::Listener implementation. |
| void onEventNotified() override; |
| |
| c2_status_t fetchGraphicBlock(uint32_t width, uint32_t height, uint32_t format, |
| C2MemoryUsage usage, |
| std::shared_ptr<C2GraphicBlock>* block /* nonnull */); |
| void setRenderCallback(const C2BufferQueueBlockPool::OnRenderCallback& renderCallback); |
| void configureProducer(const sp<HGraphicBufferProducer>& producer); |
| c2_status_t requestNewBufferSet(int32_t bufferCount); |
| c2_status_t updateGraphicBlock(bool willCancel, uint32_t oldSlot, uint32_t* newSlot, |
| std::shared_ptr<C2GraphicBlock>* block /* nonnull */); |
| c2_status_t getMinBuffersForDisplay(size_t* bufferCount); |
| bool setNotifyBlockAvailableCb(::base::OnceClosure cb); |
| |
| private: |
| friend struct C2VdaBqBlockPoolData; |
| |
| // Requested buffer formats. |
| struct BufferFormat { |
| BufferFormat(uint32_t width, uint32_t height, uint32_t pixelFormat, |
| C2AndroidMemoryUsage androidUsage) |
| : mWidth(width), mHeight(height), mPixelFormat(pixelFormat), mUsage(androidUsage) {} |
| BufferFormat() = default; |
| |
| uint32_t mWidth = 0; |
| uint32_t mHeight = 0; |
| uint32_t mPixelFormat = 0; |
| C2AndroidMemoryUsage mUsage = C2MemoryUsage(0); |
| }; |
| |
| // For C2VdaBqBlockPoolData to detach corresponding slot buffer from BufferQueue. |
| void detachBuffer(uint64_t producerId, int32_t slotId); |
| |
| // Queries the generation and usage flags from the given producer by dequeuing and requesting a |
| // buffer (the buffer is then detached and freed). |
| c2_status_t queryGenerationAndUsage(H2BGraphicBufferProducer* const producer, uint32_t width, |
| uint32_t height, uint32_t pixelFormat, |
| C2AndroidMemoryUsage androidUsage, uint32_t* generation, |
| uint64_t* usage); |
| |
| // Switches producer and transfers allocated buffers from old producer to the new one. |
| bool switchProducer(H2BGraphicBufferProducer* const newProducer, uint64_t newProducerId); |
| |
| const std::shared_ptr<C2Allocator> mAllocator; |
| |
| std::unique_ptr<H2BGraphicBufferProducer> mProducer; |
| uint64_t mProducerId; |
| C2BufferQueueBlockPool::OnRenderCallback mRenderCallback; |
| |
| // Function mutex to lock at the start of each API function call for protecting the |
| // synchronization of all member variables. |
| std::mutex mMutex; |
| // The mutex of excluding the procedures of configuring producer and allocating buffers. They |
| // should be blocked mutually. Set the timeout for acquiring lock in case of any deadlock. |
| // Configuring producer: configureProducer() called by CCodec. |
| // Allocating buffers: requestNewBufferSet(), then a loop of fetchGraphicBlock() called by |
| // compoenent until |mSlotAllocations|.size() equals |mBuffersRequested|. |
| std::timed_mutex mConfigureProducerAndAllocateBuffersMutex; |
| // The unique lock of the procedure of allocating buffers. It should be locked in the beginning |
| // of requestNewBufferSet() and unlock in the end of the loop of fetchGraphicBlock(). Note that |
| // all calls should be in the same thread. |
| std::unique_lock<std::timed_mutex> mAllocateBuffersLock; |
| |
| // The map restored C2GraphicAllocation from corresponding slot index. |
| std::map<int32_t, std::shared_ptr<C2GraphicAllocation>> mSlotAllocations; |
| // Number of buffers requested on requestNewBufferSet() call. |
| size_t mBuffersRequested; |
| // Currently requested buffer formats. |
| BufferFormat mBufferFormat; |
| // The map recorded the slot indices from old producer to new producer. |
| std::map<int32_t, int32_t> mProducerChangeSlotMap; |
| // The counter for representing the buffer count in client. Only used in producer switching |
| // case. It will be reset in switchProducer(), and accumulated in updateGraphicBlock() routine. |
| uint32_t mBuffersInClient = 0u; |
| // The indicator to record if producer has been switched. Set to true when producer is switched. |
| // Toggle off when requestNewBufferSet() is called. We forcedly detach all slots to make sure |
| // all slots are available, except the ones owned by client. |
| bool mProducerSwitched = false; |
| |
| // Listener for buffer release events. |
| sp<EventNotifier> mFetchBufferNotifier; |
| |
| std::mutex mBufferReleaseMutex; |
| // Set to true when the buffer release event is triggered after dequeueing |
| // buffer from IGBP times out. |
| bool mBufferReleasedAfterTimedOut GUARDED_BY(mBufferReleaseMutex) = false; |
| // The callback to notify the caller the buffer is available. |
| ::base::OnceClosure mNotifyBlockAvailableCb GUARDED_BY(mBufferReleaseMutex); |
| }; |
| |
| C2VdaBqBlockPool::Impl::Impl(const std::shared_ptr<C2Allocator>& allocator) |
| : mAllocator(allocator), |
| mAllocateBuffersLock(mConfigureProducerAndAllocateBuffersMutex, std::defer_lock), |
| mBuffersRequested(0u) {} |
| |
| c2_status_t C2VdaBqBlockPool::Impl::fetchGraphicBlock( |
| uint32_t width, uint32_t height, uint32_t format, C2MemoryUsage usage, |
| std::shared_ptr<C2GraphicBlock>* block /* nonnull */) { |
| ALOGV("%s()", __func__); |
| std::lock_guard<std::mutex> lock(mMutex); |
| |
| if (!mProducer) { |
| // Producer will not be configured in byte-buffer mode. Allocate buffers from allocator |
| // directly as a basic graphic block pool. |
| std::shared_ptr<C2GraphicAllocation> alloc; |
| c2_status_t err = mAllocator->newGraphicAllocation(width, height, format, usage, &alloc); |
| if (err != C2_OK) { |
| return err; |
| } |
| *block = _C2BlockFactory::CreateGraphicBlock(alloc); |
| return C2_OK; |
| } |
| |
| // The existence of |mProducerChangeSlotMap| indicates producer is just switched. Use return |
| // code C2_BAD_STATE to inform the component to handle the procedure of producer change. |
| // TODO(johnylin): consider to inform producer change to component in an active way. |
| if (!mProducerChangeSlotMap.empty()) { |
| return C2_BAD_STATE; |
| } |
| |
| C2AndroidMemoryUsage androidUsage = usage; |
| uint32_t pixelFormat = format; |
| int32_t slot; |
| sp<Fence> fence = new Fence(); |
| status_t status = |
| mProducer->dequeueBuffer(width, height, pixelFormat, androidUsage, &slot, &fence); |
| // The C2VdaBqBlockPool does not fully own the bufferqueue. After buffers are dequeued here, |
| // they are passed into the codec2 framework, processed, and eventually queued into the |
| // bufferqueue. The C2VdaBqBlockPool cannot determine exactly when a buffer gets queued. |
| // However, if every buffer is being processed by the codec2 framework, then dequeueBuffer() |
| // will return INVALID_OPERATION because of an attempt to dequeue too many buffers. |
| // The C2VdaBqBlockPool cannot prevent this from happening, so just map it to TIMED_OUT |
| // and let the C2VdaBqBlockPool's caller's timeout retry logic handle the failure. |
| if (status == android::INVALID_OPERATION) { |
| status = android::TIMED_OUT; |
| } |
| if (status == android::TIMED_OUT) { |
| std::lock_guard<std::mutex> lock(mBufferReleaseMutex); |
| mBufferReleasedAfterTimedOut = false; |
| } |
| if (status != android::NO_ERROR && status != BUFFER_NEEDS_REALLOCATION) { |
| return asC2Error(status); |
| } |
| |
| // Wait for acquire fence if we get one. |
| if (fence) { |
| status_t fenceStatus = fence->wait(kFenceWaitTimeMs); |
| if (fenceStatus != android::NO_ERROR) { |
| if (mProducer->cancelBuffer(slot, fence) != android::NO_ERROR) { |
| return C2_CORRUPTED; |
| } |
| |
| if (fenceStatus == -ETIME) { // fence wait timed out |
| ALOGV("%s(): buffer (slot=%d) fence wait timed out", __func__, slot); |
| return C2_TIMED_OUT; |
| } |
| ALOGE("buffer fence wait error: %d", fenceStatus); |
| return asC2Error(fenceStatus); |
| } |
| |
| if (mRenderCallback) { |
| nsecs_t signalTime = fence->getSignalTime(); |
| if (signalTime >= 0 && signalTime < INT64_MAX) { |
| mRenderCallback(mProducerId, slot, signalTime); |
| } else { |
| ALOGV("got fence signal time of %" PRId64 " nsec", signalTime); |
| } |
| } |
| } |
| |
| auto iter = mSlotAllocations.find(slot); |
| if (iter == mSlotAllocations.end()) { |
| if (mSlotAllocations.size() >= mBuffersRequested) { |
| // The dequeued slot has a pre-allocated buffer whose size and format is as same as |
| // currently requested (but was not dequeued during allocation cycle). Just detach it to |
| // free this slot. And try dequeueBuffer again. |
| ALOGD("dequeued a new slot index but already allocated enough buffers. Detach it."); |
| |
| if (mProducer->detachBuffer(slot) != android::NO_ERROR) { |
| return C2_CORRUPTED; |
| } |
| return C2_TIMED_OUT; |
| } |
| if (status != BUFFER_NEEDS_REALLOCATION) { |
| // The dequeued slot has a pre-allocated buffer whose size and format is as same as |
| // currently requested, so there is no BUFFER_NEEDS_REALLOCATION flag. However since the |
| // buffer reference is already dropped, still call requestBuffer to re-allocate then. |
| // Add a debug note here for tracking. |
| ALOGD("dequeued a new slot index without BUFFER_NEEDS_REALLOCATION flag."); |
| } |
| |
| // Call requestBuffer to allocate buffer for the slot and obtain the reference. |
| sp<GraphicBuffer> slotBuffer = new GraphicBuffer(); |
| status = mProducer->requestBuffer(slot, &slotBuffer); |
| if (status != android::NO_ERROR) { |
| if (mProducer->cancelBuffer(slot, fence) != android::NO_ERROR) { |
| return C2_CORRUPTED; |
| } |
| return asC2Error(status); |
| } |
| |
| // Convert GraphicBuffer to C2GraphicAllocation and wrap producer id and slot index |
| ALOGV("buffer wraps { producer id: %" PRIu64 ", slot: %d }", mProducerId, slot); |
| C2Handle* c2Handle = android::WrapNativeCodec2GrallocHandle( |
| slotBuffer->handle, slotBuffer->width, slotBuffer->height, slotBuffer->format, |
| slotBuffer->usage, slotBuffer->stride, slotBuffer->getGenerationNumber(), |
| mProducerId, slot); |
| if (!c2Handle) { |
| ALOGE("WrapNativeCodec2GrallocHandle failed"); |
| return C2_NO_MEMORY; |
| } |
| |
| std::shared_ptr<C2GraphicAllocation> alloc; |
| c2_status_t err = mAllocator->priorGraphicAllocation(c2Handle, &alloc); |
| if (err != C2_OK) { |
| ALOGE("priorGraphicAllocation failed: %d", err); |
| return err; |
| } |
| |
| mSlotAllocations[slot] = std::move(alloc); |
| if (mSlotAllocations.size() == mBuffersRequested) { |
| // Already allocated enough buffers, set allowAllocation to false to restrict the |
| // eligible slots to allocated ones for future dequeue. |
| status = mProducer->allowAllocation(false); |
| if (status != android::NO_ERROR) { |
| return asC2Error(status); |
| } |
| // Store buffer formats for future usage. |
| mBufferFormat = BufferFormat(width, height, pixelFormat, androidUsage); |
| ALOG_ASSERT(mAllocateBuffersLock.owns_lock()); |
| mAllocateBuffersLock.unlock(); |
| } |
| } |
| |
| auto poolData = std::make_shared<C2VdaBqBlockPoolData>(mProducerId, slot, shared_from_this()); |
| *block = _C2BlockFactory::CreateGraphicBlock(mSlotAllocations[slot], std::move(poolData)); |
| return C2_OK; |
| } |
| |
| void C2VdaBqBlockPool::Impl::onEventNotified() { |
| ALOGV("%s()", __func__); |
| ::base::OnceClosure outputCb; |
| { |
| std::lock_guard<std::mutex> lock(mBufferReleaseMutex); |
| |
| mBufferReleasedAfterTimedOut = true; |
| if (mNotifyBlockAvailableCb) { |
| outputCb = std::move(mNotifyBlockAvailableCb); |
| } |
| } |
| |
| // Calling the callback outside the lock to avoid the deadlock. |
| if (outputCb) { |
| std::move(outputCb).Run(); |
| } |
| } |
| |
| c2_status_t C2VdaBqBlockPool::Impl::queryGenerationAndUsage( |
| H2BGraphicBufferProducer* const producer, uint32_t width, uint32_t height, |
| uint32_t pixelFormat, C2AndroidMemoryUsage androidUsage, uint32_t* generation, |
| uint64_t* usage) { |
| ALOGV("queryGenerationAndUsage"); |
| sp<Fence> fence = new Fence(); |
| int32_t status; |
| int32_t slot; |
| |
| status = producer->dequeueBuffer(width, height, pixelFormat, androidUsage, &slot, &fence); |
| if (status != android::NO_ERROR && status != BUFFER_NEEDS_REALLOCATION) { |
| return asC2Error(status); |
| } |
| |
| // Wait for acquire fence if we get one. |
| if (fence) { |
| status_t fenceStatus = fence->wait(kFenceWaitTimeMs); |
| if (fenceStatus != android::NO_ERROR) { |
| if (producer->cancelBuffer(slot, fence) != android::NO_ERROR) { |
| return C2_CORRUPTED; |
| } |
| if (fenceStatus == -ETIME) { // fence wait timed out |
| ALOGV("%s(): buffer (slot=%d) fence wait timed out", __func__, slot); |
| return C2_TIMED_OUT; |
| } |
| ALOGE("buffer fence wait error: %d", fenceStatus); |
| return asC2Error(fenceStatus); |
| } |
| } |
| |
| // Call requestBuffer to allocate buffer for the slot and obtain the reference. |
| // Get generation number here. |
| sp<GraphicBuffer> slotBuffer = new GraphicBuffer(); |
| status = producer->requestBuffer(slot, &slotBuffer); |
| |
| // Detach and delete the temporary buffer. |
| if (producer->detachBuffer(slot) != android::NO_ERROR) { |
| return C2_CORRUPTED; |
| } |
| |
| // Check requestBuffer return flag. |
| if (status != android::NO_ERROR) { |
| return asC2Error(status); |
| } |
| |
| // Get generation number and usage from the slot buffer. |
| *usage = slotBuffer->getUsage(); |
| *generation = slotBuffer->getGenerationNumber(); |
| ALOGV("Obtained from temp buffer: generation = %u, usage = %" PRIu64 "", *generation, *usage); |
| return C2_OK; |
| } |
| |
| void C2VdaBqBlockPool::Impl::setRenderCallback( |
| const C2BufferQueueBlockPool::OnRenderCallback& renderCallback) { |
| ALOGV("setRenderCallback"); |
| std::lock_guard<std::mutex> lock(mMutex); |
| mRenderCallback = renderCallback; |
| } |
| |
| c2_status_t C2VdaBqBlockPool::Impl::requestNewBufferSet(int32_t bufferCount) { |
| if (bufferCount <= 0) { |
| ALOGE("Invalid requested buffer count = %d", bufferCount); |
| return C2_BAD_VALUE; |
| } |
| |
| if (!mAllocateBuffersLock.try_lock_for(kTimedMutexTimeoutMs)) { |
| ALOGE("Cannot acquire allocate buffers / configure producer lock over %" PRId64 " ms...", |
| static_cast<int64_t>(kTimedMutexTimeoutMs.count())); |
| return C2_BLOCKING; |
| } |
| |
| std::lock_guard<std::mutex> lock(mMutex); |
| if (!mProducer) { |
| ALOGD("No HGraphicBufferProducer is configured..."); |
| return C2_NO_INIT; |
| } |
| |
| if (mProducerSwitched) { |
| // Some slots can be occupied by buffers transferred from the old producer. They will not |
| // used in the current producer. Free the slots of the buffers here. But we cannot find a |
| // slot is associated with the staled buffer. We free all slots whose associated buffers |
| // are not owned by client. |
| ALOGI("requestNewBufferSet: detachBuffer all slots forcedly"); |
| for (int32_t slot = 0; slot < static_cast<int32_t>(NUM_BUFFER_SLOTS); ++slot) { |
| if (mSlotAllocations.find(slot) != mSlotAllocations.end()) { |
| // Skip detaching the buffer which is owned by client now. |
| continue; |
| } |
| status_t status = mProducer->detachBuffer(slot); |
| if (status == android::NO_INIT) { |
| // No more active buffer slot. Break the loop now. |
| break; |
| } else if (status != android::NO_ERROR) { |
| return C2_CORRUPTED; |
| } |
| } |
| mProducerSwitched = false; |
| } |
| |
| ALOGV("Requested new buffer count: %d, still dequeued buffer count: %zu", bufferCount, |
| mSlotAllocations.size()); |
| |
| // The remained slot indices in |mSlotAllocations| now are still dequeued (un-available). |
| // maxDequeuedBufferCount should be set to "new requested buffer count" + "still dequeued buffer |
| // count" to make sure it has enough available slots to request buffer from. |
| status_t status = mProducer->setMaxDequeuedBufferCount(bufferCount + mSlotAllocations.size()); |
| if (status != android::NO_ERROR) { |
| return asC2Error(status); |
| } |
| |
| // Release all remained slot buffer references here. CCodec should either cancel or queue its |
| // owned buffers from this set before the next resolution change. |
| mSlotAllocations.clear(); |
| mProducerChangeSlotMap.clear(); |
| mBuffersRequested = static_cast<size_t>(bufferCount); |
| |
| status = mProducer->allowAllocation(true); |
| if (status != android::NO_ERROR) { |
| return asC2Error(status); |
| } |
| return C2_OK; |
| } |
| |
| void C2VdaBqBlockPool::Impl::configureProducer(const sp<HGraphicBufferProducer>& producer) { |
| ALOGV("configureProducer"); |
| if (producer == nullptr) { |
| ALOGE("input producer is nullptr..."); |
| return; |
| } |
| |
| std::unique_lock<std::timed_mutex> configureProducerLock( |
| mConfigureProducerAndAllocateBuffersMutex, std::defer_lock); |
| if (!configureProducerLock.try_lock_for(kTimedMutexTimeoutMs)) { |
| ALOGE("Cannot acquire configure producer / allocate buffers lock over %" PRId64 " ms...", |
| static_cast<int64_t>(kTimedMutexTimeoutMs.count())); |
| return; |
| } |
| |
| std::lock_guard<std::mutex> lock(mMutex); |
| auto newProducer = std::make_unique<H2BGraphicBufferProducer>(producer); |
| uint64_t producerId; |
| if (newProducer->getUniqueId(&producerId) != android::NO_ERROR) { |
| return; |
| } |
| |
| if (mProducer && mProducerId != producerId) { |
| ALOGI("Producer (Surface) is going to switch... ( %" PRIu64 " -> %" PRIu64 " )", |
| mProducerId, producerId); |
| if (!switchProducer(newProducer.get(), producerId)) { |
| mProducerChangeSlotMap.clear(); |
| return; |
| } |
| } else { |
| mSlotAllocations.clear(); |
| } |
| |
| if (newProducer->setDequeueTimeout(0) != android::NO_ERROR) { |
| ALOGE("%s(): failed to setDequeueTimeout(0)", __func__); |
| return; |
| } |
| |
| // hack(b/146409777): Try to connect ARC-specific listener first. |
| sp<BufferReleasedNotifier> listener = new BufferReleasedNotifier(shared_from_this()); |
| if (newProducer->connect(listener, 'ARC\0', false) == android::NO_ERROR) { |
| ALOGI("connected to ARC-specific IGBP listener."); |
| mFetchBufferNotifier = listener; |
| } |
| |
| // HGraphicBufferProducer could (and should) be replaced if the client has set a new generation |
| // number to producer. The old HGraphicBufferProducer will be disconnected and deprecated then. |
| mProducer = std::move(newProducer); |
| mProducerId = producerId; |
| } |
| |
| bool C2VdaBqBlockPool::Impl::switchProducer(H2BGraphicBufferProducer* const newProducer, |
| uint64_t newProducerId) { |
| if (mAllocator->getId() == android::V4L2AllocatorId::SECURE_GRAPHIC) { |
| // TODO(johnylin): support this when we meet the use case in the future. |
| ALOGE("Switch producer for secure buffer is not supported..."); |
| return false; |
| } |
| |
| // Set maxDequeuedBufferCount to new producer. |
| // Just like requestNewBufferSet(), maxDequeuedBufferCount should be set to "requested buffer |
| // count" + "buffer count in client" to make sure it has enough available slots to request |
| // buffers from. |
| // "Requested buffer count" could be obtained by the size of |mSlotAllocations|. However, it is |
| // not able to know "buffer count in client" in blockpool's aspect. The alternative solution is |
| // to set the worse case first, which is equal to the size of |mSlotAllocations|. And in the end |
| // of updateGraphicBlock() routine, we could get the arbitrary "buffer count in client" by |
| // counting the calls of updateGraphicBlock(willCancel=true). Then we set maxDequeuedBufferCount |
| // again to the correct value. |
| if (newProducer->setMaxDequeuedBufferCount(mSlotAllocations.size() * 2) != android::NO_ERROR) { |
| return false; |
| } |
| |
| // Reset "buffer count in client". It will be accumulated in updateGraphicBlock() routine. |
| mBuffersInClient = 0; |
| |
| // Set allowAllocation to new producer. |
| if (newProducer->allowAllocation(true) != android::NO_ERROR) { |
| return false; |
| } |
| |
| // Get a buffer from the new producer to get the generation number and usage of new producer. |
| // While attaching buffers, generation number and usage must be aligned to the producer. |
| uint32_t newGeneration; |
| uint64_t newUsage; |
| c2_status_t err = queryGenerationAndUsage(newProducer, mBufferFormat.mWidth, |
| mBufferFormat.mHeight, mBufferFormat.mPixelFormat, |
| mBufferFormat.mUsage, &newGeneration, &newUsage); |
| if (err != C2_OK) { |
| ALOGE("queryGenerationAndUsage failed: %d", err); |
| return false; |
| } |
| |
| // Attach all buffers to new producer. |
| mProducerChangeSlotMap.clear(); |
| int32_t slot; |
| std::map<int32_t, std::shared_ptr<C2GraphicAllocation>> newSlotAllocations; |
| for (auto iter = mSlotAllocations.begin(); iter != mSlotAllocations.end(); ++iter) { |
| // Convert C2GraphicAllocation to GraphicBuffer. |
| uint32_t width, height, format, stride, igbp_slot, generation; |
| uint64_t usage, igbp_id; |
| android::_UnwrapNativeCodec2GrallocMetadata(iter->second->handle(), &width, &height, |
| &format, &usage, &stride, &generation, &igbp_id, |
| &igbp_slot); |
| native_handle_t* grallocHandle = |
| android::UnwrapNativeCodec2GrallocHandle(iter->second->handle()); |
| |
| // Update generation number and usage. |
| sp<GraphicBuffer> graphicBuffer = |
| new GraphicBuffer(grallocHandle, GraphicBuffer::CLONE_HANDLE, width, height, format, |
| 1, newUsage, stride); |
| if (graphicBuffer->initCheck() != android::NO_ERROR) { |
| ALOGE("Failed to create GraphicBuffer: %d", graphicBuffer->initCheck()); |
| return false; |
| } |
| graphicBuffer->setGenerationNumber(newGeneration); |
| native_handle_delete(grallocHandle); |
| |
| if (newProducer->attachBuffer(graphicBuffer, &slot) != android::NO_ERROR) { |
| return false; |
| } |
| // Convert back to C2GraphicAllocation wrapping new producer id, generation number, usage |
| // and slot index. |
| ALOGV("buffer wraps { producer id: %" PRIu64 ", slot: %d }", newProducerId, slot); |
| C2Handle* c2Handle = android::WrapNativeCodec2GrallocHandle( |
| graphicBuffer->handle, width, height, format, newUsage, stride, newGeneration, |
| newProducerId, slot); |
| if (!c2Handle) { |
| ALOGE("WrapNativeCodec2GrallocHandle failed"); |
| return false; |
| } |
| std::shared_ptr<C2GraphicAllocation> alloc; |
| c2_status_t err = mAllocator->priorGraphicAllocation(c2Handle, &alloc); |
| if (err != C2_OK) { |
| ALOGE("priorGraphicAllocation failed: %d", err); |
| return false; |
| } |
| |
| // Store to |newSlotAllocations| and also store old-to-new producer slot map. |
| ALOGV("Transfered buffer from old producer to new, slot prev: %d -> new %d", iter->first, |
| slot); |
| newSlotAllocations[slot] = std::move(alloc); |
| mProducerChangeSlotMap[iter->first] = slot; |
| } |
| |
| // Set allowAllocation to false so producer could not allocate new buffers. |
| if (newProducer->allowAllocation(false) != android::NO_ERROR) { |
| ALOGE("allowAllocation(false) failed"); |
| return false; |
| } |
| |
| // Try to detach all buffers from old producer. |
| for (const auto& slotAllocation : mSlotAllocations) { |
| status_t status = mProducer->detachBuffer(slotAllocation.first); |
| if (status != android::NO_ERROR) { |
| ALOGW("detachBuffer slot=%d from old producer failed: %d", slotAllocation.first, |
| status); |
| } |
| } |
| |
| mSlotAllocations = std::move(newSlotAllocations); |
| return true; |
| } |
| |
| c2_status_t C2VdaBqBlockPool::Impl::updateGraphicBlock( |
| bool willCancel, uint32_t oldSlot, uint32_t* newSlot, |
| std::shared_ptr<C2GraphicBlock>* block /* nonnull */) { |
| std::lock_guard<std::mutex> lock(mMutex); |
| |
| if (mProducerChangeSlotMap.empty()) { |
| ALOGD("A new buffer set is requested right after producer change, no more update needed."); |
| return C2_CANCELED; |
| } |
| |
| auto it = mProducerChangeSlotMap.find(static_cast<int32_t>(oldSlot)); |
| if (it == mProducerChangeSlotMap.end()) { |
| ALOGE("Cannot find old slot = %u in map...", oldSlot); |
| return C2_NOT_FOUND; |
| } |
| |
| int32_t slot = it->second; |
| *newSlot = static_cast<uint32_t>(slot); |
| mProducerChangeSlotMap.erase(it); |
| |
| if (willCancel) { |
| sp<Fence> fence = new Fence(); |
| // The old C2GraphicBlock might be owned by client. Cancel this slot. |
| if (mProducer->cancelBuffer(slot, fence) != android::NO_ERROR) { |
| return C2_CORRUPTED; |
| } |
| // Client might try to attach the old buffer to the current producer on client's end, |
| // although it is useless for us anymore. However it will still occupy an available slot. |
| mBuffersInClient++; |
| } else { |
| // The old C2GraphicBlock is still owned by component, replace by the new one and keep this |
| // slot dequeued. |
| auto poolData = |
| std::make_shared<C2VdaBqBlockPoolData>(mProducerId, slot, shared_from_this()); |
| *block = _C2BlockFactory::CreateGraphicBlock(mSlotAllocations[slot], std::move(poolData)); |
| } |
| |
| if (mProducerChangeSlotMap.empty()) { |
| // The updateGraphicBlock() routine is about to finish. |
| // Set the correct maxDequeuedBufferCount to producer, which is "requested buffer count" + |
| // "buffer count in client". |
| ALOGV("Requested buffer count: %zu, buffer count in client: %u", mSlotAllocations.size(), |
| mBuffersInClient); |
| if (mProducer->setMaxDequeuedBufferCount(mSlotAllocations.size() + mBuffersInClient) != |
| android::NO_ERROR) { |
| return C2_CORRUPTED; |
| } |
| mProducerSwitched = true; |
| } |
| |
| return C2_OK; |
| } |
| |
| c2_status_t C2VdaBqBlockPool::Impl::getMinBuffersForDisplay(size_t* bufferCount) { |
| std::lock_guard<std::mutex> lock(mMutex); |
| if (!mProducer) { |
| ALOGD("No HGraphicBufferProducer is configured..."); |
| return C2_NO_INIT; |
| } |
| |
| int32_t status, value; |
| status = mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &value); |
| if (status != android::NO_ERROR) { |
| ALOGE("query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS) failed: %d", status); |
| return asC2Error(status); |
| } |
| if (value <= 0) { |
| ALOGE("Illegal value of NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS = %d", value); |
| return C2_BAD_VALUE; |
| } |
| *bufferCount = static_cast<size_t>(value); |
| return C2_OK; |
| } |
| |
| void C2VdaBqBlockPool::Impl::detachBuffer(uint64_t producerId, int32_t slotId) { |
| ALOGV("detachBuffer: producer id = %" PRIu64 ", slot = %d", producerId, slotId); |
| std::lock_guard<std::mutex> lock(mMutex); |
| if (producerId == mProducerId && mProducer) { |
| if (mProducer->detachBuffer(slotId) != android::NO_ERROR) { |
| return; |
| } |
| |
| auto it = mSlotAllocations.find(slotId); |
| // It may happen that the slot is not included in |mSlotAllocations|, which means it is |
| // released after resolution change. |
| if (it != mSlotAllocations.end()) { |
| mSlotAllocations.erase(it); |
| } |
| } |
| } |
| |
| bool C2VdaBqBlockPool::Impl::setNotifyBlockAvailableCb(::base::OnceClosure cb) { |
| ALOGV("%s()", __func__); |
| if (mFetchBufferNotifier == nullptr) { |
| return false; |
| } |
| |
| ::base::OnceClosure outputCb; |
| { |
| std::lock_guard<std::mutex> lock(mBufferReleaseMutex); |
| |
| // If there is any buffer released after dequeueBuffer() timed out, then we could notify the |
| // caller directly. |
| if (mBufferReleasedAfterTimedOut) { |
| outputCb = std::move(cb); |
| } else { |
| mNotifyBlockAvailableCb = std::move(cb); |
| } |
| } |
| |
| // Calling the callback outside the lock to avoid the deadlock. |
| if (outputCb) { |
| std::move(outputCb).Run(); |
| } |
| return true; |
| } |
| |
| C2VdaBqBlockPool::C2VdaBqBlockPool(const std::shared_ptr<C2Allocator>& allocator, |
| const local_id_t localId) |
| : C2BufferQueueBlockPool(allocator, localId), mLocalId(localId), mImpl(new Impl(allocator)) {} |
| |
| c2_status_t C2VdaBqBlockPool::fetchGraphicBlock( |
| uint32_t width, uint32_t height, uint32_t format, C2MemoryUsage usage, |
| std::shared_ptr<C2GraphicBlock>* block /* nonnull */) { |
| if (mImpl) { |
| return mImpl->fetchGraphicBlock(width, height, format, usage, block); |
| } |
| return C2_NO_INIT; |
| } |
| |
| void C2VdaBqBlockPool::setRenderCallback( |
| const C2BufferQueueBlockPool::OnRenderCallback& renderCallback) { |
| if (mImpl) { |
| mImpl->setRenderCallback(renderCallback); |
| } |
| } |
| |
| c2_status_t C2VdaBqBlockPool::requestNewBufferSet(int32_t bufferCount) { |
| if (mImpl) { |
| return mImpl->requestNewBufferSet(bufferCount); |
| } |
| return C2_NO_INIT; |
| } |
| |
| void C2VdaBqBlockPool::configureProducer(const sp<HGraphicBufferProducer>& producer) { |
| if (mImpl) { |
| mImpl->configureProducer(producer); |
| } |
| } |
| |
| c2_status_t C2VdaBqBlockPool::updateGraphicBlock( |
| bool willCancel, uint32_t oldSlot, uint32_t* newSlot, |
| std::shared_ptr<C2GraphicBlock>* block /* nonnull */) { |
| if (mImpl) { |
| return mImpl->updateGraphicBlock(willCancel, oldSlot, newSlot, block); |
| } |
| return C2_NO_INIT; |
| } |
| |
| c2_status_t C2VdaBqBlockPool::getMinBuffersForDisplay(size_t* bufferCount) { |
| if (mImpl) { |
| return mImpl->getMinBuffersForDisplay(bufferCount); |
| } |
| return C2_NO_INIT; |
| } |
| |
| bool C2VdaBqBlockPool::setNotifyBlockAvailableCb(::base::OnceClosure cb) { |
| if (mImpl) { |
| return mImpl->setNotifyBlockAvailableCb(std::move(cb)); |
| } |
| return false; |
| } |
| |
| C2VdaBqBlockPoolData::C2VdaBqBlockPoolData(uint64_t producerId, int32_t slotId, |
| const std::shared_ptr<C2VdaBqBlockPool::Impl>& pool) |
| : mProducerId(producerId), mSlotId(slotId), mPool(pool) {} |
| |
| C2VdaBqBlockPoolData::~C2VdaBqBlockPoolData() { |
| if (mShared || !mPool) { |
| return; |
| } |
| mPool->detachBuffer(mProducerId, mSlotId); |
| } |
| |
| } // namespace android |
