OMXNodeInstance.cpp revision 96626b7f9a4e5c9e1e04f7f710383631d1470364 
1/*
2 * Copyright (C) 2009 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 "OMXNodeInstance"
19#include <utils/Log.h>
20
21#include <inttypes.h>
22
23#include "../include/OMXNodeInstance.h"
24#include "OMXMaster.h"
25#include "OMXUtils.h"
26#include <android/IOMXBufferSource.h>
27
28#include <OMX_Component.h>
29#include <OMX_IndexExt.h>
30#include <OMX_VideoExt.h>
31#include <OMX_AsString.h>
32
33#include <binder/IMemory.h>
34#include <cutils/properties.h>
35#include <gui/BufferQueue.h>
36#include <HardwareAPI.h>
37#include <media/stagefright/foundation/ADebug.h>
38#include <media/stagefright/foundation/ABuffer.h>
39#include <media/stagefright/foundation/ColorUtils.h>
40#include <media/stagefright/MediaErrors.h>
41#include <utils/misc.h>
42#include <utils/NativeHandle.h>
43#include <media/OMXBuffer.h>
44
45static const OMX_U32 kPortIndexInput = 0;
46static const OMX_U32 kPortIndexOutput = 1;
47
48// Quirk still supported, even though deprecated
49enum Quirks {
50    kRequiresAllocateBufferOnInputPorts   = 1,
51    kRequiresAllocateBufferOnOutputPorts  = 2,
52
53    kQuirksMask = kRequiresAllocateBufferOnInputPorts
54                | kRequiresAllocateBufferOnOutputPorts,
55};
56
57#define CLOGW(fmt, ...) ALOGW("[%p:%s] " fmt, mHandle, mName, ##__VA_ARGS__)
58
59#define CLOG_ERROR_IF(cond, fn, err, fmt, ...) \
60    ALOGE_IF(cond, #fn "(%p:%s, " fmt ") ERROR: %s(%#x)", \
61    mHandle, mName, ##__VA_ARGS__, asString(err), err)
62#define CLOG_ERROR(fn, err, fmt, ...) CLOG_ERROR_IF(true, fn, err, fmt, ##__VA_ARGS__)
63#define CLOG_IF_ERROR(fn, err, fmt, ...) \
64    CLOG_ERROR_IF((err) != OMX_ErrorNone, fn, err, fmt, ##__VA_ARGS__)
65
66#define CLOGI_(level, fn, fmt, ...) \
67    ALOGI_IF(DEBUG >= (level), #fn "(%p:%s, " fmt ")", mHandle, mName, ##__VA_ARGS__)
68#define CLOGD_(level, fn, fmt, ...) \
69    ALOGD_IF(DEBUG >= (level), #fn "(%p:%s, " fmt ")", mHandle, mName, ##__VA_ARGS__)
70
71#define CLOG_LIFE(fn, fmt, ...)     CLOGI_(ADebug::kDebugLifeCycle,     fn, fmt, ##__VA_ARGS__)
72#define CLOG_STATE(fn, fmt, ...)    CLOGI_(ADebug::kDebugState,         fn, fmt, ##__VA_ARGS__)
73#define CLOG_CONFIG(fn, fmt, ...)   CLOGI_(ADebug::kDebugConfig,        fn, fmt, ##__VA_ARGS__)
74#define CLOG_INTERNAL(fn, fmt, ...) CLOGD_(ADebug::kDebugInternalState, fn, fmt, ##__VA_ARGS__)
75
76#define CLOG_DEBUG_IF(cond, fn, fmt, ...) \
77    ALOGD_IF(cond, #fn "(%p, " fmt ")", mHandle, ##__VA_ARGS__)
78
79#define CLOG_BUFFER(fn, fmt, ...) \
80    CLOG_DEBUG_IF(DEBUG >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__)
81#define CLOG_BUMPED_BUFFER(fn, fmt, ...) \
82    CLOG_DEBUG_IF(DEBUG_BUMP >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__)
83
84/* buffer formatting */
85#define BUFFER_FMT(port, fmt, ...) "%s:%u " fmt, portString(port), (port), ##__VA_ARGS__
86#define NEW_BUFFER_FMT(buffer_id, port, fmt, ...) \
87    BUFFER_FMT(port, fmt ") (#%zu => %#x", ##__VA_ARGS__, mActiveBuffers.size(), (buffer_id))
88
89#define SIMPLE_BUFFER(port, size, data) BUFFER_FMT(port, "%zu@%p", (size), (data))
90#define SIMPLE_NEW_BUFFER(buffer_id, port, size, data) \
91    NEW_BUFFER_FMT(buffer_id, port, "%zu@%p", (size), (data))
92
93#define EMPTY_BUFFER(addr, header, fenceFd) "%#x [%u@%p fc=%d]", \
94    (addr), (header)->nAllocLen, (header)->pBuffer, (fenceFd)
95#define FULL_BUFFER(addr, header, fenceFd) "%#" PRIxPTR " [%u@%p (%u..+%u) f=%x ts=%lld fc=%d]", \
96    (intptr_t)(addr), (header)->nAllocLen, (header)->pBuffer, \
97    (header)->nOffset, (header)->nFilledLen, (header)->nFlags, (header)->nTimeStamp, (fenceFd)
98
99#define WITH_STATS_WRAPPER(fmt, ...) fmt " { IN=%zu/%zu OUT=%zu/%zu }", ##__VA_ARGS__, \
100    mInputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexInput], \
101    mOutputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexOutput]
102// TRICKY: this is needed so formatting macros expand before substitution
103#define WITH_STATS(fmt, ...) WITH_STATS_WRAPPER(fmt, ##__VA_ARGS__)
104
105namespace android {
106
107struct BufferMeta {
108    explicit BufferMeta(
109            const sp<IMemory> &mem, OMX_U32 portIndex, bool copy, OMX_U8 *backup)
110        : mMem(mem),
111          mCopyFromOmx(portIndex == kPortIndexOutput && copy),
112          mCopyToOmx(portIndex == kPortIndexInput && copy),
113          mPortIndex(portIndex),
114          mBackup(backup) {
115    }
116
117    explicit BufferMeta(OMX_U32 portIndex)
118        : mCopyFromOmx(false),
119          mCopyToOmx(false),
120          mPortIndex(portIndex),
121          mBackup(NULL) {
122    }
123
124    explicit BufferMeta(const sp<GraphicBuffer> &graphicBuffer, OMX_U32 portIndex)
125        : mGraphicBuffer(graphicBuffer),
126          mCopyFromOmx(false),
127          mCopyToOmx(false),
128          mPortIndex(portIndex),
129          mBackup(NULL) {
130    }
131
132    void CopyFromOMX(const OMX_BUFFERHEADERTYPE *header) {
133        if (!mCopyFromOmx) {
134            return;
135        }
136
137        // check component returns proper range
138        sp<ABuffer> codec = getBuffer(header, true /* limit */);
139
140        memcpy((OMX_U8 *)mMem->pointer() + header->nOffset, codec->data(), codec->size());
141    }
142
143    void CopyToOMX(const OMX_BUFFERHEADERTYPE *header) {
144        if (!mCopyToOmx) {
145            return;
146        }
147
148        memcpy(header->pBuffer + header->nOffset,
149                (const OMX_U8 *)mMem->pointer() + header->nOffset,
150                header->nFilledLen);
151    }
152
153    // return the codec buffer
154    sp<ABuffer> getBuffer(const OMX_BUFFERHEADERTYPE *header, bool limit) {
155        sp<ABuffer> buf = new ABuffer(header->pBuffer, header->nAllocLen);
156        if (limit) {
157            if (header->nOffset + header->nFilledLen > header->nOffset
158                    && header->nOffset + header->nFilledLen <= header->nAllocLen) {
159                buf->setRange(header->nOffset, header->nFilledLen);
160            } else {
161                buf->setRange(0, 0);
162            }
163        }
164        return buf;
165    }
166
167    void setGraphicBuffer(const sp<GraphicBuffer> &graphicBuffer) {
168        mGraphicBuffer = graphicBuffer;
169    }
170
171    void setNativeHandle(const sp<NativeHandle> &nativeHandle) {
172        mNativeHandle = nativeHandle;
173    }
174
175    OMX_U32 getPortIndex() {
176        return mPortIndex;
177    }
178
179    ~BufferMeta() {
180        delete[] mBackup;
181    }
182
183private:
184    sp<GraphicBuffer> mGraphicBuffer;
185    sp<NativeHandle> mNativeHandle;
186    sp<IMemory> mMem;
187    bool mCopyFromOmx;
188    bool mCopyToOmx;
189    OMX_U32 mPortIndex;
190    OMX_U8 *mBackup;
191
192    BufferMeta(const BufferMeta &);
193    BufferMeta &operator=(const BufferMeta &);
194};
195
196// static
197OMX_CALLBACKTYPE OMXNodeInstance::kCallbacks = {
198    &OnEvent, &OnEmptyBufferDone, &OnFillBufferDone
199};
200
201static inline const char *portString(OMX_U32 portIndex) {
202    switch (portIndex) {
203        case kPortIndexInput:  return "Input";
204        case kPortIndexOutput: return "Output";
205        case ~0U:              return "All";
206        default:               return "port";
207    }
208}
209
210////////////////////////////////////////////////////////////////////////////////
211
212// This provides the underlying Thread used by CallbackDispatcher.
213// Note that deriving CallbackDispatcher from Thread does not work.
214
215struct OMXNodeInstance::CallbackDispatcherThread : public Thread {
216    explicit CallbackDispatcherThread(CallbackDispatcher *dispatcher)
217        : mDispatcher(dispatcher) {
218    }
219
220private:
221    CallbackDispatcher *mDispatcher;
222
223    bool threadLoop();
224
225    CallbackDispatcherThread(const CallbackDispatcherThread &);
226    CallbackDispatcherThread &operator=(const CallbackDispatcherThread &);
227};
228
229////////////////////////////////////////////////////////////////////////////////
230
231struct OMXNodeInstance::CallbackDispatcher : public RefBase {
232    explicit CallbackDispatcher(const sp<OMXNodeInstance> &owner);
233
234    // Posts |msg| to the listener's queue. If |realTime| is true, the listener thread is notified
235    // that a new message is available on the queue. Otherwise, the message stays on the queue, but
236    // the listener is not notified of it. It will process this message when a subsequent message
237    // is posted with |realTime| set to true.
238    void post(const omx_message &msg, bool realTime = true);
239
240    bool loop();
241
242protected:
243    virtual ~CallbackDispatcher();
244
245private:
246    Mutex mLock;
247
248    sp<OMXNodeInstance> const mOwner;
249    bool mDone;
250    Condition mQueueChanged;
251    std::list<omx_message> mQueue;
252
253    sp<CallbackDispatcherThread> mThread;
254
255    void dispatch(std::list<omx_message> &messages);
256
257    CallbackDispatcher(const CallbackDispatcher &);
258    CallbackDispatcher &operator=(const CallbackDispatcher &);
259};
260
261OMXNodeInstance::CallbackDispatcher::CallbackDispatcher(const sp<OMXNodeInstance> &owner)
262    : mOwner(owner),
263      mDone(false) {
264    mThread = new CallbackDispatcherThread(this);
265    mThread->run("OMXCallbackDisp", ANDROID_PRIORITY_FOREGROUND);
266}
267
268OMXNodeInstance::CallbackDispatcher::~CallbackDispatcher() {
269    {
270        Mutex::Autolock autoLock(mLock);
271
272        mDone = true;
273        mQueueChanged.signal();
274    }
275
276    // A join on self can happen if the last ref to CallbackDispatcher
277    // is released within the CallbackDispatcherThread loop
278    status_t status = mThread->join();
279    if (status != WOULD_BLOCK) {
280        // Other than join to self, the only other error return codes are
281        // whatever readyToRun() returns, and we don't override that
282        CHECK_EQ(status, (status_t)NO_ERROR);
283    }
284}
285
286void OMXNodeInstance::CallbackDispatcher::post(const omx_message &msg, bool realTime) {
287    Mutex::Autolock autoLock(mLock);
288
289    mQueue.push_back(msg);
290    if (realTime) {
291        mQueueChanged.signal();
292    }
293}
294
295void OMXNodeInstance::CallbackDispatcher::dispatch(std::list<omx_message> &messages) {
296    if (mOwner == NULL) {
297        ALOGV("Would have dispatched a message to a node that's already gone.");
298        return;
299    }
300    mOwner->onMessages(messages);
301}
302
303bool OMXNodeInstance::CallbackDispatcher::loop() {
304    for (;;) {
305        std::list<omx_message> messages;
306
307        {
308            Mutex::Autolock autoLock(mLock);
309            while (!mDone && mQueue.empty()) {
310                mQueueChanged.wait(mLock);
311            }
312
313            if (mDone) {
314                break;
315            }
316
317            messages.swap(mQueue);
318        }
319
320        dispatch(messages);
321    }
322
323    return false;
324}
325
326////////////////////////////////////////////////////////////////////////////////
327
328bool OMXNodeInstance::CallbackDispatcherThread::threadLoop() {
329    return mDispatcher->loop();
330}
331
332////////////////////////////////////////////////////////////////////////////////
333
334OMXNodeInstance::OMXNodeInstance(
335        OMX *owner, const sp<IOMXObserver> &observer, const char *name)
336    : mOwner(owner),
337      mHandle(NULL),
338      mObserver(observer),
339      mDying(false),
340      mSailed(false),
341      mQueriedProhibitedExtensions(false),
342      mQuirks(0),
343      mBufferIDCount(0),
344      mRestorePtsFailed(false),
345      mMaxTimestampGapUs(-1ll),
346      mPrevOriginalTimeUs(-1ll),
347      mPrevModifiedTimeUs(-1ll)
348{
349    mName = ADebug::GetDebugName(name);
350    DEBUG = ADebug::GetDebugLevelFromProperty(name, "debug.stagefright.omx-debug");
351    ALOGV("debug level for %s is %d", name, DEBUG);
352    DEBUG_BUMP = DEBUG;
353    mNumPortBuffers[0] = 0;
354    mNumPortBuffers[1] = 0;
355    mDebugLevelBumpPendingBuffers[0] = 0;
356    mDebugLevelBumpPendingBuffers[1] = 0;
357    mMetadataType[0] = kMetadataBufferTypeInvalid;
358    mMetadataType[1] = kMetadataBufferTypeInvalid;
359    mPortMode[0] = IOMX::kPortModePresetByteBuffer;
360    mPortMode[1] = IOMX::kPortModePresetByteBuffer;
361    mSecureBufferType[0] = kSecureBufferTypeUnknown;
362    mSecureBufferType[1] = kSecureBufferTypeUnknown;
363    mIsSecure = AString(name).endsWith(".secure");
364    mLegacyAdaptiveExperiment = ADebug::isExperimentEnabled("legacy-adaptive");
365}
366
367OMXNodeInstance::~OMXNodeInstance() {
368    free(mName);
369    CHECK(mHandle == NULL);
370}
371
372void OMXNodeInstance::setHandle(OMX_HANDLETYPE handle) {
373    CLOG_LIFE(allocateNode, "handle=%p", handle);
374    CHECK(mHandle == NULL);
375    mHandle = handle;
376    if (handle != NULL) {
377        mDispatcher = new CallbackDispatcher(this);
378    }
379}
380
381sp<IOMXBufferSource> OMXNodeInstance::getBufferSource() {
382    Mutex::Autolock autoLock(mOMXBufferSourceLock);
383    return mOMXBufferSource;
384}
385
386void OMXNodeInstance::setBufferSource(const sp<IOMXBufferSource>& bufferSource) {
387    Mutex::Autolock autoLock(mOMXBufferSourceLock);
388    CLOG_INTERNAL(setBufferSource, "%p", bufferSource.get());
389    mOMXBufferSource = bufferSource;
390}
391
392OMX_HANDLETYPE OMXNodeInstance::handle() {
393    return mHandle;
394}
395
396sp<IOMXObserver> OMXNodeInstance::observer() {
397    return mObserver;
398}
399
400status_t OMXNodeInstance::freeNode() {
401
402    CLOG_LIFE(freeNode, "handle=%p", mHandle);
403    static int32_t kMaxNumIterations = 10;
404
405    // exit if we have already freed the node
406    if (mHandle == NULL) {
407        return mOwner->freeNode(this);
408    }
409
410    // Transition the node from its current state all the way down
411    // to "Loaded".
412    // This ensures that all active buffers are properly freed even
413    // for components that don't do this themselves on a call to
414    // "FreeHandle".
415
416    // The code below may trigger some more events to be dispatched
417    // by the OMX component - we want to ignore them as our client
418    // does not expect them.
419    mDying = true;
420
421    OMX_STATETYPE state;
422    CHECK_EQ(OMX_GetState(mHandle, &state), OMX_ErrorNone);
423    switch (state) {
424        case OMX_StateExecuting:
425        {
426            ALOGV("forcing Executing->Idle");
427            sendCommand(OMX_CommandStateSet, OMX_StateIdle);
428            OMX_ERRORTYPE err;
429            int32_t iteration = 0;
430            while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone
431                    && state != OMX_StateIdle
432                    && state != OMX_StateInvalid) {
433                if (++iteration > kMaxNumIterations) {
434                    CLOGW("failed to enter Idle state (now %s(%d), aborting.",
435                            asString(state), state);
436                    state = OMX_StateInvalid;
437                    break;
438                }
439
440                usleep(100000);
441            }
442            CHECK_EQ(err, OMX_ErrorNone);
443
444            if (state == OMX_StateInvalid) {
445                break;
446            }
447
448            // fall through
449        }
450
451        case OMX_StateIdle:
452        {
453            ALOGV("forcing Idle->Loaded");
454            sendCommand(OMX_CommandStateSet, OMX_StateLoaded);
455
456            freeActiveBuffers();
457
458            OMX_ERRORTYPE err;
459            int32_t iteration = 0;
460            while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone
461                    && state != OMX_StateLoaded
462                    && state != OMX_StateInvalid) {
463                if (++iteration > kMaxNumIterations) {
464                    CLOGW("failed to enter Loaded state (now %s(%d), aborting.",
465                            asString(state), state);
466                    state = OMX_StateInvalid;
467                    break;
468                }
469
470                ALOGV("waiting for Loaded state...");
471                usleep(100000);
472            }
473            CHECK_EQ(err, OMX_ErrorNone);
474
475            // fall through
476        }
477
478        case OMX_StateLoaded:
479        case OMX_StateInvalid:
480            break;
481
482        default:
483            LOG_ALWAYS_FATAL("unknown state %s(%#x).", asString(state), state);
484            break;
485    }
486    status_t err = mOwner->freeNode(this);
487
488    mDispatcher.clear();
489    mOMXBufferSource.clear();
490
491    mHandle = NULL;
492    CLOG_IF_ERROR(freeNode, err, "");
493    free(mName);
494    mName = NULL;
495
496    ALOGV("OMXNodeInstance going away.");
497
498    return err;
499}
500
501status_t OMXNodeInstance::sendCommand(
502        OMX_COMMANDTYPE cmd, OMX_S32 param) {
503    const sp<IOMXBufferSource> bufferSource(getBufferSource());
504    if (bufferSource != NULL && cmd == OMX_CommandStateSet) {
505        if (param == OMX_StateIdle) {
506            // Initiating transition from Executing -> Idle
507            // ACodec is waiting for all buffers to be returned, do NOT
508            // submit any more buffers to the codec.
509            bufferSource->onOmxIdle();
510        } else if (param == OMX_StateLoaded) {
511            // Initiating transition from Idle/Executing -> Loaded
512            // Buffers are about to be freed.
513            bufferSource->onOmxLoaded();
514            setBufferSource(NULL);
515        }
516
517        // fall through
518    }
519
520    Mutex::Autolock autoLock(mLock);
521
522    if (cmd == OMX_CommandStateSet) {
523        // There are no configurations past first StateSet command.
524        mSailed = true;
525    }
526
527    // bump internal-state debug level for 2 input and output frames past a command
528    {
529        Mutex::Autolock _l(mDebugLock);
530        bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */);
531    }
532
533    const char *paramString =
534        cmd == OMX_CommandStateSet ? asString((OMX_STATETYPE)param) : portString(param);
535    CLOG_STATE(sendCommand, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param);
536    OMX_ERRORTYPE err = OMX_SendCommand(mHandle, cmd, param, NULL);
537    CLOG_IF_ERROR(sendCommand, err, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param);
538    return StatusFromOMXError(err);
539}
540
541bool OMXNodeInstance::isProhibitedIndex_l(OMX_INDEXTYPE index) {
542    // these extensions can only be used from OMXNodeInstance, not by clients directly.
543    static const char *restricted_extensions[] = {
544        "OMX.google.android.index.storeMetaDataInBuffers",
545        "OMX.google.android.index.storeANWBufferInMetadata",
546        "OMX.google.android.index.prepareForAdaptivePlayback",
547        "OMX.google.android.index.configureVideoTunnelMode",
548        "OMX.google.android.index.useAndroidNativeBuffer2",
549        "OMX.google.android.index.useAndroidNativeBuffer",
550        "OMX.google.android.index.enableAndroidNativeBuffers",
551        "OMX.google.android.index.allocateNativeHandle",
552        "OMX.google.android.index.getAndroidNativeBufferUsage",
553    };
554
555    if ((index > OMX_IndexComponentStartUnused && index < OMX_IndexComponentEndUnused)
556            || (index > OMX_IndexPortStartUnused && index < OMX_IndexPortEndUnused)
557            || (index > OMX_IndexAudioStartUnused && index < OMX_IndexAudioEndUnused)
558            || (index > OMX_IndexVideoStartUnused && index < OMX_IndexVideoEndUnused)
559            || (index > OMX_IndexCommonStartUnused && index < OMX_IndexCommonEndUnused)
560            || (index > (OMX_INDEXTYPE)OMX_IndexExtAudioStartUnused
561                    && index < (OMX_INDEXTYPE)OMX_IndexExtAudioEndUnused)
562            || (index > (OMX_INDEXTYPE)OMX_IndexExtVideoStartUnused
563                    && index < (OMX_INDEXTYPE)OMX_IndexExtVideoEndUnused)
564            || (index > (OMX_INDEXTYPE)OMX_IndexExtOtherStartUnused
565                    && index < (OMX_INDEXTYPE)OMX_IndexExtOtherEndUnused)) {
566        return false;
567    }
568
569    if (!mQueriedProhibitedExtensions) {
570        for (size_t i = 0; i < NELEM(restricted_extensions); ++i) {
571            OMX_INDEXTYPE ext;
572            if (OMX_GetExtensionIndex(mHandle, (OMX_STRING)restricted_extensions[i], &ext) == OMX_ErrorNone) {
573                mProhibitedExtensions.add(ext);
574            }
575        }
576        mQueriedProhibitedExtensions = true;
577    }
578
579    return mProhibitedExtensions.indexOf(index) >= 0;
580}
581
582status_t OMXNodeInstance::getParameter(
583        OMX_INDEXTYPE index, void *params, size_t /* size */) {
584    Mutex::Autolock autoLock(mLock);
585
586    if (isProhibitedIndex_l(index)) {
587        android_errorWriteLog(0x534e4554, "29422020");
588        return BAD_INDEX;
589    }
590
591    OMX_ERRORTYPE err = OMX_GetParameter(mHandle, index, params);
592    OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
593    // some errors are expected for getParameter
594    if (err != OMX_ErrorNoMore) {
595        CLOG_IF_ERROR(getParameter, err, "%s(%#x)", asString(extIndex), index);
596    }
597    return StatusFromOMXError(err);
598}
599
600status_t OMXNodeInstance::setParameter(
601        OMX_INDEXTYPE index, const void *params, size_t size) {
602    Mutex::Autolock autoLock(mLock);
603    OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
604    CLOG_CONFIG(setParameter, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params);
605
606    if (extIndex == OMX_IndexParamMaxFrameDurationForBitrateControl) {
607        return setMaxPtsGapUs(params, size);
608    }
609
610    if (isProhibitedIndex_l(index)) {
611        android_errorWriteLog(0x534e4554, "29422020");
612        return BAD_INDEX;
613    }
614
615    OMX_ERRORTYPE err = OMX_SetParameter(
616            mHandle, index, const_cast<void *>(params));
617    CLOG_IF_ERROR(setParameter, err, "%s(%#x)", asString(extIndex), index);
618    return StatusFromOMXError(err);
619}
620
621status_t OMXNodeInstance::getConfig(
622        OMX_INDEXTYPE index, void *params, size_t /* size */) {
623    Mutex::Autolock autoLock(mLock);
624
625    if (isProhibitedIndex_l(index)) {
626        android_errorWriteLog(0x534e4554, "29422020");
627        return BAD_INDEX;
628    }
629
630    OMX_ERRORTYPE err = OMX_GetConfig(mHandle, index, params);
631    OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
632    // some errors are expected for getConfig
633    if (err != OMX_ErrorNoMore) {
634        CLOG_IF_ERROR(getConfig, err, "%s(%#x)", asString(extIndex), index);
635    }
636    return StatusFromOMXError(err);
637}
638
639status_t OMXNodeInstance::setConfig(
640        OMX_INDEXTYPE index, const void *params, size_t size) {
641    Mutex::Autolock autoLock(mLock);
642    OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
643    CLOG_CONFIG(setConfig, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params);
644
645    if (isProhibitedIndex_l(index)) {
646        android_errorWriteLog(0x534e4554, "29422020");
647        return BAD_INDEX;
648    }
649
650    OMX_ERRORTYPE err = OMX_SetConfig(
651            mHandle, index, const_cast<void *>(params));
652    CLOG_IF_ERROR(setConfig, err, "%s(%#x)", asString(extIndex), index);
653    return StatusFromOMXError(err);
654}
655
656status_t OMXNodeInstance::setPortMode(OMX_U32 portIndex, IOMX::PortMode mode) {
657    Mutex::Autolock autoLock(mLock);
658
659    if (portIndex >= NELEM(mPortMode)) {
660        ALOGE("b/31385713, portIndex(%u)", portIndex);
661        android_errorWriteLog(0x534e4554, "31385713");
662        return BAD_VALUE;
663    }
664
665    CLOG_CONFIG(setPortMode, "%s(%d), port %d", asString(mode), mode, portIndex);
666
667    switch (mode) {
668    case IOMX::kPortModeDynamicANWBuffer:
669    {
670        if (portIndex == kPortIndexOutput) {
671            if (mLegacyAdaptiveExperiment) {
672                CLOG_INTERNAL(setPortMode, "Legacy adaptive experiment: "
673                        "not setting port mode to %s(%d) on output",
674                        asString(mode), mode);
675                return StatusFromOMXError(OMX_ErrorUnsupportedIndex);
676            }
677
678            status_t err = enableNativeBuffers_l(
679                    portIndex, OMX_TRUE /*graphic*/, OMX_TRUE);
680            if (err != OK) {
681                return err;
682            }
683        }
684        (void)enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_FALSE);
685        return storeMetaDataInBuffers_l(portIndex, OMX_TRUE, NULL);
686    }
687
688    case IOMX::kPortModeDynamicNativeHandle:
689    {
690        if (portIndex != kPortIndexInput) {
691            CLOG_ERROR(setPortMode, BAD_VALUE,
692                    "%s(%d) mode is only supported on input port", asString(mode), mode);
693            return BAD_VALUE;
694        }
695        (void)enableNativeBuffers_l(portIndex, OMX_TRUE /*graphic*/, OMX_FALSE);
696        (void)enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_FALSE);
697
698        MetadataBufferType metaType = kMetadataBufferTypeNativeHandleSource;
699        return storeMetaDataInBuffers_l(portIndex, OMX_TRUE, &metaType);
700    }
701
702    case IOMX::kPortModePresetSecureBuffer:
703    {
704        // Allow on both input and output.
705        (void)storeMetaDataInBuffers_l(portIndex, OMX_FALSE, NULL);
706        (void)enableNativeBuffers_l(portIndex, OMX_TRUE /*graphic*/, OMX_FALSE);
707        return enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_TRUE);
708    }
709
710    case IOMX::kPortModePresetANWBuffer:
711    {
712        if (portIndex != kPortIndexOutput) {
713            CLOG_ERROR(setPortMode, BAD_VALUE,
714                    "%s(%d) mode is only supported on output port", asString(mode), mode);
715            return BAD_VALUE;
716        }
717
718        // Check if we're simulating legacy mode with metadata mode,
719        // if so, enable metadata mode.
720        if (mLegacyAdaptiveExperiment) {
721            if (storeMetaDataInBuffers_l(portIndex, OMX_TRUE, NULL) == OK) {
722                CLOG_INTERNAL(setPortMode, "Legacy adaptive experiment: "
723                        "metdata mode enabled successfully");
724                return OK;
725            }
726
727            CLOG_INTERNAL(setPortMode, "Legacy adaptive experiment: "
728                    "unable to enable metadata mode on output");
729
730            mLegacyAdaptiveExperiment = false;
731        }
732
733        // Disable secure buffer and enable graphic buffer
734        (void)enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_FALSE);
735        status_t err = enableNativeBuffers_l(portIndex, OMX_TRUE /*graphic*/, OMX_TRUE);
736        if (err != OK) {
737            return err;
738        }
739
740        // Not running experiment, or metadata is not supported.
741        // Disable metadata mode and use legacy mode.
742        (void)storeMetaDataInBuffers_l(portIndex, OMX_FALSE, NULL);
743        return OK;
744    }
745
746    case IOMX::kPortModePresetByteBuffer:
747    {
748        // Disable secure buffer, native buffer and metadata.
749        (void)enableNativeBuffers_l(portIndex, OMX_TRUE /*graphic*/, OMX_FALSE);
750        (void)enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_FALSE);
751        (void)storeMetaDataInBuffers_l(portIndex, OMX_FALSE, NULL);
752        return OK;
753    }
754
755    default:
756        break;
757    }
758
759    CLOG_ERROR(setPortMode, BAD_VALUE, "invalid port mode %d", mode);
760    return BAD_VALUE;
761}
762
763status_t OMXNodeInstance::enableNativeBuffers_l(
764        OMX_U32 portIndex, OMX_BOOL graphic, OMX_BOOL enable) {
765    if (portIndex >= NELEM(mSecureBufferType)) {
766        ALOGE("b/31385713, portIndex(%u)", portIndex);
767        android_errorWriteLog(0x534e4554, "31385713");
768        return BAD_VALUE;
769    }
770
771    CLOG_CONFIG(enableNativeBuffers, "%s:%u%s, %d", portString(portIndex), portIndex,
772                graphic ? ", graphic" : "", enable);
773    OMX_STRING name = const_cast<OMX_STRING>(
774            graphic ? "OMX.google.android.index.enableAndroidNativeBuffers"
775                    : "OMX.google.android.index.allocateNativeHandle");
776
777    OMX_INDEXTYPE index;
778    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
779
780    if (err == OMX_ErrorNone) {
781        EnableAndroidNativeBuffersParams params;
782        InitOMXParams(&params);
783        params.nPortIndex = portIndex;
784        params.enable = enable;
785
786        err = OMX_SetParameter(mHandle, index, &params);
787        CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d", name, index,
788                      portString(portIndex), portIndex, enable);
789        if (!graphic) {
790            if (err == OMX_ErrorNone) {
791                mSecureBufferType[portIndex] =
792                    enable ? kSecureBufferTypeNativeHandle : kSecureBufferTypeOpaque;
793            } else if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) {
794                mSecureBufferType[portIndex] = kSecureBufferTypeOpaque;
795            }
796        }
797    } else {
798        CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name);
799        if (!graphic) {
800            // Extension not supported, check for manual override with system property
801            // This is a temporary workaround until partners support the OMX extension
802            if (property_get_bool("media.mediadrmservice.enable", false)) {
803                CLOG_CONFIG(enableNativeBuffers, "system property override: using native-handles");
804                mSecureBufferType[portIndex] = kSecureBufferTypeNativeHandle;
805            } else if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) {
806                mSecureBufferType[portIndex] = kSecureBufferTypeOpaque;
807            }
808            err = OMX_ErrorNone;
809        }
810    }
811
812    return StatusFromOMXError(err);
813}
814
815status_t OMXNodeInstance::getGraphicBufferUsage(
816        OMX_U32 portIndex, OMX_U32* usage) {
817    Mutex::Autolock autoLock(mLock);
818
819    OMX_INDEXTYPE index;
820    OMX_STRING name = const_cast<OMX_STRING>(
821            "OMX.google.android.index.getAndroidNativeBufferUsage");
822    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
823
824    if (err != OMX_ErrorNone) {
825        CLOG_ERROR(getExtensionIndex, err, "%s", name);
826        return StatusFromOMXError(err);
827    }
828
829    GetAndroidNativeBufferUsageParams params;
830    InitOMXParams(&params);
831    params.nPortIndex = portIndex;
832
833    err = OMX_GetParameter(mHandle, index, &params);
834    if (err != OMX_ErrorNone) {
835        CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u", name, index,
836                portString(portIndex), portIndex);
837        return StatusFromOMXError(err);
838    }
839
840    *usage = params.nUsage;
841
842    return OK;
843}
844
845status_t OMXNodeInstance::storeMetaDataInBuffers_l(
846        OMX_U32 portIndex, OMX_BOOL enable, MetadataBufferType *type) {
847    if (mSailed) {
848        android_errorWriteLog(0x534e4554, "29422020");
849        return INVALID_OPERATION;
850    }
851    if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) {
852        android_errorWriteLog(0x534e4554, "26324358");
853        if (type != NULL) {
854            *type = kMetadataBufferTypeInvalid;
855        }
856        return BAD_VALUE;
857    }
858
859    OMX_INDEXTYPE index;
860    OMX_STRING name = const_cast<OMX_STRING>(
861            "OMX.google.android.index.storeMetaDataInBuffers");
862
863    OMX_STRING nativeBufferName = const_cast<OMX_STRING>(
864            "OMX.google.android.index.storeANWBufferInMetadata");
865    MetadataBufferType negotiatedType;
866    MetadataBufferType requestedType = type != NULL ? *type : kMetadataBufferTypeANWBuffer;
867
868    StoreMetaDataInBuffersParams params;
869    InitOMXParams(&params);
870    params.nPortIndex = portIndex;
871    params.bStoreMetaData = enable;
872
873    OMX_ERRORTYPE err =
874        requestedType == kMetadataBufferTypeANWBuffer
875                ? OMX_GetExtensionIndex(mHandle, nativeBufferName, &index)
876                : OMX_ErrorUnsupportedIndex;
877    OMX_ERRORTYPE xerr = err;
878    if (err == OMX_ErrorNone) {
879        err = OMX_SetParameter(mHandle, index, &params);
880        if (err == OMX_ErrorNone) {
881            name = nativeBufferName; // set name for debugging
882            negotiatedType = requestedType;
883        }
884    }
885    if (err != OMX_ErrorNone) {
886        err = OMX_GetExtensionIndex(mHandle, name, &index);
887        xerr = err;
888        if (err == OMX_ErrorNone) {
889            negotiatedType =
890                requestedType == kMetadataBufferTypeANWBuffer
891                        ? kMetadataBufferTypeGrallocSource : requestedType;
892            err = OMX_SetParameter(mHandle, index, &params);
893        }
894    }
895
896    // don't log loud error if component does not support metadata mode on the output
897    if (err != OMX_ErrorNone) {
898        if (err == OMX_ErrorUnsupportedIndex && portIndex == kPortIndexOutput) {
899            CLOGW("component does not support metadata mode; using fallback");
900        } else if (xerr != OMX_ErrorNone) {
901            CLOG_ERROR(getExtensionIndex, xerr, "%s", name);
902        } else {
903            CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d type=%d", name, index,
904                    portString(portIndex), portIndex, enable, negotiatedType);
905        }
906        negotiatedType = mMetadataType[portIndex];
907    } else {
908        if (!enable) {
909            negotiatedType = kMetadataBufferTypeInvalid;
910        }
911        mMetadataType[portIndex] = negotiatedType;
912    }
913    CLOG_CONFIG(storeMetaDataInBuffers, "%s:%u %srequested %s:%d negotiated %s:%d",
914            portString(portIndex), portIndex, enable ? "" : "UN",
915            asString(requestedType), requestedType, asString(negotiatedType), negotiatedType);
916
917    if (type != NULL) {
918        *type = negotiatedType;
919    }
920
921    return StatusFromOMXError(err);
922}
923
924status_t OMXNodeInstance::prepareForAdaptivePlayback(
925        OMX_U32 portIndex, OMX_BOOL enable, OMX_U32 maxFrameWidth,
926        OMX_U32 maxFrameHeight) {
927    Mutex::Autolock autolock(mLock);
928    if (mSailed) {
929        android_errorWriteLog(0x534e4554, "29422020");
930        return INVALID_OPERATION;
931    }
932    CLOG_CONFIG(prepareForAdaptivePlayback, "%s:%u en=%d max=%ux%u",
933            portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight);
934
935    if (mLegacyAdaptiveExperiment) {
936        CLOG_INTERNAL(prepareForAdaptivePlayback,
937                "Legacy adaptive experiment: reporting success");
938        return OK;
939    }
940
941    OMX_INDEXTYPE index;
942    OMX_STRING name = const_cast<OMX_STRING>(
943            "OMX.google.android.index.prepareForAdaptivePlayback");
944
945    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
946    if (err != OMX_ErrorNone) {
947        CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name);
948        return StatusFromOMXError(err);
949    }
950
951    PrepareForAdaptivePlaybackParams params;
952    InitOMXParams(&params);
953    params.nPortIndex = portIndex;
954    params.bEnable = enable;
955    params.nMaxFrameWidth = maxFrameWidth;
956    params.nMaxFrameHeight = maxFrameHeight;
957
958    err = OMX_SetParameter(mHandle, index, &params);
959    CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d max=%ux%u", name, index,
960            portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight);
961    return StatusFromOMXError(err);
962}
963
964status_t OMXNodeInstance::configureVideoTunnelMode(
965        OMX_U32 portIndex, OMX_BOOL tunneled, OMX_U32 audioHwSync,
966        native_handle_t **sidebandHandle) {
967    Mutex::Autolock autolock(mLock);
968    if (mSailed) {
969        android_errorWriteLog(0x534e4554, "29422020");
970        return INVALID_OPERATION;
971    }
972    CLOG_CONFIG(configureVideoTunnelMode, "%s:%u tun=%d sync=%u",
973            portString(portIndex), portIndex, tunneled, audioHwSync);
974
975    OMX_INDEXTYPE index;
976    OMX_STRING name = const_cast<OMX_STRING>(
977            "OMX.google.android.index.configureVideoTunnelMode");
978
979    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
980    if (err != OMX_ErrorNone) {
981        CLOG_ERROR_IF(tunneled, getExtensionIndex, err, "%s", name);
982        return StatusFromOMXError(err);
983    }
984
985    ConfigureVideoTunnelModeParams tunnelParams;
986    InitOMXParams(&tunnelParams);
987    tunnelParams.nPortIndex = portIndex;
988    tunnelParams.bTunneled = tunneled;
989    tunnelParams.nAudioHwSync = audioHwSync;
990    err = OMX_SetParameter(mHandle, index, &tunnelParams);
991    if (err != OMX_ErrorNone) {
992        CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index,
993                portString(portIndex), portIndex, tunneled, audioHwSync);
994        return StatusFromOMXError(err);
995    }
996
997    err = OMX_GetParameter(mHandle, index, &tunnelParams);
998    if (err != OMX_ErrorNone) {
999        CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index,
1000                portString(portIndex), portIndex, tunneled, audioHwSync);
1001        return StatusFromOMXError(err);
1002    }
1003    if (sidebandHandle) {
1004        *sidebandHandle = (native_handle_t*)tunnelParams.pSidebandWindow;
1005    }
1006
1007    return OK;
1008}
1009
1010status_t OMXNodeInstance::useBuffer(
1011        OMX_U32 portIndex, const OMXBuffer &omxBuffer, OMX::buffer_id *buffer) {
1012    if (buffer == NULL) {
1013        ALOGE("b/25884056");
1014        return BAD_VALUE;
1015    }
1016
1017    if (portIndex >= NELEM(mNumPortBuffers)) {
1018        return BAD_VALUE;
1019    }
1020
1021    Mutex::Autolock autoLock(mLock);
1022
1023    switch (omxBuffer.mBufferType) {
1024    case OMXBuffer::kBufferTypePreset:
1025        return useBuffer_l(portIndex, NULL, buffer);
1026
1027    case OMXBuffer::kBufferTypeSharedMem:
1028        return useBuffer_l(portIndex, omxBuffer.mMem, buffer);
1029
1030    case OMXBuffer::kBufferTypeANWBuffer:
1031        return useGraphicBuffer_l(portIndex, omxBuffer.mGraphicBuffer, buffer);
1032
1033    default:
1034        break;
1035    }
1036
1037    return BAD_VALUE;
1038}
1039
1040status_t OMXNodeInstance::useBuffer_l(
1041        OMX_U32 portIndex, const sp<IMemory> &params, OMX::buffer_id *buffer) {
1042    BufferMeta *buffer_meta;
1043    OMX_BUFFERHEADERTYPE *header;
1044    OMX_ERRORTYPE err = OMX_ErrorNone;
1045    bool isMetadata = mMetadataType[portIndex] != kMetadataBufferTypeInvalid;
1046
1047    OMX_U32 allottedSize;
1048    if (isMetadata) {
1049        if (mMetadataType[portIndex] == kMetadataBufferTypeGrallocSource) {
1050            allottedSize = sizeof(VideoGrallocMetadata);
1051        } else if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer) {
1052            allottedSize = sizeof(VideoNativeMetadata);
1053        } else if (mMetadataType[portIndex] == kMetadataBufferTypeNativeHandleSource) {
1054            allottedSize = sizeof(VideoNativeHandleMetadata);
1055        } else {
1056            return BAD_VALUE;
1057        }
1058    } else {
1059        // NULL params is allowed only in metadata mode.
1060        if (params == NULL) {
1061            ALOGE("b/25884056");
1062            return BAD_VALUE;
1063        }
1064        allottedSize = params->size();
1065    }
1066
1067    bool isOutputGraphicMetadata = (portIndex == kPortIndexOutput) &&
1068            (mMetadataType[portIndex] == kMetadataBufferTypeGrallocSource ||
1069                    mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer);
1070
1071    uint32_t requiresAllocateBufferBit =
1072        (portIndex == kPortIndexInput)
1073            ? kRequiresAllocateBufferOnInputPorts
1074            : kRequiresAllocateBufferOnOutputPorts;
1075
1076    // we use useBuffer for output metadata regardless of quirks
1077    if (!isOutputGraphicMetadata && (mQuirks & requiresAllocateBufferBit)) {
1078        // metadata buffers are not connected cross process; only copy if not meta.
1079        buffer_meta = new BufferMeta(
1080                    params, portIndex, !isMetadata /* copy */, NULL /* data */);
1081
1082        err = OMX_AllocateBuffer(
1083                mHandle, &header, portIndex, buffer_meta, allottedSize);
1084
1085        if (err != OMX_ErrorNone) {
1086            CLOG_ERROR(allocateBuffer, err,
1087                    SIMPLE_BUFFER(portIndex, (size_t)allottedSize,
1088                            params != NULL ? params->pointer() : NULL));
1089        }
1090    } else {
1091        OMX_U8 *data = NULL;
1092
1093        // metadata buffers are not connected cross process
1094        // use a backup buffer instead of the actual buffer
1095        if (isMetadata) {
1096            data = new (std::nothrow) OMX_U8[allottedSize];
1097            if (data == NULL) {
1098                return NO_MEMORY;
1099            }
1100            memset(data, 0, allottedSize);
1101
1102            buffer_meta = new BufferMeta(
1103                    params, portIndex, false /* copy */, data);
1104        } else {
1105            data = static_cast<OMX_U8 *>(params->pointer());
1106
1107            buffer_meta = new BufferMeta(
1108                    params, portIndex, false /* copy */, NULL);
1109        }
1110
1111        err = OMX_UseBuffer(
1112                mHandle, &header, portIndex, buffer_meta,
1113                allottedSize, data);
1114
1115        if (err != OMX_ErrorNone) {
1116            CLOG_ERROR(useBuffer, err, SIMPLE_BUFFER(
1117                    portIndex, (size_t)allottedSize, data));
1118        }
1119    }
1120
1121    if (err != OMX_ErrorNone) {
1122        delete buffer_meta;
1123        buffer_meta = NULL;
1124
1125        *buffer = 0;
1126
1127        return StatusFromOMXError(err);
1128    }
1129
1130    CHECK_EQ(header->pAppPrivate, buffer_meta);
1131
1132    *buffer = makeBufferID(header);
1133
1134    addActiveBuffer(portIndex, *buffer);
1135
1136    sp<IOMXBufferSource> bufferSource(getBufferSource());
1137    if (bufferSource != NULL && portIndex == kPortIndexInput) {
1138        bufferSource->onInputBufferAdded(*buffer);
1139    }
1140
1141    CLOG_BUFFER(useBuffer, NEW_BUFFER_FMT(
1142            *buffer, portIndex, "%u(%zu)@%p", allottedSize, params->size(), params->pointer()));
1143    return OK;
1144}
1145
1146status_t OMXNodeInstance::useGraphicBuffer2_l(
1147        OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
1148        OMX::buffer_id *buffer) {
1149    if (graphicBuffer == NULL || buffer == NULL) {
1150        ALOGE("b/25884056");
1151        return BAD_VALUE;
1152    }
1153
1154    // port definition
1155    OMX_PARAM_PORTDEFINITIONTYPE def;
1156    InitOMXParams(&def);
1157    def.nPortIndex = portIndex;
1158    OMX_ERRORTYPE err = OMX_GetParameter(mHandle, OMX_IndexParamPortDefinition, &def);
1159    if (err != OMX_ErrorNone) {
1160        OMX_INDEXTYPE index = OMX_IndexParamPortDefinition;
1161        CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u",
1162                asString(index), index, portString(portIndex), portIndex);
1163        return UNKNOWN_ERROR;
1164    }
1165
1166    BufferMeta *bufferMeta = new BufferMeta(graphicBuffer, portIndex);
1167
1168    OMX_BUFFERHEADERTYPE *header = NULL;
1169    OMX_U8* bufferHandle = const_cast<OMX_U8*>(
1170            reinterpret_cast<const OMX_U8*>(graphicBuffer->handle));
1171
1172    err = OMX_UseBuffer(
1173            mHandle,
1174            &header,
1175            portIndex,
1176            bufferMeta,
1177            def.nBufferSize,
1178            bufferHandle);
1179
1180    if (err != OMX_ErrorNone) {
1181        CLOG_ERROR(useBuffer, err, BUFFER_FMT(portIndex, "%u@%p", def.nBufferSize, bufferHandle));
1182        delete bufferMeta;
1183        bufferMeta = NULL;
1184        *buffer = 0;
1185        return StatusFromOMXError(err);
1186    }
1187
1188    CHECK_EQ(header->pBuffer, bufferHandle);
1189    CHECK_EQ(header->pAppPrivate, bufferMeta);
1190
1191    *buffer = makeBufferID(header);
1192
1193    addActiveBuffer(portIndex, *buffer);
1194    CLOG_BUFFER(useGraphicBuffer2, NEW_BUFFER_FMT(
1195            *buffer, portIndex, "%u@%p", def.nBufferSize, bufferHandle));
1196    return OK;
1197}
1198
1199// XXX: This function is here for backwards compatibility.  Once the OMX
1200// implementations have been updated this can be removed and useGraphicBuffer2
1201// can be renamed to useGraphicBuffer.
1202status_t OMXNodeInstance::useGraphicBuffer_l(
1203        OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
1204        OMX::buffer_id *buffer) {
1205    if (graphicBuffer == NULL || buffer == NULL) {
1206        ALOGE("b/25884056");
1207        return BAD_VALUE;
1208    }
1209
1210    // First, see if we're in metadata mode. We could be running an experiment to simulate
1211    // legacy behavior (preallocated buffers) on devices that supports meta.
1212    if (mMetadataType[portIndex] != kMetadataBufferTypeInvalid) {
1213        return useGraphicBufferWithMetadata_l(
1214                portIndex, graphicBuffer, buffer);
1215    }
1216
1217    // See if the newer version of the extension is present.
1218    OMX_INDEXTYPE index;
1219    if (OMX_GetExtensionIndex(
1220            mHandle,
1221            const_cast<OMX_STRING>("OMX.google.android.index.useAndroidNativeBuffer2"),
1222            &index) == OMX_ErrorNone) {
1223        return useGraphicBuffer2_l(portIndex, graphicBuffer, buffer);
1224    }
1225
1226    OMX_STRING name = const_cast<OMX_STRING>(
1227        "OMX.google.android.index.useAndroidNativeBuffer");
1228    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
1229    if (err != OMX_ErrorNone) {
1230        CLOG_ERROR(getExtensionIndex, err, "%s", name);
1231        return StatusFromOMXError(err);
1232    }
1233
1234    BufferMeta *bufferMeta = new BufferMeta(graphicBuffer, portIndex);
1235
1236    OMX_BUFFERHEADERTYPE *header;
1237
1238    OMX_VERSIONTYPE ver;
1239    ver.s.nVersionMajor = 1;
1240    ver.s.nVersionMinor = 0;
1241    ver.s.nRevision = 0;
1242    ver.s.nStep = 0;
1243    UseAndroidNativeBufferParams params = {
1244        sizeof(UseAndroidNativeBufferParams), ver, portIndex, bufferMeta,
1245        &header, graphicBuffer,
1246    };
1247
1248    err = OMX_SetParameter(mHandle, index, &params);
1249
1250    if (err != OMX_ErrorNone) {
1251        CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u meta=%p GB=%p", name, index,
1252                portString(portIndex), portIndex, bufferMeta, graphicBuffer->handle);
1253
1254        delete bufferMeta;
1255        bufferMeta = NULL;
1256
1257        *buffer = 0;
1258
1259        return StatusFromOMXError(err);
1260    }
1261
1262    CHECK_EQ(header->pAppPrivate, bufferMeta);
1263
1264    *buffer = makeBufferID(header);
1265
1266    addActiveBuffer(portIndex, *buffer);
1267    CLOG_BUFFER(useGraphicBuffer, NEW_BUFFER_FMT(
1268            *buffer, portIndex, "GB=%p", graphicBuffer->handle));
1269    return OK;
1270}
1271
1272status_t OMXNodeInstance::useGraphicBufferWithMetadata_l(
1273        OMX_U32 portIndex, const sp<GraphicBuffer> &graphicBuffer,
1274        OMX::buffer_id *buffer) {
1275    if (portIndex != kPortIndexOutput) {
1276        return BAD_VALUE;
1277    }
1278
1279    if (mMetadataType[portIndex] != kMetadataBufferTypeGrallocSource &&
1280            mMetadataType[portIndex] != kMetadataBufferTypeANWBuffer) {
1281        return BAD_VALUE;
1282    }
1283
1284    status_t err = useBuffer_l(portIndex, NULL, buffer);
1285    if (err != OK) {
1286        return err;
1287    }
1288
1289    OMX_BUFFERHEADERTYPE *header = findBufferHeader(*buffer, portIndex);
1290
1291    return updateGraphicBufferInMeta_l(portIndex, graphicBuffer, *buffer, header);
1292
1293}
1294
1295status_t OMXNodeInstance::updateGraphicBufferInMeta_l(
1296        OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
1297        OMX::buffer_id buffer, OMX_BUFFERHEADERTYPE *header) {
1298    // No need to check |graphicBuffer| since NULL is valid for it as below.
1299    if (header == NULL) {
1300        ALOGE("b/25884056");
1301        return BAD_VALUE;
1302    }
1303
1304    if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) {
1305        return BAD_VALUE;
1306    }
1307
1308    BufferMeta *bufferMeta = (BufferMeta *)(header->pAppPrivate);
1309    sp<ABuffer> data = bufferMeta->getBuffer(header, false /* limit */);
1310    bufferMeta->setGraphicBuffer(graphicBuffer);
1311    MetadataBufferType metaType = mMetadataType[portIndex];
1312    if (metaType == kMetadataBufferTypeGrallocSource
1313            && data->capacity() >= sizeof(VideoGrallocMetadata)) {
1314        VideoGrallocMetadata &metadata = *(VideoGrallocMetadata *)(data->data());
1315        metadata.eType = kMetadataBufferTypeGrallocSource;
1316        metadata.pHandle = graphicBuffer == NULL ? NULL : graphicBuffer->handle;
1317    } else if (metaType == kMetadataBufferTypeANWBuffer
1318            && data->capacity() >= sizeof(VideoNativeMetadata)) {
1319        VideoNativeMetadata &metadata = *(VideoNativeMetadata *)(data->data());
1320        metadata.eType = kMetadataBufferTypeANWBuffer;
1321        metadata.pBuffer = graphicBuffer == NULL ? NULL : graphicBuffer->getNativeBuffer();
1322        metadata.nFenceFd = -1;
1323    } else {
1324        CLOG_ERROR(updateGraphicBufferInMeta, BAD_VALUE, "%s:%u, %#x bad type (%d) or size (%u)",
1325            portString(portIndex), portIndex, buffer, mMetadataType[portIndex], header->nAllocLen);
1326        return BAD_VALUE;
1327    }
1328
1329    CLOG_BUFFER(updateGraphicBufferInMeta, "%s:%u, %#x := %p",
1330            portString(portIndex), portIndex, buffer,
1331            graphicBuffer == NULL ? NULL : graphicBuffer->handle);
1332    return OK;
1333}
1334
1335status_t OMXNodeInstance::updateNativeHandleInMeta_l(
1336        OMX_U32 portIndex, const sp<NativeHandle>& nativeHandle,
1337        OMX::buffer_id buffer, OMX_BUFFERHEADERTYPE *header) {
1338    // No need to check |nativeHandle| since NULL is valid for it as below.
1339    if (header == NULL) {
1340        ALOGE("b/25884056");
1341        return BAD_VALUE;
1342    }
1343
1344    if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) {
1345        return BAD_VALUE;
1346    }
1347
1348    BufferMeta *bufferMeta = (BufferMeta *)(header->pAppPrivate);
1349    sp<ABuffer> data = bufferMeta->getBuffer(header, false /* limit */);
1350    bufferMeta->setNativeHandle(nativeHandle);
1351    if (mMetadataType[portIndex] == kMetadataBufferTypeNativeHandleSource
1352            && data->capacity() >= sizeof(VideoNativeHandleMetadata)) {
1353        VideoNativeHandleMetadata &metadata = *(VideoNativeHandleMetadata *)(data->data());
1354        metadata.eType = mMetadataType[portIndex];
1355        metadata.pHandle =
1356            nativeHandle == NULL ? NULL : const_cast<native_handle*>(nativeHandle->handle());
1357    } else {
1358        CLOG_ERROR(updateNativeHandleInMeta, BAD_VALUE, "%s:%u, %#x bad type (%d) or size (%zu)",
1359            portString(portIndex), portIndex, buffer, mMetadataType[portIndex], data->capacity());
1360        return BAD_VALUE;
1361    }
1362
1363    CLOG_BUFFER(updateNativeHandleInMeta, "%s:%u, %#x := %p",
1364            portString(portIndex), portIndex, buffer,
1365            nativeHandle == NULL ? NULL : nativeHandle->handle());
1366    return OK;
1367}
1368
1369status_t OMXNodeInstance::setInputSurface(
1370        const sp<IOMXBufferSource> &bufferSource) {
1371    Mutex::Autolock autolock(mLock);
1372
1373    status_t err;
1374
1375    // only allow graphic source on input port, when there are no allocated buffers yet
1376    if (mNumPortBuffers[kPortIndexInput] > 0) {
1377        android_errorWriteLog(0x534e4554, "29422020");
1378        return INVALID_OPERATION;
1379    }
1380
1381    if (getBufferSource() != NULL) {
1382        return ALREADY_EXISTS;
1383    }
1384
1385    err = storeMetaDataInBuffers_l(kPortIndexInput, OMX_TRUE, NULL);
1386    if (err != OK) {
1387        return err;
1388    }
1389
1390    // Retrieve the width and height of the graphic buffer, set when the
1391    // codec was configured.
1392    OMX_PARAM_PORTDEFINITIONTYPE def;
1393    InitOMXParams(&def);
1394    def.nPortIndex = kPortIndexInput;
1395    OMX_ERRORTYPE oerr = OMX_GetParameter(
1396            mHandle, OMX_IndexParamPortDefinition, &def);
1397    if (oerr != OMX_ErrorNone) {
1398        OMX_INDEXTYPE index = OMX_IndexParamPortDefinition;
1399        CLOG_ERROR(getParameter, oerr, "%s(%#x): %s:%u", asString(index),
1400                index, portString(kPortIndexInput), kPortIndexInput);
1401        return UNKNOWN_ERROR;
1402    }
1403
1404    if (def.format.video.eColorFormat != OMX_COLOR_FormatAndroidOpaque) {
1405        CLOGW("createInputSurface requires COLOR_FormatSurface "
1406                "(AndroidOpaque) color format instead of %s(%#x)",
1407                asString(def.format.video.eColorFormat), def.format.video.eColorFormat);
1408        return INVALID_OPERATION;
1409    }
1410
1411    if (def.format.video.nFrameWidth == 0
1412            || def.format.video.nFrameHeight == 0) {
1413        ALOGE("Invalid video dimension %ux%u",
1414                def.format.video.nFrameWidth,
1415                def.format.video.nFrameHeight);
1416        return BAD_VALUE;
1417    }
1418
1419    setBufferSource(bufferSource);
1420    return OK;
1421}
1422
1423status_t OMXNodeInstance::allocateSecureBuffer(
1424        OMX_U32 portIndex, size_t size, OMX::buffer_id *buffer,
1425        void **buffer_data, sp<NativeHandle> *native_handle) {
1426    if (buffer == NULL || buffer_data == NULL || native_handle == NULL) {
1427        ALOGE("b/25884056");
1428        return BAD_VALUE;
1429    }
1430
1431    if (portIndex >= NELEM(mSecureBufferType)) {
1432        ALOGE("b/31385713, portIndex(%u)", portIndex);
1433        android_errorWriteLog(0x534e4554, "31385713");
1434        return BAD_VALUE;
1435    }
1436
1437    Mutex::Autolock autoLock(mLock);
1438
1439    BufferMeta *buffer_meta = new BufferMeta(portIndex);
1440
1441    OMX_BUFFERHEADERTYPE *header;
1442
1443    OMX_ERRORTYPE err = OMX_AllocateBuffer(
1444            mHandle, &header, portIndex, buffer_meta, size);
1445
1446    if (err != OMX_ErrorNone) {
1447        CLOG_ERROR(allocateBuffer, err, BUFFER_FMT(portIndex, "%zu@", size));
1448        delete buffer_meta;
1449        buffer_meta = NULL;
1450
1451        *buffer = 0;
1452
1453        return StatusFromOMXError(err);
1454    }
1455
1456    CHECK_EQ(header->pAppPrivate, buffer_meta);
1457
1458    *buffer = makeBufferID(header);
1459    if (mSecureBufferType[portIndex] == kSecureBufferTypeNativeHandle) {
1460        *buffer_data = NULL;
1461        *native_handle = NativeHandle::create(
1462                (native_handle_t *)header->pBuffer, false /* ownsHandle */);
1463    } else {
1464        *buffer_data = header->pBuffer;
1465        *native_handle = NULL;
1466    }
1467
1468    addActiveBuffer(portIndex, *buffer);
1469
1470    sp<IOMXBufferSource> bufferSource(getBufferSource());
1471    if (bufferSource != NULL && portIndex == kPortIndexInput) {
1472        bufferSource->onInputBufferAdded(*buffer);
1473    }
1474    CLOG_BUFFER(allocateSecureBuffer, NEW_BUFFER_FMT(
1475            *buffer, portIndex, "%zu@%p:%p", size, *buffer_data,
1476            *native_handle == NULL ? NULL : (*native_handle)->handle()));
1477
1478    return OK;
1479}
1480
1481status_t OMXNodeInstance::freeBuffer(
1482        OMX_U32 portIndex, OMX::buffer_id buffer) {
1483    Mutex::Autolock autoLock(mLock);
1484    CLOG_BUFFER(freeBuffer, "%s:%u %#x", portString(portIndex), portIndex, buffer);
1485
1486    removeActiveBuffer(portIndex, buffer);
1487
1488    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, portIndex);
1489    if (header == NULL) {
1490        ALOGE("b/25884056");
1491        return BAD_VALUE;
1492    }
1493    BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate);
1494
1495    OMX_ERRORTYPE err = OMX_FreeBuffer(mHandle, portIndex, header);
1496    CLOG_IF_ERROR(freeBuffer, err, "%s:%u %#x", portString(portIndex), portIndex, buffer);
1497
1498    delete buffer_meta;
1499    buffer_meta = NULL;
1500    invalidateBufferID(buffer);
1501
1502    return StatusFromOMXError(err);
1503}
1504
1505status_t OMXNodeInstance::fillBuffer(
1506        OMX::buffer_id buffer, const OMXBuffer &omxBuffer, int fenceFd) {
1507    Mutex::Autolock autoLock(mLock);
1508
1509    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexOutput);
1510    if (header == NULL) {
1511        ALOGE("b/25884056");
1512        return BAD_VALUE;
1513    }
1514
1515    if (omxBuffer.mBufferType == OMXBuffer::kBufferTypeANWBuffer) {
1516        status_t err = updateGraphicBufferInMeta_l(
1517                kPortIndexOutput, omxBuffer.mGraphicBuffer, buffer, header);
1518
1519        if (err != OK) {
1520            CLOG_ERROR(fillBuffer, err, FULL_BUFFER(
1521                    (intptr_t)header->pBuffer, header, fenceFd));
1522            return err;
1523        }
1524    } else if (omxBuffer.mBufferType != OMXBuffer::kBufferTypePreset) {
1525        return BAD_VALUE;
1526    }
1527
1528    header->nFilledLen = 0;
1529    header->nOffset = 0;
1530    header->nFlags = 0;
1531
1532    // meta now owns fenceFd
1533    status_t res = storeFenceInMeta_l(header, fenceFd, kPortIndexOutput);
1534    if (res != OK) {
1535        CLOG_ERROR(fillBuffer::storeFenceInMeta, res, EMPTY_BUFFER(buffer, header, fenceFd));
1536        return res;
1537    }
1538
1539    {
1540        Mutex::Autolock _l(mDebugLock);
1541        mOutputBuffersWithCodec.add(header);
1542        CLOG_BUMPED_BUFFER(fillBuffer, WITH_STATS(EMPTY_BUFFER(buffer, header, fenceFd)));
1543    }
1544
1545    OMX_ERRORTYPE err = OMX_FillThisBuffer(mHandle, header);
1546    if (err != OMX_ErrorNone) {
1547        CLOG_ERROR(fillBuffer, err, EMPTY_BUFFER(buffer, header, fenceFd));
1548        Mutex::Autolock _l(mDebugLock);
1549        mOutputBuffersWithCodec.remove(header);
1550    }
1551    return StatusFromOMXError(err);
1552}
1553
1554status_t OMXNodeInstance::emptyBuffer(
1555        buffer_id buffer, const OMXBuffer &omxBuffer,
1556        OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
1557    Mutex::Autolock autoLock(mLock);
1558
1559    switch (omxBuffer.mBufferType) {
1560    case OMXBuffer::kBufferTypePreset:
1561        return emptyBuffer_l(
1562                buffer, 0, omxBuffer.mRangeLength, flags, timestamp, fenceFd);
1563
1564    case OMXBuffer::kBufferTypeANWBuffer:
1565        return emptyGraphicBuffer_l(
1566                buffer, omxBuffer.mGraphicBuffer, flags, timestamp, fenceFd);
1567
1568    case OMXBuffer::kBufferTypeNativeHandle:
1569        return emptyNativeHandleBuffer_l(
1570                buffer, omxBuffer.mNativeHandle, flags, timestamp, fenceFd);
1571
1572    default:
1573        break;
1574    }
1575
1576    return BAD_VALUE;
1577}
1578
1579status_t OMXNodeInstance::emptyBuffer_l(
1580        OMX::buffer_id buffer,
1581        OMX_U32 rangeOffset, OMX_U32 rangeLength,
1582        OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
1583
1584    // no emptybuffer if using input surface
1585    if (getBufferSource() != NULL) {
1586        android_errorWriteLog(0x534e4554, "29422020");
1587        return INVALID_OPERATION;
1588    }
1589
1590    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexInput);
1591    if (header == NULL) {
1592        ALOGE("b/25884056");
1593        return BAD_VALUE;
1594    }
1595    BufferMeta *buffer_meta =
1596        static_cast<BufferMeta *>(header->pAppPrivate);
1597
1598    // set up proper filled length if component is configured for gralloc metadata mode
1599    // ignore rangeOffset in this case (as client may be assuming ANW meta buffers).
1600    if (mMetadataType[kPortIndexInput] == kMetadataBufferTypeGrallocSource) {
1601        header->nFilledLen = rangeLength ? sizeof(VideoGrallocMetadata) : 0;
1602        header->nOffset = 0;
1603    } else {
1604        // rangeLength and rangeOffset must be a subset of the allocated data in the buffer.
1605        // corner case: we permit rangeOffset == end-of-buffer with rangeLength == 0.
1606        if (rangeOffset > header->nAllocLen
1607                || rangeLength > header->nAllocLen - rangeOffset) {
1608            CLOG_ERROR(emptyBuffer, OMX_ErrorBadParameter, FULL_BUFFER(NULL, header, fenceFd));
1609            if (fenceFd >= 0) {
1610                ::close(fenceFd);
1611            }
1612            return BAD_VALUE;
1613        }
1614        header->nFilledLen = rangeLength;
1615        header->nOffset = rangeOffset;
1616
1617        buffer_meta->CopyToOMX(header);
1618    }
1619
1620    return emptyBuffer_l(header, flags, timestamp, (intptr_t)buffer, fenceFd);
1621}
1622
1623// log queued buffer activity for the next few input and/or output frames
1624// if logging at internal state level
1625void OMXNodeInstance::bumpDebugLevel_l(size_t numInputBuffers, size_t numOutputBuffers) {
1626    if (DEBUG == ADebug::kDebugInternalState) {
1627        DEBUG_BUMP = ADebug::kDebugAll;
1628        if (numInputBuffers > 0) {
1629            mDebugLevelBumpPendingBuffers[kPortIndexInput] = numInputBuffers;
1630        }
1631        if (numOutputBuffers > 0) {
1632            mDebugLevelBumpPendingBuffers[kPortIndexOutput] = numOutputBuffers;
1633        }
1634    }
1635}
1636
1637void OMXNodeInstance::unbumpDebugLevel_l(size_t portIndex) {
1638    if (mDebugLevelBumpPendingBuffers[portIndex]) {
1639        --mDebugLevelBumpPendingBuffers[portIndex];
1640    }
1641    if (!mDebugLevelBumpPendingBuffers[0]
1642            && !mDebugLevelBumpPendingBuffers[1]) {
1643        DEBUG_BUMP = DEBUG;
1644    }
1645}
1646
1647status_t OMXNodeInstance::storeFenceInMeta_l(
1648        OMX_BUFFERHEADERTYPE *header, int fenceFd, OMX_U32 portIndex) {
1649    // propagate fence if component supports it; wait for it otherwise
1650    OMX_U32 metaSize = portIndex == kPortIndexInput ? header->nFilledLen : header->nAllocLen;
1651    if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer
1652            && metaSize >= sizeof(VideoNativeMetadata)) {
1653        VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)(header->pBuffer);
1654        if (nativeMeta.nFenceFd >= 0) {
1655            ALOGE("fence (%d) already exists in meta", nativeMeta.nFenceFd);
1656            if (fenceFd >= 0) {
1657                ::close(fenceFd);
1658            }
1659            return ALREADY_EXISTS;
1660        }
1661        nativeMeta.nFenceFd = fenceFd;
1662    } else if (fenceFd >= 0) {
1663        CLOG_BUFFER(storeFenceInMeta, "waiting for fence %d", fenceFd);
1664        sp<Fence> fence = new Fence(fenceFd);
1665        return fence->wait(IOMX::kFenceTimeoutMs);
1666    }
1667    return OK;
1668}
1669
1670int OMXNodeInstance::retrieveFenceFromMeta_l(
1671        OMX_BUFFERHEADERTYPE *header, OMX_U32 portIndex) {
1672    OMX_U32 metaSize = portIndex == kPortIndexInput ? header->nAllocLen : header->nFilledLen;
1673    int fenceFd = -1;
1674    if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer
1675            && header->nAllocLen >= sizeof(VideoNativeMetadata)) {
1676        VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)(header->pBuffer);
1677        if (nativeMeta.eType == kMetadataBufferTypeANWBuffer) {
1678            fenceFd = nativeMeta.nFenceFd;
1679            nativeMeta.nFenceFd = -1;
1680        }
1681        if (metaSize < sizeof(nativeMeta) && fenceFd >= 0) {
1682            CLOG_ERROR(foundFenceInEmptyMeta, BAD_VALUE, FULL_BUFFER(
1683                    NULL, header, nativeMeta.nFenceFd));
1684            fenceFd = -1;
1685        }
1686    }
1687    return fenceFd;
1688}
1689
1690status_t OMXNodeInstance::emptyBuffer_l(
1691        OMX_BUFFERHEADERTYPE *header, OMX_U32 flags, OMX_TICKS timestamp,
1692        intptr_t debugAddr, int fenceFd) {
1693    header->nFlags = flags;
1694    header->nTimeStamp = timestamp;
1695
1696    status_t res = storeFenceInMeta_l(header, fenceFd, kPortIndexInput);
1697    if (res != OK) {
1698        CLOG_ERROR(emptyBuffer::storeFenceInMeta, res, WITH_STATS(
1699                FULL_BUFFER(debugAddr, header, fenceFd)));
1700        return res;
1701    }
1702
1703    {
1704        Mutex::Autolock _l(mDebugLock);
1705        mInputBuffersWithCodec.add(header);
1706
1707        // bump internal-state debug level for 2 input frames past a buffer with CSD
1708        if ((flags & OMX_BUFFERFLAG_CODECCONFIG) != 0) {
1709            bumpDebugLevel_l(2 /* numInputBuffers */, 0 /* numOutputBuffers */);
1710        }
1711
1712        CLOG_BUMPED_BUFFER(emptyBuffer, WITH_STATS(FULL_BUFFER(debugAddr, header, fenceFd)));
1713    }
1714
1715    OMX_ERRORTYPE err = OMX_EmptyThisBuffer(mHandle, header);
1716    CLOG_IF_ERROR(emptyBuffer, err, FULL_BUFFER(debugAddr, header, fenceFd));
1717
1718    {
1719        Mutex::Autolock _l(mDebugLock);
1720        if (err != OMX_ErrorNone) {
1721            mInputBuffersWithCodec.remove(header);
1722        } else if (!(flags & OMX_BUFFERFLAG_CODECCONFIG)) {
1723            unbumpDebugLevel_l(kPortIndexInput);
1724        }
1725    }
1726
1727    return StatusFromOMXError(err);
1728}
1729
1730// like emptyBuffer, but the data is already in header->pBuffer
1731status_t OMXNodeInstance::emptyGraphicBuffer_l(
1732        OMX::buffer_id buffer, const sp<GraphicBuffer> &graphicBuffer,
1733        OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
1734    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexInput);
1735    if (header == NULL) {
1736        ALOGE("b/25884056");
1737        return BAD_VALUE;
1738    }
1739
1740    status_t err = updateGraphicBufferInMeta_l(
1741            kPortIndexInput, graphicBuffer, buffer, header);
1742    if (err != OK) {
1743        CLOG_ERROR(emptyGraphicBuffer, err, FULL_BUFFER(
1744                (intptr_t)header->pBuffer, header, fenceFd));
1745        return err;
1746    }
1747
1748    int64_t codecTimeUs = getCodecTimestamp(timestamp);
1749
1750    header->nOffset = 0;
1751    if (graphicBuffer == NULL) {
1752        header->nFilledLen = 0;
1753    } else if (mMetadataType[kPortIndexInput] == kMetadataBufferTypeGrallocSource) {
1754        header->nFilledLen = sizeof(VideoGrallocMetadata);
1755    } else {
1756        header->nFilledLen = sizeof(VideoNativeMetadata);
1757    }
1758    return emptyBuffer_l(header, flags, codecTimeUs, (intptr_t)header->pBuffer, fenceFd);
1759}
1760
1761status_t OMXNodeInstance::setMaxPtsGapUs(const void *params, size_t size) {
1762    if (params == NULL || size != sizeof(OMX_PARAM_U32TYPE)) {
1763        CLOG_ERROR(setMaxPtsGapUs, BAD_VALUE, "invalid params (%p,%zu)", params, size);
1764        return BAD_VALUE;
1765    }
1766
1767    mMaxTimestampGapUs = (int64_t)((OMX_PARAM_U32TYPE*)params)->nU32;
1768
1769    return OK;
1770}
1771
1772int64_t OMXNodeInstance::getCodecTimestamp(OMX_TICKS timestamp) {
1773    int64_t originalTimeUs = timestamp;
1774
1775    if (mMaxTimestampGapUs > 0ll) {
1776        /* Cap timestamp gap between adjacent frames to specified max
1777         *
1778         * In the scenario of cast mirroring, encoding could be suspended for
1779         * prolonged periods. Limiting the pts gap to workaround the problem
1780         * where encoder's rate control logic produces huge frames after a
1781         * long period of suspension.
1782         */
1783        if (mPrevOriginalTimeUs >= 0ll) {
1784            int64_t timestampGapUs = originalTimeUs - mPrevOriginalTimeUs;
1785            timestamp = (timestampGapUs < mMaxTimestampGapUs ?
1786                timestampGapUs : mMaxTimestampGapUs) + mPrevModifiedTimeUs;
1787        }
1788        ALOGV("IN  timestamp: %lld -> %lld",
1789            static_cast<long long>(originalTimeUs),
1790            static_cast<long long>(timestamp));
1791    }
1792
1793    mPrevOriginalTimeUs = originalTimeUs;
1794    mPrevModifiedTimeUs = timestamp;
1795
1796    if (mMaxTimestampGapUs > 0ll && !mRestorePtsFailed) {
1797        mOriginalTimeUs.add(timestamp, originalTimeUs);
1798    }
1799
1800    return timestamp;
1801}
1802
1803status_t OMXNodeInstance::emptyNativeHandleBuffer_l(
1804        OMX::buffer_id buffer, const sp<NativeHandle> &nativeHandle,
1805        OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
1806    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexInput);
1807    if (header == NULL) {
1808        ALOGE("b/25884056");
1809        return BAD_VALUE;
1810    }
1811
1812    status_t err = updateNativeHandleInMeta_l(
1813            kPortIndexInput, nativeHandle, buffer, header);
1814    if (err != OK) {
1815        CLOG_ERROR(emptyNativeHandleBuffer_l, err, FULL_BUFFER(
1816                (intptr_t)header->pBuffer, header, fenceFd));
1817        return err;
1818    }
1819
1820    header->nOffset = 0;
1821    header->nFilledLen = (nativeHandle == NULL) ? 0 : sizeof(VideoNativeMetadata);
1822
1823    return emptyBuffer_l(header, flags, timestamp, (intptr_t)header->pBuffer, fenceFd);
1824}
1825
1826void OMXNodeInstance::codecBufferFilled(omx_message &msg) {
1827    Mutex::Autolock autoLock(mBufferIDLock);
1828
1829    if (mMaxTimestampGapUs <= 0ll || mRestorePtsFailed) {
1830        return;
1831    }
1832
1833    OMX_U32 &flags = msg.u.extended_buffer_data.flags;
1834    OMX_TICKS &timestamp = msg.u.extended_buffer_data.timestamp;
1835
1836    if (!(flags & OMX_BUFFERFLAG_CODECCONFIG)) {
1837        ssize_t index = mOriginalTimeUs.indexOfKey(timestamp);
1838        if (index >= 0) {
1839            ALOGV("OUT timestamp: %lld -> %lld",
1840                    static_cast<long long>(timestamp),
1841                    static_cast<long long>(mOriginalTimeUs[index]));
1842            timestamp = mOriginalTimeUs[index];
1843            mOriginalTimeUs.removeItemsAt(index);
1844        } else {
1845            // giving up the effort as encoder doesn't appear to preserve pts
1846            ALOGW("giving up limiting timestamp gap (pts = %lld)", timestamp);
1847            mRestorePtsFailed = true;
1848        }
1849    }
1850}
1851
1852status_t OMXNodeInstance::getExtensionIndex(
1853        const char *parameterName, OMX_INDEXTYPE *index) {
1854    Mutex::Autolock autoLock(mLock);
1855
1856    OMX_ERRORTYPE err = OMX_GetExtensionIndex(
1857            mHandle, const_cast<char *>(parameterName), index);
1858
1859    return StatusFromOMXError(err);
1860}
1861
1862status_t OMXNodeInstance::dispatchMessage(const omx_message &msg) {
1863    mDispatcher->post(msg, true /*realTime*/);
1864    return OK;
1865}
1866
1867status_t OMXNodeInstance::setQuirks(OMX_U32 quirks) {
1868    if (quirks & ~kQuirksMask) {
1869        return BAD_VALUE;
1870    }
1871
1872    mQuirks = quirks;
1873
1874    return OK;
1875}
1876
1877bool OMXNodeInstance::handleMessage(omx_message &msg) {
1878    if (msg.type == omx_message::FILL_BUFFER_DONE) {
1879        OMX_BUFFERHEADERTYPE *buffer =
1880            findBufferHeader(msg.u.extended_buffer_data.buffer, kPortIndexOutput);
1881        if (buffer == NULL) {
1882            ALOGE("b/25884056");
1883            return false;
1884        }
1885
1886        {
1887            Mutex::Autolock _l(mDebugLock);
1888            mOutputBuffersWithCodec.remove(buffer);
1889
1890            CLOG_BUMPED_BUFFER(
1891                    FBD, WITH_STATS(FULL_BUFFER(
1892                            msg.u.extended_buffer_data.buffer, buffer, msg.fenceFd)));
1893
1894            unbumpDebugLevel_l(kPortIndexOutput);
1895        }
1896
1897        BufferMeta *buffer_meta =
1898            static_cast<BufferMeta *>(buffer->pAppPrivate);
1899
1900        if (buffer->nOffset + buffer->nFilledLen < buffer->nOffset
1901                || buffer->nOffset + buffer->nFilledLen > buffer->nAllocLen) {
1902            CLOG_ERROR(onFillBufferDone, OMX_ErrorBadParameter,
1903                    FULL_BUFFER(NULL, buffer, msg.fenceFd));
1904        }
1905        buffer_meta->CopyFromOMX(buffer);
1906
1907        // fix up the buffer info (especially timestamp) if needed
1908        codecBufferFilled(msg);
1909    } else if (msg.type == omx_message::EMPTY_BUFFER_DONE) {
1910        OMX_BUFFERHEADERTYPE *buffer =
1911            findBufferHeader(msg.u.buffer_data.buffer, kPortIndexInput);
1912        if (buffer == NULL) {
1913            return false;
1914        }
1915
1916        {
1917            Mutex::Autolock _l(mDebugLock);
1918            mInputBuffersWithCodec.remove(buffer);
1919
1920            CLOG_BUMPED_BUFFER(
1921                    EBD, WITH_STATS(EMPTY_BUFFER(msg.u.buffer_data.buffer, buffer, msg.fenceFd)));
1922        }
1923
1924        const sp<IOMXBufferSource> bufferSource(getBufferSource());
1925
1926        if (bufferSource != NULL) {
1927            // This is one of the buffers used exclusively by IOMXBufferSource.
1928            // Don't dispatch a message back to ACodec, since it doesn't
1929            // know that anyone asked to have the buffer emptied and will
1930            // be very confused.
1931            bufferSource->onInputBufferEmptied(
1932                    msg.u.buffer_data.buffer, OMXFenceParcelable(msg.fenceFd));
1933            return true;
1934        }
1935    } else if (msg.type == omx_message::EVENT &&
1936            msg.u.event_data.event == OMX_EventDataSpaceChanged) {
1937        handleDataSpaceChanged(msg);
1938    }
1939
1940    return false;
1941}
1942
1943bool OMXNodeInstance::handleDataSpaceChanged(omx_message &msg) {
1944    android_dataspace dataSpace = (android_dataspace) msg.u.event_data.data1;
1945    android_dataspace origDataSpace = dataSpace;
1946
1947    if (!ColorUtils::convertDataSpaceToV0(dataSpace)) {
1948        // Do not process the data space change, don't notify client either
1949        return true;
1950    }
1951
1952    android_pixel_format pixelFormat = (android_pixel_format)msg.u.event_data.data3;
1953
1954    ColorAspects requestedAspects = ColorUtils::unpackToColorAspects(msg.u.event_data.data2);
1955    ColorAspects aspects = requestedAspects; // initially requested aspects
1956
1957    // request color aspects to encode
1958    OMX_INDEXTYPE index;
1959    status_t err = getExtensionIndex(
1960            "OMX.google.android.index.describeColorAspects", &index);
1961    if (err == OK) {
1962        // V0 dataspace
1963        DescribeColorAspectsParams params;
1964        InitOMXParams(&params);
1965        params.nPortIndex = kPortIndexInput;
1966        params.nDataSpace = origDataSpace;
1967        params.nPixelFormat = pixelFormat;
1968        params.bDataSpaceChanged = OMX_TRUE;
1969        params.sAspects = requestedAspects;
1970
1971        err = getConfig(index, &params, sizeof(params));
1972        if (err == OK) {
1973            aspects = params.sAspects;
1974            ALOGD("Codec resolved it to (R:%d(%s), P:%d(%s), M:%d(%s), T:%d(%s)) err=%d(%s)",
1975                    params.sAspects.mRange, asString(params.sAspects.mRange),
1976                    params.sAspects.mPrimaries, asString(params.sAspects.mPrimaries),
1977                    params.sAspects.mMatrixCoeffs, asString(params.sAspects.mMatrixCoeffs),
1978                    params.sAspects.mTransfer, asString(params.sAspects.mTransfer),
1979                    err, asString(err));
1980        } else {
1981            params.sAspects = aspects;
1982            err = OK;
1983        }
1984        params.bDataSpaceChanged = OMX_FALSE;
1985        for (int triesLeft = 2; --triesLeft >= 0; ) {
1986            status_t err = setConfig(index, &params, sizeof(params));
1987            if (err == OK) {
1988                err = getConfig(index, &params, sizeof(params));
1989            }
1990            if (err != OK || !ColorUtils::checkIfAspectsChangedAndUnspecifyThem(
1991                    params.sAspects, aspects)) {
1992                // if we can't set or get color aspects, still communicate dataspace to client
1993                break;
1994            }
1995
1996            ALOGW_IF(triesLeft == 0, "Codec repeatedly changed requested ColorAspects.");
1997        }
1998    }
1999
2000    ALOGV("Set color aspects to (R:%d(%s), P:%d(%s), M:%d(%s), T:%d(%s)) err=%d(%s)",
2001            aspects.mRange, asString(aspects.mRange),
2002            aspects.mPrimaries, asString(aspects.mPrimaries),
2003            aspects.mMatrixCoeffs, asString(aspects.mMatrixCoeffs),
2004            aspects.mTransfer, asString(aspects.mTransfer),
2005            err, asString(err));
2006
2007    // signal client that the dataspace has changed; this will update the output format
2008    // TODO: we should tie this to an output buffer somehow, and signal the change
2009    // just before the output buffer is returned to the client, but there are many
2010    // ways this could fail (e.g. flushing), and we are not yet supporting this scenario.
2011
2012    msg.u.event_data.data1 = (OMX_U32) dataSpace;
2013    msg.u.event_data.data2 = (OMX_U32) ColorUtils::packToU32(aspects);
2014
2015    return false;
2016}
2017
2018void OMXNodeInstance::onMessages(std::list<omx_message> &messages) {
2019    for (std::list<omx_message>::iterator it = messages.begin(); it != messages.end(); ) {
2020        if (handleMessage(*it)) {
2021            messages.erase(it++);
2022        } else {
2023            ++it;
2024        }
2025    }
2026
2027    if (!messages.empty()) {
2028        mObserver->onMessages(messages);
2029    }
2030}
2031
2032void OMXNodeInstance::onObserverDied() {
2033    ALOGE("!!! Observer died. Quickly, do something, ... anything...");
2034
2035    // Try to force shutdown of the node and hope for the best.
2036    freeNode();
2037}
2038
2039// OMXNodeInstance::OnEvent calls OMX::OnEvent, which then calls here.
2040// Don't try to acquire mLock here -- in rare circumstances this will hang.
2041void OMXNodeInstance::onEvent(
2042        OMX_EVENTTYPE event, OMX_U32 arg1, OMX_U32 arg2) {
2043    const char *arg1String = "??";
2044    const char *arg2String = "??";
2045    ADebug::Level level = ADebug::kDebugInternalState;
2046
2047    switch (event) {
2048        case OMX_EventCmdComplete:
2049            arg1String = asString((OMX_COMMANDTYPE)arg1);
2050            switch (arg1) {
2051                case OMX_CommandStateSet:
2052                    arg2String = asString((OMX_STATETYPE)arg2);
2053                    level = ADebug::kDebugState;
2054                    break;
2055                case OMX_CommandFlush:
2056                case OMX_CommandPortEnable:
2057                {
2058                    // bump internal-state debug level for 2 input and output frames
2059                    Mutex::Autolock _l(mDebugLock);
2060                    bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */);
2061                }
2062                // fall through
2063                default:
2064                    arg2String = portString(arg2);
2065            }
2066            break;
2067        case OMX_EventError:
2068            arg1String = asString((OMX_ERRORTYPE)arg1);
2069            level = ADebug::kDebugLifeCycle;
2070            break;
2071        case OMX_EventPortSettingsChanged:
2072            arg2String = asString((OMX_INDEXEXTTYPE)arg2);
2073            // fall through
2074        default:
2075            arg1String = portString(arg1);
2076    }
2077
2078    CLOGI_(level, onEvent, "%s(%x), %s(%x), %s(%x)",
2079            asString(event), event, arg1String, arg1, arg2String, arg2);
2080    const sp<IOMXBufferSource> bufferSource(getBufferSource());
2081
2082    if (bufferSource != NULL
2083            && event == OMX_EventCmdComplete
2084            && arg1 == OMX_CommandStateSet
2085            && arg2 == OMX_StateExecuting) {
2086        bufferSource->onOmxExecuting();
2087    }
2088
2089    // allow configuration if we return to the loaded state
2090    if (event == OMX_EventCmdComplete
2091            && arg1 == OMX_CommandStateSet
2092            && arg2 == OMX_StateLoaded) {
2093        mSailed = false;
2094    }
2095}
2096
2097// static
2098OMX_ERRORTYPE OMXNodeInstance::OnEvent(
2099        OMX_IN OMX_HANDLETYPE /* hComponent */,
2100        OMX_IN OMX_PTR pAppData,
2101        OMX_IN OMX_EVENTTYPE eEvent,
2102        OMX_IN OMX_U32 nData1,
2103        OMX_IN OMX_U32 nData2,
2104        OMX_IN OMX_PTR pEventData) {
2105    if (pAppData == NULL) {
2106        ALOGE("b/25884056");
2107        return OMX_ErrorBadParameter;
2108    }
2109    OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
2110    if (instance->mDying) {
2111        return OMX_ErrorNone;
2112    }
2113
2114    instance->onEvent(eEvent, nData1, nData2);
2115
2116    // output rendered events are not processed as regular events until they hit the observer
2117    if (eEvent == OMX_EventOutputRendered) {
2118        if (pEventData == NULL) {
2119            return OMX_ErrorBadParameter;
2120        }
2121
2122        // process data from array
2123        OMX_VIDEO_RENDEREVENTTYPE *renderData = (OMX_VIDEO_RENDEREVENTTYPE *)pEventData;
2124        for (size_t i = 0; i < nData1; ++i) {
2125            omx_message msg;
2126            msg.type = omx_message::FRAME_RENDERED;
2127            msg.fenceFd = -1;
2128            msg.u.render_data.timestamp = renderData[i].nMediaTimeUs;
2129            msg.u.render_data.nanoTime = renderData[i].nSystemTimeNs;
2130
2131            instance->mDispatcher->post(msg, false /* realTime */);
2132        }
2133        return OMX_ErrorNone;
2134    }
2135
2136    omx_message msg;
2137    msg.type = omx_message::EVENT;
2138    msg.fenceFd = -1;
2139    msg.u.event_data.event = eEvent;
2140    msg.u.event_data.data1 = nData1;
2141    msg.u.event_data.data2 = nData2;
2142
2143    instance->mDispatcher->post(msg, true /* realTime */);
2144
2145    return OMX_ErrorNone;
2146}
2147
2148// static
2149OMX_ERRORTYPE OMXNodeInstance::OnEmptyBufferDone(
2150        OMX_IN OMX_HANDLETYPE /* hComponent */,
2151        OMX_IN OMX_PTR pAppData,
2152        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
2153    if (pAppData == NULL) {
2154        ALOGE("b/25884056");
2155        return OMX_ErrorBadParameter;
2156    }
2157    OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
2158    if (instance->mDying) {
2159        return OMX_ErrorNone;
2160    }
2161    int fenceFd = instance->retrieveFenceFromMeta_l(pBuffer, kPortIndexOutput);
2162
2163    omx_message msg;
2164    msg.type = omx_message::EMPTY_BUFFER_DONE;
2165    msg.fenceFd = fenceFd;
2166    msg.u.buffer_data.buffer = instance->findBufferID(pBuffer);
2167    instance->mDispatcher->post(msg);
2168
2169    return OMX_ErrorNone;
2170}
2171
2172// static
2173OMX_ERRORTYPE OMXNodeInstance::OnFillBufferDone(
2174        OMX_IN OMX_HANDLETYPE /* hComponent */,
2175        OMX_IN OMX_PTR pAppData,
2176        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
2177    if (pAppData == NULL) {
2178        ALOGE("b/25884056");
2179        return OMX_ErrorBadParameter;
2180    }
2181    OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
2182    if (instance->mDying) {
2183        return OMX_ErrorNone;
2184    }
2185    int fenceFd = instance->retrieveFenceFromMeta_l(pBuffer, kPortIndexOutput);
2186
2187    omx_message msg;
2188    msg.type = omx_message::FILL_BUFFER_DONE;
2189    msg.fenceFd = fenceFd;
2190    msg.u.extended_buffer_data.buffer = instance->findBufferID(pBuffer);
2191    msg.u.extended_buffer_data.range_offset = pBuffer->nOffset;
2192    msg.u.extended_buffer_data.range_length = pBuffer->nFilledLen;
2193    msg.u.extended_buffer_data.flags = pBuffer->nFlags;
2194    msg.u.extended_buffer_data.timestamp = pBuffer->nTimeStamp;
2195    instance->mDispatcher->post(msg);
2196
2197    return OMX_ErrorNone;
2198}
2199
2200void OMXNodeInstance::addActiveBuffer(OMX_U32 portIndex, OMX::buffer_id id) {
2201    ActiveBuffer active;
2202    active.mPortIndex = portIndex;
2203    active.mID = id;
2204    mActiveBuffers.push(active);
2205
2206    if (portIndex < NELEM(mNumPortBuffers)) {
2207        ++mNumPortBuffers[portIndex];
2208    }
2209}
2210
2211void OMXNodeInstance::removeActiveBuffer(
2212        OMX_U32 portIndex, OMX::buffer_id id) {
2213    for (size_t i = 0; i < mActiveBuffers.size(); ++i) {
2214        if (mActiveBuffers[i].mPortIndex == portIndex
2215                && mActiveBuffers[i].mID == id) {
2216            mActiveBuffers.removeItemsAt(i);
2217
2218            if (portIndex < NELEM(mNumPortBuffers)) {
2219                --mNumPortBuffers[portIndex];
2220            }
2221            return;
2222        }
2223    }
2224
2225     CLOGW("Attempt to remove an active buffer [%#x] we know nothing about...", id);
2226}
2227
2228void OMXNodeInstance::freeActiveBuffers() {
2229    // Make sure to count down here, as freeBuffer will in turn remove
2230    // the active buffer from the vector...
2231    for (size_t i = mActiveBuffers.size(); i > 0;) {
2232        i--;
2233        freeBuffer(mActiveBuffers[i].mPortIndex, mActiveBuffers[i].mID);
2234    }
2235}
2236
2237OMX::buffer_id OMXNodeInstance::makeBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) {
2238    if (bufferHeader == NULL) {
2239        return 0;
2240    }
2241    Mutex::Autolock autoLock(mBufferIDLock);
2242    OMX::buffer_id buffer;
2243    do { // handle the very unlikely case of ID overflow
2244        if (++mBufferIDCount == 0) {
2245            ++mBufferIDCount;
2246        }
2247        buffer = (OMX::buffer_id)mBufferIDCount;
2248    } while (mBufferIDToBufferHeader.indexOfKey(buffer) >= 0);
2249    mBufferIDToBufferHeader.add(buffer, bufferHeader);
2250    mBufferHeaderToBufferID.add(bufferHeader, buffer);
2251    return buffer;
2252}
2253
2254OMX_BUFFERHEADERTYPE *OMXNodeInstance::findBufferHeader(
2255        OMX::buffer_id buffer, OMX_U32 portIndex) {
2256    if (buffer == 0) {
2257        return NULL;
2258    }
2259    Mutex::Autolock autoLock(mBufferIDLock);
2260    ssize_t index = mBufferIDToBufferHeader.indexOfKey(buffer);
2261    if (index < 0) {
2262        CLOGW("findBufferHeader: buffer %u not found", buffer);
2263        return NULL;
2264    }
2265    OMX_BUFFERHEADERTYPE *header = mBufferIDToBufferHeader.valueAt(index);
2266    BufferMeta *buffer_meta =
2267        static_cast<BufferMeta *>(header->pAppPrivate);
2268    if (buffer_meta->getPortIndex() != portIndex) {
2269        CLOGW("findBufferHeader: buffer %u found but with incorrect port index.", buffer);
2270        android_errorWriteLog(0x534e4554, "28816827");
2271        return NULL;
2272    }
2273    return header;
2274}
2275
2276OMX::buffer_id OMXNodeInstance::findBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) {
2277    if (bufferHeader == NULL) {
2278        return 0;
2279    }
2280    Mutex::Autolock autoLock(mBufferIDLock);
2281    ssize_t index = mBufferHeaderToBufferID.indexOfKey(bufferHeader);
2282    if (index < 0) {
2283        CLOGW("findBufferID: bufferHeader %p not found", bufferHeader);
2284        return 0;
2285    }
2286    return mBufferHeaderToBufferID.valueAt(index);
2287}
2288
2289void OMXNodeInstance::invalidateBufferID(OMX::buffer_id buffer) {
2290    if (buffer == 0) {
2291        return;
2292    }
2293    Mutex::Autolock autoLock(mBufferIDLock);
2294    ssize_t index = mBufferIDToBufferHeader.indexOfKey(buffer);
2295    if (index < 0) {
2296        CLOGW("invalidateBufferID: buffer %u not found", buffer);
2297        return;
2298    }
2299    mBufferHeaderToBufferID.removeItem(mBufferIDToBufferHeader.valueAt(index));
2300    mBufferIDToBufferHeader.removeItemsAt(index);
2301}
2302
2303}  // namespace android
2304