blob: 48f9756a64528fa36679fc38632f6cd42feccb2f [file] [log] [blame]
Pawin Vongmasa586b1982019-10-23 19:21:04 -07001/*
2 * Copyright 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "Codec2-OutputBufferQueue"
19#include <android-base/logging.h>
20
21#include <android/hardware/graphics/bufferqueue/2.0/IGraphicBufferProducer.h>
Sungtak Leea714f112021-03-16 05:40:03 -070022#include <codec2/hidl/output.h>
23#include <cutils/ashmem.h>
Pawin Vongmasa586b1982019-10-23 19:21:04 -070024#include <gui/bufferqueue/2.0/B2HGraphicBufferProducer.h>
Sungtak Leea714f112021-03-16 05:40:03 -070025#include <sys/mman.h>
Pawin Vongmasa586b1982019-10-23 19:21:04 -070026
27#include <C2AllocatorGralloc.h>
28#include <C2BlockInternal.h>
29#include <C2Buffer.h>
30#include <C2PlatformSupport.h>
Sungtak Leea714f112021-03-16 05:40:03 -070031#include <C2SurfaceSyncObj.h>
Pawin Vongmasa586b1982019-10-23 19:21:04 -070032
33#include <iomanip>
34
35namespace android {
36namespace hardware {
37namespace media {
38namespace c2 {
Pawin Vongmasa586b1982019-10-23 19:21:04 -070039
40using HGraphicBufferProducer = ::android::hardware::graphics::bufferqueue::
41 V2_0::IGraphicBufferProducer;
42using B2HGraphicBufferProducer = ::android::hardware::graphics::bufferqueue::
43 V2_0::utils::B2HGraphicBufferProducer;
44
45namespace /* unnamed */ {
46
47// Create a GraphicBuffer object from a graphic block.
48sp<GraphicBuffer> createGraphicBuffer(const C2ConstGraphicBlock& block) {
49 uint32_t width;
50 uint32_t height;
51 uint32_t format;
52 uint64_t usage;
53 uint32_t stride;
54 uint32_t generation;
55 uint64_t bqId;
56 int32_t bqSlot;
57 _UnwrapNativeCodec2GrallocMetadata(
58 block.handle(), &width, &height, &format, &usage,
59 &stride, &generation, &bqId, reinterpret_cast<uint32_t*>(&bqSlot));
60 native_handle_t *grallocHandle =
61 UnwrapNativeCodec2GrallocHandle(block.handle());
62 sp<GraphicBuffer> graphicBuffer =
63 new GraphicBuffer(grallocHandle,
64 GraphicBuffer::CLONE_HANDLE,
65 width, height, format,
66 1, usage, stride);
67 native_handle_delete(grallocHandle);
68 return graphicBuffer;
69}
70
71template <typename BlockProcessor>
72void forEachBlock(C2FrameData& frameData,
73 BlockProcessor process) {
74 for (const std::shared_ptr<C2Buffer>& buffer : frameData.buffers) {
75 if (buffer) {
76 for (const C2ConstGraphicBlock& block :
77 buffer->data().graphicBlocks()) {
78 process(block);
79 }
80 }
81 }
82}
83
84template <typename BlockProcessor>
85void forEachBlock(const std::list<std::unique_ptr<C2Work>>& workList,
86 BlockProcessor process) {
87 for (const std::unique_ptr<C2Work>& work : workList) {
88 if (!work) {
89 continue;
90 }
91 for (const std::unique_ptr<C2Worklet>& worklet : work->worklets) {
92 if (worklet) {
93 forEachBlock(worklet->output, process);
94 }
95 }
96 }
97}
98
99sp<HGraphicBufferProducer> getHgbp(const sp<IGraphicBufferProducer>& igbp) {
100 sp<HGraphicBufferProducer> hgbp =
101 igbp->getHalInterface<HGraphicBufferProducer>();
102 return hgbp ? hgbp :
103 new B2HGraphicBufferProducer(igbp);
104}
105
106status_t attachToBufferQueue(const C2ConstGraphicBlock& block,
107 const sp<IGraphicBufferProducer>& igbp,
108 uint32_t generation,
Sungtak Leea714f112021-03-16 05:40:03 -0700109 int32_t* bqSlot,
110 std::shared_ptr<C2SurfaceSyncMemory> syncMem) {
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700111 if (!igbp) {
112 LOG(WARNING) << "attachToBufferQueue -- null producer.";
113 return NO_INIT;
114 }
115
116 sp<GraphicBuffer> graphicBuffer = createGraphicBuffer(block);
117 graphicBuffer->setGenerationNumber(generation);
118
119 LOG(VERBOSE) << "attachToBufferQueue -- attaching buffer:"
120 << " block dimension " << block.width() << "x"
121 << block.height()
122 << ", graphicBuffer dimension " << graphicBuffer->getWidth() << "x"
123 << graphicBuffer->getHeight()
124 << std::hex << std::setfill('0')
125 << ", format 0x" << std::setw(8) << graphicBuffer->getPixelFormat()
126 << ", usage 0x" << std::setw(16) << graphicBuffer->getUsage()
127 << std::dec << std::setfill(' ')
128 << ", stride " << graphicBuffer->getStride()
129 << ", generation " << graphicBuffer->getGenerationNumber();
130
Sungtak Leea714f112021-03-16 05:40:03 -0700131 C2SyncVariables *syncVar = syncMem ? syncMem->mem() : nullptr;
132 status_t result = OK;
133 if (syncVar) {
134 syncVar->lock();
135 if (!syncVar->isDequeueableLocked() ||
136 syncVar->getSyncStatusLocked() == C2SyncVariables::STATUS_SWITCHING) {
137 syncVar->unlock();
138 LOG(WARNING) << "attachToBufferQueue -- attachBuffer failed: "
139 "status = " << INVALID_OPERATION << ".";
140 return INVALID_OPERATION;
141 }
142 result = igbp->attachBuffer(bqSlot, graphicBuffer);
143 if (result == OK) {
144 syncVar->notifyDequeuedLocked();
145 }
146 syncVar->unlock();
147 } else {
148 result = igbp->attachBuffer(bqSlot, graphicBuffer);
149 }
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700150 if (result != OK) {
151 LOG(WARNING) << "attachToBufferQueue -- attachBuffer failed: "
152 "status = " << result << ".";
153 return result;
154 }
155 LOG(VERBOSE) << "attachToBufferQueue -- attachBuffer returned slot #"
156 << *bqSlot << ".";
157 return OK;
158}
159
160bool getBufferQueueAssignment(const C2ConstGraphicBlock& block,
161 uint32_t* generation,
162 uint64_t* bqId,
163 int32_t* bqSlot) {
164 return _C2BlockFactory::GetBufferQueueData(
165 _C2BlockFactory::GetGraphicBlockPoolData(block),
166 generation, bqId, bqSlot);
167}
168
169} // unnamed namespace
170
171OutputBufferQueue::OutputBufferQueue()
Sungtak Leec7da7a02022-05-05 08:45:33 +0000172 : mGeneration{0}, mBqId{0}, mStopped{false} {
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700173}
174
175OutputBufferQueue::~OutputBufferQueue() {
176}
177
178bool OutputBufferQueue::configure(const sp<IGraphicBufferProducer>& igbp,
179 uint32_t generation,
Sungtak Leea714f112021-03-16 05:40:03 -0700180 uint64_t bqId,
Sungtak Leedb14cba2021-04-10 00:50:23 -0700181 int maxDequeueBufferCount,
Sungtak Leea714f112021-03-16 05:40:03 -0700182 std::shared_ptr<V1_2::SurfaceSyncObj> *syncObj) {
Chih-Yu Huangb5ec89e2021-02-09 17:37:32 +0900183 uint64_t consumerUsage = 0;
Sungtak Leeb6388022021-07-21 00:40:26 -0700184 if (igbp && igbp->getConsumerUsage(&consumerUsage) != OK) {
Chih-Yu Huangb5ec89e2021-02-09 17:37:32 +0900185 ALOGW("failed to get consumer usage");
186 }
187
Sungtak Leea714f112021-03-16 05:40:03 -0700188 // TODO : Abstract creation process into C2SurfaceSyncMemory class.
189 // use C2LinearBlock instead ashmem.
190 std::shared_ptr<C2SurfaceSyncMemory> syncMem;
191 if (syncObj && igbp) {
192 bool mapped = false;
193 int memFd = ashmem_create_region("C2SurfaceMem", sizeof(C2SyncVariables));
194 size_t memSize = memFd < 0 ? 0 : ashmem_get_size_region(memFd);
195 if (memSize > 0) {
196 syncMem = C2SurfaceSyncMemory::Create(memFd, memSize);
197 if (syncMem) {
198 mapped = true;
199 *syncObj = std::make_shared<V1_2::SurfaceSyncObj>();
200 (*syncObj)->syncMemory = syncMem->handle();
201 (*syncObj)->bqId = bqId;
202 (*syncObj)->generationId = generation;
203 (*syncObj)->consumerUsage = consumerUsage;
204 ALOGD("C2SurfaceSyncMemory created %zu(%zu)", sizeof(C2SyncVariables), memSize);
205 }
206 }
207 if (!mapped) {
208 if (memFd >= 0) {
209 ::close(memFd);
210 }
211 ALOGW("SurfaceSyncObj creation failure");
212 }
213 }
214
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700215 size_t tryNum = 0;
216 size_t success = 0;
217 sp<GraphicBuffer> buffers[BufferQueueDefs::NUM_BUFFER_SLOTS];
218 std::weak_ptr<_C2BlockPoolData>
219 poolDatas[BufferQueueDefs::NUM_BUFFER_SLOTS];
Sungtak Lee3cc67e72023-05-08 17:00:05 +0000220 std::shared_ptr<C2SurfaceSyncMemory> oldMem;
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700221 {
222 std::scoped_lock<std::mutex> l(mMutex);
Sungtak Leec7da7a02022-05-05 08:45:33 +0000223 bool stopped = mStopped;
224 mStopped = false;
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700225 if (generation == mGeneration) {
Sungtak Leedb14cba2021-04-10 00:50:23 -0700226 // case of old BlockPool destruction
227 C2SyncVariables *var = mSyncMem ? mSyncMem->mem() : nullptr;
George Burgess IV3defea72021-04-23 18:43:57 -0700228 if (syncObj && var) {
Sungtak Leedb14cba2021-04-10 00:50:23 -0700229 *syncObj = std::make_shared<V1_2::SurfaceSyncObj>();
230 (*syncObj)->bqId = bqId;
231 (*syncObj)->syncMemory = mSyncMem->handle();
232 (*syncObj)->generationId = generation;
233 (*syncObj)->consumerUsage = consumerUsage;
234 mMaxDequeueBufferCount = maxDequeueBufferCount;
235 var->lock();
236 var->setSyncStatusLocked(C2SyncVariables::STATUS_INIT);
237 var->setInitialDequeueCountLocked(mMaxDequeueBufferCount, 0);
238 var->unlock();
239 }
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700240 return false;
241 }
Sungtak Lee3cc67e72023-05-08 17:00:05 +0000242 oldMem = mSyncMem;
Sungtak Leea714f112021-03-16 05:40:03 -0700243 C2SyncVariables *oldSync = mSyncMem ? mSyncMem->mem() : nullptr;
244 if (oldSync) {
245 oldSync->lock();
246 oldSync->setSyncStatusLocked(C2SyncVariables::STATUS_SWITCHING);
247 oldSync->unlock();
248 }
249 mSyncMem.reset();
250 if (syncMem) {
251 mSyncMem = syncMem;
252 }
253 C2SyncVariables *newSync = mSyncMem ? mSyncMem->mem() : nullptr;
254
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700255 mIgbp = igbp;
256 mGeneration = generation;
257 mBqId = bqId;
258 mOwner = std::make_shared<int>(0);
Sungtak Leedb14cba2021-04-10 00:50:23 -0700259 mMaxDequeueBufferCount = maxDequeueBufferCount;
Sungtak Leeb6388022021-07-21 00:40:26 -0700260 if (igbp == nullptr) {
261 return false;
262 }
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700263 for (int i = 0; i < BufferQueueDefs::NUM_BUFFER_SLOTS; ++i) {
Sungtak Leec7da7a02022-05-05 08:45:33 +0000264 if (mBqId == 0 || !mBuffers[i] || stopped) {
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700265 continue;
266 }
267 std::shared_ptr<_C2BlockPoolData> data = mPoolDatas[i].lock();
268 if (!data ||
269 !_C2BlockFactory::BeginAttachBlockToBufferQueue(data)) {
270 continue;
271 }
272 ++tryNum;
273 int bqSlot;
Chih-Yu Huangb5ec89e2021-02-09 17:37:32 +0900274
275 // Update buffer's generation and usage.
276 if ((mBuffers[i]->getUsage() & consumerUsage) != consumerUsage) {
277 mBuffers[i] = new GraphicBuffer(
278 mBuffers[i]->handle, GraphicBuffer::CLONE_HANDLE,
279 mBuffers[i]->width, mBuffers[i]->height,
280 mBuffers[i]->format, mBuffers[i]->layerCount,
281 mBuffers[i]->getUsage() | consumerUsage,
282 mBuffers[i]->stride);
283 if (mBuffers[i]->initCheck() != OK) {
284 ALOGW("%s() failed to update usage, original usage=%" PRIx64
285 ", consumer usage=%" PRIx64,
286 __func__, mBuffers[i]->getUsage(), consumerUsage);
287 continue;
288 }
289 }
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700290 mBuffers[i]->setGenerationNumber(generation);
Chih-Yu Huangb5ec89e2021-02-09 17:37:32 +0900291
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700292 status_t result = igbp->attachBuffer(&bqSlot, mBuffers[i]);
293 if (result != OK) {
294 continue;
295 }
296 bool attach =
297 _C2BlockFactory::EndAttachBlockToBufferQueue(
Sungtak Leea714f112021-03-16 05:40:03 -0700298 data, mOwner, getHgbp(mIgbp), mSyncMem,
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700299 generation, bqId, bqSlot);
300 if (!attach) {
301 igbp->cancelBuffer(bqSlot, Fence::NO_FENCE);
302 continue;
303 }
304 buffers[bqSlot] = mBuffers[i];
305 poolDatas[bqSlot] = data;
306 ++success;
307 }
308 for (int i = 0; i < BufferQueueDefs::NUM_BUFFER_SLOTS; ++i) {
309 mBuffers[i] = buffers[i];
310 mPoolDatas[i] = poolDatas[i];
311 }
Sungtak Leea714f112021-03-16 05:40:03 -0700312 if (newSync) {
Sungtak Leedb14cba2021-04-10 00:50:23 -0700313 newSync->lock();
314 newSync->setInitialDequeueCountLocked(mMaxDequeueBufferCount, success);
315 newSync->unlock();
Sungtak Leea714f112021-03-16 05:40:03 -0700316 }
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700317 }
Sungtak Lee3cc67e72023-05-08 17:00:05 +0000318 {
319 std::scoped_lock<std::mutex> l(mOldMutex);
320 mOldMem = oldMem;
321 }
Sungtak Leea714f112021-03-16 05:40:03 -0700322 ALOGD("remote graphic buffer migration %zu/%zu",
323 success, tryNum);
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700324 return true;
325}
326
Sungtak Lee3cc67e72023-05-08 17:00:05 +0000327void OutputBufferQueue::expireOldWaiters() {
328 std::scoped_lock<std::mutex> l(mOldMutex);
329 if (mOldMem) {
330 C2SyncVariables *oldSync = mOldMem->mem();
331 if (oldSync) {
332 oldSync->notifyAll();
333 }
334 mOldMem.reset();
335 }
336}
337
Sungtak Leec7da7a02022-05-05 08:45:33 +0000338void OutputBufferQueue::stop() {
Sungtak Leec0c05962023-10-25 08:14:13 +0000339 std::shared_ptr<C2SurfaceSyncMemory> oldMem;
340 {
341 std::scoped_lock<std::mutex> l(mMutex);
342 if (mStopped) {
343 return;
344 }
345 mStopped = true;
346 mOwner.reset(); // destructor of the block will not trigger IGBP::cancel()
347 // basically configuring null surface
348 oldMem = mSyncMem;
349 mSyncMem.reset();
350 mIgbp.clear();
351 mGeneration = 0;
352 mBqId = 0;
353 }
354 {
355 std::scoped_lock<std::mutex> l(mOldMutex);
356 mOldMem = oldMem;
357 }
Sungtak Leec7da7a02022-05-05 08:45:33 +0000358}
359
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700360bool OutputBufferQueue::registerBuffer(const C2ConstGraphicBlock& block) {
361 std::shared_ptr<_C2BlockPoolData> data =
362 _C2BlockFactory::GetGraphicBlockPoolData(block);
363 if (!data) {
364 return false;
365 }
366 std::scoped_lock<std::mutex> l(mMutex);
367
Sungtak Leec7da7a02022-05-05 08:45:33 +0000368 if (!mIgbp || mStopped) {
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700369 return false;
370 }
371
372 uint32_t oldGeneration;
373 uint64_t oldId;
374 int32_t oldSlot;
375 // If the block is not bufferqueue-based, do nothing.
376 if (!_C2BlockFactory::GetBufferQueueData(
377 data, &oldGeneration, &oldId, &oldSlot) || (oldId == 0)) {
378 return false;
379 }
380 // If the block's bqId is the same as the desired bqId, just hold.
381 if ((oldId == mBqId) && (oldGeneration == mGeneration)) {
382 LOG(VERBOSE) << "holdBufferQueueBlock -- import without attaching:"
383 << " bqId " << oldId
384 << ", bqSlot " << oldSlot
385 << ", generation " << mGeneration
386 << ".";
Sungtak Leea714f112021-03-16 05:40:03 -0700387 _C2BlockFactory::HoldBlockFromBufferQueue(data, mOwner, getHgbp(mIgbp), mSyncMem);
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700388 mPoolDatas[oldSlot] = data;
389 mBuffers[oldSlot] = createGraphicBuffer(block);
390 mBuffers[oldSlot]->setGenerationNumber(mGeneration);
391 return true;
392 }
393 int32_t d = (int32_t) mGeneration - (int32_t) oldGeneration;
394 LOG(WARNING) << "receiving stale buffer: generation "
395 << mGeneration << " , diff " << d << " : slot "
396 << oldSlot;
397 return false;
398}
399
400status_t OutputBufferQueue::outputBuffer(
401 const C2ConstGraphicBlock& block,
402 const BnGraphicBufferProducer::QueueBufferInput& input,
403 BnGraphicBufferProducer::QueueBufferOutput* output) {
404 uint32_t generation;
405 uint64_t bqId;
406 int32_t bqSlot;
Sungtak Leea714f112021-03-16 05:40:03 -0700407 bool display = V1_0::utils::displayBufferQueueBlock(block);
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700408 if (!getBufferQueueAssignment(block, &generation, &bqId, &bqSlot) ||
409 bqId == 0) {
410 // Block not from bufferqueue -- it must be attached before queuing.
411
Sungtak Leea714f112021-03-16 05:40:03 -0700412 std::shared_ptr<C2SurfaceSyncMemory> syncMem;
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700413 mMutex.lock();
Sungtak Leec7da7a02022-05-05 08:45:33 +0000414 bool stopped = mStopped;
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700415 sp<IGraphicBufferProducer> outputIgbp = mIgbp;
416 uint32_t outputGeneration = mGeneration;
Sungtak Leea714f112021-03-16 05:40:03 -0700417 syncMem = mSyncMem;
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700418 mMutex.unlock();
419
Sungtak Leec7da7a02022-05-05 08:45:33 +0000420 if (stopped) {
421 LOG(INFO) << "outputBuffer -- already stopped.";
422 return DEAD_OBJECT;
423 }
424
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700425 status_t status = attachToBufferQueue(
Sungtak Leea714f112021-03-16 05:40:03 -0700426 block, outputIgbp, outputGeneration, &bqSlot, syncMem);
427
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700428 if (status != OK) {
429 LOG(WARNING) << "outputBuffer -- attaching failed.";
430 return INVALID_OPERATION;
431 }
432
Sungtak Leea714f112021-03-16 05:40:03 -0700433 auto syncVar = syncMem ? syncMem->mem() : nullptr;
434 if(syncVar) {
435 syncVar->lock();
436 status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
437 input, output);
438 if (status == OK) {
439 syncVar->notifyQueuedLocked();
440 }
441 syncVar->unlock();
442 } else {
443 status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
444 input, output);
445 }
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700446 if (status != OK) {
447 LOG(ERROR) << "outputBuffer -- queueBuffer() failed "
448 "on non-bufferqueue-based block. "
449 "Error = " << status << ".";
450 return status;
451 }
452 return OK;
453 }
454
Sungtak Leea714f112021-03-16 05:40:03 -0700455 std::shared_ptr<C2SurfaceSyncMemory> syncMem;
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700456 mMutex.lock();
Sungtak Leec7da7a02022-05-05 08:45:33 +0000457 bool stopped = mStopped;
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700458 sp<IGraphicBufferProducer> outputIgbp = mIgbp;
459 uint32_t outputGeneration = mGeneration;
460 uint64_t outputBqId = mBqId;
Sungtak Leea714f112021-03-16 05:40:03 -0700461 syncMem = mSyncMem;
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700462 mMutex.unlock();
463
Sungtak Leec7da7a02022-05-05 08:45:33 +0000464 if (stopped) {
465 LOG(INFO) << "outputBuffer -- already stopped.";
466 return DEAD_OBJECT;
467 }
468
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700469 if (!outputIgbp) {
470 LOG(VERBOSE) << "outputBuffer -- output surface is null.";
471 return NO_INIT;
472 }
473
474 if (!display) {
475 LOG(WARNING) << "outputBuffer -- cannot display "
476 "bufferqueue-based block to the bufferqueue.";
477 return UNKNOWN_ERROR;
478 }
479 if (bqId != outputBqId || generation != outputGeneration) {
480 int32_t diff = (int32_t) outputGeneration - (int32_t) generation;
481 LOG(WARNING) << "outputBuffer -- buffers from old generation to "
482 << outputGeneration << " , diff: " << diff
483 << " , slot: " << bqSlot;
484 return DEAD_OBJECT;
485 }
486
Sungtak Leea714f112021-03-16 05:40:03 -0700487 auto syncVar = syncMem ? syncMem->mem() : nullptr;
488 status_t status = OK;
489 if (syncVar) {
490 syncVar->lock();
491 status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
492 input, output);
493 if (status == OK) {
494 syncVar->notifyQueuedLocked();
495 }
496 syncVar->unlock();
497 } else {
498 status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
499 input, output);
500 }
501
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700502 if (status != OK) {
503 LOG(ERROR) << "outputBuffer -- queueBuffer() failed "
504 "on bufferqueue-based block. "
505 "Error = " << status << ".";
506 return status;
507 }
508 return OK;
509}
510
Brian Lindahl932bf602023-03-09 11:59:48 -0700511void OutputBufferQueue::pollForRenderedFrames(FrameEventHistoryDelta* delta) {
512 if (mIgbp) {
513 mIgbp->getFrameTimestamps(delta);
514 }
515}
516
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700517void OutputBufferQueue::holdBufferQueueBlocks(
518 const std::list<std::unique_ptr<C2Work>>& workList) {
519 forEachBlock(workList,
520 std::bind(&OutputBufferQueue::registerBuffer,
521 this, std::placeholders::_1));
522}
523
Sungtak Leea714f112021-03-16 05:40:03 -0700524void OutputBufferQueue::updateMaxDequeueBufferCount(int maxDequeueBufferCount) {
525 mMutex.lock();
526 mMaxDequeueBufferCount = maxDequeueBufferCount;
527 auto syncVar = mSyncMem ? mSyncMem->mem() : nullptr;
Sungtak Leec7da7a02022-05-05 08:45:33 +0000528 if (syncVar && !mStopped) {
Sungtak Leea714f112021-03-16 05:40:03 -0700529 syncVar->lock();
530 syncVar->updateMaxDequeueCountLocked(maxDequeueBufferCount);
531 syncVar->unlock();
532 }
533 mMutex.unlock();
Sungtak Leedb14cba2021-04-10 00:50:23 -0700534 ALOGD("set max dequeue count %d from update", maxDequeueBufferCount);
Sungtak Leea714f112021-03-16 05:40:03 -0700535}
536
Pawin Vongmasa586b1982019-10-23 19:21:04 -0700537} // namespace c2
538} // namespace media
539} // namespace hardware
540} // namespace android