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