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