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/FrameRenderTracker.h>
28#include <media/stagefright/MediaDefs.h>
29#include <media/stagefright/SkipCutBuffer.h>
30#include <utils/NativeHandle.h>
31#include <OMX_Audio.h>
32#include <hardware/gralloc.h>
33
34#define TRACK_BUFFER_TIMING     0
35
36namespace android {
37
38struct ABuffer;
39class ACodecBufferChannel;
40class MediaCodecBuffer;
41class MemoryDealer;
42struct DescribeColorFormat2Params;
43struct DataConverter;
44
45// Treble shared memory
46namespace hidl {
47namespace allocator {
48namespace V1_0 {
49struct IAllocator;
50} // V1_0
51} // allocator
52namespace memory {
53namespace V1_0 {
54struct IMemory;
55} // V1_0
56} // memory
57} // hidl
58
59typedef hidl::allocator::V1_0::IAllocator TAllocator;
60typedef hidl::memory::V1_0::IMemory TMemory;
61
62struct ACodec : public AHierarchicalStateMachine, public CodecBase {
63    ACodec();
64
65    void initiateSetup(const sp<AMessage> &msg);
66
67    virtual std::shared_ptr<BufferChannelBase> getBufferChannel() override;
68    virtual void initiateAllocateComponent(const sp<AMessage> &msg);
69    virtual void initiateConfigureComponent(const sp<AMessage> &msg);
70    virtual void initiateCreateInputSurface();
71    virtual void initiateSetInputSurface(const sp<PersistentSurface> &surface);
72    virtual void initiateStart();
73    virtual void initiateShutdown(bool keepComponentAllocated = false);
74
75    virtual status_t queryCapabilities(
76            const AString &name, const AString &mime, bool isEncoder,
77            sp<MediaCodecInfo::Capabilities> *caps);
78
79    virtual status_t setSurface(const sp<Surface> &surface);
80
81    virtual void signalFlush();
82    virtual void signalResume();
83
84    virtual void signalSetParameters(const sp<AMessage> &msg);
85    virtual void signalEndOfInputStream();
86    virtual void signalRequestIDRFrame();
87
88    // AHierarchicalStateMachine implements the message handling
89    virtual void onMessageReceived(const sp<AMessage> &msg) {
90        handleMessage(msg);
91    }
92
93    // Returns 0 if configuration is not supported.  NOTE: this is treated by
94    // some OMX components as auto level, and by others as invalid level.
95    static int /* OMX_VIDEO_AVCLEVELTYPE */ getAVCLevelFor(
96            int width, int height, int rate, int bitrate,
97            OMX_VIDEO_AVCPROFILETYPE profile = OMX_VIDEO_AVCProfileBaseline);
98
99    // Quirk still supported, even though deprecated
100    enum Quirks {
101        kRequiresAllocateBufferOnInputPorts   = 1,
102        kRequiresAllocateBufferOnOutputPorts  = 2,
103    };
104
105    static status_t getOMXChannelMapping(size_t numChannels, OMX_AUDIO_CHANNELTYPE map[]);
106
107    // Save the flag.
108    void setTrebleFlag(bool trebleFlag);
109    // Return the saved flag.
110    bool getTrebleFlag() const;
111
112protected:
113    virtual ~ACodec();
114
115private:
116    struct BaseState;
117    struct UninitializedState;
118    struct LoadedState;
119    struct LoadedToIdleState;
120    struct IdleToExecutingState;
121    struct ExecutingState;
122    struct OutputPortSettingsChangedState;
123    struct ExecutingToIdleState;
124    struct IdleToLoadedState;
125    struct FlushingState;
126    struct DeathNotifier;
127
128    enum {
129        kWhatSetup                   = 'setu',
130        kWhatOMXMessage              = 'omx ',
131        // same as kWhatOMXMessage - but only used with
132        // handleMessage during OMX message-list handling
133        kWhatOMXMessageItem          = 'omxI',
134        kWhatOMXMessageList          = 'omxL',
135        kWhatInputBufferFilled       = 'inpF',
136        kWhatOutputBufferDrained     = 'outD',
137        kWhatShutdown                = 'shut',
138        kWhatFlush                   = 'flus',
139        kWhatResume                  = 'resm',
140        kWhatDrainDeferredMessages   = 'drai',
141        kWhatAllocateComponent       = 'allo',
142        kWhatConfigureComponent      = 'conf',
143        kWhatSetSurface              = 'setS',
144        kWhatCreateInputSurface      = 'cisf',
145        kWhatSetInputSurface         = 'sisf',
146        kWhatSignalEndOfInputStream  = 'eois',
147        kWhatStart                   = 'star',
148        kWhatRequestIDRFrame         = 'ridr',
149        kWhatSetParameters           = 'setP',
150        kWhatSubmitOutputMetadataBufferIfEOS = 'subm',
151        kWhatOMXDied                 = 'OMXd',
152        kWhatReleaseCodecInstance    = 'relC',
153        kWhatForceStateTransition    = 'fstt',
154    };
155
156    enum {
157        kPortIndexInput  = 0,
158        kPortIndexOutput = 1
159    };
160
161    enum {
162        kFlagIsSecure                                 = 1,
163        kFlagPushBlankBuffersToNativeWindowOnShutdown = 2,
164        kFlagIsGrallocUsageProtected                  = 4,
165    };
166
167    enum {
168        kVideoGrallocUsage = (GRALLOC_USAGE_HW_TEXTURE
169                            | GRALLOC_USAGE_HW_COMPOSER
170                            | GRALLOC_USAGE_EXTERNAL_DISP),
171    };
172
173    struct BufferInfo {
174        enum Status {
175            OWNED_BY_US,
176            OWNED_BY_COMPONENT,
177            OWNED_BY_UPSTREAM,
178            OWNED_BY_DOWNSTREAM,
179            OWNED_BY_NATIVE_WINDOW,
180            UNRECOGNIZED,            // not a tracked buffer
181        };
182
183        static inline Status getSafeStatus(BufferInfo *info) {
184            return info == NULL ? UNRECOGNIZED : info->mStatus;
185        }
186
187        IOMX::buffer_id mBufferID;
188        Status mStatus;
189        unsigned mDequeuedAt;
190
191        sp<MediaCodecBuffer> mData;  // the client's buffer; if not using data conversion, this is
192                                     // the codec buffer; otherwise, it is allocated separately
193        sp<RefBase> mMemRef;         // and a reference to the IMemory, so it does not go away
194        sp<MediaCodecBuffer> mCodecData;  // the codec's buffer
195        sp<RefBase> mCodecRef;            // and a reference to the IMemory
196
197        sp<GraphicBuffer> mGraphicBuffer;
198        bool mNewGraphicBuffer;
199        int mFenceFd;
200        FrameRenderTracker::Info *mRenderInfo;
201
202        // The following field and 4 methods are used for debugging only
203        bool mIsReadFence;
204        // Store |fenceFd| and set read/write flag. Log error, if there is already a fence stored.
205        void setReadFence(int fenceFd, const char *dbg);
206        void setWriteFence(int fenceFd, const char *dbg);
207        // Log error, if the current fence is not a read/write fence.
208        void checkReadFence(const char *dbg);
209        void checkWriteFence(const char *dbg);
210    };
211
212    static const char *_asString(BufferInfo::Status s);
213    void dumpBuffers(OMX_U32 portIndex);
214
215    // If |fd| is non-negative, waits for fence with |fd| and logs an error if it fails. Returns
216    // the error code or OK on success. If |fd| is negative, it returns OK
217    status_t waitForFence(int fd, const char *dbg);
218
219#if TRACK_BUFFER_TIMING
220    struct BufferStats {
221        int64_t mEmptyBufferTimeUs;
222        int64_t mFillBufferDoneTimeUs;
223    };
224
225    KeyedVector<int64_t, BufferStats> mBufferStats;
226#endif
227
228    sp<UninitializedState> mUninitializedState;
229    sp<LoadedState> mLoadedState;
230    sp<LoadedToIdleState> mLoadedToIdleState;
231    sp<IdleToExecutingState> mIdleToExecutingState;
232    sp<ExecutingState> mExecutingState;
233    sp<OutputPortSettingsChangedState> mOutputPortSettingsChangedState;
234    sp<ExecutingToIdleState> mExecutingToIdleState;
235    sp<IdleToLoadedState> mIdleToLoadedState;
236    sp<FlushingState> mFlushingState;
237    sp<SkipCutBuffer> mSkipCutBuffer;
238    int32_t mSampleRate;
239
240    AString mComponentName;
241    uint32_t mFlags;
242    sp<IOMX> mOMX;
243    sp<IOMXNode> mOMXNode;
244    int32_t mNodeGeneration;
245    bool mTrebleFlag;
246    sp<TAllocator> mAllocator[2];
247    sp<MemoryDealer> mDealer[2];
248
249    bool mUsingNativeWindow;
250    sp<ANativeWindow> mNativeWindow;
251    int mNativeWindowUsageBits;
252    android_native_rect_t mLastNativeWindowCrop;
253    int32_t mLastNativeWindowDataSpace;
254    sp<AMessage> mConfigFormat;
255    sp<AMessage> mInputFormat;
256    sp<AMessage> mOutputFormat;
257
258    // Initial output format + configuration params that is reused as the base for all subsequent
259    // format updates. This will equal to mOutputFormat until the first actual frame is received.
260    sp<AMessage> mBaseOutputFormat;
261
262    FrameRenderTracker mRenderTracker; // render information for buffers rendered by ACodec
263    Vector<BufferInfo> mBuffers[2];
264    bool mPortEOS[2];
265    status_t mInputEOSResult;
266
267    List<sp<AMessage> > mDeferredQueue;
268
269    sp<AMessage> mLastOutputFormat;
270    bool mIsVideo;
271    bool mIsEncoder;
272    bool mFatalError;
273    bool mShutdownInProgress;
274    bool mExplicitShutdown;
275    bool mIsLegacyVP9Decoder;
276
277    // If "mKeepComponentAllocated" we only transition back to Loaded state
278    // and do not release the component instance.
279    bool mKeepComponentAllocated;
280
281    int32_t mEncoderDelay;
282    int32_t mEncoderPadding;
283    int32_t mRotationDegrees;
284
285    bool mChannelMaskPresent;
286    int32_t mChannelMask;
287    unsigned mDequeueCounter;
288    IOMX::PortMode mPortMode[2];
289    int32_t mMetadataBuffersToSubmit;
290    size_t mNumUndequeuedBuffers;
291    sp<DataConverter> mConverter[2];
292
293    sp<IGraphicBufferSource> mGraphicBufferSource;
294    int64_t mRepeatFrameDelayUs;
295    int64_t mMaxPtsGapUs;
296    float mMaxFps;
297    double mFps;
298    double mCaptureFps;
299    bool mCreateInputBuffersSuspended;
300    uint32_t mLatency;
301
302    bool mTunneled;
303
304    OMX_INDEXTYPE mDescribeColorAspectsIndex;
305    OMX_INDEXTYPE mDescribeHDRStaticInfoIndex;
306
307    std::shared_ptr<ACodecBufferChannel> mBufferChannel;
308
309    int32_t mStateGeneration;
310
311    enum {
312        kExtensionsUnchecked,
313        kExtensionsNone,
314        kExtensionsExist,
315    } mVendorExtensionsStatus;
316
317    status_t setCyclicIntraMacroblockRefresh(const sp<AMessage> &msg, int32_t mode);
318    status_t allocateBuffersOnPort(OMX_U32 portIndex);
319    status_t freeBuffersOnPort(OMX_U32 portIndex);
320    status_t freeBuffer(OMX_U32 portIndex, size_t i);
321
322    status_t handleSetSurface(const sp<Surface> &surface);
323    status_t setPortMode(int32_t portIndex, IOMX::PortMode mode);
324    status_t setupNativeWindowSizeFormatAndUsage(
325            ANativeWindow *nativeWindow /* nonnull */, int *finalUsage /* nonnull */,
326            bool reconnect);
327
328    status_t configureOutputBuffersFromNativeWindow(
329            OMX_U32 *nBufferCount, OMX_U32 *nBufferSize,
330            OMX_U32 *nMinUndequeuedBuffers, bool preregister);
331    status_t allocateOutputMetadataBuffers();
332    status_t submitOutputMetadataBuffer();
333    void signalSubmitOutputMetadataBufferIfEOS_workaround();
334    status_t allocateOutputBuffersFromNativeWindow();
335    status_t cancelBufferToNativeWindow(BufferInfo *info);
336    status_t freeOutputBuffersNotOwnedByComponent();
337    BufferInfo *dequeueBufferFromNativeWindow();
338
339    inline bool storingMetadataInDecodedBuffers() {
340        return (mPortMode[kPortIndexOutput] == IOMX::kPortModeDynamicANWBuffer) && !mIsEncoder;
341    }
342
343    inline bool usingSecureBufferOnEncoderOutput() {
344        return (mPortMode[kPortIndexOutput] == IOMX::kPortModePresetSecureBuffer) && mIsEncoder;
345    }
346
347    BufferInfo *findBufferByID(
348            uint32_t portIndex, IOMX::buffer_id bufferID,
349            ssize_t *index = NULL);
350
351    status_t fillBuffer(BufferInfo *info);
352
353    status_t setComponentRole(bool isEncoder, const char *mime);
354
355    status_t configureCodec(const char *mime, const sp<AMessage> &msg);
356
357    status_t configureTunneledVideoPlayback(int32_t audioHwSync,
358            const sp<ANativeWindow> &nativeWindow);
359
360    status_t setVideoPortFormatType(
361            OMX_U32 portIndex,
362            OMX_VIDEO_CODINGTYPE compressionFormat,
363            OMX_COLOR_FORMATTYPE colorFormat,
364            bool usingNativeBuffers = false);
365
366    status_t setSupportedOutputFormat(bool getLegacyFlexibleFormat);
367
368    status_t setupVideoDecoder(
369            const char *mime, const sp<AMessage> &msg, bool usingNativeBuffers, bool haveSwRenderer,
370            sp<AMessage> &outputformat);
371
372    status_t setupVideoEncoder(
373            const char *mime, const sp<AMessage> &msg,
374            sp<AMessage> &outputformat, sp<AMessage> &inputformat);
375
376    status_t setVideoFormatOnPort(
377            OMX_U32 portIndex,
378            int32_t width, int32_t height,
379            OMX_VIDEO_CODINGTYPE compressionFormat, float frameRate = -1.0);
380
381    // sets |portIndex| port buffer numbers to be |bufferNum|. NOTE: Component could reject
382    // this setting if the |bufferNum| is less than the minimum buffer num of the port.
383    status_t setPortBufferNum(OMX_U32 portIndex, int bufferNum);
384
385    // gets index or sets it to 0 on error. Returns error from codec.
386    status_t initDescribeColorAspectsIndex();
387
388    // sets |params|. If |readBack| is true, it re-gets them afterwards if set succeeded.
389    // returns the codec error.
390    status_t setCodecColorAspects(DescribeColorAspectsParams &params, bool readBack = false);
391
392    // gets |params|; returns the codec error. |param| should not change on error.
393    status_t getCodecColorAspects(DescribeColorAspectsParams &params);
394
395    // gets dataspace guidance from codec and platform. |params| should be set up with the color
396    // aspects to use. If |tryCodec| is true, the codec is queried first. If it succeeds, we
397    // return OK. Otherwise, we fall back to the platform guidance and return the codec error;
398    // though, we return OK if the codec failed with UNSUPPORTED, as codec guidance is optional.
399    status_t getDataSpace(
400            DescribeColorAspectsParams &params, android_dataspace *dataSpace /* nonnull */,
401            bool tryCodec);
402
403    // sets color aspects for the encoder for certain |width/height| based on |configFormat|, and
404    // set resulting color config into |outputFormat|. If |usingNativeWindow| is true, we use
405    // video defaults if config is unspecified. Returns error from the codec.
406    status_t setColorAspectsForVideoDecoder(
407            int32_t width, int32_t height, bool usingNativeWindow,
408            const sp<AMessage> &configFormat, sp<AMessage> &outputFormat);
409
410    // gets color aspects for the encoder for certain |width/height| based on |configFormat|, and
411    // set resulting color config into |outputFormat|. If |dataSpace| is non-null, it requests
412    // dataspace guidance from the codec and platform and sets it into |dataSpace|. Returns the
413    // error from the codec.
414    status_t getColorAspectsAndDataSpaceForVideoDecoder(
415            int32_t width, int32_t height, const sp<AMessage> &configFormat,
416            sp<AMessage> &outputFormat, android_dataspace *dataSpace);
417
418    // sets color aspects for the video encoder assuming bytebuffer mode for certain |configFormat|
419    // and sets resulting color config into |outputFormat|. For mediarecorder, also set dataspace
420    // into |inputFormat|. Returns the error from the codec.
421    status_t setColorAspectsForVideoEncoder(
422            const sp<AMessage> &configFormat,
423            sp<AMessage> &outputFormat, sp<AMessage> &inputFormat);
424
425    // sets color aspects for the video encoder in surface mode. This basically sets the default
426    // video values for unspecified aspects and sets the dataspace to use in the input format.
427    // Also sets the dataspace into |dataSpace|.
428    // Returns any codec errors during this configuration, except for optional steps.
429    status_t setInitialColorAspectsForVideoEncoderSurfaceAndGetDataSpace(
430            android_dataspace *dataSpace /* nonnull */);
431
432    // gets color aspects for the video encoder input port and sets them into the |format|.
433    // Returns any codec errors.
434    status_t getInputColorAspectsForVideoEncoder(sp<AMessage> &format);
435
436    // updates the encoder output format with |aspects| defaulting to |dataSpace| for
437    // unspecified values.
438    void onDataSpaceChanged(android_dataspace dataSpace, const ColorAspects &aspects);
439
440    // gets index or sets it to 0 on error. Returns error from codec.
441    status_t initDescribeHDRStaticInfoIndex();
442
443    // sets HDR static metadata for the video encoder/decoder based on |configFormat|, and
444    // sets resulting HDRStaticInfo config into |outputFormat|. Returns error from the codec.
445    status_t setHDRStaticInfoForVideoCodec(
446            OMX_U32 portIndex, const sp<AMessage> &configFormat, sp<AMessage> &outputFormat);
447
448    // sets |params|. Returns the codec error.
449    status_t setHDRStaticInfo(const DescribeHDRStaticInfoParams &params);
450
451    // gets |params|. Returns the codec error.
452    status_t getHDRStaticInfo(DescribeHDRStaticInfoParams &params);
453
454    // gets HDR static information for the video encoder/decoder port and sets them into |format|.
455    status_t getHDRStaticInfoForVideoCodec(OMX_U32 portIndex, sp<AMessage> &format);
456
457    typedef struct drcParams {
458        int32_t drcCut;
459        int32_t drcBoost;
460        int32_t heavyCompression;
461        int32_t targetRefLevel;
462        int32_t encodedTargetLevel;
463    } drcParams_t;
464
465    status_t setupAACCodec(
466            bool encoder,
467            int32_t numChannels, int32_t sampleRate, int32_t bitRate,
468            int32_t aacProfile, bool isADTS, int32_t sbrMode,
469            int32_t maxOutputChannelCount, const drcParams_t& drc,
470            int32_t pcmLimiterEnable);
471
472    status_t setupAC3Codec(bool encoder, int32_t numChannels, int32_t sampleRate);
473
474    status_t setupEAC3Codec(bool encoder, int32_t numChannels, int32_t sampleRate);
475
476    status_t selectAudioPortFormat(
477            OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE desiredFormat);
478
479    status_t setupAMRCodec(bool encoder, bool isWAMR, int32_t bitRate);
480    status_t setupG711Codec(bool encoder, int32_t sampleRate, int32_t numChannels);
481
482    status_t setupFlacCodec(
483            bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel);
484
485    status_t setupRawAudioFormat(
486            OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels,
487            AudioEncoding encoding = kAudioEncodingPcm16bit);
488
489    status_t setPriority(int32_t priority);
490    status_t setLatency(uint32_t latency);
491    status_t getLatency(uint32_t *latency);
492    status_t setOperatingRate(float rateFloat, bool isVideo);
493    status_t getIntraRefreshPeriod(uint32_t *intraRefreshPeriod);
494    status_t setIntraRefreshPeriod(uint32_t intraRefreshPeriod, bool inConfigure);
495
496    // Configures temporal layering based on |msg|. |inConfigure| shall be true iff this is called
497    // during configure() call. on success the configured layering is set in |outputFormat|. If
498    // |outputFormat| is mOutputFormat, it is copied to trigger an output format changed event.
499    status_t configureTemporalLayers(
500            const sp<AMessage> &msg, bool inConfigure, sp<AMessage> &outputFormat);
501
502    status_t setMinBufferSize(OMX_U32 portIndex, size_t size);
503
504    status_t setupMPEG4EncoderParameters(const sp<AMessage> &msg);
505    status_t setupH263EncoderParameters(const sp<AMessage> &msg);
506    status_t setupAVCEncoderParameters(const sp<AMessage> &msg);
507    status_t setupHEVCEncoderParameters(const sp<AMessage> &msg);
508    status_t setupVPXEncoderParameters(const sp<AMessage> &msg, sp<AMessage> &outputFormat);
509
510    status_t verifySupportForProfileAndLevel(int32_t profile, int32_t level);
511
512    status_t configureBitrate(
513            int32_t bitrate, OMX_VIDEO_CONTROLRATETYPE bitrateMode);
514    void configureEncoderLatency(const sp<AMessage> &msg);
515
516    status_t setupErrorCorrectionParameters();
517
518    // Returns true iff all buffers on the given port have status
519    // OWNED_BY_US or OWNED_BY_NATIVE_WINDOW.
520    bool allYourBuffersAreBelongToUs(OMX_U32 portIndex);
521
522    bool allYourBuffersAreBelongToUs();
523
524    void waitUntilAllPossibleNativeWindowBuffersAreReturnedToUs();
525
526    size_t countBuffersOwnedByComponent(OMX_U32 portIndex) const;
527    size_t countBuffersOwnedByNativeWindow() const;
528
529    void deferMessage(const sp<AMessage> &msg);
530    void processDeferredMessages();
531
532    void onFrameRendered(int64_t mediaTimeUs, nsecs_t systemNano);
533    // called when we have dequeued a buffer |buf| from the native window to track render info.
534    // |fenceFd| is the dequeue fence, and |info| points to the buffer info where this buffer is
535    // stored.
536    void updateRenderInfoForDequeuedBuffer(
537            ANativeWindowBuffer *buf, int fenceFd, BufferInfo *info);
538
539    // Checks to see if any frames have rendered up until |until|, and to notify client
540    // (MediaCodec) of rendered frames up-until the frame pointed to by |until| or the first
541    // unrendered frame. These frames are removed from the render queue.
542    // If |dropIncomplete| is true, unrendered frames up-until |until| will be dropped from the
543    // queue, allowing all rendered framed up till then to be notified of.
544    // (This will effectively clear the render queue up-until (and including) |until|.)
545    // If |until| is NULL, or is not in the rendered queue, this method will check all frames.
546    void notifyOfRenderedFrames(
547            bool dropIncomplete = false, FrameRenderTracker::Info *until = NULL);
548
549    // Pass |expectedFormat| to print a warning if the format differs from it.
550    // Using sp<> instead of const sp<>& because expectedFormat is likely the current mOutputFormat
551    // which will get updated inside.
552    void onOutputFormatChanged(sp<const AMessage> expectedFormat = NULL);
553    void addKeyFormatChangesToRenderBufferNotification(sp<AMessage> &notify);
554    void sendFormatChange();
555
556    status_t getPortFormat(OMX_U32 portIndex, sp<AMessage> &notify);
557
558    void signalError(
559            OMX_ERRORTYPE error = OMX_ErrorUndefined,
560            status_t internalError = UNKNOWN_ERROR);
561
562    status_t requestIDRFrame();
563    status_t setParameters(const sp<AMessage> &params);
564
565    // set vendor extension parameters specified in params that are supported by the codec
566    status_t setVendorParameters(const sp<AMessage> &params);
567
568    // get vendor extension parameters supported by the codec for a specific port and add it to
569    // |format|
570    status_t getVendorParameters(OMX_U32 portIndex, sp<AMessage> &format);
571
572    // Send EOS on input stream.
573    void onSignalEndOfInputStream();
574
575    // Force EXEC->IDLE->LOADED shutdown sequence if not stale.
576    void forceStateTransition(int generation);
577
578    DISALLOW_EVIL_CONSTRUCTORS(ACodec);
579};
580
581}  // namespace android
582
583#endif  // A_CODEC_H_
584