Lubancat2/Android11
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
trunk
Android11/external/v4l2_codec2/plugin_store/C2VdaBqBlockPool.cpp
gaoyang3513 f70c521994 [Mod] Firtst commit
2023-10-13 14:01:41 +00:00

1176 lines
47 KiB
C++
Raw Permalink Blame History

// 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
Reference in New Issue View Git Blame Copy Permalink