ACodec.cpp revision 516dacfb02d0b0eafe21114330c98ce0e7d90da9 
1/*
2 * Copyright (C) 2010 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 "ACodec"
19
20#include <media/stagefright/ACodec.h>
21
22#include <binder/MemoryDealer.h>
23
24#include <media/stagefright/foundation/hexdump.h>
25#include <media/stagefright/foundation/ABuffer.h>
26#include <media/stagefright/foundation/ADebug.h>
27#include <media/stagefright/foundation/AMessage.h>
28
29#include <media/stagefright/MediaCodecList.h>
30#include <media/stagefright/MediaDefs.h>
31#include <media/stagefright/NativeWindowWrapper.h>
32#include <media/stagefright/OMXClient.h>
33#include <media/stagefright/OMXCodec.h>
34
35#include <media/hardware/HardwareAPI.h>
36
37#include <OMX_Component.h>
38
39#include "include/avc_utils.h"
40
41namespace android {
42
43template<class T>
44static void InitOMXParams(T *params) {
45    params->nSize = sizeof(T);
46    params->nVersion.s.nVersionMajor = 1;
47    params->nVersion.s.nVersionMinor = 0;
48    params->nVersion.s.nRevision = 0;
49    params->nVersion.s.nStep = 0;
50}
51
52struct CodecObserver : public BnOMXObserver {
53    CodecObserver() {}
54
55    void setNotificationMessage(const sp<AMessage> &msg) {
56        mNotify = msg;
57    }
58
59    // from IOMXObserver
60    virtual void onMessage(const omx_message &omx_msg) {
61        sp<AMessage> msg = mNotify->dup();
62
63        msg->setInt32("type", omx_msg.type);
64        msg->setPointer("node", omx_msg.node);
65
66        switch (omx_msg.type) {
67            case omx_message::EVENT:
68            {
69                msg->setInt32("event", omx_msg.u.event_data.event);
70                msg->setInt32("data1", omx_msg.u.event_data.data1);
71                msg->setInt32("data2", omx_msg.u.event_data.data2);
72                break;
73            }
74
75            case omx_message::EMPTY_BUFFER_DONE:
76            {
77                msg->setPointer("buffer", omx_msg.u.buffer_data.buffer);
78                break;
79            }
80
81            case omx_message::FILL_BUFFER_DONE:
82            {
83                msg->setPointer(
84                        "buffer", omx_msg.u.extended_buffer_data.buffer);
85                msg->setInt32(
86                        "range_offset",
87                        omx_msg.u.extended_buffer_data.range_offset);
88                msg->setInt32(
89                        "range_length",
90                        omx_msg.u.extended_buffer_data.range_length);
91                msg->setInt32(
92                        "flags",
93                        omx_msg.u.extended_buffer_data.flags);
94                msg->setInt64(
95                        "timestamp",
96                        omx_msg.u.extended_buffer_data.timestamp);
97                msg->setPointer(
98                        "platform_private",
99                        omx_msg.u.extended_buffer_data.platform_private);
100                msg->setPointer(
101                        "data_ptr",
102                        omx_msg.u.extended_buffer_data.data_ptr);
103                break;
104            }
105
106            default:
107                TRESPASS();
108                break;
109        }
110
111        msg->post();
112    }
113
114protected:
115    virtual ~CodecObserver() {}
116
117private:
118    sp<AMessage> mNotify;
119
120    DISALLOW_EVIL_CONSTRUCTORS(CodecObserver);
121};
122
123////////////////////////////////////////////////////////////////////////////////
124
125struct ACodec::BaseState : public AState {
126    BaseState(ACodec *codec, const sp<AState> &parentState = NULL);
127
128protected:
129    enum PortMode {
130        KEEP_BUFFERS,
131        RESUBMIT_BUFFERS,
132        FREE_BUFFERS,
133    };
134
135    ACodec *mCodec;
136
137    virtual PortMode getPortMode(OMX_U32 portIndex);
138
139    virtual bool onMessageReceived(const sp<AMessage> &msg);
140
141    virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
142
143    virtual void onOutputBufferDrained(const sp<AMessage> &msg);
144    virtual void onInputBufferFilled(const sp<AMessage> &msg);
145
146    void postFillThisBuffer(BufferInfo *info);
147
148private:
149    bool onOMXMessage(const sp<AMessage> &msg);
150
151    bool onOMXEmptyBufferDone(IOMX::buffer_id bufferID);
152
153    bool onOMXFillBufferDone(
154            IOMX::buffer_id bufferID,
155            size_t rangeOffset, size_t rangeLength,
156            OMX_U32 flags,
157            int64_t timeUs,
158            void *platformPrivate,
159            void *dataPtr);
160
161    void getMoreInputDataIfPossible();
162
163    DISALLOW_EVIL_CONSTRUCTORS(BaseState);
164};
165
166////////////////////////////////////////////////////////////////////////////////
167
168struct ACodec::UninitializedState : public ACodec::BaseState {
169    UninitializedState(ACodec *codec);
170
171protected:
172    virtual bool onMessageReceived(const sp<AMessage> &msg);
173    virtual void stateEntered();
174
175private:
176    void onSetup(const sp<AMessage> &msg);
177    bool onAllocateComponent(const sp<AMessage> &msg);
178
179    DISALLOW_EVIL_CONSTRUCTORS(UninitializedState);
180};
181
182////////////////////////////////////////////////////////////////////////////////
183
184struct ACodec::LoadedState : public ACodec::BaseState {
185    LoadedState(ACodec *codec);
186
187protected:
188    virtual bool onMessageReceived(const sp<AMessage> &msg);
189    virtual void stateEntered();
190
191private:
192    friend struct ACodec::UninitializedState;
193
194    bool onConfigureComponent(const sp<AMessage> &msg);
195    void onStart();
196    void onShutdown(bool keepComponentAllocated);
197
198    DISALLOW_EVIL_CONSTRUCTORS(LoadedState);
199};
200
201////////////////////////////////////////////////////////////////////////////////
202
203struct ACodec::LoadedToIdleState : public ACodec::BaseState {
204    LoadedToIdleState(ACodec *codec);
205
206protected:
207    virtual bool onMessageReceived(const sp<AMessage> &msg);
208    virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
209    virtual void stateEntered();
210
211private:
212    status_t allocateBuffers();
213
214    DISALLOW_EVIL_CONSTRUCTORS(LoadedToIdleState);
215};
216
217////////////////////////////////////////////////////////////////////////////////
218
219struct ACodec::IdleToExecutingState : public ACodec::BaseState {
220    IdleToExecutingState(ACodec *codec);
221
222protected:
223    virtual bool onMessageReceived(const sp<AMessage> &msg);
224    virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
225    virtual void stateEntered();
226
227private:
228    DISALLOW_EVIL_CONSTRUCTORS(IdleToExecutingState);
229};
230
231////////////////////////////////////////////////////////////////////////////////
232
233struct ACodec::ExecutingState : public ACodec::BaseState {
234    ExecutingState(ACodec *codec);
235
236    void submitOutputBuffers();
237
238    // Submit output buffers to the decoder, submit input buffers to client
239    // to fill with data.
240    void resume();
241
242    // Returns true iff input and output buffers are in play.
243    bool active() const { return mActive; }
244
245protected:
246    virtual PortMode getPortMode(OMX_U32 portIndex);
247    virtual bool onMessageReceived(const sp<AMessage> &msg);
248    virtual void stateEntered();
249
250    virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
251
252private:
253    bool mActive;
254
255    DISALLOW_EVIL_CONSTRUCTORS(ExecutingState);
256};
257
258////////////////////////////////////////////////////////////////////////////////
259
260struct ACodec::OutputPortSettingsChangedState : public ACodec::BaseState {
261    OutputPortSettingsChangedState(ACodec *codec);
262
263protected:
264    virtual PortMode getPortMode(OMX_U32 portIndex);
265    virtual bool onMessageReceived(const sp<AMessage> &msg);
266    virtual void stateEntered();
267
268    virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
269
270private:
271    DISALLOW_EVIL_CONSTRUCTORS(OutputPortSettingsChangedState);
272};
273
274////////////////////////////////////////////////////////////////////////////////
275
276struct ACodec::ExecutingToIdleState : public ACodec::BaseState {
277    ExecutingToIdleState(ACodec *codec);
278
279protected:
280    virtual bool onMessageReceived(const sp<AMessage> &msg);
281    virtual void stateEntered();
282
283    virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
284
285    virtual void onOutputBufferDrained(const sp<AMessage> &msg);
286    virtual void onInputBufferFilled(const sp<AMessage> &msg);
287
288private:
289    void changeStateIfWeOwnAllBuffers();
290
291    bool mComponentNowIdle;
292
293    DISALLOW_EVIL_CONSTRUCTORS(ExecutingToIdleState);
294};
295
296////////////////////////////////////////////////////////////////////////////////
297
298struct ACodec::IdleToLoadedState : public ACodec::BaseState {
299    IdleToLoadedState(ACodec *codec);
300
301protected:
302    virtual bool onMessageReceived(const sp<AMessage> &msg);
303    virtual void stateEntered();
304
305    virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
306
307private:
308    DISALLOW_EVIL_CONSTRUCTORS(IdleToLoadedState);
309};
310
311////////////////////////////////////////////////////////////////////////////////
312
313struct ACodec::FlushingState : public ACodec::BaseState {
314    FlushingState(ACodec *codec);
315
316protected:
317    virtual bool onMessageReceived(const sp<AMessage> &msg);
318    virtual void stateEntered();
319
320    virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
321
322    virtual void onOutputBufferDrained(const sp<AMessage> &msg);
323    virtual void onInputBufferFilled(const sp<AMessage> &msg);
324
325private:
326    bool mFlushComplete[2];
327
328    void changeStateIfWeOwnAllBuffers();
329
330    DISALLOW_EVIL_CONSTRUCTORS(FlushingState);
331};
332
333////////////////////////////////////////////////////////////////////////////////
334
335ACodec::ACodec()
336    : mQuirks(0),
337      mNode(NULL),
338      mSentFormat(false),
339      mIsEncoder(false),
340      mShutdownInProgress(false),
341      mEncoderDelay(0),
342      mEncoderPadding(0),
343      mChannelMaskPresent(false),
344      mChannelMask(0) {
345    mUninitializedState = new UninitializedState(this);
346    mLoadedState = new LoadedState(this);
347    mLoadedToIdleState = new LoadedToIdleState(this);
348    mIdleToExecutingState = new IdleToExecutingState(this);
349    mExecutingState = new ExecutingState(this);
350
351    mOutputPortSettingsChangedState =
352        new OutputPortSettingsChangedState(this);
353
354    mExecutingToIdleState = new ExecutingToIdleState(this);
355    mIdleToLoadedState = new IdleToLoadedState(this);
356    mFlushingState = new FlushingState(this);
357
358    mPortEOS[kPortIndexInput] = mPortEOS[kPortIndexOutput] = false;
359    mInputEOSResult = OK;
360
361    changeState(mUninitializedState);
362}
363
364ACodec::~ACodec() {
365}
366
367void ACodec::setNotificationMessage(const sp<AMessage> &msg) {
368    mNotify = msg;
369}
370
371void ACodec::initiateSetup(const sp<AMessage> &msg) {
372    msg->setWhat(kWhatSetup);
373    msg->setTarget(id());
374    msg->post();
375}
376
377void ACodec::initiateAllocateComponent(const sp<AMessage> &msg) {
378    msg->setWhat(kWhatAllocateComponent);
379    msg->setTarget(id());
380    msg->post();
381}
382
383void ACodec::initiateConfigureComponent(const sp<AMessage> &msg) {
384    msg->setWhat(kWhatConfigureComponent);
385    msg->setTarget(id());
386    msg->post();
387}
388
389void ACodec::initiateStart() {
390    (new AMessage(kWhatStart, id()))->post();
391}
392
393void ACodec::signalFlush() {
394    ALOGV("[%s] signalFlush", mComponentName.c_str());
395    (new AMessage(kWhatFlush, id()))->post();
396}
397
398void ACodec::signalResume() {
399    (new AMessage(kWhatResume, id()))->post();
400}
401
402void ACodec::initiateShutdown(bool keepComponentAllocated) {
403    sp<AMessage> msg = new AMessage(kWhatShutdown, id());
404    msg->setInt32("keepComponentAllocated", keepComponentAllocated);
405    msg->post();
406}
407
408void ACodec::signalRequestIDRFrame() {
409    (new AMessage(kWhatRequestIDRFrame, id()))->post();
410}
411
412status_t ACodec::allocateBuffersOnPort(OMX_U32 portIndex) {
413    CHECK(portIndex == kPortIndexInput || portIndex == kPortIndexOutput);
414
415    CHECK(mDealer[portIndex] == NULL);
416    CHECK(mBuffers[portIndex].isEmpty());
417
418    status_t err;
419    if (mNativeWindow != NULL && portIndex == kPortIndexOutput) {
420        err = allocateOutputBuffersFromNativeWindow();
421    } else {
422        OMX_PARAM_PORTDEFINITIONTYPE def;
423        InitOMXParams(&def);
424        def.nPortIndex = portIndex;
425
426        err = mOMX->getParameter(
427                mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
428
429        if (err == OK) {
430            ALOGV("[%s] Allocating %lu buffers of size %lu on %s port",
431                    mComponentName.c_str(),
432                    def.nBufferCountActual, def.nBufferSize,
433                    portIndex == kPortIndexInput ? "input" : "output");
434
435            size_t totalSize = def.nBufferCountActual * def.nBufferSize;
436            mDealer[portIndex] = new MemoryDealer(totalSize, "ACodec");
437
438            for (OMX_U32 i = 0; i < def.nBufferCountActual; ++i) {
439                sp<IMemory> mem = mDealer[portIndex]->allocate(def.nBufferSize);
440                CHECK(mem.get() != NULL);
441
442                BufferInfo info;
443                info.mStatus = BufferInfo::OWNED_BY_US;
444
445                uint32_t requiresAllocateBufferBit =
446                    (portIndex == kPortIndexInput)
447                        ? OMXCodec::kRequiresAllocateBufferOnInputPorts
448                        : OMXCodec::kRequiresAllocateBufferOnOutputPorts;
449
450                if (portIndex == kPortIndexInput && (mFlags & kFlagIsSecure)) {
451                    mem.clear();
452
453                    void *ptr;
454                    err = mOMX->allocateBuffer(
455                            mNode, portIndex, def.nBufferSize, &info.mBufferID,
456                            &ptr);
457
458                    info.mData = new ABuffer(ptr, def.nBufferSize);
459                } else if (mQuirks & requiresAllocateBufferBit) {
460                    err = mOMX->allocateBufferWithBackup(
461                            mNode, portIndex, mem, &info.mBufferID);
462                } else {
463                    err = mOMX->useBuffer(mNode, portIndex, mem, &info.mBufferID);
464                }
465
466                if (mem != NULL) {
467                    info.mData = new ABuffer(mem->pointer(), def.nBufferSize);
468                }
469
470                mBuffers[portIndex].push(info);
471            }
472        }
473    }
474
475    if (err != OK) {
476        return err;
477    }
478
479    sp<AMessage> notify = mNotify->dup();
480    notify->setInt32("what", ACodec::kWhatBuffersAllocated);
481
482    notify->setInt32("portIndex", portIndex);
483
484    sp<PortDescription> desc = new PortDescription;
485
486    for (size_t i = 0; i < mBuffers[portIndex].size(); ++i) {
487        const BufferInfo &info = mBuffers[portIndex][i];
488
489        desc->addBuffer(info.mBufferID, info.mData);
490    }
491
492    notify->setObject("portDesc", desc);
493    notify->post();
494
495    return OK;
496}
497
498status_t ACodec::allocateOutputBuffersFromNativeWindow() {
499    OMX_PARAM_PORTDEFINITIONTYPE def;
500    InitOMXParams(&def);
501    def.nPortIndex = kPortIndexOutput;
502
503    status_t err = mOMX->getParameter(
504            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
505
506    if (err != OK) {
507        return err;
508    }
509
510    err = native_window_set_buffers_geometry(
511            mNativeWindow.get(),
512            def.format.video.nFrameWidth,
513            def.format.video.nFrameHeight,
514            def.format.video.eColorFormat);
515
516    if (err != 0) {
517        ALOGE("native_window_set_buffers_geometry failed: %s (%d)",
518                strerror(-err), -err);
519        return err;
520    }
521
522    // Set up the native window.
523    OMX_U32 usage = 0;
524    err = mOMX->getGraphicBufferUsage(mNode, kPortIndexOutput, &usage);
525    if (err != 0) {
526        ALOGW("querying usage flags from OMX IL component failed: %d", err);
527        // XXX: Currently this error is logged, but not fatal.
528        usage = 0;
529    }
530
531    if (mFlags & kFlagIsSecure) {
532        usage |= GRALLOC_USAGE_PROTECTED;
533    }
534
535    // Make sure to check whether either Stagefright or the video decoder
536    // requested protected buffers.
537    if (usage & GRALLOC_USAGE_PROTECTED) {
538        // Verify that the ANativeWindow sends images directly to
539        // SurfaceFlinger.
540        int queuesToNativeWindow = 0;
541        err = mNativeWindow->query(
542                mNativeWindow.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
543                &queuesToNativeWindow);
544        if (err != 0) {
545            ALOGE("error authenticating native window: %d", err);
546            return err;
547        }
548        if (queuesToNativeWindow != 1) {
549            ALOGE("native window could not be authenticated");
550            return PERMISSION_DENIED;
551        }
552    }
553
554    err = native_window_set_usage(
555            mNativeWindow.get(),
556            usage | GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP);
557
558    if (err != 0) {
559        ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), -err);
560        return err;
561    }
562
563    int minUndequeuedBufs = 0;
564    err = mNativeWindow->query(
565            mNativeWindow.get(), NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
566            &minUndequeuedBufs);
567
568    if (err != 0) {
569        ALOGE("NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d)",
570                strerror(-err), -err);
571        return err;
572    }
573
574    // XXX: Is this the right logic to use?  It's not clear to me what the OMX
575    // buffer counts refer to - how do they account for the renderer holding on
576    // to buffers?
577    if (def.nBufferCountActual < def.nBufferCountMin + minUndequeuedBufs) {
578        OMX_U32 newBufferCount = def.nBufferCountMin + minUndequeuedBufs;
579        def.nBufferCountActual = newBufferCount;
580        err = mOMX->setParameter(
581                mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
582
583        if (err != OK) {
584            ALOGE("[%s] setting nBufferCountActual to %lu failed: %d",
585                    mComponentName.c_str(), newBufferCount, err);
586            return err;
587        }
588    }
589
590    err = native_window_set_buffer_count(
591            mNativeWindow.get(), def.nBufferCountActual);
592
593    if (err != 0) {
594        ALOGE("native_window_set_buffer_count failed: %s (%d)", strerror(-err),
595                -err);
596        return err;
597    }
598
599    ALOGV("[%s] Allocating %lu buffers from a native window of size %lu on "
600         "output port",
601         mComponentName.c_str(), def.nBufferCountActual, def.nBufferSize);
602
603    // Dequeue buffers and send them to OMX
604    for (OMX_U32 i = 0; i < def.nBufferCountActual; i++) {
605        ANativeWindowBuffer *buf;
606        err = native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &buf);
607        if (err != 0) {
608            ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), -err);
609            break;
610        }
611
612        sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(buf, false));
613        BufferInfo info;
614        info.mStatus = BufferInfo::OWNED_BY_US;
615        info.mData = new ABuffer(0);
616        info.mGraphicBuffer = graphicBuffer;
617        mBuffers[kPortIndexOutput].push(info);
618
619        IOMX::buffer_id bufferId;
620        err = mOMX->useGraphicBuffer(mNode, kPortIndexOutput, graphicBuffer,
621                &bufferId);
622        if (err != 0) {
623            ALOGE("registering GraphicBuffer %lu with OMX IL component failed: "
624                 "%d", i, err);
625            break;
626        }
627
628        mBuffers[kPortIndexOutput].editItemAt(i).mBufferID = bufferId;
629
630        ALOGV("[%s] Registered graphic buffer with ID %p (pointer = %p)",
631             mComponentName.c_str(),
632             bufferId, graphicBuffer.get());
633    }
634
635    OMX_U32 cancelStart;
636    OMX_U32 cancelEnd;
637
638    if (err != 0) {
639        // If an error occurred while dequeuing we need to cancel any buffers
640        // that were dequeued.
641        cancelStart = 0;
642        cancelEnd = mBuffers[kPortIndexOutput].size();
643    } else {
644        // Return the last two buffers to the native window.
645        cancelStart = def.nBufferCountActual - minUndequeuedBufs;
646        cancelEnd = def.nBufferCountActual;
647    }
648
649    for (OMX_U32 i = cancelStart; i < cancelEnd; i++) {
650        BufferInfo *info = &mBuffers[kPortIndexOutput].editItemAt(i);
651        cancelBufferToNativeWindow(info);
652    }
653
654    return err;
655}
656
657status_t ACodec::cancelBufferToNativeWindow(BufferInfo *info) {
658    CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_US);
659
660    ALOGV("[%s] Calling cancelBuffer on buffer %p",
661         mComponentName.c_str(), info->mBufferID);
662
663    int err = mNativeWindow->cancelBuffer(
664        mNativeWindow.get(), info->mGraphicBuffer.get(), -1);
665
666    CHECK_EQ(err, 0);
667
668    info->mStatus = BufferInfo::OWNED_BY_NATIVE_WINDOW;
669
670    return OK;
671}
672
673ACodec::BufferInfo *ACodec::dequeueBufferFromNativeWindow() {
674    ANativeWindowBuffer *buf;
675    int fenceFd = -1;
676    if (native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &buf) != 0) {
677        ALOGE("dequeueBuffer failed.");
678        return NULL;
679    }
680
681    for (size_t i = mBuffers[kPortIndexOutput].size(); i-- > 0;) {
682        BufferInfo *info =
683            &mBuffers[kPortIndexOutput].editItemAt(i);
684
685        if (info->mGraphicBuffer->handle == buf->handle) {
686            CHECK_EQ((int)info->mStatus,
687                     (int)BufferInfo::OWNED_BY_NATIVE_WINDOW);
688
689            info->mStatus = BufferInfo::OWNED_BY_US;
690
691            return info;
692        }
693    }
694
695    TRESPASS();
696
697    return NULL;
698}
699
700status_t ACodec::freeBuffersOnPort(OMX_U32 portIndex) {
701    for (size_t i = mBuffers[portIndex].size(); i-- > 0;) {
702        CHECK_EQ((status_t)OK, freeBuffer(portIndex, i));
703    }
704
705    mDealer[portIndex].clear();
706
707    return OK;
708}
709
710status_t ACodec::freeOutputBuffersNotOwnedByComponent() {
711    for (size_t i = mBuffers[kPortIndexOutput].size(); i-- > 0;) {
712        BufferInfo *info =
713            &mBuffers[kPortIndexOutput].editItemAt(i);
714
715        if (info->mStatus !=
716                BufferInfo::OWNED_BY_COMPONENT) {
717            // We shouldn't have sent out any buffers to the client at this
718            // point.
719            CHECK_NE((int)info->mStatus, (int)BufferInfo::OWNED_BY_DOWNSTREAM);
720
721            CHECK_EQ((status_t)OK, freeBuffer(kPortIndexOutput, i));
722        }
723    }
724
725    return OK;
726}
727
728status_t ACodec::freeBuffer(OMX_U32 portIndex, size_t i) {
729    BufferInfo *info = &mBuffers[portIndex].editItemAt(i);
730
731    CHECK(info->mStatus == BufferInfo::OWNED_BY_US
732            || info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW);
733
734    if (portIndex == kPortIndexOutput && mNativeWindow != NULL
735            && info->mStatus == BufferInfo::OWNED_BY_US) {
736        CHECK_EQ((status_t)OK, cancelBufferToNativeWindow(info));
737    }
738
739    CHECK_EQ(mOMX->freeBuffer(
740                mNode, portIndex, info->mBufferID),
741             (status_t)OK);
742
743    mBuffers[portIndex].removeAt(i);
744
745    return OK;
746}
747
748ACodec::BufferInfo *ACodec::findBufferByID(
749        uint32_t portIndex, IOMX::buffer_id bufferID,
750        ssize_t *index) {
751    for (size_t i = 0; i < mBuffers[portIndex].size(); ++i) {
752        BufferInfo *info = &mBuffers[portIndex].editItemAt(i);
753
754        if (info->mBufferID == bufferID) {
755            if (index != NULL) {
756                *index = i;
757            }
758            return info;
759        }
760    }
761
762    TRESPASS();
763
764    return NULL;
765}
766
767status_t ACodec::setComponentRole(
768        bool isEncoder, const char *mime) {
769    struct MimeToRole {
770        const char *mime;
771        const char *decoderRole;
772        const char *encoderRole;
773    };
774
775    static const MimeToRole kMimeToRole[] = {
776        { MEDIA_MIMETYPE_AUDIO_MPEG,
777            "audio_decoder.mp3", "audio_encoder.mp3" },
778        { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I,
779            "audio_decoder.mp1", "audio_encoder.mp1" },
780        { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II,
781            "audio_decoder.mp2", "audio_encoder.mp2" },
782        { MEDIA_MIMETYPE_AUDIO_AMR_NB,
783            "audio_decoder.amrnb", "audio_encoder.amrnb" },
784        { MEDIA_MIMETYPE_AUDIO_AMR_WB,
785            "audio_decoder.amrwb", "audio_encoder.amrwb" },
786        { MEDIA_MIMETYPE_AUDIO_AAC,
787            "audio_decoder.aac", "audio_encoder.aac" },
788        { MEDIA_MIMETYPE_AUDIO_VORBIS,
789            "audio_decoder.vorbis", "audio_encoder.vorbis" },
790        { MEDIA_MIMETYPE_AUDIO_G711_MLAW,
791            "audio_decoder.g711mlaw", "audio_encoder.g711mlaw" },
792        { MEDIA_MIMETYPE_AUDIO_G711_ALAW,
793            "audio_decoder.g711alaw", "audio_encoder.g711alaw" },
794        { MEDIA_MIMETYPE_VIDEO_AVC,
795            "video_decoder.avc", "video_encoder.avc" },
796        { MEDIA_MIMETYPE_VIDEO_MPEG4,
797            "video_decoder.mpeg4", "video_encoder.mpeg4" },
798        { MEDIA_MIMETYPE_VIDEO_H263,
799            "video_decoder.h263", "video_encoder.h263" },
800        { MEDIA_MIMETYPE_VIDEO_VPX,
801            "video_decoder.vpx", "video_encoder.vpx" },
802        { MEDIA_MIMETYPE_AUDIO_RAW,
803            "audio_decoder.raw", "audio_encoder.raw" },
804        { MEDIA_MIMETYPE_AUDIO_FLAC,
805            "audio_decoder.flac", "audio_encoder.flac" },
806        { MEDIA_MIMETYPE_AUDIO_MSGSM,
807            "audio_decoder.gsm", "audio_encoder.gsm" },
808    };
809
810    static const size_t kNumMimeToRole =
811        sizeof(kMimeToRole) / sizeof(kMimeToRole[0]);
812
813    size_t i;
814    for (i = 0; i < kNumMimeToRole; ++i) {
815        if (!strcasecmp(mime, kMimeToRole[i].mime)) {
816            break;
817        }
818    }
819
820    if (i == kNumMimeToRole) {
821        return ERROR_UNSUPPORTED;
822    }
823
824    const char *role =
825        isEncoder ? kMimeToRole[i].encoderRole
826                  : kMimeToRole[i].decoderRole;
827
828    if (role != NULL) {
829        OMX_PARAM_COMPONENTROLETYPE roleParams;
830        InitOMXParams(&roleParams);
831
832        strncpy((char *)roleParams.cRole,
833                role, OMX_MAX_STRINGNAME_SIZE - 1);
834
835        roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0';
836
837        status_t err = mOMX->setParameter(
838                mNode, OMX_IndexParamStandardComponentRole,
839                &roleParams, sizeof(roleParams));
840
841        if (err != OK) {
842            ALOGW("[%s] Failed to set standard component role '%s'.",
843                 mComponentName.c_str(), role);
844
845            return err;
846        }
847    }
848
849    return OK;
850}
851
852status_t ACodec::configureCodec(
853        const char *mime, const sp<AMessage> &msg) {
854    int32_t encoder;
855    if (!msg->findInt32("encoder", &encoder)) {
856        encoder = false;
857    }
858
859    mIsEncoder = encoder;
860
861    status_t err = setComponentRole(encoder /* isEncoder */, mime);
862
863    if (err != OK) {
864        return err;
865    }
866
867    int32_t bitRate = 0;
868    // FLAC encoder doesn't need a bitrate, other encoders do
869    if (encoder && strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC)
870            && !msg->findInt32("bitrate", &bitRate)) {
871        return INVALID_OPERATION;
872    }
873
874    int32_t storeMeta;
875    if (encoder
876            && msg->findInt32("store-metadata-in-buffers", &storeMeta)
877            && storeMeta != 0) {
878        err = mOMX->storeMetaDataInBuffers(mNode, kPortIndexInput, OMX_TRUE);
879
880        if (err != OK) {
881            ALOGE("[%s] storeMetaDataInBuffers failed w/ err %d",
882                  mComponentName.c_str(), err);
883
884            return err;
885        }
886    }
887
888    int32_t prependSPSPPS;
889    if (encoder
890            && msg->findInt32("prepend-sps-pps-to-idr-frames", &prependSPSPPS)
891            && prependSPSPPS != 0) {
892        OMX_INDEXTYPE index;
893        err = mOMX->getExtensionIndex(
894                mNode,
895                "OMX.google.android.index.prependSPSPPSToIDRFrames",
896                &index);
897
898        if (err == OK) {
899            PrependSPSPPSToIDRFramesParams params;
900            InitOMXParams(&params);
901            params.bEnable = OMX_TRUE;
902
903            err = mOMX->setParameter(
904                    mNode, index, &params, sizeof(params));
905        }
906
907        if (err != OK) {
908            ALOGE("Encoder could not be configured to emit SPS/PPS before "
909                  "IDR frames. (err %d)", err);
910
911            return err;
912        }
913    }
914
915    if (!strncasecmp(mime, "video/", 6)) {
916        if (encoder) {
917            err = setupVideoEncoder(mime, msg);
918        } else {
919            int32_t width, height;
920            if (!msg->findInt32("width", &width)
921                    || !msg->findInt32("height", &height)) {
922                err = INVALID_OPERATION;
923            } else {
924                err = setupVideoDecoder(mime, width, height);
925            }
926        }
927    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC)) {
928        int32_t numChannels, sampleRate;
929        if (!msg->findInt32("channel-count", &numChannels)
930                || !msg->findInt32("sample-rate", &sampleRate)) {
931            err = INVALID_OPERATION;
932        } else {
933            int32_t isADTS, aacProfile;
934            if (!msg->findInt32("is-adts", &isADTS)) {
935                isADTS = 0;
936            }
937            if (!msg->findInt32("aac-profile", &aacProfile)) {
938                aacProfile = OMX_AUDIO_AACObjectNull;
939            }
940
941            err = setupAACCodec(
942                    encoder, numChannels, sampleRate, bitRate, aacProfile,
943                    isADTS != 0);
944        }
945    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_NB)) {
946        err = setupAMRCodec(encoder, false /* isWAMR */, bitRate);
947    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_WB)) {
948        err = setupAMRCodec(encoder, true /* isWAMR */, bitRate);
949    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_G711_ALAW)
950            || !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_G711_MLAW)) {
951        // These are PCM-like formats with a fixed sample rate but
952        // a variable number of channels.
953
954        int32_t numChannels;
955        if (!msg->findInt32("channel-count", &numChannels)) {
956            err = INVALID_OPERATION;
957        } else {
958            err = setupG711Codec(encoder, numChannels);
959        }
960    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC)) {
961        int32_t numChannels, sampleRate, compressionLevel = -1;
962        if (encoder &&
963                (!msg->findInt32("channel-count", &numChannels)
964                        || !msg->findInt32("sample-rate", &sampleRate))) {
965            ALOGE("missing channel count or sample rate for FLAC encoder");
966            err = INVALID_OPERATION;
967        } else {
968            if (encoder) {
969                if (!msg->findInt32(
970                            "flac-compression-level", &compressionLevel)) {
971                    compressionLevel = 5;// default FLAC compression level
972                } else if (compressionLevel < 0) {
973                    ALOGW("compression level %d outside [0..8] range, "
974                          "using 0",
975                          compressionLevel);
976                    compressionLevel = 0;
977                } else if (compressionLevel > 8) {
978                    ALOGW("compression level %d outside [0..8] range, "
979                          "using 8",
980                          compressionLevel);
981                    compressionLevel = 8;
982                }
983            }
984            err = setupFlacCodec(
985                    encoder, numChannels, sampleRate, compressionLevel);
986        }
987    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)) {
988        int32_t numChannels, sampleRate;
989        if (encoder
990                || !msg->findInt32("channel-count", &numChannels)
991                || !msg->findInt32("sample-rate", &sampleRate)) {
992            err = INVALID_OPERATION;
993        } else {
994            err = setupRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
995        }
996    }
997
998    if (err != OK) {
999        return err;
1000    }
1001
1002    if (!msg->findInt32("encoder-delay", &mEncoderDelay)) {
1003        mEncoderDelay = 0;
1004    }
1005
1006    if (!msg->findInt32("encoder-padding", &mEncoderPadding)) {
1007        mEncoderPadding = 0;
1008    }
1009
1010    if (msg->findInt32("channel-mask", &mChannelMask)) {
1011        mChannelMaskPresent = true;
1012    } else {
1013        mChannelMaskPresent = false;
1014    }
1015
1016    int32_t maxInputSize;
1017    if (msg->findInt32("max-input-size", &maxInputSize)) {
1018        err = setMinBufferSize(kPortIndexInput, (size_t)maxInputSize);
1019    } else if (!strcmp("OMX.Nvidia.aac.decoder", mComponentName.c_str())) {
1020        err = setMinBufferSize(kPortIndexInput, 8192);  // XXX
1021    }
1022
1023    return err;
1024}
1025
1026status_t ACodec::setMinBufferSize(OMX_U32 portIndex, size_t size) {
1027    OMX_PARAM_PORTDEFINITIONTYPE def;
1028    InitOMXParams(&def);
1029    def.nPortIndex = portIndex;
1030
1031    status_t err = mOMX->getParameter(
1032            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1033
1034    if (err != OK) {
1035        return err;
1036    }
1037
1038    if (def.nBufferSize >= size) {
1039        return OK;
1040    }
1041
1042    def.nBufferSize = size;
1043
1044    err = mOMX->setParameter(
1045            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1046
1047    if (err != OK) {
1048        return err;
1049    }
1050
1051    err = mOMX->getParameter(
1052            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1053
1054    if (err != OK) {
1055        return err;
1056    }
1057
1058    CHECK(def.nBufferSize >= size);
1059
1060    return OK;
1061}
1062
1063status_t ACodec::selectAudioPortFormat(
1064        OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE desiredFormat) {
1065    OMX_AUDIO_PARAM_PORTFORMATTYPE format;
1066    InitOMXParams(&format);
1067
1068    format.nPortIndex = portIndex;
1069    for (OMX_U32 index = 0;; ++index) {
1070        format.nIndex = index;
1071
1072        status_t err = mOMX->getParameter(
1073                mNode, OMX_IndexParamAudioPortFormat,
1074                &format, sizeof(format));
1075
1076        if (err != OK) {
1077            return err;
1078        }
1079
1080        if (format.eEncoding == desiredFormat) {
1081            break;
1082        }
1083    }
1084
1085    return mOMX->setParameter(
1086            mNode, OMX_IndexParamAudioPortFormat, &format, sizeof(format));
1087}
1088
1089status_t ACodec::setupAACCodec(
1090        bool encoder, int32_t numChannels, int32_t sampleRate,
1091        int32_t bitRate, int32_t aacProfile, bool isADTS) {
1092    if (encoder && isADTS) {
1093        return -EINVAL;
1094    }
1095
1096    status_t err = setupRawAudioFormat(
1097            encoder ? kPortIndexInput : kPortIndexOutput,
1098            sampleRate,
1099            numChannels);
1100
1101    if (err != OK) {
1102        return err;
1103    }
1104
1105    if (encoder) {
1106        err = selectAudioPortFormat(kPortIndexOutput, OMX_AUDIO_CodingAAC);
1107
1108        if (err != OK) {
1109            return err;
1110        }
1111
1112        OMX_PARAM_PORTDEFINITIONTYPE def;
1113        InitOMXParams(&def);
1114        def.nPortIndex = kPortIndexOutput;
1115
1116        err = mOMX->getParameter(
1117                mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1118
1119        if (err != OK) {
1120            return err;
1121        }
1122
1123        def.format.audio.bFlagErrorConcealment = OMX_TRUE;
1124        def.format.audio.eEncoding = OMX_AUDIO_CodingAAC;
1125
1126        err = mOMX->setParameter(
1127                mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1128
1129        if (err != OK) {
1130            return err;
1131        }
1132
1133        OMX_AUDIO_PARAM_AACPROFILETYPE profile;
1134        InitOMXParams(&profile);
1135        profile.nPortIndex = kPortIndexOutput;
1136
1137        err = mOMX->getParameter(
1138                mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
1139
1140        if (err != OK) {
1141            return err;
1142        }
1143
1144        profile.nChannels = numChannels;
1145
1146        profile.eChannelMode =
1147            (numChannels == 1)
1148                ? OMX_AUDIO_ChannelModeMono: OMX_AUDIO_ChannelModeStereo;
1149
1150        profile.nSampleRate = sampleRate;
1151        profile.nBitRate = bitRate;
1152        profile.nAudioBandWidth = 0;
1153        profile.nFrameLength = 0;
1154        profile.nAACtools = OMX_AUDIO_AACToolAll;
1155        profile.nAACERtools = OMX_AUDIO_AACERNone;
1156        profile.eAACProfile = (OMX_AUDIO_AACPROFILETYPE) aacProfile;
1157        profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4FF;
1158
1159        err = mOMX->setParameter(
1160                mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
1161
1162        if (err != OK) {
1163            return err;
1164        }
1165
1166        return err;
1167    }
1168
1169    OMX_AUDIO_PARAM_AACPROFILETYPE profile;
1170    InitOMXParams(&profile);
1171    profile.nPortIndex = kPortIndexInput;
1172
1173    err = mOMX->getParameter(
1174            mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
1175
1176    if (err != OK) {
1177        return err;
1178    }
1179
1180    profile.nChannels = numChannels;
1181    profile.nSampleRate = sampleRate;
1182
1183    profile.eAACStreamFormat =
1184        isADTS
1185            ? OMX_AUDIO_AACStreamFormatMP4ADTS
1186            : OMX_AUDIO_AACStreamFormatMP4FF;
1187
1188    return mOMX->setParameter(
1189            mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
1190}
1191
1192static OMX_AUDIO_AMRBANDMODETYPE pickModeFromBitRate(
1193        bool isAMRWB, int32_t bps) {
1194    if (isAMRWB) {
1195        if (bps <= 6600) {
1196            return OMX_AUDIO_AMRBandModeWB0;
1197        } else if (bps <= 8850) {
1198            return OMX_AUDIO_AMRBandModeWB1;
1199        } else if (bps <= 12650) {
1200            return OMX_AUDIO_AMRBandModeWB2;
1201        } else if (bps <= 14250) {
1202            return OMX_AUDIO_AMRBandModeWB3;
1203        } else if (bps <= 15850) {
1204            return OMX_AUDIO_AMRBandModeWB4;
1205        } else if (bps <= 18250) {
1206            return OMX_AUDIO_AMRBandModeWB5;
1207        } else if (bps <= 19850) {
1208            return OMX_AUDIO_AMRBandModeWB6;
1209        } else if (bps <= 23050) {
1210            return OMX_AUDIO_AMRBandModeWB7;
1211        }
1212
1213        // 23850 bps
1214        return OMX_AUDIO_AMRBandModeWB8;
1215    } else {  // AMRNB
1216        if (bps <= 4750) {
1217            return OMX_AUDIO_AMRBandModeNB0;
1218        } else if (bps <= 5150) {
1219            return OMX_AUDIO_AMRBandModeNB1;
1220        } else if (bps <= 5900) {
1221            return OMX_AUDIO_AMRBandModeNB2;
1222        } else if (bps <= 6700) {
1223            return OMX_AUDIO_AMRBandModeNB3;
1224        } else if (bps <= 7400) {
1225            return OMX_AUDIO_AMRBandModeNB4;
1226        } else if (bps <= 7950) {
1227            return OMX_AUDIO_AMRBandModeNB5;
1228        } else if (bps <= 10200) {
1229            return OMX_AUDIO_AMRBandModeNB6;
1230        }
1231
1232        // 12200 bps
1233        return OMX_AUDIO_AMRBandModeNB7;
1234    }
1235}
1236
1237status_t ACodec::setupAMRCodec(bool encoder, bool isWAMR, int32_t bitrate) {
1238    OMX_AUDIO_PARAM_AMRTYPE def;
1239    InitOMXParams(&def);
1240    def.nPortIndex = encoder ? kPortIndexOutput : kPortIndexInput;
1241
1242    status_t err =
1243        mOMX->getParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
1244
1245    if (err != OK) {
1246        return err;
1247    }
1248
1249    def.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatFSF;
1250    def.eAMRBandMode = pickModeFromBitRate(isWAMR, bitrate);
1251
1252    err = mOMX->setParameter(
1253            mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
1254
1255    if (err != OK) {
1256        return err;
1257    }
1258
1259    return setupRawAudioFormat(
1260            encoder ? kPortIndexInput : kPortIndexOutput,
1261            isWAMR ? 16000 : 8000 /* sampleRate */,
1262            1 /* numChannels */);
1263}
1264
1265status_t ACodec::setupG711Codec(bool encoder, int32_t numChannels) {
1266    CHECK(!encoder);  // XXX TODO
1267
1268    return setupRawAudioFormat(
1269            kPortIndexInput, 8000 /* sampleRate */, numChannels);
1270}
1271
1272status_t ACodec::setupFlacCodec(
1273        bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel) {
1274
1275    if (encoder) {
1276        OMX_AUDIO_PARAM_FLACTYPE def;
1277        InitOMXParams(&def);
1278        def.nPortIndex = kPortIndexOutput;
1279
1280        // configure compression level
1281        status_t err = mOMX->getParameter(mNode, OMX_IndexParamAudioFlac, &def, sizeof(def));
1282        if (err != OK) {
1283            ALOGE("setupFlacCodec(): Error %d getting OMX_IndexParamAudioFlac parameter", err);
1284            return err;
1285        }
1286        def.nCompressionLevel = compressionLevel;
1287        err = mOMX->setParameter(mNode, OMX_IndexParamAudioFlac, &def, sizeof(def));
1288        if (err != OK) {
1289            ALOGE("setupFlacCodec(): Error %d setting OMX_IndexParamAudioFlac parameter", err);
1290            return err;
1291        }
1292    }
1293
1294    return setupRawAudioFormat(
1295            encoder ? kPortIndexInput : kPortIndexOutput,
1296            sampleRate,
1297            numChannels);
1298}
1299
1300status_t ACodec::setupRawAudioFormat(
1301        OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels) {
1302    OMX_PARAM_PORTDEFINITIONTYPE def;
1303    InitOMXParams(&def);
1304    def.nPortIndex = portIndex;
1305
1306    status_t err = mOMX->getParameter(
1307            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1308
1309    if (err != OK) {
1310        return err;
1311    }
1312
1313    def.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
1314
1315    err = mOMX->setParameter(
1316            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1317
1318    if (err != OK) {
1319        return err;
1320    }
1321
1322    OMX_AUDIO_PARAM_PCMMODETYPE pcmParams;
1323    InitOMXParams(&pcmParams);
1324    pcmParams.nPortIndex = portIndex;
1325
1326    err = mOMX->getParameter(
1327            mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams));
1328
1329    if (err != OK) {
1330        return err;
1331    }
1332
1333    pcmParams.nChannels = numChannels;
1334    pcmParams.eNumData = OMX_NumericalDataSigned;
1335    pcmParams.bInterleaved = OMX_TRUE;
1336    pcmParams.nBitPerSample = 16;
1337    pcmParams.nSamplingRate = sampleRate;
1338    pcmParams.ePCMMode = OMX_AUDIO_PCMModeLinear;
1339
1340    if (getOMXChannelMapping(numChannels, pcmParams.eChannelMapping) != OK) {
1341        return OMX_ErrorNone;
1342    }
1343
1344    return mOMX->setParameter(
1345            mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams));
1346}
1347
1348status_t ACodec::setVideoPortFormatType(
1349        OMX_U32 portIndex,
1350        OMX_VIDEO_CODINGTYPE compressionFormat,
1351        OMX_COLOR_FORMATTYPE colorFormat) {
1352    OMX_VIDEO_PARAM_PORTFORMATTYPE format;
1353    InitOMXParams(&format);
1354    format.nPortIndex = portIndex;
1355    format.nIndex = 0;
1356    bool found = false;
1357
1358    OMX_U32 index = 0;
1359    for (;;) {
1360        format.nIndex = index;
1361        status_t err = mOMX->getParameter(
1362                mNode, OMX_IndexParamVideoPortFormat,
1363                &format, sizeof(format));
1364
1365        if (err != OK) {
1366            return err;
1367        }
1368
1369        // The following assertion is violated by TI's video decoder.
1370        // CHECK_EQ(format.nIndex, index);
1371
1372        if (!strcmp("OMX.TI.Video.encoder", mComponentName.c_str())) {
1373            if (portIndex == kPortIndexInput
1374                    && colorFormat == format.eColorFormat) {
1375                // eCompressionFormat does not seem right.
1376                found = true;
1377                break;
1378            }
1379            if (portIndex == kPortIndexOutput
1380                    && compressionFormat == format.eCompressionFormat) {
1381                // eColorFormat does not seem right.
1382                found = true;
1383                break;
1384            }
1385        }
1386
1387        if (format.eCompressionFormat == compressionFormat
1388            && format.eColorFormat == colorFormat) {
1389            found = true;
1390            break;
1391        }
1392
1393        ++index;
1394    }
1395
1396    if (!found) {
1397        return UNKNOWN_ERROR;
1398    }
1399
1400    status_t err = mOMX->setParameter(
1401            mNode, OMX_IndexParamVideoPortFormat,
1402            &format, sizeof(format));
1403
1404    return err;
1405}
1406
1407status_t ACodec::setSupportedOutputFormat() {
1408    OMX_VIDEO_PARAM_PORTFORMATTYPE format;
1409    InitOMXParams(&format);
1410    format.nPortIndex = kPortIndexOutput;
1411    format.nIndex = 0;
1412
1413    status_t err = mOMX->getParameter(
1414            mNode, OMX_IndexParamVideoPortFormat,
1415            &format, sizeof(format));
1416    CHECK_EQ(err, (status_t)OK);
1417    CHECK_EQ((int)format.eCompressionFormat, (int)OMX_VIDEO_CodingUnused);
1418
1419    CHECK(format.eColorFormat == OMX_COLOR_FormatYUV420Planar
1420           || format.eColorFormat == OMX_COLOR_FormatYUV420SemiPlanar
1421           || format.eColorFormat == OMX_COLOR_FormatCbYCrY
1422           || format.eColorFormat == OMX_TI_COLOR_FormatYUV420PackedSemiPlanar
1423           || format.eColorFormat == OMX_QCOM_COLOR_FormatYVU420SemiPlanar
1424           || format.eColorFormat == OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka);
1425
1426    return mOMX->setParameter(
1427            mNode, OMX_IndexParamVideoPortFormat,
1428            &format, sizeof(format));
1429}
1430
1431static status_t GetVideoCodingTypeFromMime(
1432        const char *mime, OMX_VIDEO_CODINGTYPE *codingType) {
1433    if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mime)) {
1434        *codingType = OMX_VIDEO_CodingAVC;
1435    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG4, mime)) {
1436        *codingType = OMX_VIDEO_CodingMPEG4;
1437    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_H263, mime)) {
1438        *codingType = OMX_VIDEO_CodingH263;
1439    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG2, mime)) {
1440        *codingType = OMX_VIDEO_CodingMPEG2;
1441    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_VPX, mime)) {
1442        *codingType = OMX_VIDEO_CodingVPX;
1443    } else {
1444        *codingType = OMX_VIDEO_CodingUnused;
1445        return ERROR_UNSUPPORTED;
1446    }
1447
1448    return OK;
1449}
1450
1451status_t ACodec::setupVideoDecoder(
1452        const char *mime, int32_t width, int32_t height) {
1453    OMX_VIDEO_CODINGTYPE compressionFormat;
1454    status_t err = GetVideoCodingTypeFromMime(mime, &compressionFormat);
1455
1456    if (err != OK) {
1457        return err;
1458    }
1459
1460    err = setVideoPortFormatType(
1461            kPortIndexInput, compressionFormat, OMX_COLOR_FormatUnused);
1462
1463    if (err != OK) {
1464        return err;
1465    }
1466
1467    err = setSupportedOutputFormat();
1468
1469    if (err != OK) {
1470        return err;
1471    }
1472
1473    err = setVideoFormatOnPort(
1474            kPortIndexInput, width, height, compressionFormat);
1475
1476    if (err != OK) {
1477        return err;
1478    }
1479
1480    err = setVideoFormatOnPort(
1481            kPortIndexOutput, width, height, OMX_VIDEO_CodingUnused);
1482
1483    if (err != OK) {
1484        return err;
1485    }
1486
1487    return OK;
1488}
1489
1490status_t ACodec::setupVideoEncoder(const char *mime, const sp<AMessage> &msg) {
1491    int32_t tmp;
1492    if (!msg->findInt32("color-format", &tmp)) {
1493        return INVALID_OPERATION;
1494    }
1495
1496    OMX_COLOR_FORMATTYPE colorFormat =
1497        static_cast<OMX_COLOR_FORMATTYPE>(tmp);
1498
1499    status_t err = setVideoPortFormatType(
1500            kPortIndexInput, OMX_VIDEO_CodingUnused, colorFormat);
1501
1502    if (err != OK) {
1503        ALOGE("[%s] does not support color format %d",
1504              mComponentName.c_str(), colorFormat);
1505
1506        return err;
1507    }
1508
1509    /* Input port configuration */
1510
1511    OMX_PARAM_PORTDEFINITIONTYPE def;
1512    InitOMXParams(&def);
1513
1514    OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
1515
1516    def.nPortIndex = kPortIndexInput;
1517
1518    err = mOMX->getParameter(
1519            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1520
1521    if (err != OK) {
1522        return err;
1523    }
1524
1525    int32_t width, height, bitrate;
1526    if (!msg->findInt32("width", &width)
1527            || !msg->findInt32("height", &height)
1528            || !msg->findInt32("bitrate", &bitrate)) {
1529        return INVALID_OPERATION;
1530    }
1531
1532    video_def->nFrameWidth = width;
1533    video_def->nFrameHeight = height;
1534
1535    int32_t stride;
1536    if (!msg->findInt32("stride", &stride)) {
1537        stride = width;
1538    }
1539
1540    video_def->nStride = stride;
1541
1542    int32_t sliceHeight;
1543    if (!msg->findInt32("slice-height", &sliceHeight)) {
1544        sliceHeight = height;
1545    }
1546
1547    video_def->nSliceHeight = sliceHeight;
1548
1549    def.nBufferSize = (video_def->nStride * video_def->nSliceHeight * 3) / 2;
1550
1551    float frameRate;
1552    if (!msg->findFloat("frame-rate", &frameRate)) {
1553        int32_t tmp;
1554        if (!msg->findInt32("frame-rate", &tmp)) {
1555            return INVALID_OPERATION;
1556        }
1557        frameRate = (float)tmp;
1558    }
1559
1560    video_def->xFramerate = (OMX_U32)(frameRate * 65536.0f);
1561    video_def->eCompressionFormat = OMX_VIDEO_CodingUnused;
1562    video_def->eColorFormat = colorFormat;
1563
1564    err = mOMX->setParameter(
1565            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1566
1567    if (err != OK) {
1568        ALOGE("[%s] failed to set input port definition parameters.",
1569              mComponentName.c_str());
1570
1571        return err;
1572    }
1573
1574    /* Output port configuration */
1575
1576    OMX_VIDEO_CODINGTYPE compressionFormat;
1577    err = GetVideoCodingTypeFromMime(mime, &compressionFormat);
1578
1579    if (err != OK) {
1580        return err;
1581    }
1582
1583    err = setVideoPortFormatType(
1584            kPortIndexOutput, compressionFormat, OMX_COLOR_FormatUnused);
1585
1586    if (err != OK) {
1587        ALOGE("[%s] does not support compression format %d",
1588             mComponentName.c_str(), compressionFormat);
1589
1590        return err;
1591    }
1592
1593    def.nPortIndex = kPortIndexOutput;
1594
1595    err = mOMX->getParameter(
1596            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1597
1598    if (err != OK) {
1599        return err;
1600    }
1601
1602    video_def->nFrameWidth = width;
1603    video_def->nFrameHeight = height;
1604    video_def->xFramerate = 0;
1605    video_def->nBitrate = bitrate;
1606    video_def->eCompressionFormat = compressionFormat;
1607    video_def->eColorFormat = OMX_COLOR_FormatUnused;
1608
1609    err = mOMX->setParameter(
1610            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1611
1612    if (err != OK) {
1613        ALOGE("[%s] failed to set output port definition parameters.",
1614              mComponentName.c_str());
1615
1616        return err;
1617    }
1618
1619    switch (compressionFormat) {
1620        case OMX_VIDEO_CodingMPEG4:
1621            err = setupMPEG4EncoderParameters(msg);
1622            break;
1623
1624        case OMX_VIDEO_CodingH263:
1625            err = setupH263EncoderParameters(msg);
1626            break;
1627
1628        case OMX_VIDEO_CodingAVC:
1629            err = setupAVCEncoderParameters(msg);
1630            break;
1631
1632        default:
1633            break;
1634    }
1635
1636    ALOGI("setupVideoEncoder succeeded");
1637
1638    return err;
1639}
1640
1641status_t ACodec::setCyclicIntraMacroblockRefresh(const sp<AMessage> &msg, int32_t mode) {
1642    OMX_VIDEO_PARAM_INTRAREFRESHTYPE params;
1643    InitOMXParams(&params);
1644    params.nPortIndex = kPortIndexOutput;
1645
1646    params.eRefreshMode = static_cast<OMX_VIDEO_INTRAREFRESHTYPE>(mode);
1647
1648    if (params.eRefreshMode == OMX_VIDEO_IntraRefreshCyclic ||
1649            params.eRefreshMode == OMX_VIDEO_IntraRefreshBoth) {
1650        int32_t mbs;
1651        if (!msg->findInt32("intra-refresh-CIR-mbs", &mbs)) {
1652            return INVALID_OPERATION;
1653        }
1654        params.nCirMBs = mbs;
1655    }
1656
1657    if (params.eRefreshMode == OMX_VIDEO_IntraRefreshAdaptive ||
1658            params.eRefreshMode == OMX_VIDEO_IntraRefreshBoth) {
1659        int32_t mbs;
1660        if (!msg->findInt32("intra-refresh-AIR-mbs", &mbs)) {
1661            return INVALID_OPERATION;
1662        }
1663        params.nAirMBs = mbs;
1664
1665        int32_t ref;
1666        if (!msg->findInt32("intra-refresh-AIR-ref", &ref)) {
1667            return INVALID_OPERATION;
1668        }
1669        params.nAirRef = ref;
1670    }
1671
1672    status_t err = mOMX->setParameter(
1673            mNode, OMX_IndexParamVideoIntraRefresh,
1674            &params, sizeof(params));
1675    return err;
1676}
1677
1678static OMX_U32 setPFramesSpacing(int32_t iFramesInterval, int32_t frameRate) {
1679    if (iFramesInterval < 0) {
1680        return 0xFFFFFFFF;
1681    } else if (iFramesInterval == 0) {
1682        return 0;
1683    }
1684    OMX_U32 ret = frameRate * iFramesInterval;
1685    CHECK(ret > 1);
1686    return ret;
1687}
1688
1689static OMX_VIDEO_CONTROLRATETYPE getBitrateMode(const sp<AMessage> &msg) {
1690    int32_t tmp;
1691    if (!msg->findInt32("bitrate-mode", &tmp)) {
1692        return OMX_Video_ControlRateVariable;
1693    }
1694
1695    return static_cast<OMX_VIDEO_CONTROLRATETYPE>(tmp);
1696}
1697
1698status_t ACodec::setupMPEG4EncoderParameters(const sp<AMessage> &msg) {
1699    int32_t bitrate, iFrameInterval;
1700    if (!msg->findInt32("bitrate", &bitrate)
1701            || !msg->findInt32("i-frame-interval", &iFrameInterval)) {
1702        return INVALID_OPERATION;
1703    }
1704
1705    OMX_VIDEO_CONTROLRATETYPE bitrateMode = getBitrateMode(msg);
1706
1707    float frameRate;
1708    if (!msg->findFloat("frame-rate", &frameRate)) {
1709        int32_t tmp;
1710        if (!msg->findInt32("frame-rate", &tmp)) {
1711            return INVALID_OPERATION;
1712        }
1713        frameRate = (float)tmp;
1714    }
1715
1716    OMX_VIDEO_PARAM_MPEG4TYPE mpeg4type;
1717    InitOMXParams(&mpeg4type);
1718    mpeg4type.nPortIndex = kPortIndexOutput;
1719
1720    status_t err = mOMX->getParameter(
1721            mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type));
1722
1723    if (err != OK) {
1724        return err;
1725    }
1726
1727    mpeg4type.nSliceHeaderSpacing = 0;
1728    mpeg4type.bSVH = OMX_FALSE;
1729    mpeg4type.bGov = OMX_FALSE;
1730
1731    mpeg4type.nAllowedPictureTypes =
1732        OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
1733
1734    mpeg4type.nPFrames = setPFramesSpacing(iFrameInterval, frameRate);
1735    if (mpeg4type.nPFrames == 0) {
1736        mpeg4type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
1737    }
1738    mpeg4type.nBFrames = 0;
1739    mpeg4type.nIDCVLCThreshold = 0;
1740    mpeg4type.bACPred = OMX_TRUE;
1741    mpeg4type.nMaxPacketSize = 256;
1742    mpeg4type.nTimeIncRes = 1000;
1743    mpeg4type.nHeaderExtension = 0;
1744    mpeg4type.bReversibleVLC = OMX_FALSE;
1745
1746    int32_t profile;
1747    if (msg->findInt32("profile", &profile)) {
1748        int32_t level;
1749        if (!msg->findInt32("level", &level)) {
1750            return INVALID_OPERATION;
1751        }
1752
1753        err = verifySupportForProfileAndLevel(profile, level);
1754
1755        if (err != OK) {
1756            return err;
1757        }
1758
1759        mpeg4type.eProfile = static_cast<OMX_VIDEO_MPEG4PROFILETYPE>(profile);
1760        mpeg4type.eLevel = static_cast<OMX_VIDEO_MPEG4LEVELTYPE>(level);
1761    }
1762
1763    err = mOMX->setParameter(
1764            mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type));
1765
1766    if (err != OK) {
1767        return err;
1768    }
1769
1770    err = configureBitrate(bitrate, bitrateMode);
1771
1772    if (err != OK) {
1773        return err;
1774    }
1775
1776    return setupErrorCorrectionParameters();
1777}
1778
1779status_t ACodec::setupH263EncoderParameters(const sp<AMessage> &msg) {
1780    int32_t bitrate, iFrameInterval;
1781    if (!msg->findInt32("bitrate", &bitrate)
1782            || !msg->findInt32("i-frame-interval", &iFrameInterval)) {
1783        return INVALID_OPERATION;
1784    }
1785
1786    OMX_VIDEO_CONTROLRATETYPE bitrateMode = getBitrateMode(msg);
1787
1788    float frameRate;
1789    if (!msg->findFloat("frame-rate", &frameRate)) {
1790        int32_t tmp;
1791        if (!msg->findInt32("frame-rate", &tmp)) {
1792            return INVALID_OPERATION;
1793        }
1794        frameRate = (float)tmp;
1795    }
1796
1797    OMX_VIDEO_PARAM_H263TYPE h263type;
1798    InitOMXParams(&h263type);
1799    h263type.nPortIndex = kPortIndexOutput;
1800
1801    status_t err = mOMX->getParameter(
1802            mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type));
1803
1804    if (err != OK) {
1805        return err;
1806    }
1807
1808    h263type.nAllowedPictureTypes =
1809        OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
1810
1811    h263type.nPFrames = setPFramesSpacing(iFrameInterval, frameRate);
1812    if (h263type.nPFrames == 0) {
1813        h263type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
1814    }
1815    h263type.nBFrames = 0;
1816
1817    int32_t profile;
1818    if (msg->findInt32("profile", &profile)) {
1819        int32_t level;
1820        if (!msg->findInt32("level", &level)) {
1821            return INVALID_OPERATION;
1822        }
1823
1824        err = verifySupportForProfileAndLevel(profile, level);
1825
1826        if (err != OK) {
1827            return err;
1828        }
1829
1830        h263type.eProfile = static_cast<OMX_VIDEO_H263PROFILETYPE>(profile);
1831        h263type.eLevel = static_cast<OMX_VIDEO_H263LEVELTYPE>(level);
1832    }
1833
1834    h263type.bPLUSPTYPEAllowed = OMX_FALSE;
1835    h263type.bForceRoundingTypeToZero = OMX_FALSE;
1836    h263type.nPictureHeaderRepetition = 0;
1837    h263type.nGOBHeaderInterval = 0;
1838
1839    err = mOMX->setParameter(
1840            mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type));
1841
1842    if (err != OK) {
1843        return err;
1844    }
1845
1846    err = configureBitrate(bitrate, bitrateMode);
1847
1848    if (err != OK) {
1849        return err;
1850    }
1851
1852    return setupErrorCorrectionParameters();
1853}
1854
1855status_t ACodec::setupAVCEncoderParameters(const sp<AMessage> &msg) {
1856    int32_t bitrate, iFrameInterval;
1857    if (!msg->findInt32("bitrate", &bitrate)
1858            || !msg->findInt32("i-frame-interval", &iFrameInterval)) {
1859        return INVALID_OPERATION;
1860    }
1861
1862    OMX_VIDEO_CONTROLRATETYPE bitrateMode = getBitrateMode(msg);
1863
1864    float frameRate;
1865    if (!msg->findFloat("frame-rate", &frameRate)) {
1866        int32_t tmp;
1867        if (!msg->findInt32("frame-rate", &tmp)) {
1868            return INVALID_OPERATION;
1869        }
1870        frameRate = (float)tmp;
1871    }
1872
1873    status_t err = OK;
1874    int32_t intraRefreshMode = 0;
1875    if (msg->findInt32("intra-refresh-mode", &intraRefreshMode)) {
1876        err = setCyclicIntraMacroblockRefresh(msg, intraRefreshMode);
1877        if (err != OK) {
1878            ALOGE("Setting intra macroblock refresh mode (%d) failed: 0x%x",
1879                    err, intraRefreshMode);
1880            return err;
1881        }
1882    }
1883
1884    OMX_VIDEO_PARAM_AVCTYPE h264type;
1885    InitOMXParams(&h264type);
1886    h264type.nPortIndex = kPortIndexOutput;
1887
1888    err = mOMX->getParameter(
1889            mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));
1890
1891    if (err != OK) {
1892        return err;
1893    }
1894
1895    h264type.nAllowedPictureTypes =
1896        OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
1897
1898    int32_t profile;
1899    if (msg->findInt32("profile", &profile)) {
1900        int32_t level;
1901        if (!msg->findInt32("level", &level)) {
1902            return INVALID_OPERATION;
1903        }
1904
1905        err = verifySupportForProfileAndLevel(profile, level);
1906
1907        if (err != OK) {
1908            return err;
1909        }
1910
1911        h264type.eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>(profile);
1912        h264type.eLevel = static_cast<OMX_VIDEO_AVCLEVELTYPE>(level);
1913    }
1914
1915    // XXX
1916    if (h264type.eProfile != OMX_VIDEO_AVCProfileBaseline) {
1917        ALOGW("Use baseline profile instead of %d for AVC recording",
1918            h264type.eProfile);
1919        h264type.eProfile = OMX_VIDEO_AVCProfileBaseline;
1920    }
1921
1922    if (h264type.eProfile == OMX_VIDEO_AVCProfileBaseline) {
1923        h264type.nSliceHeaderSpacing = 0;
1924        h264type.bUseHadamard = OMX_TRUE;
1925        h264type.nRefFrames = 1;
1926        h264type.nBFrames = 0;
1927        h264type.nPFrames = setPFramesSpacing(iFrameInterval, frameRate);
1928        if (h264type.nPFrames == 0) {
1929            h264type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
1930        }
1931        h264type.nRefIdx10ActiveMinus1 = 0;
1932        h264type.nRefIdx11ActiveMinus1 = 0;
1933        h264type.bEntropyCodingCABAC = OMX_FALSE;
1934        h264type.bWeightedPPrediction = OMX_FALSE;
1935        h264type.bconstIpred = OMX_FALSE;
1936        h264type.bDirect8x8Inference = OMX_FALSE;
1937        h264type.bDirectSpatialTemporal = OMX_FALSE;
1938        h264type.nCabacInitIdc = 0;
1939    }
1940
1941    if (h264type.nBFrames != 0) {
1942        h264type.nAllowedPictureTypes |= OMX_VIDEO_PictureTypeB;
1943    }
1944
1945    h264type.bEnableUEP = OMX_FALSE;
1946    h264type.bEnableFMO = OMX_FALSE;
1947    h264type.bEnableASO = OMX_FALSE;
1948    h264type.bEnableRS = OMX_FALSE;
1949    h264type.bFrameMBsOnly = OMX_TRUE;
1950    h264type.bMBAFF = OMX_FALSE;
1951    h264type.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable;
1952
1953    err = mOMX->setParameter(
1954            mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));
1955
1956    if (err != OK) {
1957        return err;
1958    }
1959
1960    return configureBitrate(bitrate, bitrateMode);
1961}
1962
1963status_t ACodec::verifySupportForProfileAndLevel(
1964        int32_t profile, int32_t level) {
1965    OMX_VIDEO_PARAM_PROFILELEVELTYPE params;
1966    InitOMXParams(&params);
1967    params.nPortIndex = kPortIndexOutput;
1968
1969    for (params.nProfileIndex = 0;; ++params.nProfileIndex) {
1970        status_t err = mOMX->getParameter(
1971                mNode,
1972                OMX_IndexParamVideoProfileLevelQuerySupported,
1973                &params,
1974                sizeof(params));
1975
1976        if (err != OK) {
1977            return err;
1978        }
1979
1980        int32_t supportedProfile = static_cast<int32_t>(params.eProfile);
1981        int32_t supportedLevel = static_cast<int32_t>(params.eLevel);
1982
1983        if (profile == supportedProfile && level <= supportedLevel) {
1984            return OK;
1985        }
1986    }
1987}
1988
1989status_t ACodec::configureBitrate(
1990        int32_t bitrate, OMX_VIDEO_CONTROLRATETYPE bitrateMode) {
1991    OMX_VIDEO_PARAM_BITRATETYPE bitrateType;
1992    InitOMXParams(&bitrateType);
1993    bitrateType.nPortIndex = kPortIndexOutput;
1994
1995    status_t err = mOMX->getParameter(
1996            mNode, OMX_IndexParamVideoBitrate,
1997            &bitrateType, sizeof(bitrateType));
1998
1999    if (err != OK) {
2000        return err;
2001    }
2002
2003    bitrateType.eControlRate = bitrateMode;
2004    bitrateType.nTargetBitrate = bitrate;
2005
2006    return mOMX->setParameter(
2007            mNode, OMX_IndexParamVideoBitrate,
2008            &bitrateType, sizeof(bitrateType));
2009}
2010
2011status_t ACodec::setupErrorCorrectionParameters() {
2012    OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType;
2013    InitOMXParams(&errorCorrectionType);
2014    errorCorrectionType.nPortIndex = kPortIndexOutput;
2015
2016    status_t err = mOMX->getParameter(
2017            mNode, OMX_IndexParamVideoErrorCorrection,
2018            &errorCorrectionType, sizeof(errorCorrectionType));
2019
2020    if (err != OK) {
2021        return OK;  // Optional feature. Ignore this failure
2022    }
2023
2024    errorCorrectionType.bEnableHEC = OMX_FALSE;
2025    errorCorrectionType.bEnableResync = OMX_TRUE;
2026    errorCorrectionType.nResynchMarkerSpacing = 256;
2027    errorCorrectionType.bEnableDataPartitioning = OMX_FALSE;
2028    errorCorrectionType.bEnableRVLC = OMX_FALSE;
2029
2030    return mOMX->setParameter(
2031            mNode, OMX_IndexParamVideoErrorCorrection,
2032            &errorCorrectionType, sizeof(errorCorrectionType));
2033}
2034
2035status_t ACodec::setVideoFormatOnPort(
2036        OMX_U32 portIndex,
2037        int32_t width, int32_t height, OMX_VIDEO_CODINGTYPE compressionFormat) {
2038    OMX_PARAM_PORTDEFINITIONTYPE def;
2039    InitOMXParams(&def);
2040    def.nPortIndex = portIndex;
2041
2042    OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
2043
2044    status_t err = mOMX->getParameter(
2045            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
2046
2047    CHECK_EQ(err, (status_t)OK);
2048
2049    if (portIndex == kPortIndexInput) {
2050        // XXX Need a (much) better heuristic to compute input buffer sizes.
2051        const size_t X = 64 * 1024;
2052        if (def.nBufferSize < X) {
2053            def.nBufferSize = X;
2054        }
2055    }
2056
2057    CHECK_EQ((int)def.eDomain, (int)OMX_PortDomainVideo);
2058
2059    video_def->nFrameWidth = width;
2060    video_def->nFrameHeight = height;
2061
2062    if (portIndex == kPortIndexInput) {
2063        video_def->eCompressionFormat = compressionFormat;
2064        video_def->eColorFormat = OMX_COLOR_FormatUnused;
2065    }
2066
2067    err = mOMX->setParameter(
2068            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
2069
2070    return err;
2071}
2072
2073status_t ACodec::initNativeWindow() {
2074    if (mNativeWindow != NULL) {
2075        return mOMX->enableGraphicBuffers(mNode, kPortIndexOutput, OMX_TRUE);
2076    }
2077
2078    mOMX->enableGraphicBuffers(mNode, kPortIndexOutput, OMX_FALSE);
2079    return OK;
2080}
2081
2082size_t ACodec::countBuffersOwnedByComponent(OMX_U32 portIndex) const {
2083    size_t n = 0;
2084
2085    for (size_t i = 0; i < mBuffers[portIndex].size(); ++i) {
2086        const BufferInfo &info = mBuffers[portIndex].itemAt(i);
2087
2088        if (info.mStatus == BufferInfo::OWNED_BY_COMPONENT) {
2089            ++n;
2090        }
2091    }
2092
2093    return n;
2094}
2095
2096bool ACodec::allYourBuffersAreBelongToUs(
2097        OMX_U32 portIndex) {
2098    for (size_t i = 0; i < mBuffers[portIndex].size(); ++i) {
2099        BufferInfo *info = &mBuffers[portIndex].editItemAt(i);
2100
2101        if (info->mStatus != BufferInfo::OWNED_BY_US
2102                && info->mStatus != BufferInfo::OWNED_BY_NATIVE_WINDOW) {
2103            ALOGV("[%s] Buffer %p on port %ld still has status %d",
2104                    mComponentName.c_str(),
2105                    info->mBufferID, portIndex, info->mStatus);
2106            return false;
2107        }
2108    }
2109
2110    return true;
2111}
2112
2113bool ACodec::allYourBuffersAreBelongToUs() {
2114    return allYourBuffersAreBelongToUs(kPortIndexInput)
2115        && allYourBuffersAreBelongToUs(kPortIndexOutput);
2116}
2117
2118void ACodec::deferMessage(const sp<AMessage> &msg) {
2119    bool wasEmptyBefore = mDeferredQueue.empty();
2120    mDeferredQueue.push_back(msg);
2121}
2122
2123void ACodec::processDeferredMessages() {
2124    List<sp<AMessage> > queue = mDeferredQueue;
2125    mDeferredQueue.clear();
2126
2127    List<sp<AMessage> >::iterator it = queue.begin();
2128    while (it != queue.end()) {
2129        onMessageReceived(*it++);
2130    }
2131}
2132
2133void ACodec::sendFormatChange() {
2134    sp<AMessage> notify = mNotify->dup();
2135    notify->setInt32("what", kWhatOutputFormatChanged);
2136
2137    OMX_PARAM_PORTDEFINITIONTYPE def;
2138    InitOMXParams(&def);
2139    def.nPortIndex = kPortIndexOutput;
2140
2141    CHECK_EQ(mOMX->getParameter(
2142                mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)),
2143             (status_t)OK);
2144
2145    CHECK_EQ((int)def.eDir, (int)OMX_DirOutput);
2146
2147    switch (def.eDomain) {
2148        case OMX_PortDomainVideo:
2149        {
2150            OMX_VIDEO_PORTDEFINITIONTYPE *videoDef = &def.format.video;
2151
2152            notify->setString("mime", MEDIA_MIMETYPE_VIDEO_RAW);
2153            notify->setInt32("width", videoDef->nFrameWidth);
2154            notify->setInt32("height", videoDef->nFrameHeight);
2155            notify->setInt32("stride", videoDef->nStride);
2156            notify->setInt32("slice-height", videoDef->nSliceHeight);
2157            notify->setInt32("color-format", videoDef->eColorFormat);
2158
2159            OMX_CONFIG_RECTTYPE rect;
2160            InitOMXParams(&rect);
2161            rect.nPortIndex = kPortIndexOutput;
2162
2163            if (mOMX->getConfig(
2164                        mNode, OMX_IndexConfigCommonOutputCrop,
2165                        &rect, sizeof(rect)) != OK) {
2166                rect.nLeft = 0;
2167                rect.nTop = 0;
2168                rect.nWidth = videoDef->nFrameWidth;
2169                rect.nHeight = videoDef->nFrameHeight;
2170            }
2171
2172            CHECK_GE(rect.nLeft, 0);
2173            CHECK_GE(rect.nTop, 0);
2174            CHECK_GE(rect.nWidth, 0u);
2175            CHECK_GE(rect.nHeight, 0u);
2176            CHECK_LE(rect.nLeft + rect.nWidth - 1, videoDef->nFrameWidth);
2177            CHECK_LE(rect.nTop + rect.nHeight - 1, videoDef->nFrameHeight);
2178
2179            notify->setRect(
2180                    "crop",
2181                    rect.nLeft,
2182                    rect.nTop,
2183                    rect.nLeft + rect.nWidth - 1,
2184                    rect.nTop + rect.nHeight - 1);
2185
2186            if (mNativeWindow != NULL) {
2187                android_native_rect_t crop;
2188                crop.left = rect.nLeft;
2189                crop.top = rect.nTop;
2190                crop.right = rect.nLeft + rect.nWidth;
2191                crop.bottom = rect.nTop + rect.nHeight;
2192
2193                CHECK_EQ(0, native_window_set_crop(
2194                            mNativeWindow.get(), &crop));
2195            }
2196            break;
2197        }
2198
2199        case OMX_PortDomainAudio:
2200        {
2201            OMX_AUDIO_PORTDEFINITIONTYPE *audioDef = &def.format.audio;
2202            CHECK_EQ((int)audioDef->eEncoding, (int)OMX_AUDIO_CodingPCM);
2203
2204            OMX_AUDIO_PARAM_PCMMODETYPE params;
2205            InitOMXParams(&params);
2206            params.nPortIndex = kPortIndexOutput;
2207
2208            CHECK_EQ(mOMX->getParameter(
2209                        mNode, OMX_IndexParamAudioPcm,
2210                        &params, sizeof(params)),
2211                     (status_t)OK);
2212
2213            CHECK(params.nChannels == 1 || params.bInterleaved);
2214            CHECK_EQ(params.nBitPerSample, 16u);
2215            CHECK_EQ((int)params.eNumData, (int)OMX_NumericalDataSigned);
2216            CHECK_EQ((int)params.ePCMMode, (int)OMX_AUDIO_PCMModeLinear);
2217
2218            notify->setString("mime", MEDIA_MIMETYPE_AUDIO_RAW);
2219            notify->setInt32("channel-count", params.nChannels);
2220            notify->setInt32("sample-rate", params.nSamplingRate);
2221            if (mEncoderDelay + mEncoderPadding) {
2222                size_t frameSize = params.nChannels * sizeof(int16_t);
2223                if (mSkipCutBuffer != NULL) {
2224                    size_t prevbufsize = mSkipCutBuffer->size();
2225                    if (prevbufsize != 0) {
2226                        ALOGW("Replacing SkipCutBuffer holding %d bytes", prevbufsize);
2227                    }
2228                }
2229                mSkipCutBuffer = new SkipCutBuffer(mEncoderDelay * frameSize,
2230                                                   mEncoderPadding * frameSize);
2231            }
2232
2233            if (mChannelMaskPresent) {
2234                notify->setInt32("channel-mask", mChannelMask);
2235            }
2236
2237            break;
2238        }
2239
2240        default:
2241            TRESPASS();
2242    }
2243
2244    notify->post();
2245
2246    mSentFormat = true;
2247}
2248
2249void ACodec::signalError(OMX_ERRORTYPE error, status_t internalError) {
2250    sp<AMessage> notify = mNotify->dup();
2251    notify->setInt32("what", ACodec::kWhatError);
2252    notify->setInt32("omx-error", error);
2253    notify->setInt32("err", internalError);
2254    notify->post();
2255}
2256
2257status_t ACodec::pushBlankBuffersToNativeWindow() {
2258    status_t err = NO_ERROR;
2259    ANativeWindowBuffer* anb = NULL;
2260    int numBufs = 0;
2261    int minUndequeuedBufs = 0;
2262
2263    // We need to reconnect to the ANativeWindow as a CPU client to ensure that
2264    // no frames get dropped by SurfaceFlinger assuming that these are video
2265    // frames.
2266    err = native_window_api_disconnect(mNativeWindow.get(),
2267            NATIVE_WINDOW_API_MEDIA);
2268    if (err != NO_ERROR) {
2269        ALOGE("error pushing blank frames: api_disconnect failed: %s (%d)",
2270                strerror(-err), -err);
2271        return err;
2272    }
2273
2274    err = native_window_api_connect(mNativeWindow.get(),
2275            NATIVE_WINDOW_API_CPU);
2276    if (err != NO_ERROR) {
2277        ALOGE("error pushing blank frames: api_connect failed: %s (%d)",
2278                strerror(-err), -err);
2279        return err;
2280    }
2281
2282    err = native_window_set_buffers_geometry(mNativeWindow.get(), 1, 1,
2283            HAL_PIXEL_FORMAT_RGBX_8888);
2284    if (err != NO_ERROR) {
2285        ALOGE("error pushing blank frames: set_buffers_geometry failed: %s (%d)",
2286                strerror(-err), -err);
2287        goto error;
2288    }
2289
2290    err = native_window_set_usage(mNativeWindow.get(),
2291            GRALLOC_USAGE_SW_WRITE_OFTEN);
2292    if (err != NO_ERROR) {
2293        ALOGE("error pushing blank frames: set_usage failed: %s (%d)",
2294                strerror(-err), -err);
2295        goto error;
2296    }
2297
2298    err = mNativeWindow->query(mNativeWindow.get(),
2299            NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBufs);
2300    if (err != NO_ERROR) {
2301        ALOGE("error pushing blank frames: MIN_UNDEQUEUED_BUFFERS query "
2302                "failed: %s (%d)", strerror(-err), -err);
2303        goto error;
2304    }
2305
2306    numBufs = minUndequeuedBufs + 1;
2307    err = native_window_set_buffer_count(mNativeWindow.get(), numBufs);
2308    if (err != NO_ERROR) {
2309        ALOGE("error pushing blank frames: set_buffer_count failed: %s (%d)",
2310                strerror(-err), -err);
2311        goto error;
2312    }
2313
2314    // We  push numBufs + 1 buffers to ensure that we've drawn into the same
2315    // buffer twice.  This should guarantee that the buffer has been displayed
2316    // on the screen and then been replaced, so an previous video frames are
2317    // guaranteed NOT to be currently displayed.
2318    for (int i = 0; i < numBufs + 1; i++) {
2319        int fenceFd = -1;
2320        err = native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &anb);
2321        if (err != NO_ERROR) {
2322            ALOGE("error pushing blank frames: dequeueBuffer failed: %s (%d)",
2323                    strerror(-err), -err);
2324            goto error;
2325        }
2326
2327        sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
2328
2329        // Fill the buffer with the a 1x1 checkerboard pattern ;)
2330        uint32_t* img = NULL;
2331        err = buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
2332        if (err != NO_ERROR) {
2333            ALOGE("error pushing blank frames: lock failed: %s (%d)",
2334                    strerror(-err), -err);
2335            goto error;
2336        }
2337
2338        *img = 0;
2339
2340        err = buf->unlock();
2341        if (err != NO_ERROR) {
2342            ALOGE("error pushing blank frames: unlock failed: %s (%d)",
2343                    strerror(-err), -err);
2344            goto error;
2345        }
2346
2347        err = mNativeWindow->queueBuffer(mNativeWindow.get(),
2348                buf->getNativeBuffer(), -1);
2349        if (err != NO_ERROR) {
2350            ALOGE("error pushing blank frames: queueBuffer failed: %s (%d)",
2351                    strerror(-err), -err);
2352            goto error;
2353        }
2354
2355        anb = NULL;
2356    }
2357
2358error:
2359
2360    if (err != NO_ERROR) {
2361        // Clean up after an error.
2362        if (anb != NULL) {
2363            mNativeWindow->cancelBuffer(mNativeWindow.get(), anb, -1);
2364        }
2365
2366        native_window_api_disconnect(mNativeWindow.get(),
2367                NATIVE_WINDOW_API_CPU);
2368        native_window_api_connect(mNativeWindow.get(),
2369                NATIVE_WINDOW_API_MEDIA);
2370
2371        return err;
2372    } else {
2373        // Clean up after success.
2374        err = native_window_api_disconnect(mNativeWindow.get(),
2375                NATIVE_WINDOW_API_CPU);
2376        if (err != NO_ERROR) {
2377            ALOGE("error pushing blank frames: api_disconnect failed: %s (%d)",
2378                    strerror(-err), -err);
2379            return err;
2380        }
2381
2382        err = native_window_api_connect(mNativeWindow.get(),
2383                NATIVE_WINDOW_API_MEDIA);
2384        if (err != NO_ERROR) {
2385            ALOGE("error pushing blank frames: api_connect failed: %s (%d)",
2386                    strerror(-err), -err);
2387            return err;
2388        }
2389
2390        return NO_ERROR;
2391    }
2392}
2393
2394////////////////////////////////////////////////////////////////////////////////
2395
2396ACodec::PortDescription::PortDescription() {
2397}
2398
2399status_t ACodec::requestIDRFrame() {
2400    if (!mIsEncoder) {
2401        return ERROR_UNSUPPORTED;
2402    }
2403
2404    OMX_CONFIG_INTRAREFRESHVOPTYPE params;
2405    InitOMXParams(&params);
2406
2407    params.nPortIndex = kPortIndexOutput;
2408    params.IntraRefreshVOP = OMX_TRUE;
2409
2410    return mOMX->setConfig(
2411            mNode,
2412            OMX_IndexConfigVideoIntraVOPRefresh,
2413            &params,
2414            sizeof(params));
2415}
2416
2417void ACodec::PortDescription::addBuffer(
2418        IOMX::buffer_id id, const sp<ABuffer> &buffer) {
2419    mBufferIDs.push_back(id);
2420    mBuffers.push_back(buffer);
2421}
2422
2423size_t ACodec::PortDescription::countBuffers() {
2424    return mBufferIDs.size();
2425}
2426
2427IOMX::buffer_id ACodec::PortDescription::bufferIDAt(size_t index) const {
2428    return mBufferIDs.itemAt(index);
2429}
2430
2431sp<ABuffer> ACodec::PortDescription::bufferAt(size_t index) const {
2432    return mBuffers.itemAt(index);
2433}
2434
2435////////////////////////////////////////////////////////////////////////////////
2436
2437ACodec::BaseState::BaseState(ACodec *codec, const sp<AState> &parentState)
2438    : AState(parentState),
2439      mCodec(codec) {
2440}
2441
2442ACodec::BaseState::PortMode ACodec::BaseState::getPortMode(OMX_U32 portIndex) {
2443    return KEEP_BUFFERS;
2444}
2445
2446bool ACodec::BaseState::onMessageReceived(const sp<AMessage> &msg) {
2447    switch (msg->what()) {
2448        case kWhatInputBufferFilled:
2449        {
2450            onInputBufferFilled(msg);
2451            break;
2452        }
2453
2454        case kWhatOutputBufferDrained:
2455        {
2456            onOutputBufferDrained(msg);
2457            break;
2458        }
2459
2460        case ACodec::kWhatOMXMessage:
2461        {
2462            return onOMXMessage(msg);
2463        }
2464
2465        default:
2466            return false;
2467    }
2468
2469    return true;
2470}
2471
2472bool ACodec::BaseState::onOMXMessage(const sp<AMessage> &msg) {
2473    int32_t type;
2474    CHECK(msg->findInt32("type", &type));
2475
2476    IOMX::node_id nodeID;
2477    CHECK(msg->findPointer("node", &nodeID));
2478    CHECK_EQ(nodeID, mCodec->mNode);
2479
2480    switch (type) {
2481        case omx_message::EVENT:
2482        {
2483            int32_t event, data1, data2;
2484            CHECK(msg->findInt32("event", &event));
2485            CHECK(msg->findInt32("data1", &data1));
2486            CHECK(msg->findInt32("data2", &data2));
2487
2488            if (event == OMX_EventCmdComplete
2489                    && data1 == OMX_CommandFlush
2490                    && data2 == (int32_t)OMX_ALL) {
2491                // Use of this notification is not consistent across
2492                // implementations. We'll drop this notification and rely
2493                // on flush-complete notifications on the individual port
2494                // indices instead.
2495
2496                return true;
2497            }
2498
2499            return onOMXEvent(
2500                    static_cast<OMX_EVENTTYPE>(event),
2501                    static_cast<OMX_U32>(data1),
2502                    static_cast<OMX_U32>(data2));
2503        }
2504
2505        case omx_message::EMPTY_BUFFER_DONE:
2506        {
2507            IOMX::buffer_id bufferID;
2508            CHECK(msg->findPointer("buffer", &bufferID));
2509
2510            return onOMXEmptyBufferDone(bufferID);
2511        }
2512
2513        case omx_message::FILL_BUFFER_DONE:
2514        {
2515            IOMX::buffer_id bufferID;
2516            CHECK(msg->findPointer("buffer", &bufferID));
2517
2518            int32_t rangeOffset, rangeLength, flags;
2519            int64_t timeUs;
2520            void *platformPrivate;
2521            void *dataPtr;
2522
2523            CHECK(msg->findInt32("range_offset", &rangeOffset));
2524            CHECK(msg->findInt32("range_length", &rangeLength));
2525            CHECK(msg->findInt32("flags", &flags));
2526            CHECK(msg->findInt64("timestamp", &timeUs));
2527            CHECK(msg->findPointer("platform_private", &platformPrivate));
2528            CHECK(msg->findPointer("data_ptr", &dataPtr));
2529
2530            return onOMXFillBufferDone(
2531                    bufferID,
2532                    (size_t)rangeOffset, (size_t)rangeLength,
2533                    (OMX_U32)flags,
2534                    timeUs,
2535                    platformPrivate,
2536                    dataPtr);
2537        }
2538
2539        default:
2540            TRESPASS();
2541            break;
2542    }
2543}
2544
2545bool ACodec::BaseState::onOMXEvent(
2546        OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
2547    if (event != OMX_EventError) {
2548        ALOGV("[%s] EVENT(%d, 0x%08lx, 0x%08lx)",
2549             mCodec->mComponentName.c_str(), event, data1, data2);
2550
2551        return false;
2552    }
2553
2554    ALOGE("[%s] ERROR(0x%08lx)", mCodec->mComponentName.c_str(), data1);
2555
2556    mCodec->signalError((OMX_ERRORTYPE)data1);
2557
2558    return true;
2559}
2560
2561bool ACodec::BaseState::onOMXEmptyBufferDone(IOMX::buffer_id bufferID) {
2562    ALOGV("[%s] onOMXEmptyBufferDone %p",
2563         mCodec->mComponentName.c_str(), bufferID);
2564
2565    BufferInfo *info =
2566        mCodec->findBufferByID(kPortIndexInput, bufferID);
2567
2568    CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_COMPONENT);
2569    info->mStatus = BufferInfo::OWNED_BY_US;
2570
2571    const sp<AMessage> &bufferMeta = info->mData->meta();
2572    void *mediaBuffer;
2573    if (bufferMeta->findPointer("mediaBuffer", &mediaBuffer)
2574            && mediaBuffer != NULL) {
2575        // We're in "store-metadata-in-buffers" mode, the underlying
2576        // OMX component had access to data that's implicitly refcounted
2577        // by this "mediaBuffer" object. Now that the OMX component has
2578        // told us that it's done with the input buffer, we can decrement
2579        // the mediaBuffer's reference count.
2580
2581        ALOGV("releasing mbuf %p", mediaBuffer);
2582
2583        ((MediaBuffer *)mediaBuffer)->release();
2584        mediaBuffer = NULL;
2585
2586        bufferMeta->setPointer("mediaBuffer", NULL);
2587    }
2588
2589    PortMode mode = getPortMode(kPortIndexInput);
2590
2591    switch (mode) {
2592        case KEEP_BUFFERS:
2593            break;
2594
2595        case RESUBMIT_BUFFERS:
2596            postFillThisBuffer(info);
2597            break;
2598
2599        default:
2600        {
2601            CHECK_EQ((int)mode, (int)FREE_BUFFERS);
2602            TRESPASS();  // Not currently used
2603            break;
2604        }
2605    }
2606
2607    return true;
2608}
2609
2610void ACodec::BaseState::postFillThisBuffer(BufferInfo *info) {
2611    if (mCodec->mPortEOS[kPortIndexInput]) {
2612        return;
2613    }
2614
2615    CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_US);
2616
2617    sp<AMessage> notify = mCodec->mNotify->dup();
2618    notify->setInt32("what", ACodec::kWhatFillThisBuffer);
2619    notify->setPointer("buffer-id", info->mBufferID);
2620
2621    info->mData->meta()->clear();
2622    notify->setBuffer("buffer", info->mData);
2623
2624    sp<AMessage> reply = new AMessage(kWhatInputBufferFilled, mCodec->id());
2625    reply->setPointer("buffer-id", info->mBufferID);
2626
2627    notify->setMessage("reply", reply);
2628
2629    notify->post();
2630
2631    info->mStatus = BufferInfo::OWNED_BY_UPSTREAM;
2632}
2633
2634void ACodec::BaseState::onInputBufferFilled(const sp<AMessage> &msg) {
2635    IOMX::buffer_id bufferID;
2636    CHECK(msg->findPointer("buffer-id", &bufferID));
2637
2638    sp<ABuffer> buffer;
2639    int32_t err = OK;
2640    bool eos = false;
2641
2642    if (!msg->findBuffer("buffer", &buffer)) {
2643        CHECK(msg->findInt32("err", &err));
2644
2645        ALOGV("[%s] saw error %d instead of an input buffer",
2646             mCodec->mComponentName.c_str(), err);
2647
2648        buffer.clear();
2649
2650        eos = true;
2651    }
2652
2653    int32_t tmp;
2654    if (buffer != NULL && buffer->meta()->findInt32("eos", &tmp) && tmp) {
2655        eos = true;
2656        err = ERROR_END_OF_STREAM;
2657    }
2658
2659    BufferInfo *info = mCodec->findBufferByID(kPortIndexInput, bufferID);
2660    CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_UPSTREAM);
2661
2662    info->mStatus = BufferInfo::OWNED_BY_US;
2663
2664    PortMode mode = getPortMode(kPortIndexInput);
2665
2666    switch (mode) {
2667        case KEEP_BUFFERS:
2668        {
2669            if (eos) {
2670                if (!mCodec->mPortEOS[kPortIndexInput]) {
2671                    mCodec->mPortEOS[kPortIndexInput] = true;
2672                    mCodec->mInputEOSResult = err;
2673                }
2674            }
2675            break;
2676        }
2677
2678        case RESUBMIT_BUFFERS:
2679        {
2680            if (buffer != NULL && !mCodec->mPortEOS[kPortIndexInput]) {
2681                int64_t timeUs;
2682                CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2683
2684                OMX_U32 flags = OMX_BUFFERFLAG_ENDOFFRAME;
2685
2686                int32_t isCSD;
2687                if (buffer->meta()->findInt32("csd", &isCSD) && isCSD != 0) {
2688                    flags |= OMX_BUFFERFLAG_CODECCONFIG;
2689                }
2690
2691                if (eos) {
2692                    flags |= OMX_BUFFERFLAG_EOS;
2693                }
2694
2695                if (buffer != info->mData) {
2696                    ALOGV("[%s] Needs to copy input data for buffer %p. (%p != %p)",
2697                         mCodec->mComponentName.c_str(),
2698                         bufferID,
2699                         buffer.get(), info->mData.get());
2700
2701                    CHECK_LE(buffer->size(), info->mData->capacity());
2702                    memcpy(info->mData->data(), buffer->data(), buffer->size());
2703                }
2704
2705                if (flags & OMX_BUFFERFLAG_CODECCONFIG) {
2706                    ALOGV("[%s] calling emptyBuffer %p w/ codec specific data",
2707                         mCodec->mComponentName.c_str(), bufferID);
2708                } else if (flags & OMX_BUFFERFLAG_EOS) {
2709                    ALOGV("[%s] calling emptyBuffer %p w/ EOS",
2710                         mCodec->mComponentName.c_str(), bufferID);
2711                } else {
2712#if TRACK_BUFFER_TIMING
2713                    ALOGI("[%s] calling emptyBuffer %p w/ time %lld us",
2714                         mCodec->mComponentName.c_str(), bufferID, timeUs);
2715#else
2716                    ALOGV("[%s] calling emptyBuffer %p w/ time %lld us",
2717                         mCodec->mComponentName.c_str(), bufferID, timeUs);
2718#endif
2719                }
2720
2721#if TRACK_BUFFER_TIMING
2722                ACodec::BufferStats stats;
2723                stats.mEmptyBufferTimeUs = ALooper::GetNowUs();
2724                stats.mFillBufferDoneTimeUs = -1ll;
2725                mCodec->mBufferStats.add(timeUs, stats);
2726#endif
2727
2728                CHECK_EQ(mCodec->mOMX->emptyBuffer(
2729                            mCodec->mNode,
2730                            bufferID,
2731                            0,
2732                            buffer->size(),
2733                            flags,
2734                            timeUs),
2735                         (status_t)OK);
2736
2737                info->mStatus = BufferInfo::OWNED_BY_COMPONENT;
2738
2739                if (!eos) {
2740                    getMoreInputDataIfPossible();
2741                } else {
2742                    ALOGV("[%s] Signalled EOS on the input port",
2743                         mCodec->mComponentName.c_str());
2744
2745                    mCodec->mPortEOS[kPortIndexInput] = true;
2746                    mCodec->mInputEOSResult = err;
2747                }
2748            } else if (!mCodec->mPortEOS[kPortIndexInput]) {
2749                if (err != ERROR_END_OF_STREAM) {
2750                    ALOGV("[%s] Signalling EOS on the input port "
2751                         "due to error %d",
2752                         mCodec->mComponentName.c_str(), err);
2753                } else {
2754                    ALOGV("[%s] Signalling EOS on the input port",
2755                         mCodec->mComponentName.c_str());
2756                }
2757
2758                ALOGV("[%s] calling emptyBuffer %p signalling EOS",
2759                     mCodec->mComponentName.c_str(), bufferID);
2760
2761                CHECK_EQ(mCodec->mOMX->emptyBuffer(
2762                            mCodec->mNode,
2763                            bufferID,
2764                            0,
2765                            0,
2766                            OMX_BUFFERFLAG_EOS,
2767                            0),
2768                         (status_t)OK);
2769
2770                info->mStatus = BufferInfo::OWNED_BY_COMPONENT;
2771
2772                mCodec->mPortEOS[kPortIndexInput] = true;
2773                mCodec->mInputEOSResult = err;
2774            }
2775            break;
2776
2777            default:
2778                CHECK_EQ((int)mode, (int)FREE_BUFFERS);
2779                break;
2780        }
2781    }
2782}
2783
2784void ACodec::BaseState::getMoreInputDataIfPossible() {
2785    if (mCodec->mPortEOS[kPortIndexInput]) {
2786        return;
2787    }
2788
2789    BufferInfo *eligible = NULL;
2790
2791    for (size_t i = 0; i < mCodec->mBuffers[kPortIndexInput].size(); ++i) {
2792        BufferInfo *info = &mCodec->mBuffers[kPortIndexInput].editItemAt(i);
2793
2794#if 0
2795        if (info->mStatus == BufferInfo::OWNED_BY_UPSTREAM) {
2796            // There's already a "read" pending.
2797            return;
2798        }
2799#endif
2800
2801        if (info->mStatus == BufferInfo::OWNED_BY_US) {
2802            eligible = info;
2803        }
2804    }
2805
2806    if (eligible == NULL) {
2807        return;
2808    }
2809
2810    postFillThisBuffer(eligible);
2811}
2812
2813bool ACodec::BaseState::onOMXFillBufferDone(
2814        IOMX::buffer_id bufferID,
2815        size_t rangeOffset, size_t rangeLength,
2816        OMX_U32 flags,
2817        int64_t timeUs,
2818        void *platformPrivate,
2819        void *dataPtr) {
2820    ALOGV("[%s] onOMXFillBufferDone %p time %lld us, flags = 0x%08lx",
2821         mCodec->mComponentName.c_str(), bufferID, timeUs, flags);
2822
2823    ssize_t index;
2824
2825#if TRACK_BUFFER_TIMING
2826    index = mCodec->mBufferStats.indexOfKey(timeUs);
2827    if (index >= 0) {
2828        ACodec::BufferStats *stats = &mCodec->mBufferStats.editValueAt(index);
2829        stats->mFillBufferDoneTimeUs = ALooper::GetNowUs();
2830
2831        ALOGI("frame PTS %lld: %lld",
2832                timeUs,
2833                stats->mFillBufferDoneTimeUs - stats->mEmptyBufferTimeUs);
2834
2835        mCodec->mBufferStats.removeItemsAt(index);
2836        stats = NULL;
2837    }
2838#endif
2839
2840    BufferInfo *info =
2841        mCodec->findBufferByID(kPortIndexOutput, bufferID, &index);
2842
2843    CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_COMPONENT);
2844
2845    info->mStatus = BufferInfo::OWNED_BY_US;
2846
2847    PortMode mode = getPortMode(kPortIndexOutput);
2848
2849    switch (mode) {
2850        case KEEP_BUFFERS:
2851            break;
2852
2853        case RESUBMIT_BUFFERS:
2854        {
2855            if (rangeLength == 0 && !(flags & OMX_BUFFERFLAG_EOS)) {
2856                ALOGV("[%s] calling fillBuffer %p",
2857                     mCodec->mComponentName.c_str(), info->mBufferID);
2858
2859                CHECK_EQ(mCodec->mOMX->fillBuffer(
2860                            mCodec->mNode, info->mBufferID),
2861                         (status_t)OK);
2862
2863                info->mStatus = BufferInfo::OWNED_BY_COMPONENT;
2864                break;
2865            }
2866
2867            if (!mCodec->mIsEncoder && !mCodec->mSentFormat) {
2868                mCodec->sendFormatChange();
2869            }
2870
2871            if (mCodec->mNativeWindow == NULL) {
2872                info->mData->setRange(rangeOffset, rangeLength);
2873
2874#if 0
2875                if (IsIDR(info->mData)) {
2876                    ALOGI("IDR frame");
2877                }
2878#endif
2879            }
2880
2881            if (mCodec->mSkipCutBuffer != NULL) {
2882                mCodec->mSkipCutBuffer->submit(info->mData);
2883            }
2884            info->mData->meta()->setInt64("timeUs", timeUs);
2885
2886            sp<AMessage> notify = mCodec->mNotify->dup();
2887            notify->setInt32("what", ACodec::kWhatDrainThisBuffer);
2888            notify->setPointer("buffer-id", info->mBufferID);
2889            notify->setBuffer("buffer", info->mData);
2890            notify->setInt32("flags", flags);
2891
2892            sp<AMessage> reply =
2893                new AMessage(kWhatOutputBufferDrained, mCodec->id());
2894
2895            reply->setPointer("buffer-id", info->mBufferID);
2896
2897            notify->setMessage("reply", reply);
2898
2899            notify->post();
2900
2901            info->mStatus = BufferInfo::OWNED_BY_DOWNSTREAM;
2902
2903            if (flags & OMX_BUFFERFLAG_EOS) {
2904                ALOGV("[%s] saw output EOS", mCodec->mComponentName.c_str());
2905
2906                sp<AMessage> notify = mCodec->mNotify->dup();
2907                notify->setInt32("what", ACodec::kWhatEOS);
2908                notify->setInt32("err", mCodec->mInputEOSResult);
2909                notify->post();
2910
2911                mCodec->mPortEOS[kPortIndexOutput] = true;
2912            }
2913            break;
2914        }
2915
2916        default:
2917        {
2918            CHECK_EQ((int)mode, (int)FREE_BUFFERS);
2919
2920            CHECK_EQ((status_t)OK,
2921                     mCodec->freeBuffer(kPortIndexOutput, index));
2922            break;
2923        }
2924    }
2925
2926    return true;
2927}
2928
2929void ACodec::BaseState::onOutputBufferDrained(const sp<AMessage> &msg) {
2930    IOMX::buffer_id bufferID;
2931    CHECK(msg->findPointer("buffer-id", &bufferID));
2932
2933    ssize_t index;
2934    BufferInfo *info =
2935        mCodec->findBufferByID(kPortIndexOutput, bufferID, &index);
2936    CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_DOWNSTREAM);
2937
2938    int32_t render;
2939    if (mCodec->mNativeWindow != NULL
2940            && msg->findInt32("render", &render) && render != 0) {
2941        // The client wants this buffer to be rendered.
2942
2943        status_t err;
2944        if ((err = mCodec->mNativeWindow->queueBuffer(
2945                    mCodec->mNativeWindow.get(),
2946                    info->mGraphicBuffer.get(), -1)) == OK) {
2947            info->mStatus = BufferInfo::OWNED_BY_NATIVE_WINDOW;
2948        } else {
2949            mCodec->signalError(OMX_ErrorUndefined, err);
2950            info->mStatus = BufferInfo::OWNED_BY_US;
2951        }
2952    } else {
2953        info->mStatus = BufferInfo::OWNED_BY_US;
2954    }
2955
2956    PortMode mode = getPortMode(kPortIndexOutput);
2957
2958    switch (mode) {
2959        case KEEP_BUFFERS:
2960        {
2961            // XXX fishy, revisit!!! What about the FREE_BUFFERS case below?
2962
2963            if (info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW) {
2964                // We cannot resubmit the buffer we just rendered, dequeue
2965                // the spare instead.
2966
2967                info = mCodec->dequeueBufferFromNativeWindow();
2968            }
2969            break;
2970        }
2971
2972        case RESUBMIT_BUFFERS:
2973        {
2974            if (!mCodec->mPortEOS[kPortIndexOutput]) {
2975                if (info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW) {
2976                    // We cannot resubmit the buffer we just rendered, dequeue
2977                    // the spare instead.
2978
2979                    info = mCodec->dequeueBufferFromNativeWindow();
2980                }
2981
2982                if (info != NULL) {
2983                    ALOGV("[%s] calling fillBuffer %p",
2984                         mCodec->mComponentName.c_str(), info->mBufferID);
2985
2986                    CHECK_EQ(mCodec->mOMX->fillBuffer(mCodec->mNode, info->mBufferID),
2987                             (status_t)OK);
2988
2989                    info->mStatus = BufferInfo::OWNED_BY_COMPONENT;
2990                }
2991            }
2992            break;
2993        }
2994
2995        default:
2996        {
2997            CHECK_EQ((int)mode, (int)FREE_BUFFERS);
2998
2999            CHECK_EQ((status_t)OK,
3000                     mCodec->freeBuffer(kPortIndexOutput, index));
3001            break;
3002        }
3003    }
3004}
3005
3006////////////////////////////////////////////////////////////////////////////////
3007
3008ACodec::UninitializedState::UninitializedState(ACodec *codec)
3009    : BaseState(codec) {
3010}
3011
3012void ACodec::UninitializedState::stateEntered() {
3013    ALOGV("Now uninitialized");
3014}
3015
3016bool ACodec::UninitializedState::onMessageReceived(const sp<AMessage> &msg) {
3017    bool handled = false;
3018
3019    switch (msg->what()) {
3020        case ACodec::kWhatSetup:
3021        {
3022            onSetup(msg);
3023
3024            handled = true;
3025            break;
3026        }
3027
3028        case ACodec::kWhatAllocateComponent:
3029        {
3030            onAllocateComponent(msg);
3031            handled = true;
3032            break;
3033        }
3034
3035        case ACodec::kWhatShutdown:
3036        {
3037            int32_t keepComponentAllocated;
3038            CHECK(msg->findInt32(
3039                        "keepComponentAllocated", &keepComponentAllocated));
3040            CHECK(!keepComponentAllocated);
3041
3042            sp<AMessage> notify = mCodec->mNotify->dup();
3043            notify->setInt32("what", ACodec::kWhatShutdownCompleted);
3044            notify->post();
3045
3046            handled = true;
3047            break;
3048        }
3049
3050        case ACodec::kWhatFlush:
3051        {
3052            sp<AMessage> notify = mCodec->mNotify->dup();
3053            notify->setInt32("what", ACodec::kWhatFlushCompleted);
3054            notify->post();
3055
3056            handled = true;
3057            break;
3058        }
3059
3060        default:
3061            return BaseState::onMessageReceived(msg);
3062    }
3063
3064    return handled;
3065}
3066
3067void ACodec::UninitializedState::onSetup(
3068        const sp<AMessage> &msg) {
3069    if (onAllocateComponent(msg)
3070            && mCodec->mLoadedState->onConfigureComponent(msg)) {
3071        mCodec->mLoadedState->onStart();
3072    }
3073}
3074
3075bool ACodec::UninitializedState::onAllocateComponent(const sp<AMessage> &msg) {
3076    ALOGV("onAllocateComponent");
3077
3078    CHECK(mCodec->mNode == NULL);
3079
3080    OMXClient client;
3081    CHECK_EQ(client.connect(), (status_t)OK);
3082
3083    sp<IOMX> omx = client.interface();
3084
3085    Vector<OMXCodec::CodecNameAndQuirks> matchingCodecs;
3086
3087    AString mime;
3088
3089    AString componentName;
3090    uint32_t quirks = 0;
3091    if (msg->findString("componentName", &componentName)) {
3092        ssize_t index = matchingCodecs.add();
3093        OMXCodec::CodecNameAndQuirks *entry = &matchingCodecs.editItemAt(index);
3094        entry->mName = String8(componentName.c_str());
3095
3096        if (!OMXCodec::findCodecQuirks(
3097                    componentName.c_str(), &entry->mQuirks)) {
3098            entry->mQuirks = 0;
3099        }
3100    } else {
3101        CHECK(msg->findString("mime", &mime));
3102
3103        int32_t encoder;
3104        if (!msg->findInt32("encoder", &encoder)) {
3105            encoder = false;
3106        }
3107
3108        OMXCodec::findMatchingCodecs(
3109                mime.c_str(),
3110                encoder, // createEncoder
3111                NULL,  // matchComponentName
3112                0,     // flags
3113                &matchingCodecs);
3114    }
3115
3116    sp<CodecObserver> observer = new CodecObserver;
3117    IOMX::node_id node = NULL;
3118
3119    for (size_t matchIndex = 0; matchIndex < matchingCodecs.size();
3120            ++matchIndex) {
3121        componentName = matchingCodecs.itemAt(matchIndex).mName.string();
3122        quirks = matchingCodecs.itemAt(matchIndex).mQuirks;
3123
3124        pid_t tid = androidGetTid();
3125        int prevPriority = androidGetThreadPriority(tid);
3126        androidSetThreadPriority(tid, ANDROID_PRIORITY_FOREGROUND);
3127        status_t err = omx->allocateNode(componentName.c_str(), observer, &node);
3128        androidSetThreadPriority(tid, prevPriority);
3129
3130        if (err == OK) {
3131            break;
3132        }
3133
3134        node = NULL;
3135    }
3136
3137    if (node == NULL) {
3138        if (!mime.empty()) {
3139            ALOGE("Unable to instantiate a decoder for type '%s'.",
3140                 mime.c_str());
3141        } else {
3142            ALOGE("Unable to instantiate decoder '%s'.", componentName.c_str());
3143        }
3144
3145        mCodec->signalError(OMX_ErrorComponentNotFound);
3146        return false;
3147    }
3148
3149    sp<AMessage> notify = new AMessage(kWhatOMXMessage, mCodec->id());
3150    observer->setNotificationMessage(notify);
3151
3152    mCodec->mComponentName = componentName;
3153    mCodec->mFlags = 0;
3154
3155    if (componentName.endsWith(".secure")) {
3156        mCodec->mFlags |= kFlagIsSecure;
3157    }
3158
3159    mCodec->mQuirks = quirks;
3160    mCodec->mOMX = omx;
3161    mCodec->mNode = node;
3162
3163    {
3164        sp<AMessage> notify = mCodec->mNotify->dup();
3165        notify->setInt32("what", ACodec::kWhatComponentAllocated);
3166        notify->setString("componentName", mCodec->mComponentName.c_str());
3167        notify->post();
3168    }
3169
3170    mCodec->changeState(mCodec->mLoadedState);
3171
3172    return true;
3173}
3174
3175////////////////////////////////////////////////////////////////////////////////
3176
3177ACodec::LoadedState::LoadedState(ACodec *codec)
3178    : BaseState(codec) {
3179}
3180
3181void ACodec::LoadedState::stateEntered() {
3182    ALOGV("[%s] Now Loaded", mCodec->mComponentName.c_str());
3183
3184    mCodec->mPortEOS[kPortIndexInput] =
3185        mCodec->mPortEOS[kPortIndexOutput] = false;
3186
3187    mCodec->mInputEOSResult = OK;
3188
3189    if (mCodec->mShutdownInProgress) {
3190        bool keepComponentAllocated = mCodec->mKeepComponentAllocated;
3191
3192        mCodec->mShutdownInProgress = false;
3193        mCodec->mKeepComponentAllocated = false;
3194
3195        onShutdown(keepComponentAllocated);
3196    }
3197}
3198
3199void ACodec::LoadedState::onShutdown(bool keepComponentAllocated) {
3200    if (!keepComponentAllocated) {
3201        CHECK_EQ(mCodec->mOMX->freeNode(mCodec->mNode), (status_t)OK);
3202
3203        mCodec->mNativeWindow.clear();
3204        mCodec->mNode = NULL;
3205        mCodec->mOMX.clear();
3206        mCodec->mQuirks = 0;
3207        mCodec->mFlags = 0;
3208        mCodec->mComponentName.clear();
3209
3210        mCodec->changeState(mCodec->mUninitializedState);
3211    }
3212
3213    sp<AMessage> notify = mCodec->mNotify->dup();
3214    notify->setInt32("what", ACodec::kWhatShutdownCompleted);
3215    notify->post();
3216}
3217
3218bool ACodec::LoadedState::onMessageReceived(const sp<AMessage> &msg) {
3219    bool handled = false;
3220
3221    switch (msg->what()) {
3222        case ACodec::kWhatConfigureComponent:
3223        {
3224            onConfigureComponent(msg);
3225            handled = true;
3226            break;
3227        }
3228
3229        case ACodec::kWhatStart:
3230        {
3231            onStart();
3232            handled = true;
3233            break;
3234        }
3235
3236        case ACodec::kWhatShutdown:
3237        {
3238            int32_t keepComponentAllocated;
3239            CHECK(msg->findInt32(
3240                        "keepComponentAllocated", &keepComponentAllocated));
3241
3242            onShutdown(keepComponentAllocated);
3243
3244            handled = true;
3245            break;
3246        }
3247
3248        case ACodec::kWhatFlush:
3249        {
3250            sp<AMessage> notify = mCodec->mNotify->dup();
3251            notify->setInt32("what", ACodec::kWhatFlushCompleted);
3252            notify->post();
3253
3254            handled = true;
3255            break;
3256        }
3257
3258        default:
3259            return BaseState::onMessageReceived(msg);
3260    }
3261
3262    return handled;
3263}
3264
3265bool ACodec::LoadedState::onConfigureComponent(
3266        const sp<AMessage> &msg) {
3267    ALOGV("onConfigureComponent");
3268
3269    CHECK(mCodec->mNode != NULL);
3270
3271    AString mime;
3272    CHECK(msg->findString("mime", &mime));
3273
3274    status_t err = mCodec->configureCodec(mime.c_str(), msg);
3275
3276    if (err != OK) {
3277        ALOGE("[%s] configureCodec returning error %d",
3278              mCodec->mComponentName.c_str(), err);
3279
3280        mCodec->signalError(OMX_ErrorUndefined, err);
3281        return false;
3282    }
3283
3284    sp<RefBase> obj;
3285    if (msg->findObject("native-window", &obj)
3286            && strncmp("OMX.google.", mCodec->mComponentName.c_str(), 11)) {
3287        sp<NativeWindowWrapper> nativeWindow(
3288                static_cast<NativeWindowWrapper *>(obj.get()));
3289        CHECK(nativeWindow != NULL);
3290        mCodec->mNativeWindow = nativeWindow->getNativeWindow();
3291
3292        native_window_set_scaling_mode(
3293                mCodec->mNativeWindow.get(),
3294                NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
3295    }
3296    CHECK_EQ((status_t)OK, mCodec->initNativeWindow());
3297
3298    {
3299        sp<AMessage> notify = mCodec->mNotify->dup();
3300        notify->setInt32("what", ACodec::kWhatComponentConfigured);
3301        notify->post();
3302    }
3303
3304    return true;
3305}
3306
3307void ACodec::LoadedState::onStart() {
3308    ALOGV("onStart");
3309
3310    CHECK_EQ(mCodec->mOMX->sendCommand(
3311                mCodec->mNode, OMX_CommandStateSet, OMX_StateIdle),
3312             (status_t)OK);
3313
3314    mCodec->changeState(mCodec->mLoadedToIdleState);
3315}
3316
3317////////////////////////////////////////////////////////////////////////////////
3318
3319ACodec::LoadedToIdleState::LoadedToIdleState(ACodec *codec)
3320    : BaseState(codec) {
3321}
3322
3323void ACodec::LoadedToIdleState::stateEntered() {
3324    ALOGV("[%s] Now Loaded->Idle", mCodec->mComponentName.c_str());
3325
3326    status_t err;
3327    if ((err = allocateBuffers()) != OK) {
3328        ALOGE("Failed to allocate buffers after transitioning to IDLE state "
3329             "(error 0x%08x)",
3330             err);
3331
3332        mCodec->signalError(OMX_ErrorUndefined, err);
3333
3334        mCodec->changeState(mCodec->mLoadedState);
3335    }
3336}
3337
3338status_t ACodec::LoadedToIdleState::allocateBuffers() {
3339    status_t err = mCodec->allocateBuffersOnPort(kPortIndexInput);
3340
3341    if (err != OK) {
3342        return err;
3343    }
3344
3345    return mCodec->allocateBuffersOnPort(kPortIndexOutput);
3346}
3347
3348bool ACodec::LoadedToIdleState::onMessageReceived(const sp<AMessage> &msg) {
3349    switch (msg->what()) {
3350        case kWhatShutdown:
3351        {
3352            mCodec->deferMessage(msg);
3353            return true;
3354        }
3355
3356        default:
3357            return BaseState::onMessageReceived(msg);
3358    }
3359}
3360
3361bool ACodec::LoadedToIdleState::onOMXEvent(
3362        OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
3363    switch (event) {
3364        case OMX_EventCmdComplete:
3365        {
3366            CHECK_EQ(data1, (OMX_U32)OMX_CommandStateSet);
3367            CHECK_EQ(data2, (OMX_U32)OMX_StateIdle);
3368
3369            CHECK_EQ(mCodec->mOMX->sendCommand(
3370                        mCodec->mNode, OMX_CommandStateSet, OMX_StateExecuting),
3371                     (status_t)OK);
3372
3373            mCodec->changeState(mCodec->mIdleToExecutingState);
3374
3375            return true;
3376        }
3377
3378        default:
3379            return BaseState::onOMXEvent(event, data1, data2);
3380    }
3381}
3382
3383////////////////////////////////////////////////////////////////////////////////
3384
3385ACodec::IdleToExecutingState::IdleToExecutingState(ACodec *codec)
3386    : BaseState(codec) {
3387}
3388
3389void ACodec::IdleToExecutingState::stateEntered() {
3390    ALOGV("[%s] Now Idle->Executing", mCodec->mComponentName.c_str());
3391}
3392
3393bool ACodec::IdleToExecutingState::onMessageReceived(const sp<AMessage> &msg) {
3394    switch (msg->what()) {
3395        case kWhatShutdown:
3396        {
3397            mCodec->deferMessage(msg);
3398            return true;
3399        }
3400
3401        default:
3402            return BaseState::onMessageReceived(msg);
3403    }
3404}
3405
3406bool ACodec::IdleToExecutingState::onOMXEvent(
3407        OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
3408    switch (event) {
3409        case OMX_EventCmdComplete:
3410        {
3411            CHECK_EQ(data1, (OMX_U32)OMX_CommandStateSet);
3412            CHECK_EQ(data2, (OMX_U32)OMX_StateExecuting);
3413
3414            mCodec->mExecutingState->resume();
3415            mCodec->changeState(mCodec->mExecutingState);
3416
3417            return true;
3418        }
3419
3420        default:
3421            return BaseState::onOMXEvent(event, data1, data2);
3422    }
3423}
3424
3425////////////////////////////////////////////////////////////////////////////////
3426
3427ACodec::ExecutingState::ExecutingState(ACodec *codec)
3428    : BaseState(codec),
3429      mActive(false) {
3430}
3431
3432ACodec::BaseState::PortMode ACodec::ExecutingState::getPortMode(
3433        OMX_U32 portIndex) {
3434    return RESUBMIT_BUFFERS;
3435}
3436
3437void ACodec::ExecutingState::submitOutputBuffers() {
3438    for (size_t i = 0; i < mCodec->mBuffers[kPortIndexOutput].size(); ++i) {
3439        BufferInfo *info = &mCodec->mBuffers[kPortIndexOutput].editItemAt(i);
3440
3441        if (mCodec->mNativeWindow != NULL) {
3442            CHECK(info->mStatus == BufferInfo::OWNED_BY_US
3443                    || info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW);
3444
3445            if (info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW) {
3446                continue;
3447            }
3448        } else {
3449            CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_US);
3450        }
3451
3452        ALOGV("[%s] calling fillBuffer %p",
3453             mCodec->mComponentName.c_str(), info->mBufferID);
3454
3455        CHECK_EQ(mCodec->mOMX->fillBuffer(mCodec->mNode, info->mBufferID),
3456                 (status_t)OK);
3457
3458        info->mStatus = BufferInfo::OWNED_BY_COMPONENT;
3459    }
3460}
3461
3462void ACodec::ExecutingState::resume() {
3463    if (mActive) {
3464        ALOGV("[%s] We're already active, no need to resume.",
3465             mCodec->mComponentName.c_str());
3466
3467        return;
3468    }
3469
3470    submitOutputBuffers();
3471
3472    // Post the first input buffer.
3473    CHECK_GT(mCodec->mBuffers[kPortIndexInput].size(), 0u);
3474    BufferInfo *info = &mCodec->mBuffers[kPortIndexInput].editItemAt(0);
3475
3476    postFillThisBuffer(info);
3477
3478    mActive = true;
3479}
3480
3481void ACodec::ExecutingState::stateEntered() {
3482    ALOGV("[%s] Now Executing", mCodec->mComponentName.c_str());
3483
3484    mCodec->processDeferredMessages();
3485}
3486
3487bool ACodec::ExecutingState::onMessageReceived(const sp<AMessage> &msg) {
3488    bool handled = false;
3489
3490    switch (msg->what()) {
3491        case kWhatShutdown:
3492        {
3493            int32_t keepComponentAllocated;
3494            CHECK(msg->findInt32(
3495                        "keepComponentAllocated", &keepComponentAllocated));
3496
3497            mCodec->mShutdownInProgress = true;
3498            mCodec->mKeepComponentAllocated = keepComponentAllocated;
3499
3500            mActive = false;
3501
3502            CHECK_EQ(mCodec->mOMX->sendCommand(
3503                        mCodec->mNode, OMX_CommandStateSet, OMX_StateIdle),
3504                     (status_t)OK);
3505
3506            mCodec->changeState(mCodec->mExecutingToIdleState);
3507
3508            handled = true;
3509            break;
3510        }
3511
3512        case kWhatFlush:
3513        {
3514            ALOGV("[%s] ExecutingState flushing now "
3515                 "(codec owns %d/%d input, %d/%d output).",
3516                    mCodec->mComponentName.c_str(),
3517                    mCodec->countBuffersOwnedByComponent(kPortIndexInput),
3518                    mCodec->mBuffers[kPortIndexInput].size(),
3519                    mCodec->countBuffersOwnedByComponent(kPortIndexOutput),
3520                    mCodec->mBuffers[kPortIndexOutput].size());
3521
3522            mActive = false;
3523
3524            CHECK_EQ(mCodec->mOMX->sendCommand(
3525                        mCodec->mNode, OMX_CommandFlush, OMX_ALL),
3526                     (status_t)OK);
3527
3528            mCodec->changeState(mCodec->mFlushingState);
3529
3530            handled = true;
3531            break;
3532        }
3533
3534        case kWhatResume:
3535        {
3536            resume();
3537
3538            handled = true;
3539            break;
3540        }
3541
3542        case kWhatRequestIDRFrame:
3543        {
3544            status_t err = mCodec->requestIDRFrame();
3545            if (err != OK) {
3546                ALOGW("Requesting an IDR frame failed.");
3547            }
3548
3549            handled = true;
3550            break;
3551        }
3552
3553        default:
3554            handled = BaseState::onMessageReceived(msg);
3555            break;
3556    }
3557
3558    return handled;
3559}
3560
3561bool ACodec::ExecutingState::onOMXEvent(
3562        OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
3563    switch (event) {
3564        case OMX_EventPortSettingsChanged:
3565        {
3566            CHECK_EQ(data1, (OMX_U32)kPortIndexOutput);
3567
3568            if (data2 == 0 || data2 == OMX_IndexParamPortDefinition) {
3569                CHECK_EQ(mCodec->mOMX->sendCommand(
3570                            mCodec->mNode,
3571                            OMX_CommandPortDisable, kPortIndexOutput),
3572                         (status_t)OK);
3573
3574                mCodec->freeOutputBuffersNotOwnedByComponent();
3575
3576                mCodec->changeState(mCodec->mOutputPortSettingsChangedState);
3577            } else if (data2 == OMX_IndexConfigCommonOutputCrop) {
3578                mCodec->mSentFormat = false;
3579            } else {
3580                ALOGV("[%s] OMX_EventPortSettingsChanged 0x%08lx",
3581                     mCodec->mComponentName.c_str(), data2);
3582            }
3583
3584            return true;
3585        }
3586
3587        case OMX_EventBufferFlag:
3588        {
3589            return true;
3590        }
3591
3592        default:
3593            return BaseState::onOMXEvent(event, data1, data2);
3594    }
3595}
3596
3597////////////////////////////////////////////////////////////////////////////////
3598
3599ACodec::OutputPortSettingsChangedState::OutputPortSettingsChangedState(
3600        ACodec *codec)
3601    : BaseState(codec) {
3602}
3603
3604ACodec::BaseState::PortMode ACodec::OutputPortSettingsChangedState::getPortMode(
3605        OMX_U32 portIndex) {
3606    if (portIndex == kPortIndexOutput) {
3607        return FREE_BUFFERS;
3608    }
3609
3610    CHECK_EQ(portIndex, (OMX_U32)kPortIndexInput);
3611
3612    return RESUBMIT_BUFFERS;
3613}
3614
3615bool ACodec::OutputPortSettingsChangedState::onMessageReceived(
3616        const sp<AMessage> &msg) {
3617    bool handled = false;
3618
3619    switch (msg->what()) {
3620        case kWhatFlush:
3621        case kWhatShutdown:
3622        case kWhatResume:
3623        {
3624            if (msg->what() == kWhatResume) {
3625                ALOGV("[%s] Deferring resume", mCodec->mComponentName.c_str());
3626            }
3627
3628            mCodec->deferMessage(msg);
3629            handled = true;
3630            break;
3631        }
3632
3633        default:
3634            handled = BaseState::onMessageReceived(msg);
3635            break;
3636    }
3637
3638    return handled;
3639}
3640
3641void ACodec::OutputPortSettingsChangedState::stateEntered() {
3642    ALOGV("[%s] Now handling output port settings change",
3643         mCodec->mComponentName.c_str());
3644}
3645
3646bool ACodec::OutputPortSettingsChangedState::onOMXEvent(
3647        OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
3648    switch (event) {
3649        case OMX_EventCmdComplete:
3650        {
3651            if (data1 == (OMX_U32)OMX_CommandPortDisable) {
3652                CHECK_EQ(data2, (OMX_U32)kPortIndexOutput);
3653
3654                ALOGV("[%s] Output port now disabled.",
3655                        mCodec->mComponentName.c_str());
3656
3657                CHECK(mCodec->mBuffers[kPortIndexOutput].isEmpty());
3658                mCodec->mDealer[kPortIndexOutput].clear();
3659
3660                CHECK_EQ(mCodec->mOMX->sendCommand(
3661                            mCodec->mNode, OMX_CommandPortEnable, kPortIndexOutput),
3662                         (status_t)OK);
3663
3664                status_t err;
3665                if ((err = mCodec->allocateBuffersOnPort(
3666                                kPortIndexOutput)) != OK) {
3667                    ALOGE("Failed to allocate output port buffers after "
3668                         "port reconfiguration (error 0x%08x)",
3669                         err);
3670
3671                    mCodec->signalError(OMX_ErrorUndefined, err);
3672
3673                    // This is technically not correct, but appears to be
3674                    // the only way to free the component instance.
3675                    // Controlled transitioning from excecuting->idle
3676                    // and idle->loaded seem impossible probably because
3677                    // the output port never finishes re-enabling.
3678                    mCodec->mShutdownInProgress = true;
3679                    mCodec->mKeepComponentAllocated = false;
3680                    mCodec->changeState(mCodec->mLoadedState);
3681                }
3682
3683                return true;
3684            } else if (data1 == (OMX_U32)OMX_CommandPortEnable) {
3685                CHECK_EQ(data2, (OMX_U32)kPortIndexOutput);
3686
3687                mCodec->mSentFormat = false;
3688
3689                ALOGV("[%s] Output port now reenabled.",
3690                        mCodec->mComponentName.c_str());
3691
3692                if (mCodec->mExecutingState->active()) {
3693                    mCodec->mExecutingState->submitOutputBuffers();
3694                }
3695
3696                mCodec->changeState(mCodec->mExecutingState);
3697
3698                return true;
3699            }
3700
3701            return false;
3702        }
3703
3704        default:
3705            return false;
3706    }
3707}
3708
3709////////////////////////////////////////////////////////////////////////////////
3710
3711ACodec::ExecutingToIdleState::ExecutingToIdleState(ACodec *codec)
3712    : BaseState(codec),
3713      mComponentNowIdle(false) {
3714}
3715
3716bool ACodec::ExecutingToIdleState::onMessageReceived(const sp<AMessage> &msg) {
3717    bool handled = false;
3718
3719    switch (msg->what()) {
3720        case kWhatFlush:
3721        {
3722            // Don't send me a flush request if you previously wanted me
3723            // to shutdown.
3724            TRESPASS();
3725            break;
3726        }
3727
3728        case kWhatShutdown:
3729        {
3730            // We're already doing that...
3731
3732            handled = true;
3733            break;
3734        }
3735
3736        default:
3737            handled = BaseState::onMessageReceived(msg);
3738            break;
3739    }
3740
3741    return handled;
3742}
3743
3744void ACodec::ExecutingToIdleState::stateEntered() {
3745    ALOGV("[%s] Now Executing->Idle", mCodec->mComponentName.c_str());
3746
3747    mComponentNowIdle = false;
3748    mCodec->mSentFormat = false;
3749}
3750
3751bool ACodec::ExecutingToIdleState::onOMXEvent(
3752        OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
3753    switch (event) {
3754        case OMX_EventCmdComplete:
3755        {
3756            CHECK_EQ(data1, (OMX_U32)OMX_CommandStateSet);
3757            CHECK_EQ(data2, (OMX_U32)OMX_StateIdle);
3758
3759            mComponentNowIdle = true;
3760
3761            changeStateIfWeOwnAllBuffers();
3762
3763            return true;
3764        }
3765
3766        case OMX_EventPortSettingsChanged:
3767        case OMX_EventBufferFlag:
3768        {
3769            // We're shutting down and don't care about this anymore.
3770            return true;
3771        }
3772
3773        default:
3774            return BaseState::onOMXEvent(event, data1, data2);
3775    }
3776}
3777
3778void ACodec::ExecutingToIdleState::changeStateIfWeOwnAllBuffers() {
3779    if (mComponentNowIdle && mCodec->allYourBuffersAreBelongToUs()) {
3780        CHECK_EQ(mCodec->mOMX->sendCommand(
3781                    mCodec->mNode, OMX_CommandStateSet, OMX_StateLoaded),
3782                 (status_t)OK);
3783
3784        CHECK_EQ(mCodec->freeBuffersOnPort(kPortIndexInput), (status_t)OK);
3785        CHECK_EQ(mCodec->freeBuffersOnPort(kPortIndexOutput), (status_t)OK);
3786
3787        if (mCodec->mFlags & kFlagIsSecure && mCodec->mNativeWindow != NULL) {
3788            // We push enough 1x1 blank buffers to ensure that one of
3789            // them has made it to the display.  This allows the OMX
3790            // component teardown to zero out any protected buffers
3791            // without the risk of scanning out one of those buffers.
3792            mCodec->pushBlankBuffersToNativeWindow();
3793        }
3794
3795        mCodec->changeState(mCodec->mIdleToLoadedState);
3796    }
3797}
3798
3799void ACodec::ExecutingToIdleState::onInputBufferFilled(
3800        const sp<AMessage> &msg) {
3801    BaseState::onInputBufferFilled(msg);
3802
3803    changeStateIfWeOwnAllBuffers();
3804}
3805
3806void ACodec::ExecutingToIdleState::onOutputBufferDrained(
3807        const sp<AMessage> &msg) {
3808    BaseState::onOutputBufferDrained(msg);
3809
3810    changeStateIfWeOwnAllBuffers();
3811}
3812
3813////////////////////////////////////////////////////////////////////////////////
3814
3815ACodec::IdleToLoadedState::IdleToLoadedState(ACodec *codec)
3816    : BaseState(codec) {
3817}
3818
3819bool ACodec::IdleToLoadedState::onMessageReceived(const sp<AMessage> &msg) {
3820    bool handled = false;
3821
3822    switch (msg->what()) {
3823        case kWhatShutdown:
3824        {
3825            // We're already doing that...
3826
3827            handled = true;
3828            break;
3829        }
3830
3831        case kWhatFlush:
3832        {
3833            // Don't send me a flush request if you previously wanted me
3834            // to shutdown.
3835            TRESPASS();
3836            break;
3837        }
3838
3839        default:
3840            handled = BaseState::onMessageReceived(msg);
3841            break;
3842    }
3843
3844    return handled;
3845}
3846
3847void ACodec::IdleToLoadedState::stateEntered() {
3848    ALOGV("[%s] Now Idle->Loaded", mCodec->mComponentName.c_str());
3849}
3850
3851bool ACodec::IdleToLoadedState::onOMXEvent(
3852        OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
3853    switch (event) {
3854        case OMX_EventCmdComplete:
3855        {
3856            CHECK_EQ(data1, (OMX_U32)OMX_CommandStateSet);
3857            CHECK_EQ(data2, (OMX_U32)OMX_StateLoaded);
3858
3859            mCodec->changeState(mCodec->mLoadedState);
3860
3861            return true;
3862        }
3863
3864        default:
3865            return BaseState::onOMXEvent(event, data1, data2);
3866    }
3867}
3868
3869////////////////////////////////////////////////////////////////////////////////
3870
3871ACodec::FlushingState::FlushingState(ACodec *codec)
3872    : BaseState(codec) {
3873}
3874
3875void ACodec::FlushingState::stateEntered() {
3876    ALOGV("[%s] Now Flushing", mCodec->mComponentName.c_str());
3877
3878    mFlushComplete[kPortIndexInput] = mFlushComplete[kPortIndexOutput] = false;
3879}
3880
3881bool ACodec::FlushingState::onMessageReceived(const sp<AMessage> &msg) {
3882    bool handled = false;
3883
3884    switch (msg->what()) {
3885        case kWhatShutdown:
3886        {
3887            mCodec->deferMessage(msg);
3888            break;
3889        }
3890
3891        case kWhatFlush:
3892        {
3893            // We're already doing this right now.
3894            handled = true;
3895            break;
3896        }
3897
3898        default:
3899            handled = BaseState::onMessageReceived(msg);
3900            break;
3901    }
3902
3903    return handled;
3904}
3905
3906bool ACodec::FlushingState::onOMXEvent(
3907        OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
3908    ALOGV("[%s] FlushingState onOMXEvent(%d,%ld)",
3909            mCodec->mComponentName.c_str(), event, data1);
3910
3911    switch (event) {
3912        case OMX_EventCmdComplete:
3913        {
3914            CHECK_EQ(data1, (OMX_U32)OMX_CommandFlush);
3915
3916            if (data2 == kPortIndexInput || data2 == kPortIndexOutput) {
3917                CHECK(!mFlushComplete[data2]);
3918                mFlushComplete[data2] = true;
3919
3920                if (mFlushComplete[kPortIndexInput]
3921                        && mFlushComplete[kPortIndexOutput]) {
3922                    changeStateIfWeOwnAllBuffers();
3923                }
3924            } else {
3925                CHECK_EQ(data2, OMX_ALL);
3926                CHECK(mFlushComplete[kPortIndexInput]);
3927                CHECK(mFlushComplete[kPortIndexOutput]);
3928
3929                changeStateIfWeOwnAllBuffers();
3930            }
3931
3932            return true;
3933        }
3934
3935        case OMX_EventPortSettingsChanged:
3936        {
3937            sp<AMessage> msg = new AMessage(kWhatOMXMessage, mCodec->id());
3938            msg->setInt32("type", omx_message::EVENT);
3939            msg->setPointer("node", mCodec->mNode);
3940            msg->setInt32("event", event);
3941            msg->setInt32("data1", data1);
3942            msg->setInt32("data2", data2);
3943
3944            ALOGV("[%s] Deferring OMX_EventPortSettingsChanged",
3945                 mCodec->mComponentName.c_str());
3946
3947            mCodec->deferMessage(msg);
3948
3949            return true;
3950        }
3951
3952        default:
3953            return BaseState::onOMXEvent(event, data1, data2);
3954    }
3955
3956    return true;
3957}
3958
3959void ACodec::FlushingState::onOutputBufferDrained(const sp<AMessage> &msg) {
3960    BaseState::onOutputBufferDrained(msg);
3961
3962    changeStateIfWeOwnAllBuffers();
3963}
3964
3965void ACodec::FlushingState::onInputBufferFilled(const sp<AMessage> &msg) {
3966    BaseState::onInputBufferFilled(msg);
3967
3968    changeStateIfWeOwnAllBuffers();
3969}
3970
3971void ACodec::FlushingState::changeStateIfWeOwnAllBuffers() {
3972    if (mFlushComplete[kPortIndexInput]
3973            && mFlushComplete[kPortIndexOutput]
3974            && mCodec->allYourBuffersAreBelongToUs()) {
3975        sp<AMessage> notify = mCodec->mNotify->dup();
3976        notify->setInt32("what", ACodec::kWhatFlushCompleted);
3977        notify->post();
3978
3979        mCodec->mPortEOS[kPortIndexInput] =
3980            mCodec->mPortEOS[kPortIndexOutput] = false;
3981
3982        mCodec->mInputEOSResult = OK;
3983
3984        mCodec->changeState(mCodec->mExecutingState);
3985    }
3986}
3987
3988}  // namespace android
3989