ACodec.h revision d8cbe4a024ef54adf043b6ea31fa22271b8b2c51 
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/CodecBase.h>
26#include <media/stagefright/SkipCutBuffer.h>
27#include <OMX_Audio.h>
28
29#define TRACK_BUFFER_TIMING     0
30
31namespace android {
32
33struct ABuffer;
34struct MemoryDealer;
35
36struct ACodec : public AHierarchicalStateMachine, public CodecBase {
37    ACodec();
38
39    virtual void setNotificationMessage(const sp<AMessage> &msg);
40
41    void initiateSetup(const sp<AMessage> &msg);
42
43    virtual void initiateAllocateComponent(const sp<AMessage> &msg);
44    virtual void initiateConfigureComponent(const sp<AMessage> &msg);
45    virtual void initiateCreateInputSurface();
46    virtual void initiateStart();
47    virtual void initiateShutdown(bool keepComponentAllocated = false);
48
49    virtual void signalFlush();
50    virtual void signalResume();
51
52    virtual void signalSetParameters(const sp<AMessage> &msg);
53    virtual void signalEndOfInputStream();
54    virtual void signalRequestIDRFrame();
55
56    // AHierarchicalStateMachine implements the message handling
57    virtual void onMessageReceived(const sp<AMessage> &msg) {
58        handleMessage(msg);
59    }
60
61    struct PortDescription : public CodecBase::PortDescription {
62        size_t countBuffers();
63        IOMX::buffer_id bufferIDAt(size_t index) const;
64        sp<ABuffer> bufferAt(size_t index) const;
65
66    private:
67        friend struct ACodec;
68
69        Vector<IOMX::buffer_id> mBufferIDs;
70        Vector<sp<ABuffer> > mBuffers;
71
72        PortDescription();
73        void addBuffer(IOMX::buffer_id id, const sp<ABuffer> &buffer);
74
75        DISALLOW_EVIL_CONSTRUCTORS(PortDescription);
76    };
77
78protected:
79    virtual ~ACodec();
80
81private:
82    struct BaseState;
83    struct UninitializedState;
84    struct LoadedState;
85    struct LoadedToIdleState;
86    struct IdleToExecutingState;
87    struct ExecutingState;
88    struct OutputPortSettingsChangedState;
89    struct ExecutingToIdleState;
90    struct IdleToLoadedState;
91    struct FlushingState;
92    struct DeathNotifier;
93
94    enum {
95        kWhatSetup                   = 'setu',
96        kWhatOMXMessage              = 'omx ',
97        kWhatInputBufferFilled       = 'inpF',
98        kWhatOutputBufferDrained     = 'outD',
99        kWhatShutdown                = 'shut',
100        kWhatFlush                   = 'flus',
101        kWhatResume                  = 'resm',
102        kWhatDrainDeferredMessages   = 'drai',
103        kWhatAllocateComponent       = 'allo',
104        kWhatConfigureComponent      = 'conf',
105        kWhatCreateInputSurface      = 'cisf',
106        kWhatSignalEndOfInputStream  = 'eois',
107        kWhatStart                   = 'star',
108        kWhatRequestIDRFrame         = 'ridr',
109        kWhatSetParameters           = 'setP',
110        kWhatSubmitOutputMetaDataBufferIfEOS = 'subm',
111        kWhatOMXDied                 = 'OMXd',
112    };
113
114    enum {
115        kPortIndexInput  = 0,
116        kPortIndexOutput = 1
117    };
118
119    enum {
120        kFlagIsSecure                                 = 1,
121        kFlagPushBlankBuffersToNativeWindowOnShutdown = 2,
122    };
123
124    struct BufferInfo {
125        enum Status {
126            OWNED_BY_US,
127            OWNED_BY_COMPONENT,
128            OWNED_BY_UPSTREAM,
129            OWNED_BY_DOWNSTREAM,
130            OWNED_BY_NATIVE_WINDOW,
131        };
132
133        IOMX::buffer_id mBufferID;
134        Status mStatus;
135        unsigned mDequeuedAt;
136
137        sp<ABuffer> mData;
138        sp<GraphicBuffer> mGraphicBuffer;
139    };
140
141#if TRACK_BUFFER_TIMING
142    struct BufferStats {
143        int64_t mEmptyBufferTimeUs;
144        int64_t mFillBufferDoneTimeUs;
145    };
146
147    KeyedVector<int64_t, BufferStats> mBufferStats;
148#endif
149
150    sp<AMessage> mNotify;
151
152    sp<UninitializedState> mUninitializedState;
153    sp<LoadedState> mLoadedState;
154    sp<LoadedToIdleState> mLoadedToIdleState;
155    sp<IdleToExecutingState> mIdleToExecutingState;
156    sp<ExecutingState> mExecutingState;
157    sp<OutputPortSettingsChangedState> mOutputPortSettingsChangedState;
158    sp<ExecutingToIdleState> mExecutingToIdleState;
159    sp<IdleToLoadedState> mIdleToLoadedState;
160    sp<FlushingState> mFlushingState;
161    sp<SkipCutBuffer> mSkipCutBuffer;
162
163    AString mComponentName;
164    uint32_t mFlags;
165    uint32_t mQuirks;
166    sp<IOMX> mOMX;
167    IOMX::node_id mNode;
168    sp<MemoryDealer> mDealer[2];
169
170    sp<ANativeWindow> mNativeWindow;
171    sp<AMessage> mInputFormat;
172    sp<AMessage> mOutputFormat;
173
174    Vector<BufferInfo> mBuffers[2];
175    bool mPortEOS[2];
176    status_t mInputEOSResult;
177
178    List<sp<AMessage> > mDeferredQueue;
179
180    bool mSentFormat;
181    bool mIsEncoder;
182    bool mUseMetadataOnEncoderOutput;
183    bool mShutdownInProgress;
184    bool mExplicitShutdown;
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    unsigned mDequeueCounter;
196    bool mStoreMetaDataInOutputBuffers;
197    int32_t mMetaDataBuffersToSubmit;
198    size_t mNumUndequeuedBuffers;
199
200    int64_t mRepeatFrameDelayUs;
201    int64_t mMaxPtsGapUs;
202
203    int64_t mTimePerFrameUs;
204    int64_t mTimePerCaptureUs;
205
206    bool mCreateInputBuffersSuspended;
207
208    status_t setCyclicIntraMacroblockRefresh(const sp<AMessage> &msg, int32_t mode);
209    status_t allocateBuffersOnPort(OMX_U32 portIndex);
210    status_t freeBuffersOnPort(OMX_U32 portIndex);
211    status_t freeBuffer(OMX_U32 portIndex, size_t i);
212
213    status_t configureOutputBuffersFromNativeWindow(
214            OMX_U32 *nBufferCount, OMX_U32 *nBufferSize,
215            OMX_U32 *nMinUndequeuedBuffers);
216    status_t allocateOutputMetaDataBuffers();
217    status_t submitOutputMetaDataBuffer();
218    void signalSubmitOutputMetaDataBufferIfEOS_workaround();
219    status_t allocateOutputBuffersFromNativeWindow();
220    status_t cancelBufferToNativeWindow(BufferInfo *info);
221    status_t freeOutputBuffersNotOwnedByComponent();
222    BufferInfo *dequeueBufferFromNativeWindow();
223
224    BufferInfo *findBufferByID(
225            uint32_t portIndex, IOMX::buffer_id bufferID,
226            ssize_t *index = NULL);
227
228    status_t setComponentRole(bool isEncoder, const char *mime);
229    status_t configureCodec(const char *mime, const sp<AMessage> &msg);
230
231    status_t setVideoPortFormatType(
232            OMX_U32 portIndex,
233            OMX_VIDEO_CODINGTYPE compressionFormat,
234            OMX_COLOR_FORMATTYPE colorFormat);
235
236    status_t setSupportedOutputFormat();
237
238    status_t setupVideoDecoder(
239            const char *mime, int32_t width, int32_t height);
240
241    status_t setupVideoEncoder(
242            const char *mime, const sp<AMessage> &msg);
243
244    status_t setVideoFormatOnPort(
245            OMX_U32 portIndex,
246            int32_t width, int32_t height,
247            OMX_VIDEO_CODINGTYPE compressionFormat);
248
249    status_t setupAACCodec(
250            bool encoder,
251            int32_t numChannels, int32_t sampleRate, int32_t bitRate,
252            int32_t aacProfile, bool isADTS);
253
254    status_t setupAC3Codec(bool encoder, int32_t numChannels, int32_t sampleRate);
255
256    status_t selectAudioPortFormat(
257            OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE desiredFormat);
258
259    status_t setupAMRCodec(bool encoder, bool isWAMR, int32_t bitRate);
260    status_t setupG711Codec(bool encoder, int32_t numChannels);
261
262    status_t setupFlacCodec(
263            bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel);
264
265    status_t setupRawAudioFormat(
266            OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels);
267
268    status_t setMinBufferSize(OMX_U32 portIndex, size_t size);
269
270    status_t setupMPEG4EncoderParameters(const sp<AMessage> &msg);
271    status_t setupH263EncoderParameters(const sp<AMessage> &msg);
272    status_t setupAVCEncoderParameters(const sp<AMessage> &msg);
273    status_t setupHEVCEncoderParameters(const sp<AMessage> &msg);
274    status_t setupVPXEncoderParameters(const sp<AMessage> &msg);
275
276    status_t verifySupportForProfileAndLevel(int32_t profile, int32_t level);
277
278    status_t configureBitrate(
279            int32_t bitrate, OMX_VIDEO_CONTROLRATETYPE bitrateMode);
280
281    status_t setupErrorCorrectionParameters();
282
283    status_t initNativeWindow();
284
285    status_t pushBlankBuffersToNativeWindow();
286
287    // Returns true iff all buffers on the given port have status
288    // OWNED_BY_US or OWNED_BY_NATIVE_WINDOW.
289    bool allYourBuffersAreBelongToUs(OMX_U32 portIndex);
290
291    bool allYourBuffersAreBelongToUs();
292
293    void waitUntilAllPossibleNativeWindowBuffersAreReturnedToUs();
294
295    size_t countBuffersOwnedByComponent(OMX_U32 portIndex) const;
296    size_t countBuffersOwnedByNativeWindow() const;
297
298    void deferMessage(const sp<AMessage> &msg);
299    void processDeferredMessages();
300
301    void sendFormatChange(const sp<AMessage> &reply);
302    status_t getPortFormat(OMX_U32 portIndex, sp<AMessage> &notify);
303
304    void signalError(
305            OMX_ERRORTYPE error = OMX_ErrorUndefined,
306            status_t internalError = UNKNOWN_ERROR);
307
308    status_t requestIDRFrame();
309    status_t setParameters(const sp<AMessage> &params);
310
311    // Send EOS on input stream.
312    void onSignalEndOfInputStream();
313
314    DISALLOW_EVIL_CONSTRUCTORS(ACodec);
315};
316
317}  // namespace android
318
319#endif  // A_CODEC_H_
320