OMXCodec.h revision 456db75516efc889e1ee4e5e16021e77c03b0941 
1/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef OMX_CODEC_H_
18
19#define OMX_CODEC_H_
20
21#include <media/IOMX.h>
22#include <media/stagefright/MediaBuffer.h>
23#include <media/stagefright/MediaSource.h>
24#include <utils/threads.h>
25
26namespace android {
27
28class MemoryDealer;
29struct OMXCodecObserver;
30
31struct OMXCodec : public MediaSource,
32                  public MediaBufferObserver {
33    static sp<OMXCodec> Create(
34            const sp<IOMX> &omx,
35            const sp<MetaData> &meta, bool createEncoder,
36            const sp<MediaSource> &source);
37
38    virtual status_t start(MetaData *params = NULL);
39    virtual status_t stop();
40
41    virtual sp<MetaData> getFormat();
42
43    virtual status_t read(
44            MediaBuffer **buffer, const ReadOptions *options = NULL);
45
46    void on_message(const omx_message &msg);
47
48    // from MediaBufferObserver
49    virtual void signalBufferReturned(MediaBuffer *buffer);
50
51protected:
52    virtual ~OMXCodec();
53
54private:
55    enum State {
56        DEAD,
57        LOADED,
58        LOADED_TO_IDLE,
59        IDLE_TO_EXECUTING,
60        EXECUTING,
61        EXECUTING_TO_IDLE,
62        IDLE_TO_LOADED,
63        RECONFIGURING,
64        ERROR
65    };
66
67    enum {
68        kPortIndexInput  = 0,
69        kPortIndexOutput = 1
70    };
71
72    enum PortStatus {
73        ENABLED,
74        DISABLING,
75        DISABLED,
76        ENABLING,
77        SHUTTING_DOWN,
78    };
79
80    enum Quirks {
81        kNeedsFlushBeforeDisable             = 1,
82        kWantsNALFragments                   = 2,
83        kRequiresLoadedToIdleAfterAllocation = 4,
84        kRequiresAllocateBufferOnInputPorts  = 8,
85        kRequiresFlushCompleteEmulation      = 16,
86        kRequiresAllocateBufferOnOutputPorts = 32,
87        kRequiresFlushBeforeShutdown         = 64,
88    };
89
90    struct BufferInfo {
91        IOMX::buffer_id mBuffer;
92        bool mOwnedByComponent;
93        sp<IMemory> mMem;
94        MediaBuffer *mMediaBuffer;
95    };
96
97    struct CodecSpecificData {
98        size_t mSize;
99        uint8_t mData[1];
100    };
101
102    sp<IOMX> mOMX;
103    IOMX::node_id mNode;
104    sp<OMXCodecObserver> mObserver;
105    uint32_t mQuirks;
106    bool mIsEncoder;
107    char *mMIME;
108    char *mComponentName;
109    sp<MetaData> mOutputFormat;
110    sp<MediaSource> mSource;
111    Vector<CodecSpecificData *> mCodecSpecificData;
112    size_t mCodecSpecificDataIndex;
113
114    sp<MemoryDealer> mDealer[2];
115
116    State mState;
117    Vector<BufferInfo> mPortBuffers[2];
118    PortStatus mPortStatus[2];
119    bool mInitialBufferSubmit;
120    bool mSignalledEOS;
121    bool mNoMoreOutputData;
122    int64_t mSeekTimeUs;
123
124    Mutex mLock;
125    Condition mAsyncCompletion;
126
127    // A list of indices into mPortStatus[kPortIndexOutput] filled with data.
128    List<size_t> mFilledBuffers;
129    Condition mBufferFilled;
130
131    OMXCodec(const sp<IOMX> &omx, IOMX::node_id node, uint32_t quirks,
132             bool isEncoder, const char *mime, const char *componentName,
133             const sp<MediaSource> &source);
134
135    void addCodecSpecificData(const void *data, size_t size);
136    void clearCodecSpecificData();
137
138    void setComponentRole();
139
140    void setAMRFormat();
141    void setAMRWBFormat();
142    void setAACFormat(int32_t numChannels, int32_t sampleRate);
143
144    status_t setVideoPortFormatType(
145            OMX_U32 portIndex,
146            OMX_VIDEO_CODINGTYPE compressionFormat,
147            OMX_COLOR_FORMATTYPE colorFormat);
148
149    void setVideoInputFormat(
150            const char *mime, OMX_U32 width, OMX_U32 height);
151
152    void setVideoOutputFormat(
153            const char *mime, OMX_U32 width, OMX_U32 height);
154
155    void setImageOutputFormat(
156            OMX_COLOR_FORMATTYPE format, OMX_U32 width, OMX_U32 height);
157
158    void setJPEGInputFormat(
159            OMX_U32 width, OMX_U32 height, OMX_U32 compressedSize);
160
161    void setMinBufferSize(OMX_U32 portIndex, OMX_U32 size);
162
163    void setRawAudioFormat(
164            OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels);
165
166    status_t allocateBuffers();
167    status_t allocateBuffersOnPort(OMX_U32 portIndex);
168
169    status_t freeBuffersOnPort(
170            OMX_U32 portIndex, bool onlyThoseWeOwn = false);
171
172    void drainInputBuffer(IOMX::buffer_id buffer);
173    void fillOutputBuffer(IOMX::buffer_id buffer);
174    void drainInputBuffer(BufferInfo *info);
175    void fillOutputBuffer(BufferInfo *info);
176
177    void drainInputBuffers();
178    void fillOutputBuffers();
179
180    // Returns true iff a flush was initiated and a completion event is
181    // upcoming, false otherwise (A flush was not necessary as we own all
182    // the buffers on that port).
183    // This method will ONLY ever return false for a component with quirk
184    // "kRequiresFlushCompleteEmulation".
185    bool flushPortAsync(OMX_U32 portIndex);
186
187    void disablePortAsync(OMX_U32 portIndex);
188    void enablePortAsync(OMX_U32 portIndex);
189
190    static size_t countBuffersWeOwn(const Vector<BufferInfo> &buffers);
191    static bool isIntermediateState(State state);
192
193    void onEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
194    void onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data);
195    void onStateChange(OMX_STATETYPE newState);
196    void onPortSettingsChanged(OMX_U32 portIndex);
197
198    void setState(State newState);
199
200    status_t init();
201    void initOutputFormat(const sp<MetaData> &inputFormat);
202
203    void dumpPortStatus(OMX_U32 portIndex);
204
205    OMXCodec(const OMXCodec &);
206    OMXCodec &operator=(const OMXCodec &);
207};
208
209}  // namespace android
210
211#endif  // OMX_CODEC_H_
212