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