Implement hardware.interface.media.c2@1.2 HAL
Implement block allocator using BufferQueue.
Bug: 157111613
Change-Id: I9d9e5b777f2253cd18960236dcbec73668ae215e
diff --git a/media/codec2/hidl/client/Android.bp b/media/codec2/hidl/client/Android.bp
index b3ca5b1..0e52813 100644
--- a/media/codec2/hidl/client/Android.bp
+++ b/media/codec2/hidl/client/Android.bp
@@ -12,6 +12,11 @@
srcs: [
"client.cpp",
+ "output.cpp",
+ ],
+
+ header_libs: [
+ "libcodec2_internal", // private
],
shared_libs: [
diff --git a/media/codec2/hidl/client/client.cpp b/media/codec2/hidl/client/client.cpp
index 0a61fe2..0296004 100644
--- a/media/codec2/hidl/client/client.cpp
+++ b/media/codec2/hidl/client/client.cpp
@@ -33,17 +33,17 @@
#include <android-base/properties.h>
#include <bufferpool/ClientManager.h>
-#include <codec2/hidl/1.0/OutputBufferQueue.h>
#include <codec2/hidl/1.0/types.h>
-#include <codec2/hidl/1.1/OutputBufferQueue.h>
#include <codec2/hidl/1.1/types.h>
#include <codec2/hidl/1.2/types.h>
+#include <codec2/hidl/output.h>
#include <cutils/native_handle.h>
#include <gui/bufferqueue/2.0/B2HGraphicBufferProducer.h>
#include <gui/bufferqueue/2.0/H2BGraphicBufferProducer.h>
#include <hidl/HidlSupport.h>
+
#include <deque>
#include <iterator>
#include <limits>
@@ -74,6 +74,7 @@
V2_0::utils::B2HGraphicBufferProducer;
using H2BGraphicBufferProducer2 = ::android::hardware::graphics::bufferqueue::
V2_0::utils::H2BGraphicBufferProducer;
+using ::android::hardware::media::c2::V1_2::SurfaceSyncObj;
namespace /* unnamed */ {
@@ -593,9 +594,9 @@
// Codec2Client::Component::OutputBufferQueue
struct Codec2Client::Component::OutputBufferQueue :
- hardware::media::c2::V1_1::utils::OutputBufferQueue {
+ hardware::media::c2::OutputBufferQueue {
OutputBufferQueue()
- : hardware::media::c2::V1_1::utils::OutputBufferQueue() {
+ : hardware::media::c2::OutputBufferQueue() {
}
};
@@ -1492,22 +1493,29 @@
igbp = new B2HGraphicBufferProducer2(surface);
}
+ std::shared_ptr<SurfaceSyncObj> syncObj;
+
if (!surface) {
- mOutputBufferQueue->configure(nullIgbp, generation, 0);
+ mOutputBufferQueue->configure(nullIgbp, generation, 0, nullptr);
} else if (surface->getUniqueId(&bqId) != OK) {
LOG(ERROR) << "setOutputSurface -- "
"cannot obtain bufferqueue id.";
bqId = 0;
- mOutputBufferQueue->configure(nullIgbp, generation, 0);
+ mOutputBufferQueue->configure(nullIgbp, generation, 0, nullptr);
} else {
- mOutputBufferQueue->configure(surface, generation, bqId);
+ mOutputBufferQueue->configure(surface, generation, bqId,
+ mBase1_2 ? &syncObj : nullptr);
}
- ALOGD("generation remote change %u", generation);
+ ALOGD("surface generation remote change %u HAL ver: %s",
+ generation, syncObj ? "1.2" : "1.0");
- (void)mBase1_2;
- Return<Status> transStatus = mBase1_0->setOutputSurface(
- static_cast<uint64_t>(blockPoolId),
- bqId == 0 ? nullHgbp : igbp);
+ Return<Status> transStatus = syncObj ?
+ mBase1_2->setOutputSurfaceWithSyncObj(
+ static_cast<uint64_t>(blockPoolId),
+ bqId == 0 ? nullHgbp : igbp, *syncObj) :
+ mBase1_0->setOutputSurface(
+ static_cast<uint64_t>(blockPoolId),
+ bqId == 0 ? nullHgbp : igbp);
if (!transStatus.isOk()) {
LOG(ERROR) << "setOutputSurface -- transaction failed.";
return C2_TRANSACTION_FAILED;
@@ -1517,6 +1525,7 @@
if (status != C2_OK) {
LOG(DEBUG) << "setOutputSurface -- call failed: " << status << ".";
}
+ ALOGD("Surface configure completed");
return status;
}
@@ -1527,6 +1536,11 @@
return mOutputBufferQueue->outputBuffer(block, input, output);
}
+void Codec2Client::Component::setOutputSurfaceMaxDequeueCount(
+ int maxDequeueCount) {
+ mOutputBufferQueue->updateMaxDequeueBufferCount(maxDequeueCount);
+}
+
c2_status_t Codec2Client::Component::connectToInputSurface(
const std::shared_ptr<InputSurface>& inputSurface,
std::shared_ptr<InputSurfaceConnection>* connection) {
diff --git a/media/codec2/hidl/client/include/codec2/hidl/client.h b/media/codec2/hidl/client/include/codec2/hidl/client.h
index b574829..eca268e 100644
--- a/media/codec2/hidl/client/include/codec2/hidl/client.h
+++ b/media/codec2/hidl/client/include/codec2/hidl/client.h
@@ -407,6 +407,9 @@
const QueueBufferInput& input,
QueueBufferOutput* output);
+ // Set max dequeue count for output surface.
+ void setOutputSurfaceMaxDequeueCount(int maxDequeueCount);
+
// Connect to a given InputSurface.
c2_status_t connectToInputSurface(
const std::shared_ptr<InputSurface>& inputSurface,
diff --git a/media/codec2/hidl/client/include/codec2/hidl/output.h b/media/codec2/hidl/client/include/codec2/hidl/output.h
new file mode 100644
index 0000000..0f03b36
--- /dev/null
+++ b/media/codec2/hidl/client/include/codec2/hidl/output.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CODEC2_HIDL_V1_0_UTILS_OUTPUT_BUFFER_QUEUE
+#define CODEC2_HIDL_V1_0_UTILS_OUTPUT_BUFFER_QUEUE
+
+#include <gui/IGraphicBufferProducer.h>
+#include <codec2/hidl/1.0/types.h>
+#include <codec2/hidl/1.2/types.h>
+#include <C2Work.h>
+
+struct C2_HIDE _C2BlockPoolData;
+class C2SurfaceSyncMemory;
+
+namespace android {
+namespace hardware {
+namespace media {
+namespace c2 {
+
+
+// BufferQueue-Based Block Operations
+// ==================================
+
+// Manage BufferQueue and graphic blocks for both component and codec.
+// Manage graphic blocks ownership consistently during surface change.
+struct OutputBufferQueue {
+
+ OutputBufferQueue();
+
+ ~OutputBufferQueue();
+
+ // Configure a new surface to render graphic blocks.
+ // Graphic blocks from older surface will be migrated to new surface.
+ bool configure(const sp<IGraphicBufferProducer>& igbp,
+ uint32_t generation,
+ uint64_t bqId,
+ std::shared_ptr<V1_2::SurfaceSyncObj> *syncObj);
+
+ // Render a graphic block to current surface.
+ status_t outputBuffer(
+ const C2ConstGraphicBlock& block,
+ const BnGraphicBufferProducer::QueueBufferInput& input,
+ BnGraphicBufferProducer::QueueBufferOutput* output);
+
+ // Call holdBufferQueueBlock() on output blocks in the given workList.
+ // The OutputBufferQueue will take the ownership of output blocks.
+ //
+ // Note: This function should be called after WorkBundle has been received
+ // from another process.
+ void holdBufferQueueBlocks(
+ const std::list<std::unique_ptr<C2Work>>& workList);
+
+ // Update # of max dequeue buffer from BQ. If # of max dequeued buffer is shared
+ // via shared memory between HAL and framework, Update # of max dequeued buffer
+ // and synchronize.
+ void updateMaxDequeueBufferCount(int maxDequeueBufferCount);
+
+private:
+
+ std::mutex mMutex;
+ sp<IGraphicBufferProducer> mIgbp;
+ uint32_t mGeneration;
+ uint64_t mBqId;
+ int32_t mMaxDequeueBufferCount;
+ std::shared_ptr<int> mOwner;
+ // To migrate existing buffers
+ sp<GraphicBuffer> mBuffers[BufferQueueDefs::NUM_BUFFER_SLOTS]; // find a better way
+ std::weak_ptr<_C2BlockPoolData> mPoolDatas[BufferQueueDefs::NUM_BUFFER_SLOTS];
+ std::shared_ptr<C2SurfaceSyncMemory> mSyncMem;
+
+ bool registerBuffer(const C2ConstGraphicBlock& block);
+};
+
+} // namespace c2
+} // namespace media
+} // namespace hardware
+} // namespace android
+
+#endif // CODEC2_HIDL_V1_0_UTILS_OUTPUT_BUFFER_QUEUE
diff --git a/media/codec2/hidl/client/output.cpp b/media/codec2/hidl/client/output.cpp
new file mode 100644
index 0000000..7df0da2
--- /dev/null
+++ b/media/codec2/hidl/client/output.cpp
@@ -0,0 +1,461 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "Codec2-OutputBufferQueue"
+#include <android-base/logging.h>
+
+#include <android/hardware/graphics/bufferqueue/2.0/IGraphicBufferProducer.h>
+#include <codec2/hidl/output.h>
+#include <cutils/ashmem.h>
+#include <gui/bufferqueue/2.0/B2HGraphicBufferProducer.h>
+#include <sys/mman.h>
+
+#include <C2AllocatorGralloc.h>
+#include <C2BlockInternal.h>
+#include <C2Buffer.h>
+#include <C2PlatformSupport.h>
+#include <C2SurfaceSyncObj.h>
+
+#include <iomanip>
+
+namespace android {
+namespace hardware {
+namespace media {
+namespace c2 {
+
+using HGraphicBufferProducer = ::android::hardware::graphics::bufferqueue::
+ V2_0::IGraphicBufferProducer;
+using B2HGraphicBufferProducer = ::android::hardware::graphics::bufferqueue::
+ V2_0::utils::B2HGraphicBufferProducer;
+
+namespace /* unnamed */ {
+
+// Create a GraphicBuffer object from a graphic block.
+sp<GraphicBuffer> createGraphicBuffer(const C2ConstGraphicBlock& block) {
+ uint32_t width;
+ uint32_t height;
+ uint32_t format;
+ uint64_t usage;
+ uint32_t stride;
+ uint32_t generation;
+ uint64_t bqId;
+ int32_t bqSlot;
+ _UnwrapNativeCodec2GrallocMetadata(
+ block.handle(), &width, &height, &format, &usage,
+ &stride, &generation, &bqId, reinterpret_cast<uint32_t*>(&bqSlot));
+ native_handle_t *grallocHandle =
+ UnwrapNativeCodec2GrallocHandle(block.handle());
+ sp<GraphicBuffer> graphicBuffer =
+ new GraphicBuffer(grallocHandle,
+ GraphicBuffer::CLONE_HANDLE,
+ width, height, format,
+ 1, usage, stride);
+ native_handle_delete(grallocHandle);
+ return graphicBuffer;
+}
+
+template <typename BlockProcessor>
+void forEachBlock(C2FrameData& frameData,
+ BlockProcessor process) {
+ for (const std::shared_ptr<C2Buffer>& buffer : frameData.buffers) {
+ if (buffer) {
+ for (const C2ConstGraphicBlock& block :
+ buffer->data().graphicBlocks()) {
+ process(block);
+ }
+ }
+ }
+}
+
+template <typename BlockProcessor>
+void forEachBlock(const std::list<std::unique_ptr<C2Work>>& workList,
+ BlockProcessor process) {
+ for (const std::unique_ptr<C2Work>& work : workList) {
+ if (!work) {
+ continue;
+ }
+ for (const std::unique_ptr<C2Worklet>& worklet : work->worklets) {
+ if (worklet) {
+ forEachBlock(worklet->output, process);
+ }
+ }
+ }
+}
+
+sp<HGraphicBufferProducer> getHgbp(const sp<IGraphicBufferProducer>& igbp) {
+ sp<HGraphicBufferProducer> hgbp =
+ igbp->getHalInterface<HGraphicBufferProducer>();
+ return hgbp ? hgbp :
+ new B2HGraphicBufferProducer(igbp);
+}
+
+status_t attachToBufferQueue(const C2ConstGraphicBlock& block,
+ const sp<IGraphicBufferProducer>& igbp,
+ uint32_t generation,
+ int32_t* bqSlot,
+ std::shared_ptr<C2SurfaceSyncMemory> syncMem) {
+ if (!igbp) {
+ LOG(WARNING) << "attachToBufferQueue -- null producer.";
+ return NO_INIT;
+ }
+
+ sp<GraphicBuffer> graphicBuffer = createGraphicBuffer(block);
+ graphicBuffer->setGenerationNumber(generation);
+
+ LOG(VERBOSE) << "attachToBufferQueue -- attaching buffer:"
+ << " block dimension " << block.width() << "x"
+ << block.height()
+ << ", graphicBuffer dimension " << graphicBuffer->getWidth() << "x"
+ << graphicBuffer->getHeight()
+ << std::hex << std::setfill('0')
+ << ", format 0x" << std::setw(8) << graphicBuffer->getPixelFormat()
+ << ", usage 0x" << std::setw(16) << graphicBuffer->getUsage()
+ << std::dec << std::setfill(' ')
+ << ", stride " << graphicBuffer->getStride()
+ << ", generation " << graphicBuffer->getGenerationNumber();
+
+ C2SyncVariables *syncVar = syncMem ? syncMem->mem() : nullptr;
+ status_t result = OK;
+ if (syncVar) {
+ syncVar->lock();
+ if (!syncVar->isDequeueableLocked() ||
+ syncVar->getSyncStatusLocked() == C2SyncVariables::STATUS_SWITCHING) {
+ syncVar->unlock();
+ LOG(WARNING) << "attachToBufferQueue -- attachBuffer failed: "
+ "status = " << INVALID_OPERATION << ".";
+ return INVALID_OPERATION;
+ }
+ result = igbp->attachBuffer(bqSlot, graphicBuffer);
+ if (result == OK) {
+ syncVar->notifyDequeuedLocked();
+ }
+ syncVar->unlock();
+ } else {
+ result = igbp->attachBuffer(bqSlot, graphicBuffer);
+ }
+ if (result != OK) {
+ LOG(WARNING) << "attachToBufferQueue -- attachBuffer failed: "
+ "status = " << result << ".";
+ return result;
+ }
+ LOG(VERBOSE) << "attachToBufferQueue -- attachBuffer returned slot #"
+ << *bqSlot << ".";
+ return OK;
+}
+
+bool getBufferQueueAssignment(const C2ConstGraphicBlock& block,
+ uint32_t* generation,
+ uint64_t* bqId,
+ int32_t* bqSlot) {
+ return _C2BlockFactory::GetBufferQueueData(
+ _C2BlockFactory::GetGraphicBlockPoolData(block),
+ generation, bqId, bqSlot);
+}
+
+} // unnamed namespace
+
+OutputBufferQueue::OutputBufferQueue()
+ : mGeneration{0}, mBqId{0} {
+}
+
+OutputBufferQueue::~OutputBufferQueue() {
+}
+
+bool OutputBufferQueue::configure(const sp<IGraphicBufferProducer>& igbp,
+ uint32_t generation,
+ uint64_t bqId,
+ std::shared_ptr<V1_2::SurfaceSyncObj> *syncObj) {
+ uint64_t consumerUsage = 0;
+ if (igbp->getConsumerUsage(&consumerUsage) != OK) {
+ ALOGW("failed to get consumer usage");
+ }
+
+ // TODO : Abstract creation process into C2SurfaceSyncMemory class.
+ // use C2LinearBlock instead ashmem.
+ std::shared_ptr<C2SurfaceSyncMemory> syncMem;
+ if (syncObj && igbp) {
+ bool mapped = false;
+ int memFd = ashmem_create_region("C2SurfaceMem", sizeof(C2SyncVariables));
+ size_t memSize = memFd < 0 ? 0 : ashmem_get_size_region(memFd);
+ if (memSize > 0) {
+ syncMem = C2SurfaceSyncMemory::Create(memFd, memSize);
+ if (syncMem) {
+ mapped = true;
+ *syncObj = std::make_shared<V1_2::SurfaceSyncObj>();
+ (*syncObj)->syncMemory = syncMem->handle();
+ (*syncObj)->bqId = bqId;
+ (*syncObj)->generationId = generation;
+ (*syncObj)->consumerUsage = consumerUsage;
+ ALOGD("C2SurfaceSyncMemory created %zu(%zu)", sizeof(C2SyncVariables), memSize);
+ }
+ }
+ if (!mapped) {
+ if (memFd >= 0) {
+ ::close(memFd);
+ }
+ ALOGW("SurfaceSyncObj creation failure");
+ }
+ }
+
+ size_t tryNum = 0;
+ size_t success = 0;
+ sp<GraphicBuffer> buffers[BufferQueueDefs::NUM_BUFFER_SLOTS];
+ std::weak_ptr<_C2BlockPoolData>
+ poolDatas[BufferQueueDefs::NUM_BUFFER_SLOTS];
+ {
+ std::scoped_lock<std::mutex> l(mMutex);
+ if (generation == mGeneration) {
+ return false;
+ }
+ std::shared_ptr<C2SurfaceSyncMemory> oldMem = mSyncMem;
+ C2SyncVariables *oldSync = mSyncMem ? mSyncMem->mem() : nullptr;
+ if (oldSync) {
+ oldSync->lock();
+ oldSync->setSyncStatusLocked(C2SyncVariables::STATUS_SWITCHING);
+ oldSync->unlock();
+ }
+ mSyncMem.reset();
+ if (syncMem) {
+ mSyncMem = syncMem;
+ }
+ C2SyncVariables *newSync = mSyncMem ? mSyncMem->mem() : nullptr;
+
+ mIgbp = igbp;
+ mGeneration = generation;
+ mBqId = bqId;
+ mOwner = std::make_shared<int>(0);
+ for (int i = 0; i < BufferQueueDefs::NUM_BUFFER_SLOTS; ++i) {
+ if (mBqId == 0 || !mBuffers[i]) {
+ continue;
+ }
+ std::shared_ptr<_C2BlockPoolData> data = mPoolDatas[i].lock();
+ if (!data ||
+ !_C2BlockFactory::BeginAttachBlockToBufferQueue(data)) {
+ continue;
+ }
+ ++tryNum;
+ int bqSlot;
+
+ // Update buffer's generation and usage.
+ if ((mBuffers[i]->getUsage() & consumerUsage) != consumerUsage) {
+ mBuffers[i] = new GraphicBuffer(
+ mBuffers[i]->handle, GraphicBuffer::CLONE_HANDLE,
+ mBuffers[i]->width, mBuffers[i]->height,
+ mBuffers[i]->format, mBuffers[i]->layerCount,
+ mBuffers[i]->getUsage() | consumerUsage,
+ mBuffers[i]->stride);
+ if (mBuffers[i]->initCheck() != OK) {
+ ALOGW("%s() failed to update usage, original usage=%" PRIx64
+ ", consumer usage=%" PRIx64,
+ __func__, mBuffers[i]->getUsage(), consumerUsage);
+ continue;
+ }
+ }
+ mBuffers[i]->setGenerationNumber(generation);
+
+ status_t result = igbp->attachBuffer(&bqSlot, mBuffers[i]);
+ if (result != OK) {
+ continue;
+ }
+ bool attach =
+ _C2BlockFactory::EndAttachBlockToBufferQueue(
+ data, mOwner, getHgbp(mIgbp), mSyncMem,
+ generation, bqId, bqSlot);
+ if (!attach) {
+ igbp->cancelBuffer(bqSlot, Fence::NO_FENCE);
+ continue;
+ }
+ buffers[bqSlot] = mBuffers[i];
+ poolDatas[bqSlot] = data;
+ ++success;
+ }
+ for (int i = 0; i < BufferQueueDefs::NUM_BUFFER_SLOTS; ++i) {
+ mBuffers[i] = buffers[i];
+ mPoolDatas[i] = poolDatas[i];
+ }
+ if (newSync) {
+ newSync->setInitialDequeueCount(mMaxDequeueBufferCount, success);
+ }
+ }
+ ALOGD("remote graphic buffer migration %zu/%zu",
+ success, tryNum);
+ return true;
+}
+
+bool OutputBufferQueue::registerBuffer(const C2ConstGraphicBlock& block) {
+ std::shared_ptr<_C2BlockPoolData> data =
+ _C2BlockFactory::GetGraphicBlockPoolData(block);
+ if (!data) {
+ return false;
+ }
+ std::scoped_lock<std::mutex> l(mMutex);
+
+ if (!mIgbp) {
+ return false;
+ }
+
+ uint32_t oldGeneration;
+ uint64_t oldId;
+ int32_t oldSlot;
+ // If the block is not bufferqueue-based, do nothing.
+ if (!_C2BlockFactory::GetBufferQueueData(
+ data, &oldGeneration, &oldId, &oldSlot) || (oldId == 0)) {
+ return false;
+ }
+ // If the block's bqId is the same as the desired bqId, just hold.
+ if ((oldId == mBqId) && (oldGeneration == mGeneration)) {
+ LOG(VERBOSE) << "holdBufferQueueBlock -- import without attaching:"
+ << " bqId " << oldId
+ << ", bqSlot " << oldSlot
+ << ", generation " << mGeneration
+ << ".";
+ _C2BlockFactory::HoldBlockFromBufferQueue(data, mOwner, getHgbp(mIgbp), mSyncMem);
+ mPoolDatas[oldSlot] = data;
+ mBuffers[oldSlot] = createGraphicBuffer(block);
+ mBuffers[oldSlot]->setGenerationNumber(mGeneration);
+ return true;
+ }
+ int32_t d = (int32_t) mGeneration - (int32_t) oldGeneration;
+ LOG(WARNING) << "receiving stale buffer: generation "
+ << mGeneration << " , diff " << d << " : slot "
+ << oldSlot;
+ return false;
+}
+
+status_t OutputBufferQueue::outputBuffer(
+ const C2ConstGraphicBlock& block,
+ const BnGraphicBufferProducer::QueueBufferInput& input,
+ BnGraphicBufferProducer::QueueBufferOutput* output) {
+ uint32_t generation;
+ uint64_t bqId;
+ int32_t bqSlot;
+ bool display = V1_0::utils::displayBufferQueueBlock(block);
+ if (!getBufferQueueAssignment(block, &generation, &bqId, &bqSlot) ||
+ bqId == 0) {
+ // Block not from bufferqueue -- it must be attached before queuing.
+
+ std::shared_ptr<C2SurfaceSyncMemory> syncMem;
+ mMutex.lock();
+ sp<IGraphicBufferProducer> outputIgbp = mIgbp;
+ uint32_t outputGeneration = mGeneration;
+ syncMem = mSyncMem;
+ mMutex.unlock();
+
+ status_t status = attachToBufferQueue(
+ block, outputIgbp, outputGeneration, &bqSlot, syncMem);
+
+ if (status != OK) {
+ LOG(WARNING) << "outputBuffer -- attaching failed.";
+ return INVALID_OPERATION;
+ }
+
+ auto syncVar = syncMem ? syncMem->mem() : nullptr;
+ if(syncVar) {
+ syncVar->lock();
+ status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
+ input, output);
+ if (status == OK) {
+ syncVar->notifyQueuedLocked();
+ }
+ syncVar->unlock();
+ } else {
+ status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
+ input, output);
+ }
+ if (status != OK) {
+ LOG(ERROR) << "outputBuffer -- queueBuffer() failed "
+ "on non-bufferqueue-based block. "
+ "Error = " << status << ".";
+ return status;
+ }
+ return OK;
+ }
+
+ std::shared_ptr<C2SurfaceSyncMemory> syncMem;
+ mMutex.lock();
+ sp<IGraphicBufferProducer> outputIgbp = mIgbp;
+ uint32_t outputGeneration = mGeneration;
+ uint64_t outputBqId = mBqId;
+ syncMem = mSyncMem;
+ mMutex.unlock();
+
+ if (!outputIgbp) {
+ LOG(VERBOSE) << "outputBuffer -- output surface is null.";
+ return NO_INIT;
+ }
+
+ if (!display) {
+ LOG(WARNING) << "outputBuffer -- cannot display "
+ "bufferqueue-based block to the bufferqueue.";
+ return UNKNOWN_ERROR;
+ }
+ if (bqId != outputBqId || generation != outputGeneration) {
+ int32_t diff = (int32_t) outputGeneration - (int32_t) generation;
+ LOG(WARNING) << "outputBuffer -- buffers from old generation to "
+ << outputGeneration << " , diff: " << diff
+ << " , slot: " << bqSlot;
+ return DEAD_OBJECT;
+ }
+
+ auto syncVar = syncMem ? syncMem->mem() : nullptr;
+ status_t status = OK;
+ if (syncVar) {
+ syncVar->lock();
+ status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
+ input, output);
+ if (status == OK) {
+ syncVar->notifyQueuedLocked();
+ }
+ syncVar->unlock();
+ } else {
+ status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
+ input, output);
+ }
+
+ if (status != OK) {
+ LOG(ERROR) << "outputBuffer -- queueBuffer() failed "
+ "on bufferqueue-based block. "
+ "Error = " << status << ".";
+ return status;
+ }
+ return OK;
+}
+
+void OutputBufferQueue::holdBufferQueueBlocks(
+ const std::list<std::unique_ptr<C2Work>>& workList) {
+ forEachBlock(workList,
+ std::bind(&OutputBufferQueue::registerBuffer,
+ this, std::placeholders::_1));
+}
+
+void OutputBufferQueue::updateMaxDequeueBufferCount(int maxDequeueBufferCount) {
+ mMutex.lock();
+ mMaxDequeueBufferCount = maxDequeueBufferCount;
+ auto syncVar = mSyncMem ? mSyncMem->mem() : nullptr;
+ if (syncVar) {
+ syncVar->lock();
+ syncVar->updateMaxDequeueCountLocked(maxDequeueBufferCount);
+ syncVar->unlock();
+ }
+ mMutex.unlock();
+}
+
+} // namespace c2
+} // namespace media
+} // namespace hardware
+} // namespace android
+