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