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