ACodec.h revision 6610a7d621c634fe059b855ca7eb3f58fb8d0757 
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#ifndef A_CODEC_H_
18
19#define A_CODEC_H_
20
21#include <stdint.h>
22#include <android/native_window.h>
23#include <media/IOMX.h>
24#include <media/stagefright/foundation/AHierarchicalStateMachine.h>
25#include <media/stagefright/SkipCutBuffer.h>
26#include <OMX_Audio.h>
27
28#define TRACK_BUFFER_TIMING     0
29
30namespace android {
31
32struct ABuffer;
33struct MemoryDealer;
34
35struct ACodec : public AHierarchicalStateMachine {
36    enum {
37        kWhatFillThisBuffer      = 'fill',
38        kWhatDrainThisBuffer     = 'drai',
39        kWhatEOS                 = 'eos ',
40        kWhatShutdownCompleted   = 'scom',
41        kWhatFlushCompleted      = 'fcom',
42        kWhatOutputFormatChanged = 'outC',
43        kWhatError               = 'erro',
44        kWhatComponentAllocated  = 'cAll',
45        kWhatComponentConfigured = 'cCon',
46        kWhatInputSurfaceCreated = 'isfc',
47        kWhatSignaledInputEOS    = 'seos',
48        kWhatBuffersAllocated    = 'allc',
49        kWhatOMXDied             = 'OMXd',
50    };
51
52    ACodec();
53
54    void setNotificationMessage(const sp<AMessage> &msg);
55    void initiateSetup(const sp<AMessage> &msg);
56    void signalFlush();
57    void signalResume();
58    void initiateShutdown(bool keepComponentAllocated = false);
59
60    void signalSetParameters(const sp<AMessage> &msg);
61    void signalEndOfInputStream();
62
63    void initiateAllocateComponent(const sp<AMessage> &msg);
64    void initiateConfigureComponent(const sp<AMessage> &msg);
65    void initiateCreateInputSurface();
66    void initiateStart();
67
68    void signalRequestIDRFrame();
69
70    struct PortDescription : public RefBase {
71        size_t countBuffers();
72        IOMX::buffer_id bufferIDAt(size_t index) const;
73        sp<ABuffer> bufferAt(size_t index) const;
74
75    private:
76        friend struct ACodec;
77
78        Vector<IOMX::buffer_id> mBufferIDs;
79        Vector<sp<ABuffer> > mBuffers;
80
81        PortDescription();
82        void addBuffer(IOMX::buffer_id id, const sp<ABuffer> &buffer);
83
84        DISALLOW_EVIL_CONSTRUCTORS(PortDescription);
85    };
86
87protected:
88    virtual ~ACodec();
89
90private:
91    struct BaseState;
92    struct UninitializedState;
93    struct LoadedState;
94    struct LoadedToIdleState;
95    struct IdleToExecutingState;
96    struct ExecutingState;
97    struct OutputPortSettingsChangedState;
98    struct ExecutingToIdleState;
99    struct IdleToLoadedState;
100    struct FlushingState;
101    struct DeathNotifier;
102
103    enum {
104        kWhatSetup                   = 'setu',
105        kWhatOMXMessage              = 'omx ',
106        kWhatInputBufferFilled       = 'inpF',
107        kWhatOutputBufferDrained     = 'outD',
108        kWhatShutdown                = 'shut',
109        kWhatFlush                   = 'flus',
110        kWhatResume                  = 'resm',
111        kWhatDrainDeferredMessages   = 'drai',
112        kWhatAllocateComponent       = 'allo',
113        kWhatConfigureComponent      = 'conf',
114        kWhatCreateInputSurface      = 'cisf',
115        kWhatSignalEndOfInputStream  = 'eois',
116        kWhatStart                   = 'star',
117        kWhatRequestIDRFrame         = 'ridr',
118        kWhatSetParameters           = 'setP',
119    };
120
121    enum {
122        kPortIndexInput  = 0,
123        kPortIndexOutput = 1
124    };
125
126    enum {
127        kFlagIsSecure   = 1,
128    };
129
130    struct BufferInfo {
131        enum Status {
132            OWNED_BY_US,
133            OWNED_BY_COMPONENT,
134            OWNED_BY_UPSTREAM,
135            OWNED_BY_DOWNSTREAM,
136            OWNED_BY_NATIVE_WINDOW,
137        };
138
139        IOMX::buffer_id mBufferID;
140        Status mStatus;
141
142        sp<ABuffer> mData;
143        sp<GraphicBuffer> mGraphicBuffer;
144    };
145
146#if TRACK_BUFFER_TIMING
147    struct BufferStats {
148        int64_t mEmptyBufferTimeUs;
149        int64_t mFillBufferDoneTimeUs;
150    };
151
152    KeyedVector<int64_t, BufferStats> mBufferStats;
153#endif
154
155    sp<AMessage> mNotify;
156
157    sp<UninitializedState> mUninitializedState;
158    sp<LoadedState> mLoadedState;
159    sp<LoadedToIdleState> mLoadedToIdleState;
160    sp<IdleToExecutingState> mIdleToExecutingState;
161    sp<ExecutingState> mExecutingState;
162    sp<OutputPortSettingsChangedState> mOutputPortSettingsChangedState;
163    sp<ExecutingToIdleState> mExecutingToIdleState;
164    sp<IdleToLoadedState> mIdleToLoadedState;
165    sp<FlushingState> mFlushingState;
166    sp<SkipCutBuffer> mSkipCutBuffer;
167
168    AString mComponentName;
169    uint32_t mFlags;
170    uint32_t mQuirks;
171    sp<IOMX> mOMX;
172    IOMX::node_id mNode;
173    sp<MemoryDealer> mDealer[2];
174
175    sp<ANativeWindow> mNativeWindow;
176
177    Vector<BufferInfo> mBuffers[2];
178    bool mPortEOS[2];
179    status_t mInputEOSResult;
180
181    List<sp<AMessage> > mDeferredQueue;
182
183    bool mSentFormat;
184    bool mIsEncoder;
185
186    bool mShutdownInProgress;
187
188    // If "mKeepComponentAllocated" we only transition back to Loaded state
189    // and do not release the component instance.
190    bool mKeepComponentAllocated;
191
192    int32_t mEncoderDelay;
193    int32_t mEncoderPadding;
194
195    bool mChannelMaskPresent;
196    int32_t mChannelMask;
197
198    status_t setCyclicIntraMacroblockRefresh(const sp<AMessage> &msg, int32_t mode);
199    status_t allocateBuffersOnPort(OMX_U32 portIndex);
200    status_t freeBuffersOnPort(OMX_U32 portIndex);
201    status_t freeBuffer(OMX_U32 portIndex, size_t i);
202
203    status_t allocateOutputBuffersFromNativeWindow();
204    status_t cancelBufferToNativeWindow(BufferInfo *info);
205    status_t freeOutputBuffersNotOwnedByComponent();
206    BufferInfo *dequeueBufferFromNativeWindow();
207
208    BufferInfo *findBufferByID(
209            uint32_t portIndex, IOMX::buffer_id bufferID,
210            ssize_t *index = NULL);
211
212    status_t setComponentRole(bool isEncoder, const char *mime);
213    status_t configureCodec(const char *mime, const sp<AMessage> &msg);
214
215    status_t setVideoPortFormatType(
216            OMX_U32 portIndex,
217            OMX_VIDEO_CODINGTYPE compressionFormat,
218            OMX_COLOR_FORMATTYPE colorFormat);
219
220    status_t setSupportedOutputFormat();
221
222    status_t setupVideoDecoder(
223            const char *mime, int32_t width, int32_t height);
224
225    status_t setupVideoEncoder(
226            const char *mime, const sp<AMessage> &msg);
227
228    status_t setVideoFormatOnPort(
229            OMX_U32 portIndex,
230            int32_t width, int32_t height,
231            OMX_VIDEO_CODINGTYPE compressionFormat);
232
233    status_t setupAACCodec(
234            bool encoder,
235            int32_t numChannels, int32_t sampleRate, int32_t bitRate,
236            int32_t aacProfile, bool isADTS);
237
238    status_t selectAudioPortFormat(
239            OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE desiredFormat);
240
241    status_t setupAMRCodec(bool encoder, bool isWAMR, int32_t bitRate);
242    status_t setupG711Codec(bool encoder, int32_t numChannels);
243
244    status_t setupFlacCodec(
245            bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel);
246
247    status_t setupRawAudioFormat(
248            OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels);
249
250    status_t setMinBufferSize(OMX_U32 portIndex, size_t size);
251
252    status_t setupMPEG4EncoderParameters(const sp<AMessage> &msg);
253    status_t setupH263EncoderParameters(const sp<AMessage> &msg);
254    status_t setupAVCEncoderParameters(const sp<AMessage> &msg);
255
256    status_t verifySupportForProfileAndLevel(int32_t profile, int32_t level);
257
258    status_t configureBitrate(
259            int32_t bitrate, OMX_VIDEO_CONTROLRATETYPE bitrateMode);
260
261    status_t setupErrorCorrectionParameters();
262
263    status_t initNativeWindow();
264
265    status_t pushBlankBuffersToNativeWindow();
266
267    // Returns true iff all buffers on the given port have status OWNED_BY_US.
268    bool allYourBuffersAreBelongToUs(OMX_U32 portIndex);
269
270    bool allYourBuffersAreBelongToUs();
271
272    size_t countBuffersOwnedByComponent(OMX_U32 portIndex) const;
273
274    void deferMessage(const sp<AMessage> &msg);
275    void processDeferredMessages();
276
277    void sendFormatChange();
278
279    void signalError(
280            OMX_ERRORTYPE error = OMX_ErrorUndefined,
281            status_t internalError = UNKNOWN_ERROR);
282
283    status_t requestIDRFrame();
284    status_t setParameters(const sp<AMessage> &params);
285
286    // Send EOS on input stream.
287    void onSignalEndOfInputStream();
288
289    DISALLOW_EVIL_CONSTRUCTORS(ACodec);
290};
291
292}  // namespace android
293
294#endif  // A_CODEC_H_
295