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