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