ACodec.h revision 8f469e18c307cb9dc0d16ed9225972aa8be4516f 
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 initiateSetInputSurface(const sp<PersistentSurface> &surface);
48    virtual void initiateStart();
49    virtual void initiateShutdown(bool keepComponentAllocated = false);
50
51    virtual status_t setSurface(const sp<Surface> &surface);
52
53    virtual void signalFlush();
54    virtual void signalResume();
55
56    virtual void signalSetParameters(const sp<AMessage> &msg);
57    virtual void signalEndOfInputStream();
58    virtual void signalRequestIDRFrame();
59
60    // AHierarchicalStateMachine implements the message handling
61    virtual void onMessageReceived(const sp<AMessage> &msg) {
62        handleMessage(msg);
63    }
64
65    struct PortDescription : public CodecBase::PortDescription {
66        size_t countBuffers();
67        IOMX::buffer_id bufferIDAt(size_t index) const;
68        sp<ABuffer> bufferAt(size_t index) const;
69
70    private:
71        friend struct ACodec;
72
73        Vector<IOMX::buffer_id> mBufferIDs;
74        Vector<sp<ABuffer> > mBuffers;
75
76        PortDescription();
77        void addBuffer(IOMX::buffer_id id, const sp<ABuffer> &buffer);
78
79        DISALLOW_EVIL_CONSTRUCTORS(PortDescription);
80    };
81
82    static bool isFlexibleColorFormat(
83            const sp<IOMX> &omx, IOMX::node_id node,
84            uint32_t colorFormat, bool usingNativeBuffers, OMX_U32 *flexibleEquivalent);
85
86    // Returns 0 if configuration is not supported.  NOTE: this is treated by
87    // some OMX components as auto level, and by others as invalid level.
88    static int /* OMX_VIDEO_AVCLEVELTYPE */ getAVCLevelFor(
89            int width, int height, int rate, int bitrate,
90            OMX_VIDEO_AVCPROFILETYPE profile = OMX_VIDEO_AVCProfileBaseline);
91
92protected:
93    virtual ~ACodec();
94
95private:
96    struct BaseState;
97    struct UninitializedState;
98    struct LoadedState;
99    struct LoadedToIdleState;
100    struct IdleToExecutingState;
101    struct ExecutingState;
102    struct OutputPortSettingsChangedState;
103    struct ExecutingToIdleState;
104    struct IdleToLoadedState;
105    struct FlushingState;
106    struct DeathNotifier;
107
108    enum {
109        kWhatSetup                   = 'setu',
110        kWhatOMXMessage              = 'omx ',
111        kWhatInputBufferFilled       = 'inpF',
112        kWhatOutputBufferDrained     = 'outD',
113        kWhatShutdown                = 'shut',
114        kWhatFlush                   = 'flus',
115        kWhatResume                  = 'resm',
116        kWhatDrainDeferredMessages   = 'drai',
117        kWhatAllocateComponent       = 'allo',
118        kWhatConfigureComponent      = 'conf',
119        kWhatSetSurface              = 'setS',
120        kWhatCreateInputSurface      = 'cisf',
121        kWhatSetInputSurface         = 'sisf',
122        kWhatSignalEndOfInputStream  = 'eois',
123        kWhatStart                   = 'star',
124        kWhatRequestIDRFrame         = 'ridr',
125        kWhatSetParameters           = 'setP',
126        kWhatSubmitOutputMetaDataBufferIfEOS = 'subm',
127        kWhatOMXDied                 = 'OMXd',
128        kWhatReleaseCodecInstance    = 'relC',
129    };
130
131    enum {
132        kPortIndexInput  = 0,
133        kPortIndexOutput = 1
134    };
135
136    enum {
137        kFlagIsSecure                                 = 1,
138        kFlagPushBlankBuffersToNativeWindowOnShutdown = 2,
139        kFlagIsGrallocUsageProtected                  = 4,
140    };
141
142    struct BufferInfo {
143        enum Status {
144            OWNED_BY_US,
145            OWNED_BY_COMPONENT,
146            OWNED_BY_UPSTREAM,
147            OWNED_BY_DOWNSTREAM,
148            OWNED_BY_NATIVE_WINDOW,
149        };
150
151        IOMX::buffer_id mBufferID;
152        Status mStatus;
153        unsigned mDequeuedAt;
154
155        sp<ABuffer> mData;
156        sp<GraphicBuffer> mGraphicBuffer;
157    };
158
159#if TRACK_BUFFER_TIMING
160    struct BufferStats {
161        int64_t mEmptyBufferTimeUs;
162        int64_t mFillBufferDoneTimeUs;
163    };
164
165    KeyedVector<int64_t, BufferStats> mBufferStats;
166#endif
167
168    sp<AMessage> mNotify;
169
170    sp<UninitializedState> mUninitializedState;
171    sp<LoadedState> mLoadedState;
172    sp<LoadedToIdleState> mLoadedToIdleState;
173    sp<IdleToExecutingState> mIdleToExecutingState;
174    sp<ExecutingState> mExecutingState;
175    sp<OutputPortSettingsChangedState> mOutputPortSettingsChangedState;
176    sp<ExecutingToIdleState> mExecutingToIdleState;
177    sp<IdleToLoadedState> mIdleToLoadedState;
178    sp<FlushingState> mFlushingState;
179    sp<SkipCutBuffer> mSkipCutBuffer;
180
181    AString mComponentName;
182    uint32_t mFlags;
183    uint32_t mQuirks;
184    sp<IOMX> mOMX;
185    IOMX::node_id mNode;
186    sp<MemoryDealer> mDealer[2];
187
188    sp<ANativeWindow> mNativeWindow;
189    sp<AMessage> mInputFormat;
190    sp<AMessage> mOutputFormat;
191    sp<AMessage> mBaseOutputFormat;
192
193    Vector<BufferInfo> mBuffers[2];
194    bool mPortEOS[2];
195    status_t mInputEOSResult;
196
197    List<sp<AMessage> > mDeferredQueue;
198
199    bool mSentFormat;
200    bool mIsVideo;
201    bool mIsEncoder;
202    bool mUseMetadataOnEncoderOutput;
203    bool mShutdownInProgress;
204    bool mExplicitShutdown;
205
206    // If "mKeepComponentAllocated" we only transition back to Loaded state
207    // and do not release the component instance.
208    bool mKeepComponentAllocated;
209
210    int32_t mEncoderDelay;
211    int32_t mEncoderPadding;
212    int32_t mRotationDegrees;
213
214    bool mChannelMaskPresent;
215    int32_t mChannelMask;
216    unsigned mDequeueCounter;
217    bool mStoreMetaDataInOutputBuffers;
218    int32_t mMetaDataBuffersToSubmit;
219    size_t mNumUndequeuedBuffers;
220
221    int64_t mRepeatFrameDelayUs;
222    int64_t mMaxPtsGapUs;
223    float mMaxFps;
224
225    int64_t mTimePerFrameUs;
226    int64_t mTimePerCaptureUs;
227
228    bool mCreateInputBuffersSuspended;
229
230    bool mTunneled;
231
232    status_t setCyclicIntraMacroblockRefresh(const sp<AMessage> &msg, int32_t mode);
233    status_t allocateBuffersOnPort(OMX_U32 portIndex);
234    status_t freeBuffersOnPort(OMX_U32 portIndex);
235    status_t freeBuffer(OMX_U32 portIndex, size_t i);
236
237    status_t handleSetSurface(const sp<Surface> &surface);
238    status_t setupNativeWindowSizeFormatAndUsage(ANativeWindow *nativeWindow /* nonnull */);
239
240    status_t configureOutputBuffersFromNativeWindow(
241            OMX_U32 *nBufferCount, OMX_U32 *nBufferSize,
242            OMX_U32 *nMinUndequeuedBuffers);
243    status_t allocateOutputMetaDataBuffers();
244    status_t submitOutputMetaDataBuffer();
245    void signalSubmitOutputMetaDataBufferIfEOS_workaround();
246    status_t allocateOutputBuffersFromNativeWindow();
247    status_t cancelBufferToNativeWindow(BufferInfo *info);
248    status_t freeOutputBuffersNotOwnedByComponent();
249    BufferInfo *dequeueBufferFromNativeWindow();
250
251    BufferInfo *findBufferByID(
252            uint32_t portIndex, IOMX::buffer_id bufferID,
253            ssize_t *index = NULL);
254
255    status_t setComponentRole(bool isEncoder, const char *mime);
256    status_t configureCodec(const char *mime, const sp<AMessage> &msg);
257
258    status_t configureTunneledVideoPlayback(int32_t audioHwSync,
259            const sp<ANativeWindow> &nativeWindow);
260
261    status_t setVideoPortFormatType(
262            OMX_U32 portIndex,
263            OMX_VIDEO_CODINGTYPE compressionFormat,
264            OMX_COLOR_FORMATTYPE colorFormat,
265            bool usingNativeBuffers = false);
266
267    status_t setSupportedOutputFormat(bool getLegacyFlexibleFormat);
268
269    status_t setupVideoDecoder(
270            const char *mime, const sp<AMessage> &msg, bool usingNativeBuffers);
271
272    status_t setupVideoEncoder(
273            const char *mime, const sp<AMessage> &msg);
274
275    status_t setVideoFormatOnPort(
276            OMX_U32 portIndex,
277            int32_t width, int32_t height,
278            OMX_VIDEO_CODINGTYPE compressionFormat, float frameRate = -1.0);
279
280    typedef struct drcParams {
281        int32_t drcCut;
282        int32_t drcBoost;
283        int32_t heavyCompression;
284        int32_t targetRefLevel;
285        int32_t encodedTargetLevel;
286    } drcParams_t;
287
288    status_t setupAACCodec(
289            bool encoder,
290            int32_t numChannels, int32_t sampleRate, int32_t bitRate,
291            int32_t aacProfile, bool isADTS, int32_t sbrMode,
292            int32_t maxOutputChannelCount, const drcParams_t& drc,
293            int32_t pcmLimiterEnable);
294
295    status_t setupAC3Codec(bool encoder, int32_t numChannels, int32_t sampleRate);
296
297    status_t setupEAC3Codec(bool encoder, int32_t numChannels, int32_t sampleRate);
298
299    status_t selectAudioPortFormat(
300            OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE desiredFormat);
301
302    status_t setupAMRCodec(bool encoder, bool isWAMR, int32_t bitRate);
303    status_t setupG711Codec(bool encoder, int32_t sampleRate, int32_t numChannels);
304
305    status_t setupFlacCodec(
306            bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel);
307
308    status_t setupRawAudioFormat(
309            OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels);
310
311    status_t setPriority(int32_t priority);
312    status_t setOperatingRate(float rateFloat, bool isVideo);
313
314    status_t setMinBufferSize(OMX_U32 portIndex, size_t size);
315
316    status_t setupMPEG4EncoderParameters(const sp<AMessage> &msg);
317    status_t setupH263EncoderParameters(const sp<AMessage> &msg);
318    status_t setupAVCEncoderParameters(const sp<AMessage> &msg);
319    status_t setupHEVCEncoderParameters(const sp<AMessage> &msg);
320    status_t setupVPXEncoderParameters(const sp<AMessage> &msg);
321
322    status_t verifySupportForProfileAndLevel(int32_t profile, int32_t level);
323
324    status_t configureBitrate(
325            int32_t bitrate, OMX_VIDEO_CONTROLRATETYPE bitrateMode);
326
327    status_t setupErrorCorrectionParameters();
328
329    status_t initNativeWindow();
330
331    // Returns true iff all buffers on the given port have status
332    // OWNED_BY_US or OWNED_BY_NATIVE_WINDOW.
333    bool allYourBuffersAreBelongToUs(OMX_U32 portIndex);
334
335    bool allYourBuffersAreBelongToUs();
336
337    void waitUntilAllPossibleNativeWindowBuffersAreReturnedToUs();
338
339    size_t countBuffersOwnedByComponent(OMX_U32 portIndex) const;
340    size_t countBuffersOwnedByNativeWindow() const;
341
342    void deferMessage(const sp<AMessage> &msg);
343    void processDeferredMessages();
344
345    void sendFormatChange(const sp<AMessage> &reply);
346    status_t getPortFormat(OMX_U32 portIndex, sp<AMessage> &notify);
347
348    void signalError(
349            OMX_ERRORTYPE error = OMX_ErrorUndefined,
350            status_t internalError = UNKNOWN_ERROR);
351
352    static bool describeDefaultColorFormat(DescribeColorFormatParams &describeParams);
353    static bool describeColorFormat(
354        const sp<IOMX> &omx, IOMX::node_id node,
355        DescribeColorFormatParams &describeParams);
356
357    status_t requestIDRFrame();
358    status_t setParameters(const sp<AMessage> &params);
359
360    // Send EOS on input stream.
361    void onSignalEndOfInputStream();
362
363    DISALLOW_EVIL_CONSTRUCTORS(ACodec);
364};
365
366}  // namespace android
367
368#endif  // A_CODEC_H_
369