1 /*
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 #ifdef __LP64__
18 #define OMX_ANDROID_COMPILE_AS_32BIT_ON_64BIT_PLATFORMS
19 #endif
20
21 //#define LOG_NDEBUG 0
22 #define LOG_TAG "C2OMXNode"
23 #include <log/log.h>
24
25 #include <C2AllocatorGralloc.h>
26 #include <C2BlockInternal.h>
27 #include <C2Component.h>
28 #include <C2Config.h>
29 #include <C2PlatformSupport.h>
30
31 #include <OMX_Component.h>
32 #include <OMX_Index.h>
33 #include <OMX_IndexExt.h>
34
35 #include <android/fdsan.h>
36 #include <media/stagefright/foundation/ColorUtils.h>
37 #include <media/stagefright/omx/OMXUtils.h>
38 #include <media/stagefright/MediaErrors.h>
39 #include <ui/Fence.h>
40 #include <ui/GraphicBuffer.h>
41 #include <utils/Thread.h>
42
43 #include "utils/Codec2Mapper.h"
44 #include "C2OMXNode.h"
45 #include "Codec2Buffer.h"
46
47 namespace android {
48
49 namespace {
50
51 constexpr OMX_U32 kPortIndexInput = 0;
52
53 class Buffer2D : public C2Buffer {
54 public:
Buffer2D(C2ConstGraphicBlock block)55 explicit Buffer2D(C2ConstGraphicBlock block) : C2Buffer({ block }) {}
56 };
57
58 } // namespace
59
60 class C2OMXNode::QueueThread : public Thread {
61 public:
QueueThread()62 QueueThread() : Thread(false) {}
63 ~QueueThread() override = default;
queue(const std::shared_ptr<Codec2Client::Component> & comp,int fenceFd,std::unique_ptr<C2Work> && work,android::base::unique_fd && fd0,android::base::unique_fd && fd1)64 void queue(
65 const std::shared_ptr<Codec2Client::Component> &comp,
66 int fenceFd,
67 std::unique_ptr<C2Work> &&work,
68 android::base::unique_fd &&fd0,
69 android::base::unique_fd &&fd1) {
70 Mutexed<Jobs>::Locked jobs(mJobs);
71 auto it = jobs->queues.try_emplace(comp, comp).first;
72 it->second.workList.emplace_back(
73 std::move(work), fenceFd, std::move(fd0), std::move(fd1));
74 jobs->cond.broadcast();
75 }
76
setDataspace(android_dataspace dataspace)77 void setDataspace(android_dataspace dataspace) {
78 Mutexed<Jobs>::Locked jobs(mJobs);
79 ColorUtils::convertDataSpaceToV0(dataspace);
80 jobs->configUpdate.emplace_back(new C2StreamDataSpaceInfo::input(0u, dataspace));
81 int32_t standard;
82 int32_t transfer;
83 int32_t range;
84 ColorUtils::getColorConfigFromDataSpace(dataspace, &range, &standard, &transfer);
85 std::unique_ptr<C2StreamColorAspectsInfo::input> colorAspects =
86 std::make_unique<C2StreamColorAspectsInfo::input>(0u);
87 if (C2Mapper::map(standard, &colorAspects->primaries, &colorAspects->matrix)
88 && C2Mapper::map(transfer, &colorAspects->transfer)
89 && C2Mapper::map(range, &colorAspects->range)) {
90 jobs->configUpdate.push_back(std::move(colorAspects));
91 }
92 }
93
setPriority(int priority)94 void setPriority(int priority) {
95 androidSetThreadPriority(getTid(), priority);
96 }
97
98 protected:
threadLoop()99 bool threadLoop() override {
100 constexpr nsecs_t kIntervalNs = nsecs_t(10) * 1000 * 1000; // 10ms
101 constexpr nsecs_t kWaitNs = kIntervalNs * 2;
102 for (int i = 0; i < 2; ++i) {
103 Mutexed<Jobs>::Locked jobs(mJobs);
104 nsecs_t nowNs = systemTime();
105 bool queued = false;
106 for (auto it = jobs->queues.begin(); it != jobs->queues.end(); ) {
107 Queue &queue = it->second;
108 if (queue.workList.empty()
109 || (queue.lastQueuedTimestampNs != 0 &&
110 nowNs - queue.lastQueuedTimestampNs < kIntervalNs)) {
111 ++it;
112 continue;
113 }
114 std::shared_ptr<Codec2Client::Component> comp = queue.component.lock();
115 if (!comp) {
116 it = jobs->queues.erase(it);
117 continue;
118 }
119 std::list<std::unique_ptr<C2Work>> items;
120 std::vector<int> fenceFds;
121 std::vector<android::base::unique_fd> uniqueFds;
122 while (!queue.workList.empty()) {
123 items.push_back(std::move(queue.workList.front().work));
124 fenceFds.push_back(queue.workList.front().fenceFd);
125 uniqueFds.push_back(std::move(queue.workList.front().fd0));
126 uniqueFds.push_back(std::move(queue.workList.front().fd1));
127 queue.workList.pop_front();
128 }
129 for (const std::unique_ptr<C2Param> ¶m : jobs->configUpdate) {
130 items.front()->input.configUpdate.emplace_back(C2Param::Copy(*param));
131 }
132
133 jobs.unlock();
134 for (int fenceFd : fenceFds) {
135 sp<Fence> fence(new Fence(fenceFd));
136 fence->waitForever(LOG_TAG);
137 }
138 queue.lastQueuedTimestampNs = nowNs;
139 comp->queue(&items);
140 for (android::base::unique_fd &ufd : uniqueFds) {
141 (void)ufd.release();
142 }
143 jobs.lock();
144
145 it = jobs->queues.upper_bound(comp);
146 queued = true;
147 }
148 if (queued) {
149 jobs->configUpdate.clear();
150 return true;
151 }
152 if (i == 0) {
153 jobs.waitForConditionRelative(jobs->cond, kWaitNs);
154 }
155 }
156 return true;
157 }
158
159 private:
160 struct WorkFence {
WorkFenceandroid::C2OMXNode::QueueThread::WorkFence161 WorkFence(std::unique_ptr<C2Work> &&w, int fd) : work(std::move(w)), fenceFd(fd) {}
162
WorkFenceandroid::C2OMXNode::QueueThread::WorkFence163 WorkFence(
164 std::unique_ptr<C2Work> &&w,
165 int fd,
166 android::base::unique_fd &&uniqueFd0,
167 android::base::unique_fd &&uniqueFd1)
168 : work(std::move(w)),
169 fenceFd(fd),
170 fd0(std::move(uniqueFd0)),
171 fd1(std::move(uniqueFd1)) {}
172
173 std::unique_ptr<C2Work> work;
174 int fenceFd;
175 android::base::unique_fd fd0;
176 android::base::unique_fd fd1;
177 };
178 struct Queue {
Queueandroid::C2OMXNode::QueueThread::Queue179 Queue(const std::shared_ptr<Codec2Client::Component> &comp)
180 : component(comp), lastQueuedTimestampNs(0) {}
181 Queue(const Queue &) = delete;
182 Queue &operator =(const Queue &) = delete;
183
184 std::weak_ptr<Codec2Client::Component> component;
185 std::list<WorkFence> workList;
186 nsecs_t lastQueuedTimestampNs;
187 };
188 struct Jobs {
189 std::map<std::weak_ptr<Codec2Client::Component>,
190 Queue,
191 std::owner_less<std::weak_ptr<Codec2Client::Component>>> queues;
192 std::vector<std::unique_ptr<C2Param>> configUpdate;
193 Condition cond;
194 };
195 Mutexed<Jobs> mJobs;
196 };
197
C2OMXNode(const std::shared_ptr<Codec2Client::Component> & comp)198 C2OMXNode::C2OMXNode(const std::shared_ptr<Codec2Client::Component> &comp)
199 : mComp(comp), mFrameIndex(0), mWidth(0), mHeight(0), mUsage(0),
200 mAdjustTimestampGapUs(0), mFirstInputFrame(true),
201 mQueueThread(new QueueThread) {
202 android_fdsan_set_error_level(ANDROID_FDSAN_ERROR_LEVEL_WARN_ALWAYS);
203 mQueueThread->run("C2OMXNode", PRIORITY_AUDIO);
204
205 android_dataspace ds = HAL_DATASPACE_UNKNOWN;
206 mDataspace.lock().set(ds);
207 uint32_t pf = PIXEL_FORMAT_UNKNOWN;
208 mPixelFormat.lock().set(pf);
209 }
210
freeNode()211 status_t C2OMXNode::freeNode() {
212 mComp.reset();
213 android_fdsan_set_error_level(ANDROID_FDSAN_ERROR_LEVEL_WARN_ONCE);
214 return mQueueThread->requestExitAndWait();
215 }
216
sendCommand(OMX_COMMANDTYPE cmd,OMX_S32 param)217 status_t C2OMXNode::sendCommand(OMX_COMMANDTYPE cmd, OMX_S32 param) {
218 if (cmd == OMX_CommandStateSet && param == OMX_StateLoaded) {
219 // Reset first input frame so if C2OMXNode is recycled, the timestamp does not become
220 // negative. This is a workaround for HW codecs that do not handle timestamp rollover.
221 mFirstInputFrame = true;
222 }
223 return ERROR_UNSUPPORTED;
224 }
225
getParameter(OMX_INDEXTYPE index,void * params,size_t size)226 status_t C2OMXNode::getParameter(OMX_INDEXTYPE index, void *params, size_t size) {
227 status_t err = ERROR_UNSUPPORTED;
228 switch ((uint32_t)index) {
229 case OMX_IndexParamConsumerUsageBits: {
230 OMX_U32 *usage = (OMX_U32 *)params;
231 *usage = mUsage;
232 err = OK;
233 break;
234 }
235 case OMX_IndexParamConsumerUsageBits64: {
236 OMX_U64 *usage = (OMX_U64 *)params;
237 *usage = mUsage;
238 err = OK;
239 break;
240 }
241 case OMX_IndexParamPortDefinition: {
242 if (size < sizeof(OMX_PARAM_PORTDEFINITIONTYPE)) {
243 return BAD_VALUE;
244 }
245 OMX_PARAM_PORTDEFINITIONTYPE *pDef = (OMX_PARAM_PORTDEFINITIONTYPE *)params;
246 if (pDef->nPortIndex != kPortIndexInput) {
247 break;
248 }
249
250 pDef->nBufferCountActual = 16;
251
252 // WORKAROUND: having more slots improve performance while consuming
253 // more memory. This is a temporary workaround to reduce memory for
254 // larger-than-4K scenario.
255 if (mWidth * mHeight > 4096 * 2340) {
256 std::shared_ptr<Codec2Client::Component> comp = mComp.lock();
257 C2PortActualDelayTuning::input inputDelay(0);
258 C2ActualPipelineDelayTuning pipelineDelay(0);
259 c2_status_t c2err = C2_NOT_FOUND;
260 if (comp) {
261 c2err = comp->query(
262 {&inputDelay, &pipelineDelay}, {}, C2_DONT_BLOCK, nullptr);
263 }
264 if (c2err == C2_OK || c2err == C2_BAD_INDEX) {
265 pDef->nBufferCountActual = 4;
266 pDef->nBufferCountActual += (inputDelay ? inputDelay.value : 0u);
267 pDef->nBufferCountActual += (pipelineDelay ? pipelineDelay.value : 0u);
268 }
269 }
270
271 pDef->eDomain = OMX_PortDomainVideo;
272 pDef->format.video.nFrameWidth = mWidth;
273 pDef->format.video.nFrameHeight = mHeight;
274 pDef->format.video.eColorFormat = OMX_COLOR_FormatAndroidOpaque;
275 err = OK;
276 break;
277 }
278 default:
279 break;
280 }
281 return err;
282 }
283
setParameter(OMX_INDEXTYPE index,const void * params,size_t size)284 status_t C2OMXNode::setParameter(OMX_INDEXTYPE index, const void *params, size_t size) {
285 if (params == NULL) {
286 return BAD_VALUE;
287 }
288 switch ((uint32_t)index) {
289 case OMX_IndexParamMaxFrameDurationForBitrateControl:
290 // handle max/fixed frame duration control
291 if (size != sizeof(OMX_PARAM_U32TYPE)) {
292 return BAD_VALUE;
293 }
294 // The incoming number is an int32_t contained in OMX_U32.
295 mAdjustTimestampGapUs = (int32_t)((OMX_PARAM_U32TYPE*)params)->nU32;
296 return OK;
297
298 case OMX_IndexParamConsumerUsageBits:
299 if (size != sizeof(OMX_U32)) {
300 return BAD_VALUE;
301 }
302 mUsage = *((OMX_U32 *)params);
303 return OK;
304
305 case OMX_IndexParamConsumerUsageBits64:
306 if (size != sizeof(OMX_U64)) {
307 return BAD_VALUE;
308 }
309 mUsage = *((OMX_U64 *)params);
310 return OK;
311 }
312 return ERROR_UNSUPPORTED;
313 }
314
getConfig(OMX_INDEXTYPE index,void * config,size_t size)315 status_t C2OMXNode::getConfig(OMX_INDEXTYPE index, void *config, size_t size) {
316 (void)index;
317 (void)config;
318 (void)size;
319 return ERROR_UNSUPPORTED;
320 }
321
setConfig(OMX_INDEXTYPE index,const void * config,size_t size)322 status_t C2OMXNode::setConfig(OMX_INDEXTYPE index, const void *config, size_t size) {
323 (void)index;
324 (void)config;
325 (void)size;
326 return ERROR_UNSUPPORTED;
327 }
328
setPortMode(OMX_U32 portIndex,IOMX::PortMode mode)329 status_t C2OMXNode::setPortMode(OMX_U32 portIndex, IOMX::PortMode mode) {
330 (void)portIndex;
331 (void)mode;
332 return ERROR_UNSUPPORTED;
333 }
334
prepareForAdaptivePlayback(OMX_U32 portIndex,OMX_BOOL enable,OMX_U32 maxFrameWidth,OMX_U32 maxFrameHeight)335 status_t C2OMXNode::prepareForAdaptivePlayback(
336 OMX_U32 portIndex, OMX_BOOL enable,
337 OMX_U32 maxFrameWidth, OMX_U32 maxFrameHeight) {
338 (void)portIndex;
339 (void)enable;
340 (void)maxFrameWidth;
341 (void)maxFrameHeight;
342 return ERROR_UNSUPPORTED;
343 }
344
configureVideoTunnelMode(OMX_U32 portIndex,OMX_BOOL tunneled,OMX_U32 audioHwSync,native_handle_t ** sidebandHandle)345 status_t C2OMXNode::configureVideoTunnelMode(
346 OMX_U32 portIndex, OMX_BOOL tunneled,
347 OMX_U32 audioHwSync, native_handle_t **sidebandHandle) {
348 (void)portIndex;
349 (void)tunneled;
350 (void)audioHwSync;
351 *sidebandHandle = nullptr;
352 return ERROR_UNSUPPORTED;
353 }
354
getGraphicBufferUsage(OMX_U32 portIndex,OMX_U32 * usage)355 status_t C2OMXNode::getGraphicBufferUsage(OMX_U32 portIndex, OMX_U32* usage) {
356 (void)portIndex;
357 *usage = 0;
358 return ERROR_UNSUPPORTED;
359 }
360
setInputSurface(const sp<IOMXBufferSource> & bufferSource)361 status_t C2OMXNode::setInputSurface(const sp<IOMXBufferSource> &bufferSource) {
362 c2_status_t err = GetCodec2PlatformAllocatorStore()->fetchAllocator(
363 C2PlatformAllocatorStore::GRALLOC,
364 &mAllocator);
365 if (err != OK) {
366 return UNKNOWN_ERROR;
367 }
368 mBufferSource = bufferSource;
369 return OK;
370 }
371
allocateSecureBuffer(OMX_U32 portIndex,size_t size,buffer_id * buffer,void ** bufferData,sp<NativeHandle> * nativeHandle)372 status_t C2OMXNode::allocateSecureBuffer(
373 OMX_U32 portIndex, size_t size, buffer_id *buffer,
374 void **bufferData, sp<NativeHandle> *nativeHandle) {
375 (void)portIndex;
376 (void)size;
377 (void)nativeHandle;
378 *buffer = 0;
379 *bufferData = nullptr;
380 return ERROR_UNSUPPORTED;
381 }
382
useBuffer(OMX_U32 portIndex,const OMXBuffer & omxBuf,buffer_id * buffer)383 status_t C2OMXNode::useBuffer(
384 OMX_U32 portIndex, const OMXBuffer &omxBuf, buffer_id *buffer) {
385 (void)portIndex;
386 (void)omxBuf;
387 *buffer = 0;
388 return ERROR_UNSUPPORTED;
389 }
390
freeBuffer(OMX_U32 portIndex,buffer_id buffer)391 status_t C2OMXNode::freeBuffer(OMX_U32 portIndex, buffer_id buffer) {
392 (void)portIndex;
393 (void)buffer;
394 return ERROR_UNSUPPORTED;
395 }
396
fillBuffer(buffer_id buffer,const OMXBuffer & omxBuf,int fenceFd)397 status_t C2OMXNode::fillBuffer(
398 buffer_id buffer, const OMXBuffer &omxBuf, int fenceFd) {
399 (void)buffer;
400 (void)omxBuf;
401 (void)fenceFd;
402 return ERROR_UNSUPPORTED;
403 }
404
emptyBuffer(buffer_id buffer,const OMXBuffer & omxBuf,OMX_U32 flags,OMX_TICKS timestamp,int fenceFd)405 status_t C2OMXNode::emptyBuffer(
406 buffer_id buffer, const OMXBuffer &omxBuf,
407 OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
408 std::shared_ptr<Codec2Client::Component> comp = mComp.lock();
409 if (!comp) {
410 return NO_INIT;
411 }
412
413 uint32_t c2Flags = (flags & OMX_BUFFERFLAG_EOS)
414 ? C2FrameData::FLAG_END_OF_STREAM : 0;
415 std::shared_ptr<C2GraphicBlock> block;
416
417 android::base::unique_fd fd0, fd1;
418 C2Handle *handle = nullptr;
419 if (omxBuf.mBufferType == OMXBuffer::kBufferTypeANWBuffer
420 && omxBuf.mGraphicBuffer != nullptr) {
421 std::shared_ptr<C2GraphicAllocation> alloc;
422 handle = WrapNativeCodec2GrallocHandle(
423 omxBuf.mGraphicBuffer->handle,
424 omxBuf.mGraphicBuffer->width,
425 omxBuf.mGraphicBuffer->height,
426 omxBuf.mGraphicBuffer->format,
427 omxBuf.mGraphicBuffer->usage,
428 omxBuf.mGraphicBuffer->stride);
429 if (handle != nullptr) {
430 // unique_fd takes ownership of the fds, we'll get warning if these
431 // fds get closed by somebody else. Onwership will be released before
432 // we return, so that the fds get closed as usually when this function
433 // goes out of scope (when both items and block are gone).
434 native_handle_t *nativeHandle = reinterpret_cast<native_handle_t*>(handle);
435 fd0.reset(nativeHandle->numFds > 0 ? nativeHandle->data[0] : -1);
436 fd1.reset(nativeHandle->numFds > 1 ? nativeHandle->data[1] : -1);
437 }
438 c2_status_t err = mAllocator->priorGraphicAllocation(handle, &alloc);
439 if (err != OK) {
440 (void)fd0.release();
441 (void)fd1.release();
442 native_handle_close(handle);
443 native_handle_delete(handle);
444 return UNKNOWN_ERROR;
445 }
446 block = _C2BlockFactory::CreateGraphicBlock(alloc);
447 } else if (!(flags & OMX_BUFFERFLAG_EOS)) {
448 return BAD_VALUE;
449 }
450
451 std::unique_ptr<C2Work> work(new C2Work);
452 work->input.flags = (C2FrameData::flags_t)c2Flags;
453 work->input.ordinal.timestamp = timestamp;
454
455 // WORKAROUND: adjust timestamp based on gapUs
456 {
457 work->input.ordinal.customOrdinal = timestamp; // save input timestamp
458 if (mFirstInputFrame) {
459 // grab timestamps on first frame
460 mPrevInputTimestamp = timestamp;
461 mPrevCodecTimestamp = timestamp;
462 mFirstInputFrame = false;
463 } else if (mAdjustTimestampGapUs > 0) {
464 work->input.ordinal.timestamp =
465 mPrevCodecTimestamp
466 + c2_min((timestamp - mPrevInputTimestamp).peek(), mAdjustTimestampGapUs);
467 } else if (mAdjustTimestampGapUs < 0) {
468 work->input.ordinal.timestamp = mPrevCodecTimestamp - mAdjustTimestampGapUs;
469 }
470 mPrevInputTimestamp = work->input.ordinal.customOrdinal;
471 mPrevCodecTimestamp = work->input.ordinal.timestamp;
472 ALOGV("adjusting %lld to %lld (gap=%lld)",
473 work->input.ordinal.customOrdinal.peekll(),
474 work->input.ordinal.timestamp.peekll(),
475 (long long)mAdjustTimestampGapUs);
476 }
477
478 work->input.ordinal.frameIndex = mFrameIndex++;
479 work->input.buffers.clear();
480 if (block) {
481 std::shared_ptr<C2Buffer> c2Buffer(
482 new Buffer2D(block->share(
483 C2Rect(block->width(), block->height()), ::C2Fence())));
484 work->input.buffers.push_back(c2Buffer);
485 std::shared_ptr<C2StreamHdrStaticInfo::input> staticInfo;
486 std::shared_ptr<C2StreamHdrDynamicMetadataInfo::input> dynamicInfo;
487 GetHdrMetadataFromGralloc4Handle(
488 block->handle(),
489 &staticInfo,
490 &dynamicInfo);
491 if (staticInfo && *staticInfo) {
492 c2Buffer->setInfo(staticInfo);
493 }
494 if (dynamicInfo && *dynamicInfo) {
495 c2Buffer->setInfo(dynamicInfo);
496 }
497 }
498 work->worklets.clear();
499 work->worklets.emplace_back(new C2Worklet);
500 mBufferIdsInUse.lock()->emplace(work->input.ordinal.frameIndex.peeku(), buffer);
501 mQueueThread->queue(comp, fenceFd, std::move(work), std::move(fd0), std::move(fd1));
502
503 return OK;
504 }
505
getExtensionIndex(const char * parameterName,OMX_INDEXTYPE * index)506 status_t C2OMXNode::getExtensionIndex(
507 const char *parameterName, OMX_INDEXTYPE *index) {
508 (void)parameterName;
509 *index = OMX_IndexMax;
510 return ERROR_UNSUPPORTED;
511 }
512
dispatchMessage(const omx_message & msg)513 status_t C2OMXNode::dispatchMessage(const omx_message& msg) {
514 if (msg.type != omx_message::EVENT) {
515 return ERROR_UNSUPPORTED;
516 }
517 if (msg.u.event_data.event != OMX_EventDataSpaceChanged) {
518 return ERROR_UNSUPPORTED;
519 }
520 android_dataspace dataSpace = (android_dataspace)msg.u.event_data.data1;
521 uint32_t pixelFormat = msg.u.event_data.data3;
522
523 ALOGD("dataspace changed to %#x pixel format: %#x", dataSpace, pixelFormat);
524 mQueueThread->setDataspace(dataSpace);
525
526 mDataspace.lock().set(dataSpace);
527 mPixelFormat.lock().set(pixelFormat);
528 return OK;
529 }
530
getSource()531 sp<IOMXBufferSource> C2OMXNode::getSource() {
532 return mBufferSource;
533 }
534
setFrameSize(uint32_t width,uint32_t height)535 void C2OMXNode::setFrameSize(uint32_t width, uint32_t height) {
536 mWidth = width;
537 mHeight = height;
538 }
539
onInputBufferDone(c2_cntr64_t index)540 void C2OMXNode::onInputBufferDone(c2_cntr64_t index) {
541 if (!mBufferSource) {
542 ALOGD("Buffer source not set (index=%llu)", index.peekull());
543 return;
544 }
545
546 int32_t bufferId = 0;
547 {
548 decltype(mBufferIdsInUse)::Locked bufferIds(mBufferIdsInUse);
549 auto it = bufferIds->find(index.peeku());
550 if (it == bufferIds->end()) {
551 ALOGV("Untracked input index %llu (maybe already removed)", index.peekull());
552 return;
553 }
554 bufferId = it->second;
555 (void)bufferIds->erase(it);
556 }
557 (void)mBufferSource->onInputBufferEmptied(bufferId, -1);
558 }
559
getDataspace()560 android_dataspace C2OMXNode::getDataspace() {
561 return *mDataspace.lock();
562 }
563
getPixelFormat()564 uint32_t C2OMXNode::getPixelFormat() {
565 return *mPixelFormat.lock();
566 }
567
setPriority(int priority)568 void C2OMXNode::setPriority(int priority) {
569 mQueueThread->setPriority(priority);
570 }
571
572 } // namespace android
573