OMXCodec.h revision d07139e2e817a9b3ae9c87ba4e1e8d65d3e549da 
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    enum CreationFlags {
34        kPreferSoftwareCodecs = 1,
35    };
36    static sp<MediaSource> Create(
37            const sp<IOMX> &omx,
38            const sp<MetaData> &meta, bool createEncoder,
39            const sp<MediaSource> &source,
40            const char *matchComponentName = NULL,
41            uint32_t flags = 0);
42
43    static void setComponentRole(
44            const sp<IOMX> &omx, IOMX::node_id node, bool isEncoder,
45            const char *mime);
46
47    virtual status_t start(MetaData *params = NULL);
48    virtual status_t stop();
49
50    virtual sp<MetaData> getFormat();
51
52    virtual status_t read(
53            MediaBuffer **buffer, const ReadOptions *options = NULL);
54
55    void on_message(const omx_message &msg);
56
57    // from MediaBufferObserver
58    virtual void signalBufferReturned(MediaBuffer *buffer);
59
60protected:
61    virtual ~OMXCodec();
62
63private:
64    enum State {
65        DEAD,
66        LOADED,
67        LOADED_TO_IDLE,
68        IDLE_TO_EXECUTING,
69        EXECUTING,
70        EXECUTING_TO_IDLE,
71        IDLE_TO_LOADED,
72        RECONFIGURING,
73        ERROR
74    };
75
76    enum {
77        kPortIndexInput  = 0,
78        kPortIndexOutput = 1
79    };
80
81    enum PortStatus {
82        ENABLED,
83        DISABLING,
84        DISABLED,
85        ENABLING,
86        SHUTTING_DOWN,
87    };
88
89    enum Quirks {
90        kNeedsFlushBeforeDisable              = 1,
91        kWantsNALFragments                    = 2,
92        kRequiresLoadedToIdleAfterAllocation  = 4,
93        kRequiresAllocateBufferOnInputPorts   = 8,
94        kRequiresFlushCompleteEmulation       = 16,
95        kRequiresAllocateBufferOnOutputPorts  = 32,
96        kRequiresFlushBeforeShutdown          = 64,
97        kDefersOutputBufferAllocation         = 128,
98        kDecoderLiesAboutNumberOfChannels     = 256,
99        kInputBufferSizesAreBogus             = 512,
100        kSupportsMultipleFramesPerInputBuffer = 1024,
101        kAvoidMemcopyInputRecordingFrames     = 2048,
102    };
103
104    struct BufferInfo {
105        IOMX::buffer_id mBuffer;
106        bool mOwnedByComponent;
107        sp<IMemory> mMem;
108        size_t mSize;
109        void *mData;
110        MediaBuffer *mMediaBuffer;
111    };
112
113    struct CodecSpecificData {
114        size_t mSize;
115        uint8_t mData[1];
116    };
117
118    sp<IOMX> mOMX;
119    bool mOMXLivesLocally;
120    IOMX::node_id mNode;
121    uint32_t mQuirks;
122    bool mIsEncoder;
123    char *mMIME;
124    char *mComponentName;
125    sp<MetaData> mOutputFormat;
126    sp<MediaSource> mSource;
127    Vector<CodecSpecificData *> mCodecSpecificData;
128    size_t mCodecSpecificDataIndex;
129
130    sp<MemoryDealer> mDealer[2];
131
132    State mState;
133    Vector<BufferInfo> mPortBuffers[2];
134    PortStatus mPortStatus[2];
135    bool mInitialBufferSubmit;
136    bool mSignalledEOS;
137    status_t mFinalStatus;
138    bool mNoMoreOutputData;
139    bool mOutputPortSettingsHaveChanged;
140    int64_t mSeekTimeUs;
141
142    MediaBuffer *mLeftOverBuffer;
143
144    Mutex mLock;
145    Condition mAsyncCompletion;
146
147    // A list of indices into mPortStatus[kPortIndexOutput] filled with data.
148    List<size_t> mFilledBuffers;
149    Condition mBufferFilled;
150
151    OMXCodec(const sp<IOMX> &omx, IOMX::node_id node, uint32_t quirks,
152             bool isEncoder, const char *mime, const char *componentName,
153             const sp<MediaSource> &source);
154
155    void addCodecSpecificData(const void *data, size_t size);
156    void clearCodecSpecificData();
157
158    void setComponentRole();
159
160    void setAMRFormat(bool isWAMR, int32_t bitRate);
161    void setAACFormat(int32_t numChannels, int32_t sampleRate, int32_t bitRate);
162
163    status_t setVideoPortFormatType(
164            OMX_U32 portIndex,
165            OMX_VIDEO_CODINGTYPE compressionFormat,
166            OMX_COLOR_FORMATTYPE colorFormat);
167
168    void setVideoInputFormat(
169            const char *mime, OMX_U32 width, OMX_U32 height,
170            OMX_U32 frameRate, OMX_U32 bitRate);
171
172    status_t setupMPEG4EncoderParameters();
173    status_t setupAVCEncoderParameters();
174
175    status_t setVideoOutputFormat(
176            const char *mime, OMX_U32 width, OMX_U32 height);
177
178    void setImageOutputFormat(
179            OMX_COLOR_FORMATTYPE format, OMX_U32 width, OMX_U32 height);
180
181    void setJPEGInputFormat(
182            OMX_U32 width, OMX_U32 height, OMX_U32 compressedSize);
183
184    void setMinBufferSize(OMX_U32 portIndex, OMX_U32 size);
185
186    void setRawAudioFormat(
187            OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels);
188
189    status_t allocateBuffers();
190    status_t allocateBuffersOnPort(OMX_U32 portIndex);
191
192    status_t freeBuffersOnPort(
193            OMX_U32 portIndex, bool onlyThoseWeOwn = false);
194
195    void drainInputBuffer(IOMX::buffer_id buffer);
196    void fillOutputBuffer(IOMX::buffer_id buffer);
197    void drainInputBuffer(BufferInfo *info);
198    void fillOutputBuffer(BufferInfo *info);
199
200    void drainInputBuffers();
201    void fillOutputBuffers();
202
203    // Returns true iff a flush was initiated and a completion event is
204    // upcoming, false otherwise (A flush was not necessary as we own all
205    // the buffers on that port).
206    // This method will ONLY ever return false for a component with quirk
207    // "kRequiresFlushCompleteEmulation".
208    bool flushPortAsync(OMX_U32 portIndex);
209
210    void disablePortAsync(OMX_U32 portIndex);
211    void enablePortAsync(OMX_U32 portIndex);
212
213    static size_t countBuffersWeOwn(const Vector<BufferInfo> &buffers);
214    static bool isIntermediateState(State state);
215
216    void onEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2);
217    void onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data);
218    void onStateChange(OMX_STATETYPE newState);
219    void onPortSettingsChanged(OMX_U32 portIndex);
220
221    void setState(State newState);
222
223    status_t init();
224    void initOutputFormat(const sp<MetaData> &inputFormat);
225
226    void dumpPortStatus(OMX_U32 portIndex);
227
228    status_t configureCodec(const sp<MetaData> &meta);
229
230    static uint32_t getComponentQuirks(const char *componentName);
231
232    static void findMatchingCodecs(
233            const char *mime,
234            bool createEncoder, const char *matchComponentName,
235            uint32_t flags,
236            Vector<String8> *matchingCodecs);
237
238    OMXCodec(const OMXCodec &);
239    OMXCodec &operator=(const OMXCodec &);
240};
241
242struct CodecProfileLevel {
243    OMX_U32 mProfile;
244    OMX_U32 mLevel;
245};
246
247struct CodecCapabilities {
248    String8 mComponentName;
249    Vector<CodecProfileLevel> mProfileLevels;
250};
251
252// Return a vector of componentNames with supported profile/level pairs
253// supporting the given mime type, if queryDecoders==true, returns components
254// that decode content of the given type, otherwise returns components
255// that encode content of the given type.
256// profile and level indications only make sense for h.263, mpeg4 and avc
257// video.
258// The profile/level values correspond to
259// OMX_VIDEO_H263PROFILETYPE, OMX_VIDEO_MPEG4PROFILETYPE,
260// OMX_VIDEO_AVCPROFILETYPE, OMX_VIDEO_H263LEVELTYPE, OMX_VIDEO_MPEG4LEVELTYPE
261// and OMX_VIDEO_AVCLEVELTYPE respectively.
262
263status_t QueryCodecs(
264        const sp<IOMX> &omx,
265        const char *mimeType, bool queryDecoders,
266        Vector<CodecCapabilities> *results);
267
268}  // namespace android
269
270#endif  // OMX_CODEC_H_
271