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