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