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