OMXNodeInstance.cpp revision 1b40f2804a27b695e9e53fb1699b64cb0dd387f9 
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 "GraphicBufferSource.h"
27
28#include <OMX_Component.h>
29#include <OMX_IndexExt.h>
30#include <OMX_AsString.h>
31
32#include <binder/IMemory.h>
33#include <cutils/properties.h>
34#include <gui/BufferQueue.h>
35#include <HardwareAPI.h>
36#include <media/stagefright/foundation/ADebug.h>
37#include <media/stagefright/foundation/ABuffer.h>
38#include <media/stagefright/MediaErrors.h>
39#include <utils/misc.h>
40#include <utils/NativeHandle.h>
41
42static const OMX_U32 kPortIndexInput = 0;
43static const OMX_U32 kPortIndexOutput = 1;
44
45#define CLOGW(fmt, ...) ALOGW("[%x:%s] " fmt, mNodeID, mName, ##__VA_ARGS__)
46
47#define CLOG_ERROR_IF(cond, fn, err, fmt, ...) \
48    ALOGE_IF(cond, #fn "(%x:%s, " fmt ") ERROR: %s(%#x)", \
49    mNodeID, mName, ##__VA_ARGS__, asString(err), err)
50#define CLOG_ERROR(fn, err, fmt, ...) CLOG_ERROR_IF(true, fn, err, fmt, ##__VA_ARGS__)
51#define CLOG_IF_ERROR(fn, err, fmt, ...) \
52    CLOG_ERROR_IF((err) != OMX_ErrorNone, fn, err, fmt, ##__VA_ARGS__)
53
54#define CLOGI_(level, fn, fmt, ...) \
55    ALOGI_IF(DEBUG >= (level), #fn "(%x:%s, " fmt ")", mNodeID, mName, ##__VA_ARGS__)
56#define CLOGD_(level, fn, fmt, ...) \
57    ALOGD_IF(DEBUG >= (level), #fn "(%x:%s, " fmt ")", mNodeID, mName, ##__VA_ARGS__)
58
59#define CLOG_LIFE(fn, fmt, ...)     CLOGI_(ADebug::kDebugLifeCycle,     fn, fmt, ##__VA_ARGS__)
60#define CLOG_STATE(fn, fmt, ...)    CLOGI_(ADebug::kDebugState,         fn, fmt, ##__VA_ARGS__)
61#define CLOG_CONFIG(fn, fmt, ...)   CLOGI_(ADebug::kDebugConfig,        fn, fmt, ##__VA_ARGS__)
62#define CLOG_INTERNAL(fn, fmt, ...) CLOGD_(ADebug::kDebugInternalState, fn, fmt, ##__VA_ARGS__)
63
64#define CLOG_DEBUG_IF(cond, fn, fmt, ...) \
65    ALOGD_IF(cond, #fn "(%x, " fmt ")", mNodeID, ##__VA_ARGS__)
66
67#define CLOG_BUFFER(fn, fmt, ...) \
68    CLOG_DEBUG_IF(DEBUG >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__)
69#define CLOG_BUMPED_BUFFER(fn, fmt, ...) \
70    CLOG_DEBUG_IF(DEBUG_BUMP >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__)
71
72/* buffer formatting */
73#define BUFFER_FMT(port, fmt, ...) "%s:%u " fmt, portString(port), (port), ##__VA_ARGS__
74#define NEW_BUFFER_FMT(buffer_id, port, fmt, ...) \
75    BUFFER_FMT(port, fmt ") (#%zu => %#x", ##__VA_ARGS__, mActiveBuffers.size(), (buffer_id))
76
77#define SIMPLE_BUFFER(port, size, data) BUFFER_FMT(port, "%zu@%p", (size), (data))
78#define SIMPLE_NEW_BUFFER(buffer_id, port, size, data) \
79    NEW_BUFFER_FMT(buffer_id, port, "%zu@%p", (size), (data))
80
81#define EMPTY_BUFFER(addr, header, fenceFd) "%#x [%u@%p fc=%d]", \
82    (addr), (header)->nAllocLen, (header)->pBuffer, (fenceFd)
83#define FULL_BUFFER(addr, header, fenceFd) "%#" PRIxPTR " [%u@%p (%u..+%u) f=%x ts=%lld fc=%d]", \
84    (intptr_t)(addr), (header)->nAllocLen, (header)->pBuffer, \
85    (header)->nOffset, (header)->nFilledLen, (header)->nFlags, (header)->nTimeStamp, (fenceFd)
86
87#define WITH_STATS_WRAPPER(fmt, ...) fmt " { IN=%zu/%zu OUT=%zu/%zu }", ##__VA_ARGS__, \
88    mInputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexInput], \
89    mOutputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexOutput]
90// TRICKY: this is needed so formatting macros expand before substitution
91#define WITH_STATS(fmt, ...) WITH_STATS_WRAPPER(fmt, ##__VA_ARGS__)
92
93namespace android {
94
95struct BufferMeta {
96    BufferMeta(const sp<IMemory> &mem, bool is_backup = false)
97        : mMem(mem),
98          mIsBackup(is_backup) {
99    }
100
101    BufferMeta(size_t size)
102        : mSize(size),
103          mIsBackup(false) {
104    }
105
106    BufferMeta(const sp<GraphicBuffer> &graphicBuffer)
107        : mGraphicBuffer(graphicBuffer),
108          mIsBackup(false) {
109    }
110
111    void CopyFromOMX(const OMX_BUFFERHEADERTYPE *header) {
112        if (!mIsBackup) {
113            return;
114        }
115
116        // check component returns proper range
117        sp<ABuffer> codec = getBuffer(header, false /* backup */, true /* limit */);
118
119        memcpy((OMX_U8 *)mMem->pointer() + header->nOffset, codec->data(), codec->size());
120    }
121
122    void CopyToOMX(const OMX_BUFFERHEADERTYPE *header) {
123        if (!mIsBackup) {
124            return;
125        }
126
127        memcpy(header->pBuffer + header->nOffset,
128                (const OMX_U8 *)mMem->pointer() + header->nOffset,
129                header->nFilledLen);
130    }
131
132    // return either the codec or the backup buffer
133    sp<ABuffer> getBuffer(const OMX_BUFFERHEADERTYPE *header, bool backup, bool limit) {
134        sp<ABuffer> buf;
135        if (backup && mMem != NULL) {
136            buf = new ABuffer(mMem->pointer(), mMem->size());
137        } else {
138            buf = new ABuffer(header->pBuffer, header->nAllocLen);
139        }
140        if (limit) {
141            if (header->nOffset + header->nFilledLen > header->nOffset
142                    && header->nOffset + header->nFilledLen <= header->nAllocLen) {
143                buf->setRange(header->nOffset, header->nFilledLen);
144            } else {
145                buf->setRange(0, 0);
146            }
147        }
148        return buf;
149    }
150
151    void setGraphicBuffer(const sp<GraphicBuffer> &graphicBuffer) {
152        mGraphicBuffer = graphicBuffer;
153    }
154
155private:
156    sp<GraphicBuffer> mGraphicBuffer;
157    sp<IMemory> mMem;
158    size_t mSize;
159    bool mIsBackup;
160
161    BufferMeta(const BufferMeta &);
162    BufferMeta &operator=(const BufferMeta &);
163};
164
165// static
166OMX_CALLBACKTYPE OMXNodeInstance::kCallbacks = {
167    &OnEvent, &OnEmptyBufferDone, &OnFillBufferDone
168};
169
170static inline const char *portString(OMX_U32 portIndex) {
171    switch (portIndex) {
172        case kPortIndexInput:  return "Input";
173        case kPortIndexOutput: return "Output";
174        case ~0U:              return "All";
175        default:               return "port";
176    }
177}
178
179OMXNodeInstance::OMXNodeInstance(
180        OMX *owner, const sp<IOMXObserver> &observer, const char *name)
181    : mOwner(owner),
182      mNodeID(0),
183      mHandle(NULL),
184      mObserver(observer),
185      mDying(false),
186      mBufferIDCount(0)
187{
188    mName = ADebug::GetDebugName(name);
189    DEBUG = ADebug::GetDebugLevelFromProperty(name, "debug.stagefright.omx-debug");
190    ALOGV("debug level for %s is %d", name, DEBUG);
191    DEBUG_BUMP = DEBUG;
192    mNumPortBuffers[0] = 0;
193    mNumPortBuffers[1] = 0;
194    mDebugLevelBumpPendingBuffers[0] = 0;
195    mDebugLevelBumpPendingBuffers[1] = 0;
196    mMetadataType[0] = kMetadataBufferTypeInvalid;
197    mMetadataType[1] = kMetadataBufferTypeInvalid;
198    mSecureBufferType[0] = kSecureBufferTypeUnknown;
199    mSecureBufferType[1] = kSecureBufferTypeUnknown;
200    mIsSecure = AString(name).endsWith(".secure");
201}
202
203OMXNodeInstance::~OMXNodeInstance() {
204    free(mName);
205    CHECK(mHandle == NULL);
206}
207
208void OMXNodeInstance::setHandle(OMX::node_id node_id, OMX_HANDLETYPE handle) {
209    mNodeID = node_id;
210    CLOG_LIFE(allocateNode, "handle=%p", handle);
211    CHECK(mHandle == NULL);
212    mHandle = handle;
213}
214
215sp<GraphicBufferSource> OMXNodeInstance::getGraphicBufferSource() {
216    Mutex::Autolock autoLock(mGraphicBufferSourceLock);
217    return mGraphicBufferSource;
218}
219
220void OMXNodeInstance::setGraphicBufferSource(
221        const sp<GraphicBufferSource>& bufferSource) {
222    Mutex::Autolock autoLock(mGraphicBufferSourceLock);
223    CLOG_INTERNAL(setGraphicBufferSource, "%p", bufferSource.get());
224    mGraphicBufferSource = bufferSource;
225}
226
227OMX *OMXNodeInstance::owner() {
228    return mOwner;
229}
230
231sp<IOMXObserver> OMXNodeInstance::observer() {
232    return mObserver;
233}
234
235OMX::node_id OMXNodeInstance::nodeID() {
236    return mNodeID;
237}
238
239status_t OMXNodeInstance::freeNode(OMXMaster *master) {
240    CLOG_LIFE(freeNode, "handle=%p", mHandle);
241    static int32_t kMaxNumIterations = 10;
242
243    // exit if we have already freed the node
244    if (mHandle == NULL) {
245        return OK;
246    }
247
248    // Transition the node from its current state all the way down
249    // to "Loaded".
250    // This ensures that all active buffers are properly freed even
251    // for components that don't do this themselves on a call to
252    // "FreeHandle".
253
254    // The code below may trigger some more events to be dispatched
255    // by the OMX component - we want to ignore them as our client
256    // does not expect them.
257    mDying = true;
258
259    OMX_STATETYPE state;
260    CHECK_EQ(OMX_GetState(mHandle, &state), OMX_ErrorNone);
261    switch (state) {
262        case OMX_StateExecuting:
263        {
264            ALOGV("forcing Executing->Idle");
265            sendCommand(OMX_CommandStateSet, OMX_StateIdle);
266            OMX_ERRORTYPE err;
267            int32_t iteration = 0;
268            while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone
269                    && state != OMX_StateIdle
270                    && state != OMX_StateInvalid) {
271                if (++iteration > kMaxNumIterations) {
272                    CLOGW("failed to enter Idle state (now %s(%d), aborting.",
273                            asString(state), state);
274                    state = OMX_StateInvalid;
275                    break;
276                }
277
278                usleep(100000);
279            }
280            CHECK_EQ(err, OMX_ErrorNone);
281
282            if (state == OMX_StateInvalid) {
283                break;
284            }
285
286            // fall through
287        }
288
289        case OMX_StateIdle:
290        {
291            ALOGV("forcing Idle->Loaded");
292            sendCommand(OMX_CommandStateSet, OMX_StateLoaded);
293
294            freeActiveBuffers();
295
296            OMX_ERRORTYPE err;
297            int32_t iteration = 0;
298            while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone
299                    && state != OMX_StateLoaded
300                    && state != OMX_StateInvalid) {
301                if (++iteration > kMaxNumIterations) {
302                    CLOGW("failed to enter Loaded state (now %s(%d), aborting.",
303                            asString(state), state);
304                    state = OMX_StateInvalid;
305                    break;
306                }
307
308                ALOGV("waiting for Loaded state...");
309                usleep(100000);
310            }
311            CHECK_EQ(err, OMX_ErrorNone);
312
313            // fall through
314        }
315
316        case OMX_StateLoaded:
317        case OMX_StateInvalid:
318            break;
319
320        default:
321            LOG_ALWAYS_FATAL("unknown state %s(%#x).", asString(state), state);
322            break;
323    }
324
325    ALOGV("[%x:%s] calling destroyComponentInstance", mNodeID, mName);
326    OMX_ERRORTYPE err = master->destroyComponentInstance(
327            static_cast<OMX_COMPONENTTYPE *>(mHandle));
328
329    mHandle = NULL;
330    CLOG_IF_ERROR(freeNode, err, "");
331    free(mName);
332    mName = NULL;
333
334    mOwner->invalidateNodeID(mNodeID);
335    mNodeID = 0;
336
337    ALOGV("OMXNodeInstance going away.");
338    delete this;
339
340    return StatusFromOMXError(err);
341}
342
343status_t OMXNodeInstance::sendCommand(
344        OMX_COMMANDTYPE cmd, OMX_S32 param) {
345    const sp<GraphicBufferSource>& bufferSource(getGraphicBufferSource());
346    if (bufferSource != NULL && cmd == OMX_CommandStateSet) {
347        if (param == OMX_StateIdle) {
348            // Initiating transition from Executing -> Idle
349            // ACodec is waiting for all buffers to be returned, do NOT
350            // submit any more buffers to the codec.
351            bufferSource->omxIdle();
352        } else if (param == OMX_StateLoaded) {
353            // Initiating transition from Idle/Executing -> Loaded
354            // Buffers are about to be freed.
355            bufferSource->omxLoaded();
356            setGraphicBufferSource(NULL);
357        }
358
359        // fall through
360    }
361
362    Mutex::Autolock autoLock(mLock);
363
364    // bump internal-state debug level for 2 input and output frames past a command
365    {
366        Mutex::Autolock _l(mDebugLock);
367        bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */);
368    }
369
370    const char *paramString =
371        cmd == OMX_CommandStateSet ? asString((OMX_STATETYPE)param) : portString(param);
372    CLOG_STATE(sendCommand, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param);
373    OMX_ERRORTYPE err = OMX_SendCommand(mHandle, cmd, param, NULL);
374    CLOG_IF_ERROR(sendCommand, err, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param);
375    return StatusFromOMXError(err);
376}
377
378status_t OMXNodeInstance::getParameter(
379        OMX_INDEXTYPE index, void *params, size_t /* size */) {
380    Mutex::Autolock autoLock(mLock);
381
382    OMX_ERRORTYPE err = OMX_GetParameter(mHandle, index, params);
383    OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
384    // some errors are expected for getParameter
385    if (err != OMX_ErrorNoMore) {
386        CLOG_IF_ERROR(getParameter, err, "%s(%#x)", asString(extIndex), index);
387    }
388    return StatusFromOMXError(err);
389}
390
391status_t OMXNodeInstance::setParameter(
392        OMX_INDEXTYPE index, const void *params, size_t size) {
393    Mutex::Autolock autoLock(mLock);
394    OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
395    CLOG_CONFIG(setParameter, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params);
396
397    OMX_ERRORTYPE err = OMX_SetParameter(
398            mHandle, index, const_cast<void *>(params));
399    CLOG_IF_ERROR(setParameter, err, "%s(%#x)", asString(extIndex), index);
400    return StatusFromOMXError(err);
401}
402
403status_t OMXNodeInstance::getConfig(
404        OMX_INDEXTYPE index, void *params, size_t /* size */) {
405    Mutex::Autolock autoLock(mLock);
406
407    OMX_ERRORTYPE err = OMX_GetConfig(mHandle, index, params);
408    OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
409    // some errors are expected for getConfig
410    if (err != OMX_ErrorNoMore) {
411        CLOG_IF_ERROR(getConfig, err, "%s(%#x)", asString(extIndex), index);
412    }
413    return StatusFromOMXError(err);
414}
415
416status_t OMXNodeInstance::setConfig(
417        OMX_INDEXTYPE index, const void *params, size_t size) {
418    Mutex::Autolock autoLock(mLock);
419    OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
420    CLOG_CONFIG(setConfig, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params);
421
422    OMX_ERRORTYPE err = OMX_SetConfig(
423            mHandle, index, const_cast<void *>(params));
424    CLOG_IF_ERROR(setConfig, err, "%s(%#x)", asString(extIndex), index);
425    return StatusFromOMXError(err);
426}
427
428status_t OMXNodeInstance::getState(OMX_STATETYPE* state) {
429    Mutex::Autolock autoLock(mLock);
430
431    OMX_ERRORTYPE err = OMX_GetState(mHandle, state);
432    CLOG_IF_ERROR(getState, err, "");
433    return StatusFromOMXError(err);
434}
435
436status_t OMXNodeInstance::enableNativeBuffers(
437        OMX_U32 portIndex, OMX_BOOL graphic, OMX_BOOL enable) {
438    Mutex::Autolock autoLock(mLock);
439    CLOG_CONFIG(enableNativeBuffers, "%s:%u%s, %d", portString(portIndex), portIndex,
440                graphic ? ", graphic" : "", enable);
441    OMX_STRING name = const_cast<OMX_STRING>(
442            graphic ? "OMX.google.android.index.enableAndroidNativeBuffers"
443                    : "OMX.google.android.index.allocateNativeHandle");
444
445    OMX_INDEXTYPE index;
446    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
447
448    if (err == OMX_ErrorNone) {
449        EnableAndroidNativeBuffersParams params;
450        InitOMXParams(&params);
451        params.nPortIndex = portIndex;
452        params.enable = enable;
453
454        err = OMX_SetParameter(mHandle, index, &params);
455        CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d", name, index,
456                      portString(portIndex), portIndex, enable);
457        if (!graphic) {
458            if (err == OMX_ErrorNone) {
459                mSecureBufferType[portIndex] =
460                    enable ? kSecureBufferTypeNativeHandle : kSecureBufferTypeOpaque;
461            } else if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) {
462                mSecureBufferType[portIndex] = kSecureBufferTypeOpaque;
463            }
464        }
465    } else {
466        CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name);
467        if (!graphic) {
468            // Extension not supported, check for manual override with system property
469            // This is a temporary workaround until partners support the OMX extension
470            char value[PROPERTY_VALUE_MAX];
471            if (property_get("media.mediadrmservice.enable", value, NULL)
472                && (!strcmp("1", value) || !strcasecmp("true", value))) {
473                CLOG_CONFIG(enableNativeBuffers, "system property override: using native-handles");
474                mSecureBufferType[portIndex] = kSecureBufferTypeNativeHandle;
475            } else if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) {
476                mSecureBufferType[portIndex] = kSecureBufferTypeOpaque;
477            }
478            err = OMX_ErrorNone;
479        }
480    }
481
482    return StatusFromOMXError(err);
483}
484
485status_t OMXNodeInstance::getGraphicBufferUsage(
486        OMX_U32 portIndex, OMX_U32* usage) {
487    Mutex::Autolock autoLock(mLock);
488
489    OMX_INDEXTYPE index;
490    OMX_STRING name = const_cast<OMX_STRING>(
491            "OMX.google.android.index.getAndroidNativeBufferUsage");
492    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
493
494    if (err != OMX_ErrorNone) {
495        CLOG_ERROR(getExtensionIndex, err, "%s", name);
496        return StatusFromOMXError(err);
497    }
498
499    GetAndroidNativeBufferUsageParams params;
500    InitOMXParams(&params);
501    params.nPortIndex = portIndex;
502
503    err = OMX_GetParameter(mHandle, index, &params);
504    if (err != OMX_ErrorNone) {
505        CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u", name, index,
506                portString(portIndex), portIndex);
507        return StatusFromOMXError(err);
508    }
509
510    *usage = params.nUsage;
511
512    return OK;
513}
514
515status_t OMXNodeInstance::storeMetaDataInBuffers(
516        OMX_U32 portIndex, OMX_BOOL enable, MetadataBufferType *type) {
517    Mutex::Autolock autolock(mLock);
518    CLOG_CONFIG(storeMetaDataInBuffers, "%s:%u en:%d", portString(portIndex), portIndex, enable);
519    return storeMetaDataInBuffers_l(portIndex, enable, type);
520}
521
522status_t OMXNodeInstance::storeMetaDataInBuffers_l(
523        OMX_U32 portIndex, OMX_BOOL enable, MetadataBufferType *type) {
524    if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) {
525        android_errorWriteLog(0x534e4554, "26324358");
526        return BAD_VALUE;
527    }
528
529    OMX_INDEXTYPE index;
530    OMX_STRING name = const_cast<OMX_STRING>(
531            "OMX.google.android.index.storeMetaDataInBuffers");
532
533    OMX_STRING nativeBufferName = const_cast<OMX_STRING>(
534            "OMX.google.android.index.storeANWBufferInMetadata");
535    MetadataBufferType negotiatedType;
536
537    StoreMetaDataInBuffersParams params;
538    InitOMXParams(&params);
539    params.nPortIndex = portIndex;
540    params.bStoreMetaData = enable;
541
542    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, nativeBufferName, &index);
543    OMX_ERRORTYPE xerr = err;
544    if (err == OMX_ErrorNone) {
545        err = OMX_SetParameter(mHandle, index, &params);
546        if (err == OMX_ErrorNone) {
547            name = nativeBufferName; // set name for debugging
548            negotiatedType = kMetadataBufferTypeANWBuffer;
549        }
550    }
551    if (err != OMX_ErrorNone) {
552        err = OMX_GetExtensionIndex(mHandle, name, &index);
553        xerr = err;
554        if (err == OMX_ErrorNone) {
555            negotiatedType = kMetadataBufferTypeGrallocSource;
556            err = OMX_SetParameter(mHandle, index, &params);
557        }
558    }
559
560    // don't log loud error if component does not support metadata mode on the output
561    if (err != OMX_ErrorNone) {
562        if (err == OMX_ErrorUnsupportedIndex && portIndex == kPortIndexOutput) {
563            CLOGW("component does not support metadata mode; using fallback");
564        } else if (xerr != OMX_ErrorNone) {
565            CLOG_ERROR(getExtensionIndex, xerr, "%s", name);
566        } else {
567            CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d type=%d", name, index,
568                    portString(portIndex), portIndex, enable, negotiatedType);
569        }
570        negotiatedType = mMetadataType[portIndex];
571    } else {
572        if (!enable) {
573            negotiatedType = kMetadataBufferTypeInvalid;
574        }
575        mMetadataType[portIndex] = negotiatedType;
576    }
577    CLOG_CONFIG(storeMetaDataInBuffers, "%s:%u negotiated %s:%d",
578            portString(portIndex), portIndex, asString(negotiatedType), negotiatedType);
579
580    if (type != NULL) {
581        *type = negotiatedType;
582    }
583
584    return StatusFromOMXError(err);
585}
586
587status_t OMXNodeInstance::prepareForAdaptivePlayback(
588        OMX_U32 portIndex, OMX_BOOL enable, OMX_U32 maxFrameWidth,
589        OMX_U32 maxFrameHeight) {
590    Mutex::Autolock autolock(mLock);
591    CLOG_CONFIG(prepareForAdaptivePlayback, "%s:%u en=%d max=%ux%u",
592            portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight);
593
594    OMX_INDEXTYPE index;
595    OMX_STRING name = const_cast<OMX_STRING>(
596            "OMX.google.android.index.prepareForAdaptivePlayback");
597
598    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
599    if (err != OMX_ErrorNone) {
600        CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name);
601        return StatusFromOMXError(err);
602    }
603
604    PrepareForAdaptivePlaybackParams params;
605    InitOMXParams(&params);
606    params.nPortIndex = portIndex;
607    params.bEnable = enable;
608    params.nMaxFrameWidth = maxFrameWidth;
609    params.nMaxFrameHeight = maxFrameHeight;
610
611    err = OMX_SetParameter(mHandle, index, &params);
612    CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d max=%ux%u", name, index,
613            portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight);
614    return StatusFromOMXError(err);
615}
616
617status_t OMXNodeInstance::configureVideoTunnelMode(
618        OMX_U32 portIndex, OMX_BOOL tunneled, OMX_U32 audioHwSync,
619        native_handle_t **sidebandHandle) {
620    Mutex::Autolock autolock(mLock);
621    CLOG_CONFIG(configureVideoTunnelMode, "%s:%u tun=%d sync=%u",
622            portString(portIndex), portIndex, tunneled, audioHwSync);
623
624    OMX_INDEXTYPE index;
625    OMX_STRING name = const_cast<OMX_STRING>(
626            "OMX.google.android.index.configureVideoTunnelMode");
627
628    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
629    if (err != OMX_ErrorNone) {
630        CLOG_ERROR_IF(tunneled, getExtensionIndex, err, "%s", name);
631        return StatusFromOMXError(err);
632    }
633
634    ConfigureVideoTunnelModeParams tunnelParams;
635    InitOMXParams(&tunnelParams);
636    tunnelParams.nPortIndex = portIndex;
637    tunnelParams.bTunneled = tunneled;
638    tunnelParams.nAudioHwSync = audioHwSync;
639    err = OMX_SetParameter(mHandle, index, &tunnelParams);
640    if (err != OMX_ErrorNone) {
641        CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index,
642                portString(portIndex), portIndex, tunneled, audioHwSync);
643        return StatusFromOMXError(err);
644    }
645
646    err = OMX_GetParameter(mHandle, index, &tunnelParams);
647    if (err != OMX_ErrorNone) {
648        CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index,
649                portString(portIndex), portIndex, tunneled, audioHwSync);
650        return StatusFromOMXError(err);
651    }
652    if (sidebandHandle) {
653        *sidebandHandle = (native_handle_t*)tunnelParams.pSidebandWindow;
654    }
655
656    return OK;
657}
658
659status_t OMXNodeInstance::useBuffer(
660        OMX_U32 portIndex, const sp<IMemory> &params,
661        OMX::buffer_id *buffer, OMX_U32 allottedSize) {
662    if (params == NULL || buffer == NULL) {
663        ALOGE("b/25884056");
664        return BAD_VALUE;
665    }
666
667    Mutex::Autolock autoLock(mLock);
668    if (allottedSize > params->size()) {
669        return BAD_VALUE;
670    }
671
672    BufferMeta *buffer_meta = new BufferMeta(params);
673
674    OMX_BUFFERHEADERTYPE *header;
675
676    OMX_ERRORTYPE err = OMX_UseBuffer(
677            mHandle, &header, portIndex, buffer_meta,
678            allottedSize, static_cast<OMX_U8 *>(params->pointer()));
679
680    if (err != OMX_ErrorNone) {
681        CLOG_ERROR(useBuffer, err, SIMPLE_BUFFER(
682                portIndex, (size_t)allottedSize, params->pointer()));
683
684        delete buffer_meta;
685        buffer_meta = NULL;
686
687        *buffer = 0;
688
689        return StatusFromOMXError(err);
690    }
691
692    CHECK_EQ(header->pAppPrivate, buffer_meta);
693
694    *buffer = makeBufferID(header);
695
696    addActiveBuffer(portIndex, *buffer);
697
698    sp<GraphicBufferSource> bufferSource(getGraphicBufferSource());
699    if (bufferSource != NULL && portIndex == kPortIndexInput) {
700        bufferSource->addCodecBuffer(header);
701    }
702
703    CLOG_BUFFER(useBuffer, NEW_BUFFER_FMT(
704            *buffer, portIndex, "%u(%zu)@%p", allottedSize, params->size(), params->pointer()));
705    return OK;
706}
707
708status_t OMXNodeInstance::useGraphicBuffer2_l(
709        OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
710        OMX::buffer_id *buffer) {
711    if (graphicBuffer == NULL || buffer == NULL) {
712        ALOGE("b/25884056");
713        return BAD_VALUE;
714    }
715
716    // port definition
717    OMX_PARAM_PORTDEFINITIONTYPE def;
718    InitOMXParams(&def);
719    def.nPortIndex = portIndex;
720    OMX_ERRORTYPE err = OMX_GetParameter(mHandle, OMX_IndexParamPortDefinition, &def);
721    if (err != OMX_ErrorNone) {
722        OMX_INDEXTYPE index = OMX_IndexParamPortDefinition;
723        CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u",
724                asString(index), index, portString(portIndex), portIndex);
725        return UNKNOWN_ERROR;
726    }
727
728    BufferMeta *bufferMeta = new BufferMeta(graphicBuffer);
729
730    OMX_BUFFERHEADERTYPE *header = NULL;
731    OMX_U8* bufferHandle = const_cast<OMX_U8*>(
732            reinterpret_cast<const OMX_U8*>(graphicBuffer->handle));
733
734    err = OMX_UseBuffer(
735            mHandle,
736            &header,
737            portIndex,
738            bufferMeta,
739            def.nBufferSize,
740            bufferHandle);
741
742    if (err != OMX_ErrorNone) {
743        CLOG_ERROR(useBuffer, err, BUFFER_FMT(portIndex, "%u@%p", def.nBufferSize, bufferHandle));
744        delete bufferMeta;
745        bufferMeta = NULL;
746        *buffer = 0;
747        return StatusFromOMXError(err);
748    }
749
750    CHECK_EQ(header->pBuffer, bufferHandle);
751    CHECK_EQ(header->pAppPrivate, bufferMeta);
752
753    *buffer = makeBufferID(header);
754
755    addActiveBuffer(portIndex, *buffer);
756    CLOG_BUFFER(useGraphicBuffer2, NEW_BUFFER_FMT(
757            *buffer, portIndex, "%u@%p", def.nBufferSize, bufferHandle));
758    return OK;
759}
760
761// XXX: This function is here for backwards compatibility.  Once the OMX
762// implementations have been updated this can be removed and useGraphicBuffer2
763// can be renamed to useGraphicBuffer.
764status_t OMXNodeInstance::useGraphicBuffer(
765        OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
766        OMX::buffer_id *buffer) {
767    if (graphicBuffer == NULL || buffer == NULL) {
768        ALOGE("b/25884056");
769        return BAD_VALUE;
770    }
771    Mutex::Autolock autoLock(mLock);
772
773    // See if the newer version of the extension is present.
774    OMX_INDEXTYPE index;
775    if (OMX_GetExtensionIndex(
776            mHandle,
777            const_cast<OMX_STRING>("OMX.google.android.index.useAndroidNativeBuffer2"),
778            &index) == OMX_ErrorNone) {
779        return useGraphicBuffer2_l(portIndex, graphicBuffer, buffer);
780    }
781
782    OMX_STRING name = const_cast<OMX_STRING>(
783        "OMX.google.android.index.useAndroidNativeBuffer");
784    OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index);
785    if (err != OMX_ErrorNone) {
786        CLOG_ERROR(getExtensionIndex, err, "%s", name);
787        return StatusFromOMXError(err);
788    }
789
790    BufferMeta *bufferMeta = new BufferMeta(graphicBuffer);
791
792    OMX_BUFFERHEADERTYPE *header;
793
794    OMX_VERSIONTYPE ver;
795    ver.s.nVersionMajor = 1;
796    ver.s.nVersionMinor = 0;
797    ver.s.nRevision = 0;
798    ver.s.nStep = 0;
799    UseAndroidNativeBufferParams params = {
800        sizeof(UseAndroidNativeBufferParams), ver, portIndex, bufferMeta,
801        &header, graphicBuffer,
802    };
803
804    err = OMX_SetParameter(mHandle, index, &params);
805
806    if (err != OMX_ErrorNone) {
807        CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u meta=%p GB=%p", name, index,
808                portString(portIndex), portIndex, bufferMeta, graphicBuffer->handle);
809
810        delete bufferMeta;
811        bufferMeta = NULL;
812
813        *buffer = 0;
814
815        return StatusFromOMXError(err);
816    }
817
818    CHECK_EQ(header->pAppPrivate, bufferMeta);
819
820    *buffer = makeBufferID(header);
821
822    addActiveBuffer(portIndex, *buffer);
823    CLOG_BUFFER(useGraphicBuffer, NEW_BUFFER_FMT(
824            *buffer, portIndex, "GB=%p", graphicBuffer->handle));
825    return OK;
826}
827
828status_t OMXNodeInstance::updateGraphicBufferInMeta_l(
829        OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
830        OMX::buffer_id buffer, OMX_BUFFERHEADERTYPE *header) {
831    // No need to check |graphicBuffer| since NULL is valid for it as below.
832    if (header == NULL) {
833        ALOGE("b/25884056");
834        return BAD_VALUE;
835    }
836
837    if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) {
838        return BAD_VALUE;
839    }
840
841    BufferMeta *bufferMeta = (BufferMeta *)(header->pAppPrivate);
842    bufferMeta->setGraphicBuffer(graphicBuffer);
843    if (mMetadataType[portIndex] == kMetadataBufferTypeGrallocSource
844            && header->nAllocLen >= sizeof(VideoGrallocMetadata)) {
845        VideoGrallocMetadata &metadata = *(VideoGrallocMetadata *)(header->pBuffer);
846        metadata.eType = kMetadataBufferTypeGrallocSource;
847        metadata.pHandle = graphicBuffer == NULL ? NULL : graphicBuffer->handle;
848    } else if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer
849            && header->nAllocLen >= sizeof(VideoNativeMetadata)) {
850        VideoNativeMetadata &metadata = *(VideoNativeMetadata *)(header->pBuffer);
851        metadata.eType = kMetadataBufferTypeANWBuffer;
852        metadata.pBuffer = graphicBuffer == NULL ? NULL : graphicBuffer->getNativeBuffer();
853        metadata.nFenceFd = -1;
854    } else {
855        CLOG_BUFFER(updateGraphicBufferInMeta, "%s:%u, %#x bad type (%d) or size (%u)",
856            portString(portIndex), portIndex, buffer, mMetadataType[portIndex], header->nAllocLen);
857        return BAD_VALUE;
858    }
859
860    CLOG_BUFFER(updateGraphicBufferInMeta, "%s:%u, %#x := %p",
861            portString(portIndex), portIndex, buffer,
862            graphicBuffer == NULL ? NULL : graphicBuffer->handle);
863    return OK;
864}
865
866status_t OMXNodeInstance::updateGraphicBufferInMeta(
867        OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer,
868        OMX::buffer_id buffer) {
869    Mutex::Autolock autoLock(mLock);
870    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer);
871    return updateGraphicBufferInMeta_l(portIndex, graphicBuffer, buffer, header);
872}
873
874status_t OMXNodeInstance::createGraphicBufferSource(
875        OMX_U32 portIndex, sp<IGraphicBufferConsumer> bufferConsumer, MetadataBufferType *type) {
876    status_t err;
877
878    const sp<GraphicBufferSource>& surfaceCheck = getGraphicBufferSource();
879    if (surfaceCheck != NULL) {
880        if (portIndex < NELEM(mMetadataType) && type != NULL) {
881            *type = mMetadataType[portIndex];
882        }
883        return ALREADY_EXISTS;
884    }
885
886    // Input buffers will hold meta-data (ANativeWindowBuffer references).
887    err = storeMetaDataInBuffers_l(portIndex, OMX_TRUE, type);
888    if (err != OK) {
889        return err;
890    }
891
892    // Retrieve the width and height of the graphic buffer, set when the
893    // codec was configured.
894    OMX_PARAM_PORTDEFINITIONTYPE def;
895    InitOMXParams(&def);
896    def.nPortIndex = portIndex;
897    OMX_ERRORTYPE oerr = OMX_GetParameter(
898            mHandle, OMX_IndexParamPortDefinition, &def);
899    if (oerr != OMX_ErrorNone) {
900        OMX_INDEXTYPE index = OMX_IndexParamPortDefinition;
901        CLOG_ERROR(getParameter, oerr, "%s(%#x): %s:%u",
902                asString(index), index, portString(portIndex), portIndex);
903        return UNKNOWN_ERROR;
904    }
905
906    if (def.format.video.eColorFormat != OMX_COLOR_FormatAndroidOpaque) {
907        CLOGW("createInputSurface requires COLOR_FormatSurface "
908                "(AndroidOpaque) color format instead of %s(%#x)",
909                asString(def.format.video.eColorFormat), def.format.video.eColorFormat);
910        return INVALID_OPERATION;
911    }
912
913    uint32_t usageBits;
914    oerr = OMX_GetParameter(
915            mHandle, (OMX_INDEXTYPE)OMX_IndexParamConsumerUsageBits, &usageBits);
916    if (oerr != OMX_ErrorNone) {
917        usageBits = 0;
918    }
919
920    sp<GraphicBufferSource> bufferSource = new GraphicBufferSource(this,
921            def.format.video.nFrameWidth,
922            def.format.video.nFrameHeight,
923            def.nBufferCountActual,
924            usageBits,
925            bufferConsumer);
926
927    if ((err = bufferSource->initCheck()) != OK) {
928        return err;
929    }
930    setGraphicBufferSource(bufferSource);
931
932    return OK;
933}
934
935status_t OMXNodeInstance::createInputSurface(
936        OMX_U32 portIndex, android_dataspace dataSpace,
937        sp<IGraphicBufferProducer> *bufferProducer, MetadataBufferType *type) {
938    if (bufferProducer == NULL) {
939        ALOGE("b/25884056");
940        return BAD_VALUE;
941    }
942
943    Mutex::Autolock autolock(mLock);
944    status_t err = createGraphicBufferSource(portIndex, NULL /* bufferConsumer */, type);
945
946    if (err != OK) {
947        return err;
948    }
949
950    mGraphicBufferSource->setDefaultDataSpace(dataSpace);
951
952    *bufferProducer = mGraphicBufferSource->getIGraphicBufferProducer();
953    return OK;
954}
955
956//static
957status_t OMXNodeInstance::createPersistentInputSurface(
958        sp<IGraphicBufferProducer> *bufferProducer,
959        sp<IGraphicBufferConsumer> *bufferConsumer) {
960    if (bufferProducer == NULL || bufferConsumer == NULL) {
961        ALOGE("b/25884056");
962        return BAD_VALUE;
963    }
964    String8 name("GraphicBufferSource");
965
966    sp<IGraphicBufferProducer> producer;
967    sp<IGraphicBufferConsumer> consumer;
968    BufferQueue::createBufferQueue(&producer, &consumer);
969    consumer->setConsumerName(name);
970    consumer->setConsumerUsageBits(GRALLOC_USAGE_HW_VIDEO_ENCODER);
971
972    sp<BufferQueue::ProxyConsumerListener> proxy =
973        new BufferQueue::ProxyConsumerListener(NULL);
974    status_t err = consumer->consumerConnect(proxy, false);
975    if (err != NO_ERROR) {
976        ALOGE("Error connecting to BufferQueue: %s (%d)",
977                strerror(-err), err);
978        return err;
979    }
980
981    *bufferProducer = producer;
982    *bufferConsumer = consumer;
983
984    return OK;
985}
986
987status_t OMXNodeInstance::setInputSurface(
988        OMX_U32 portIndex, const sp<IGraphicBufferConsumer> &bufferConsumer,
989        MetadataBufferType *type) {
990    Mutex::Autolock autolock(mLock);
991    return createGraphicBufferSource(portIndex, bufferConsumer, type);
992}
993
994void OMXNodeInstance::signalEvent(OMX_EVENTTYPE event, OMX_U32 arg1, OMX_U32 arg2) {
995    mOwner->OnEvent(mNodeID, event, arg1, arg2, NULL);
996}
997
998status_t OMXNodeInstance::signalEndOfInputStream() {
999    // For non-Surface input, the MediaCodec should convert the call to a
1000    // pair of requests (dequeue input buffer, queue input buffer with EOS
1001    // flag set).  Seems easier than doing the equivalent from here.
1002    sp<GraphicBufferSource> bufferSource(getGraphicBufferSource());
1003    if (bufferSource == NULL) {
1004        CLOGW("signalEndOfInputStream can only be used with Surface input");
1005        return INVALID_OPERATION;
1006    }
1007    return bufferSource->signalEndOfInputStream();
1008}
1009
1010status_t OMXNodeInstance::allocateSecureBuffer(
1011        OMX_U32 portIndex, size_t size, OMX::buffer_id *buffer,
1012        void **buffer_data, sp<NativeHandle> *native_handle) {
1013    if (buffer == NULL || buffer_data == NULL || native_handle == NULL) {
1014        ALOGE("b/25884056");
1015        return BAD_VALUE;
1016    }
1017
1018    Mutex::Autolock autoLock(mLock);
1019
1020    BufferMeta *buffer_meta = new BufferMeta(size);
1021
1022    OMX_BUFFERHEADERTYPE *header;
1023
1024    OMX_ERRORTYPE err = OMX_AllocateBuffer(
1025            mHandle, &header, portIndex, buffer_meta, size);
1026
1027    if (err != OMX_ErrorNone) {
1028        CLOG_ERROR(allocateBuffer, err, BUFFER_FMT(portIndex, "%zu@", size));
1029        delete buffer_meta;
1030        buffer_meta = NULL;
1031
1032        *buffer = 0;
1033
1034        return StatusFromOMXError(err);
1035    }
1036
1037    CHECK_EQ(header->pAppPrivate, buffer_meta);
1038
1039    *buffer = makeBufferID(header);
1040    if (mSecureBufferType[portIndex] == kSecureBufferTypeNativeHandle) {
1041        *buffer_data = NULL;
1042        *native_handle = NativeHandle::create(
1043                (native_handle_t *)header->pBuffer, false /* ownsHandle */);
1044    } else {
1045        *buffer_data = header->pBuffer;
1046        *native_handle = NULL;
1047    }
1048
1049    addActiveBuffer(portIndex, *buffer);
1050
1051    sp<GraphicBufferSource> bufferSource(getGraphicBufferSource());
1052    if (bufferSource != NULL && portIndex == kPortIndexInput) {
1053        bufferSource->addCodecBuffer(header);
1054    }
1055    CLOG_BUFFER(allocateSecureBuffer, NEW_BUFFER_FMT(
1056            *buffer, portIndex, "%zu@%p:%p", size, *buffer_data,
1057            *native_handle == NULL ? NULL : (*native_handle)->handle()));
1058
1059    return OK;
1060}
1061
1062status_t OMXNodeInstance::allocateBufferWithBackup(
1063        OMX_U32 portIndex, const sp<IMemory> &params,
1064        OMX::buffer_id *buffer, OMX_U32 allottedSize) {
1065    if (params == NULL || buffer == NULL) {
1066        ALOGE("b/25884056");
1067        return BAD_VALUE;
1068    }
1069
1070    Mutex::Autolock autoLock(mLock);
1071    if (allottedSize > params->size()) {
1072        return BAD_VALUE;
1073    }
1074
1075    BufferMeta *buffer_meta = new BufferMeta(params, true);
1076
1077    OMX_BUFFERHEADERTYPE *header;
1078
1079    OMX_ERRORTYPE err = OMX_AllocateBuffer(
1080            mHandle, &header, portIndex, buffer_meta, allottedSize);
1081    if (err != OMX_ErrorNone) {
1082        CLOG_ERROR(allocateBufferWithBackup, err,
1083                SIMPLE_BUFFER(portIndex, (size_t)allottedSize, params->pointer()));
1084        delete buffer_meta;
1085        buffer_meta = NULL;
1086
1087        *buffer = 0;
1088
1089        return StatusFromOMXError(err);
1090    }
1091
1092    CHECK_EQ(header->pAppPrivate, buffer_meta);
1093
1094    *buffer = makeBufferID(header);
1095
1096    addActiveBuffer(portIndex, *buffer);
1097
1098    sp<GraphicBufferSource> bufferSource(getGraphicBufferSource());
1099    if (bufferSource != NULL && portIndex == kPortIndexInput) {
1100        bufferSource->addCodecBuffer(header);
1101    }
1102
1103    CLOG_BUFFER(allocateBufferWithBackup, NEW_BUFFER_FMT(*buffer, portIndex, "%zu@%p :> %u@%p",
1104            params->size(), params->pointer(), allottedSize, header->pBuffer));
1105
1106    return OK;
1107}
1108
1109status_t OMXNodeInstance::freeBuffer(
1110        OMX_U32 portIndex, OMX::buffer_id buffer) {
1111    Mutex::Autolock autoLock(mLock);
1112    CLOG_BUFFER(freeBuffer, "%s:%u %#x", portString(portIndex), portIndex, buffer);
1113
1114    removeActiveBuffer(portIndex, buffer);
1115
1116    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer);
1117    if (header == NULL) {
1118        ALOGE("b/25884056");
1119        return BAD_VALUE;
1120    }
1121    BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate);
1122
1123    OMX_ERRORTYPE err = OMX_FreeBuffer(mHandle, portIndex, header);
1124    CLOG_IF_ERROR(freeBuffer, err, "%s:%u %#x", portString(portIndex), portIndex, buffer);
1125
1126    delete buffer_meta;
1127    buffer_meta = NULL;
1128    invalidateBufferID(buffer);
1129
1130    return StatusFromOMXError(err);
1131}
1132
1133status_t OMXNodeInstance::fillBuffer(OMX::buffer_id buffer, int fenceFd) {
1134    Mutex::Autolock autoLock(mLock);
1135
1136    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer);
1137    if (header == NULL) {
1138        ALOGE("b/25884056");
1139        return BAD_VALUE;
1140    }
1141    header->nFilledLen = 0;
1142    header->nOffset = 0;
1143    header->nFlags = 0;
1144
1145    // meta now owns fenceFd
1146    status_t res = storeFenceInMeta_l(header, fenceFd, kPortIndexOutput);
1147    if (res != OK) {
1148        CLOG_ERROR(fillBuffer::storeFenceInMeta, res, EMPTY_BUFFER(buffer, header, fenceFd));
1149        return res;
1150    }
1151
1152    {
1153        Mutex::Autolock _l(mDebugLock);
1154        mOutputBuffersWithCodec.add(header);
1155        CLOG_BUMPED_BUFFER(fillBuffer, WITH_STATS(EMPTY_BUFFER(buffer, header, fenceFd)));
1156    }
1157
1158    OMX_ERRORTYPE err = OMX_FillThisBuffer(mHandle, header);
1159    if (err != OMX_ErrorNone) {
1160        CLOG_ERROR(fillBuffer, err, EMPTY_BUFFER(buffer, header, fenceFd));
1161        Mutex::Autolock _l(mDebugLock);
1162        mOutputBuffersWithCodec.remove(header);
1163    }
1164    return StatusFromOMXError(err);
1165}
1166
1167status_t OMXNodeInstance::emptyBuffer(
1168        OMX::buffer_id buffer,
1169        OMX_U32 rangeOffset, OMX_U32 rangeLength,
1170        OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
1171    Mutex::Autolock autoLock(mLock);
1172
1173    OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer);
1174    if (header == NULL) {
1175        ALOGE("b/25884056");
1176        return BAD_VALUE;
1177    }
1178    BufferMeta *buffer_meta =
1179        static_cast<BufferMeta *>(header->pAppPrivate);
1180    sp<ABuffer> backup = buffer_meta->getBuffer(header, true /* backup */, false /* limit */);
1181    sp<ABuffer> codec = buffer_meta->getBuffer(header, false /* backup */, false /* limit */);
1182
1183    // convert incoming ANW meta buffers if component is configured for gralloc metadata mode
1184    // ignore rangeOffset in this case
1185    if (mMetadataType[kPortIndexInput] == kMetadataBufferTypeGrallocSource
1186            && backup->capacity() >= sizeof(VideoNativeMetadata)
1187            && codec->capacity() >= sizeof(VideoGrallocMetadata)
1188            && ((VideoNativeMetadata *)backup->base())->eType
1189                    == kMetadataBufferTypeANWBuffer) {
1190        VideoNativeMetadata &backupMeta = *(VideoNativeMetadata *)backup->base();
1191        VideoGrallocMetadata &codecMeta = *(VideoGrallocMetadata *)codec->base();
1192        CLOG_BUFFER(emptyBuffer, "converting ANWB %p to handle %p",
1193                backupMeta.pBuffer, backupMeta.pBuffer->handle);
1194        codecMeta.pHandle = backupMeta.pBuffer != NULL ? backupMeta.pBuffer->handle : NULL;
1195        codecMeta.eType = kMetadataBufferTypeGrallocSource;
1196        header->nFilledLen = rangeLength ? sizeof(codecMeta) : 0;
1197        header->nOffset = 0;
1198    } else {
1199        // rangeLength and rangeOffset must be a subset of the allocated data in the buffer.
1200        // corner case: we permit rangeOffset == end-of-buffer with rangeLength == 0.
1201        if (rangeOffset > header->nAllocLen
1202                || rangeLength > header->nAllocLen - rangeOffset) {
1203            CLOG_ERROR(emptyBuffer, OMX_ErrorBadParameter, FULL_BUFFER(NULL, header, fenceFd));
1204            if (fenceFd >= 0) {
1205                ::close(fenceFd);
1206            }
1207            return BAD_VALUE;
1208        }
1209        header->nFilledLen = rangeLength;
1210        header->nOffset = rangeOffset;
1211
1212        buffer_meta->CopyToOMX(header);
1213    }
1214
1215    return emptyBuffer_l(header, flags, timestamp, (intptr_t)buffer, fenceFd);
1216}
1217
1218// log queued buffer activity for the next few input and/or output frames
1219// if logging at internal state level
1220void OMXNodeInstance::bumpDebugLevel_l(size_t numInputBuffers, size_t numOutputBuffers) {
1221    if (DEBUG == ADebug::kDebugInternalState) {
1222        DEBUG_BUMP = ADebug::kDebugAll;
1223        if (numInputBuffers > 0) {
1224            mDebugLevelBumpPendingBuffers[kPortIndexInput] = numInputBuffers;
1225        }
1226        if (numOutputBuffers > 0) {
1227            mDebugLevelBumpPendingBuffers[kPortIndexOutput] = numOutputBuffers;
1228        }
1229    }
1230}
1231
1232void OMXNodeInstance::unbumpDebugLevel_l(size_t portIndex) {
1233    if (mDebugLevelBumpPendingBuffers[portIndex]) {
1234        --mDebugLevelBumpPendingBuffers[portIndex];
1235    }
1236    if (!mDebugLevelBumpPendingBuffers[0]
1237            && !mDebugLevelBumpPendingBuffers[1]) {
1238        DEBUG_BUMP = DEBUG;
1239    }
1240}
1241
1242status_t OMXNodeInstance::storeFenceInMeta_l(
1243        OMX_BUFFERHEADERTYPE *header, int fenceFd, OMX_U32 portIndex) {
1244    // propagate fence if component supports it; wait for it otherwise
1245    OMX_U32 metaSize = portIndex == kPortIndexInput ? header->nFilledLen : header->nAllocLen;
1246    if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer
1247            && metaSize >= sizeof(VideoNativeMetadata)) {
1248        VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)(header->pBuffer);
1249        if (nativeMeta.nFenceFd >= 0) {
1250            ALOGE("fence (%d) already exists in meta", nativeMeta.nFenceFd);
1251            if (fenceFd >= 0) {
1252                ::close(fenceFd);
1253            }
1254            return ALREADY_EXISTS;
1255        }
1256        nativeMeta.nFenceFd = fenceFd;
1257    } else if (fenceFd >= 0) {
1258        CLOG_BUFFER(storeFenceInMeta, "waiting for fence %d", fenceFd);
1259        sp<Fence> fence = new Fence(fenceFd);
1260        return fence->wait(IOMX::kFenceTimeoutMs);
1261    }
1262    return OK;
1263}
1264
1265int OMXNodeInstance::retrieveFenceFromMeta_l(
1266        OMX_BUFFERHEADERTYPE *header, OMX_U32 portIndex) {
1267    OMX_U32 metaSize = portIndex == kPortIndexInput ? header->nAllocLen : header->nFilledLen;
1268    int fenceFd = -1;
1269    if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer
1270            && header->nAllocLen >= sizeof(VideoNativeMetadata)) {
1271        VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)(header->pBuffer);
1272        if (nativeMeta.eType == kMetadataBufferTypeANWBuffer) {
1273            fenceFd = nativeMeta.nFenceFd;
1274            nativeMeta.nFenceFd = -1;
1275        }
1276        if (metaSize < sizeof(nativeMeta) && fenceFd >= 0) {
1277            CLOG_ERROR(foundFenceInEmptyMeta, BAD_VALUE, FULL_BUFFER(
1278                    NULL, header, nativeMeta.nFenceFd));
1279            fenceFd = -1;
1280        }
1281    }
1282    return fenceFd;
1283}
1284
1285status_t OMXNodeInstance::emptyBuffer_l(
1286        OMX_BUFFERHEADERTYPE *header, OMX_U32 flags, OMX_TICKS timestamp,
1287        intptr_t debugAddr, int fenceFd) {
1288    header->nFlags = flags;
1289    header->nTimeStamp = timestamp;
1290
1291    status_t res = storeFenceInMeta_l(header, fenceFd, kPortIndexInput);
1292    if (res != OK) {
1293        CLOG_ERROR(emptyBuffer::storeFenceInMeta, res, WITH_STATS(
1294                FULL_BUFFER(debugAddr, header, fenceFd)));
1295        return res;
1296    }
1297
1298    {
1299        Mutex::Autolock _l(mDebugLock);
1300        mInputBuffersWithCodec.add(header);
1301
1302        // bump internal-state debug level for 2 input frames past a buffer with CSD
1303        if ((flags & OMX_BUFFERFLAG_CODECCONFIG) != 0) {
1304            bumpDebugLevel_l(2 /* numInputBuffers */, 0 /* numOutputBuffers */);
1305        }
1306
1307        CLOG_BUMPED_BUFFER(emptyBuffer, WITH_STATS(FULL_BUFFER(debugAddr, header, fenceFd)));
1308    }
1309
1310    OMX_ERRORTYPE err = OMX_EmptyThisBuffer(mHandle, header);
1311    CLOG_IF_ERROR(emptyBuffer, err, FULL_BUFFER(debugAddr, header, fenceFd));
1312
1313    {
1314        Mutex::Autolock _l(mDebugLock);
1315        if (err != OMX_ErrorNone) {
1316            mInputBuffersWithCodec.remove(header);
1317        } else if (!(flags & OMX_BUFFERFLAG_CODECCONFIG)) {
1318            unbumpDebugLevel_l(kPortIndexInput);
1319        }
1320    }
1321
1322    return StatusFromOMXError(err);
1323}
1324
1325// like emptyBuffer, but the data is already in header->pBuffer
1326status_t OMXNodeInstance::emptyGraphicBuffer(
1327        OMX_BUFFERHEADERTYPE *header, const sp<GraphicBuffer> &graphicBuffer,
1328        OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
1329    if (header == NULL) {
1330        ALOGE("b/25884056");
1331        return BAD_VALUE;
1332    }
1333
1334    Mutex::Autolock autoLock(mLock);
1335    OMX::buffer_id buffer = findBufferID(header);
1336    status_t err = updateGraphicBufferInMeta_l(kPortIndexInput, graphicBuffer, buffer, header);
1337    if (err != OK) {
1338        CLOG_ERROR(emptyGraphicBuffer, err, FULL_BUFFER(
1339                (intptr_t)header->pBuffer, header, fenceFd));
1340        return err;
1341    }
1342
1343    header->nOffset = 0;
1344    header->nFilledLen = graphicBuffer == NULL ? 0 : header->nAllocLen;
1345    return emptyBuffer_l(header, flags, timestamp, (intptr_t)header->pBuffer, fenceFd);
1346}
1347
1348status_t OMXNodeInstance::getExtensionIndex(
1349        const char *parameterName, OMX_INDEXTYPE *index) {
1350    Mutex::Autolock autoLock(mLock);
1351
1352    OMX_ERRORTYPE err = OMX_GetExtensionIndex(
1353            mHandle, const_cast<char *>(parameterName), index);
1354
1355    return StatusFromOMXError(err);
1356}
1357
1358inline static const char *asString(IOMX::InternalOptionType i, const char *def = "??") {
1359    switch (i) {
1360        case IOMX::INTERNAL_OPTION_SUSPEND:           return "SUSPEND";
1361        case IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY:
1362            return "REPEAT_PREVIOUS_FRAME_DELAY";
1363        case IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP: return "MAX_TIMESTAMP_GAP";
1364        case IOMX::INTERNAL_OPTION_MAX_FPS:           return "MAX_FPS";
1365        case IOMX::INTERNAL_OPTION_START_TIME:        return "START_TIME";
1366        case IOMX::INTERNAL_OPTION_TIME_LAPSE:        return "TIME_LAPSE";
1367        default:                                      return def;
1368    }
1369}
1370
1371template<typename T>
1372static bool getInternalOption(
1373        const void *data, size_t size, T *out) {
1374    if (size != sizeof(T)) {
1375        return false;
1376    }
1377    *out = *(T*)data;
1378    return true;
1379}
1380
1381status_t OMXNodeInstance::setInternalOption(
1382        OMX_U32 portIndex,
1383        IOMX::InternalOptionType type,
1384        const void *data,
1385        size_t size) {
1386    CLOG_CONFIG(setInternalOption, "%s(%d): %s:%u %zu@%p",
1387            asString(type), type, portString(portIndex), portIndex, size, data);
1388    switch (type) {
1389        case IOMX::INTERNAL_OPTION_SUSPEND:
1390        case IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY:
1391        case IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP:
1392        case IOMX::INTERNAL_OPTION_MAX_FPS:
1393        case IOMX::INTERNAL_OPTION_START_TIME:
1394        case IOMX::INTERNAL_OPTION_TIME_LAPSE:
1395        case IOMX::INTERNAL_OPTION_COLOR_ASPECTS:
1396        {
1397            const sp<GraphicBufferSource> &bufferSource =
1398                getGraphicBufferSource();
1399
1400            if (bufferSource == NULL || portIndex != kPortIndexInput) {
1401                CLOGW("setInternalOption is only for Surface input");
1402                return ERROR_UNSUPPORTED;
1403            }
1404
1405            if (type == IOMX::INTERNAL_OPTION_SUSPEND) {
1406                bool suspend;
1407                if (!getInternalOption(data, size, &suspend)) {
1408                    return INVALID_OPERATION;
1409                }
1410
1411                CLOG_CONFIG(setInternalOption, "suspend=%d", suspend);
1412                bufferSource->suspend(suspend);
1413            } else if (type == IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY) {
1414                int64_t delayUs;
1415                if (!getInternalOption(data, size, &delayUs)) {
1416                    return INVALID_OPERATION;
1417                }
1418
1419                CLOG_CONFIG(setInternalOption, "delayUs=%lld", (long long)delayUs);
1420                return bufferSource->setRepeatPreviousFrameDelayUs(delayUs);
1421            } else if (type == IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP) {
1422                int64_t maxGapUs;
1423                if (!getInternalOption(data, size, &maxGapUs)) {
1424                    return INVALID_OPERATION;
1425                }
1426
1427                CLOG_CONFIG(setInternalOption, "gapUs=%lld", (long long)maxGapUs);
1428                return bufferSource->setMaxTimestampGapUs(maxGapUs);
1429            } else if (type == IOMX::INTERNAL_OPTION_MAX_FPS) {
1430                float maxFps;
1431                if (!getInternalOption(data, size, &maxFps)) {
1432                    return INVALID_OPERATION;
1433                }
1434
1435                CLOG_CONFIG(setInternalOption, "maxFps=%f", maxFps);
1436                return bufferSource->setMaxFps(maxFps);
1437            } else if (type == IOMX::INTERNAL_OPTION_START_TIME) {
1438                int64_t skipFramesBeforeUs;
1439                if (!getInternalOption(data, size, &skipFramesBeforeUs)) {
1440                    return INVALID_OPERATION;
1441                }
1442
1443                CLOG_CONFIG(setInternalOption, "beforeUs=%lld", (long long)skipFramesBeforeUs);
1444                bufferSource->setSkipFramesBeforeUs(skipFramesBeforeUs);
1445            } else if (type == IOMX::INTERNAL_OPTION_TIME_LAPSE) {
1446                GraphicBufferSource::TimeLapseConfig config;
1447                if (!getInternalOption(data, size, &config)) {
1448                    return INVALID_OPERATION;
1449                }
1450
1451                CLOG_CONFIG(setInternalOption, "perFrameUs=%lld perCaptureUs=%lld",
1452                        (long long)config.mTimePerFrameUs, (long long)config.mTimePerCaptureUs);
1453
1454                return bufferSource->setTimeLapseConfig(config);
1455            } else if (type == IOMX::INTERNAL_OPTION_COLOR_ASPECTS) {
1456                ColorAspects aspects;
1457                if (!getInternalOption(data, size, &aspects)) {
1458                    return INVALID_OPERATION;
1459                }
1460
1461                CLOG_CONFIG(setInternalOption, "setting color aspects");
1462                bufferSource->setColorAspects(aspects);
1463            }
1464
1465            return OK;
1466        }
1467
1468        default:
1469            return ERROR_UNSUPPORTED;
1470    }
1471}
1472
1473bool OMXNodeInstance::handleMessage(omx_message &msg) {
1474    const sp<GraphicBufferSource>& bufferSource(getGraphicBufferSource());
1475
1476    if (msg.type == omx_message::FILL_BUFFER_DONE) {
1477        OMX_BUFFERHEADERTYPE *buffer =
1478            findBufferHeader(msg.u.extended_buffer_data.buffer);
1479        if (buffer == NULL) {
1480            ALOGE("b/25884056");
1481            return BAD_VALUE;
1482        }
1483
1484        {
1485            Mutex::Autolock _l(mDebugLock);
1486            mOutputBuffersWithCodec.remove(buffer);
1487
1488            CLOG_BUMPED_BUFFER(
1489                    FBD, WITH_STATS(FULL_BUFFER(
1490                            msg.u.extended_buffer_data.buffer, buffer, msg.fenceFd)));
1491
1492            unbumpDebugLevel_l(kPortIndexOutput);
1493        }
1494
1495        BufferMeta *buffer_meta =
1496            static_cast<BufferMeta *>(buffer->pAppPrivate);
1497
1498        if (buffer->nOffset + buffer->nFilledLen < buffer->nOffset
1499                || buffer->nOffset + buffer->nFilledLen > buffer->nAllocLen) {
1500            CLOG_ERROR(onFillBufferDone, OMX_ErrorBadParameter,
1501                    FULL_BUFFER(NULL, buffer, msg.fenceFd));
1502        }
1503        buffer_meta->CopyFromOMX(buffer);
1504
1505        if (bufferSource != NULL) {
1506            // fix up the buffer info (especially timestamp) if needed
1507            bufferSource->codecBufferFilled(buffer);
1508
1509            msg.u.extended_buffer_data.timestamp = buffer->nTimeStamp;
1510        }
1511    } else if (msg.type == omx_message::EMPTY_BUFFER_DONE) {
1512        OMX_BUFFERHEADERTYPE *buffer =
1513            findBufferHeader(msg.u.buffer_data.buffer);
1514
1515        {
1516            Mutex::Autolock _l(mDebugLock);
1517            mInputBuffersWithCodec.remove(buffer);
1518
1519            CLOG_BUMPED_BUFFER(
1520                    EBD, WITH_STATS(EMPTY_BUFFER(msg.u.buffer_data.buffer, buffer, msg.fenceFd)));
1521        }
1522
1523        if (bufferSource != NULL) {
1524            // This is one of the buffers used exclusively by
1525            // GraphicBufferSource.
1526            // Don't dispatch a message back to ACodec, since it doesn't
1527            // know that anyone asked to have the buffer emptied and will
1528            // be very confused.
1529            bufferSource->codecBufferEmptied(buffer, msg.fenceFd);
1530            return true;
1531        }
1532    }
1533
1534    return false;
1535}
1536
1537void OMXNodeInstance::onMessages(std::list<omx_message> &messages) {
1538    for (std::list<omx_message>::iterator it = messages.begin(); it != messages.end(); ) {
1539        if (handleMessage(*it)) {
1540            messages.erase(it++);
1541        } else {
1542            ++it;
1543        }
1544    }
1545
1546    if (!messages.empty()) {
1547        mObserver->onMessages(messages);
1548    }
1549}
1550
1551void OMXNodeInstance::onObserverDied(OMXMaster *master) {
1552    ALOGE("!!! Observer died. Quickly, do something, ... anything...");
1553
1554    // Try to force shutdown of the node and hope for the best.
1555    freeNode(master);
1556}
1557
1558void OMXNodeInstance::onGetHandleFailed() {
1559    delete this;
1560}
1561
1562// OMXNodeInstance::OnEvent calls OMX::OnEvent, which then calls here.
1563// Don't try to acquire mLock here -- in rare circumstances this will hang.
1564void OMXNodeInstance::onEvent(
1565        OMX_EVENTTYPE event, OMX_U32 arg1, OMX_U32 arg2) {
1566    const char *arg1String = "??";
1567    const char *arg2String = "??";
1568    ADebug::Level level = ADebug::kDebugInternalState;
1569
1570    switch (event) {
1571        case OMX_EventCmdComplete:
1572            arg1String = asString((OMX_COMMANDTYPE)arg1);
1573            switch (arg1) {
1574                case OMX_CommandStateSet:
1575                    arg2String = asString((OMX_STATETYPE)arg2);
1576                    level = ADebug::kDebugState;
1577                    break;
1578                case OMX_CommandFlush:
1579                case OMX_CommandPortEnable:
1580                {
1581                    // bump internal-state debug level for 2 input and output frames
1582                    Mutex::Autolock _l(mDebugLock);
1583                    bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */);
1584                }
1585                // fall through
1586                default:
1587                    arg2String = portString(arg2);
1588            }
1589            break;
1590        case OMX_EventError:
1591            arg1String = asString((OMX_ERRORTYPE)arg1);
1592            level = ADebug::kDebugLifeCycle;
1593            break;
1594        case OMX_EventPortSettingsChanged:
1595            arg2String = asString((OMX_INDEXEXTTYPE)arg2);
1596            // fall through
1597        default:
1598            arg1String = portString(arg1);
1599    }
1600
1601    CLOGI_(level, onEvent, "%s(%x), %s(%x), %s(%x)",
1602            asString(event), event, arg1String, arg1, arg2String, arg2);
1603    const sp<GraphicBufferSource>& bufferSource(getGraphicBufferSource());
1604
1605    if (bufferSource != NULL
1606            && event == OMX_EventCmdComplete
1607            && arg1 == OMX_CommandStateSet
1608            && arg2 == OMX_StateExecuting) {
1609        bufferSource->omxExecuting();
1610    }
1611}
1612
1613// static
1614OMX_ERRORTYPE OMXNodeInstance::OnEvent(
1615        OMX_IN OMX_HANDLETYPE /* hComponent */,
1616        OMX_IN OMX_PTR pAppData,
1617        OMX_IN OMX_EVENTTYPE eEvent,
1618        OMX_IN OMX_U32 nData1,
1619        OMX_IN OMX_U32 nData2,
1620        OMX_IN OMX_PTR pEventData) {
1621    if (pAppData == NULL) {
1622        ALOGE("b/25884056");
1623        return OMX_ErrorBadParameter;
1624    }
1625    OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
1626    if (instance->mDying) {
1627        return OMX_ErrorNone;
1628    }
1629    return instance->owner()->OnEvent(
1630            instance->nodeID(), eEvent, nData1, nData2, pEventData);
1631}
1632
1633// static
1634OMX_ERRORTYPE OMXNodeInstance::OnEmptyBufferDone(
1635        OMX_IN OMX_HANDLETYPE /* hComponent */,
1636        OMX_IN OMX_PTR pAppData,
1637        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
1638    if (pAppData == NULL) {
1639        ALOGE("b/25884056");
1640        return OMX_ErrorBadParameter;
1641    }
1642    OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
1643    if (instance->mDying) {
1644        return OMX_ErrorNone;
1645    }
1646    int fenceFd = instance->retrieveFenceFromMeta_l(pBuffer, kPortIndexOutput);
1647    return instance->owner()->OnEmptyBufferDone(instance->nodeID(),
1648            instance->findBufferID(pBuffer), pBuffer, fenceFd);
1649}
1650
1651// static
1652OMX_ERRORTYPE OMXNodeInstance::OnFillBufferDone(
1653        OMX_IN OMX_HANDLETYPE /* hComponent */,
1654        OMX_IN OMX_PTR pAppData,
1655        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
1656    if (pAppData == NULL) {
1657        ALOGE("b/25884056");
1658        return OMX_ErrorBadParameter;
1659    }
1660    OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
1661    if (instance->mDying) {
1662        return OMX_ErrorNone;
1663    }
1664    int fenceFd = instance->retrieveFenceFromMeta_l(pBuffer, kPortIndexOutput);
1665    return instance->owner()->OnFillBufferDone(instance->nodeID(),
1666            instance->findBufferID(pBuffer), pBuffer, fenceFd);
1667}
1668
1669void OMXNodeInstance::addActiveBuffer(OMX_U32 portIndex, OMX::buffer_id id) {
1670    ActiveBuffer active;
1671    active.mPortIndex = portIndex;
1672    active.mID = id;
1673    mActiveBuffers.push(active);
1674
1675    if (portIndex < NELEM(mNumPortBuffers)) {
1676        ++mNumPortBuffers[portIndex];
1677    }
1678}
1679
1680void OMXNodeInstance::removeActiveBuffer(
1681        OMX_U32 portIndex, OMX::buffer_id id) {
1682    for (size_t i = 0; i < mActiveBuffers.size(); ++i) {
1683        if (mActiveBuffers[i].mPortIndex == portIndex
1684                && mActiveBuffers[i].mID == id) {
1685            mActiveBuffers.removeItemsAt(i);
1686
1687            if (portIndex < NELEM(mNumPortBuffers)) {
1688                --mNumPortBuffers[portIndex];
1689            }
1690            return;
1691        }
1692    }
1693
1694     CLOGW("Attempt to remove an active buffer [%#x] we know nothing about...", id);
1695}
1696
1697void OMXNodeInstance::freeActiveBuffers() {
1698    // Make sure to count down here, as freeBuffer will in turn remove
1699    // the active buffer from the vector...
1700    for (size_t i = mActiveBuffers.size(); i > 0;) {
1701        i--;
1702        freeBuffer(mActiveBuffers[i].mPortIndex, mActiveBuffers[i].mID);
1703    }
1704}
1705
1706OMX::buffer_id OMXNodeInstance::makeBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) {
1707    if (bufferHeader == NULL) {
1708        return 0;
1709    }
1710    Mutex::Autolock autoLock(mBufferIDLock);
1711    OMX::buffer_id buffer;
1712    do { // handle the very unlikely case of ID overflow
1713        if (++mBufferIDCount == 0) {
1714            ++mBufferIDCount;
1715        }
1716        buffer = (OMX::buffer_id)mBufferIDCount;
1717    } while (mBufferIDToBufferHeader.indexOfKey(buffer) >= 0);
1718    mBufferIDToBufferHeader.add(buffer, bufferHeader);
1719    mBufferHeaderToBufferID.add(bufferHeader, buffer);
1720    return buffer;
1721}
1722
1723OMX_BUFFERHEADERTYPE *OMXNodeInstance::findBufferHeader(OMX::buffer_id buffer) {
1724    if (buffer == 0) {
1725        return NULL;
1726    }
1727    Mutex::Autolock autoLock(mBufferIDLock);
1728    ssize_t index = mBufferIDToBufferHeader.indexOfKey(buffer);
1729    if (index < 0) {
1730        CLOGW("findBufferHeader: buffer %u not found", buffer);
1731        return NULL;
1732    }
1733    return mBufferIDToBufferHeader.valueAt(index);
1734}
1735
1736OMX::buffer_id OMXNodeInstance::findBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) {
1737    if (bufferHeader == NULL) {
1738        return 0;
1739    }
1740    Mutex::Autolock autoLock(mBufferIDLock);
1741    ssize_t index = mBufferHeaderToBufferID.indexOfKey(bufferHeader);
1742    if (index < 0) {
1743        CLOGW("findBufferID: bufferHeader %p not found", bufferHeader);
1744        return 0;
1745    }
1746    return mBufferHeaderToBufferID.valueAt(index);
1747}
1748
1749void OMXNodeInstance::invalidateBufferID(OMX::buffer_id buffer) {
1750    if (buffer == 0) {
1751        return;
1752    }
1753    Mutex::Autolock autoLock(mBufferIDLock);
1754    ssize_t index = mBufferIDToBufferHeader.indexOfKey(buffer);
1755    if (index < 0) {
1756        CLOGW("invalidateBufferID: buffer %u not found", buffer);
1757        return;
1758    }
1759    mBufferHeaderToBufferID.removeItem(mBufferIDToBufferHeader.valueAt(index));
1760    mBufferIDToBufferHeader.removeItemsAt(index);
1761}
1762
1763}  // namespace android
1764