MediaCodec.h revision a2eb22c1de262aa3fa7c356537ac2fe165afdf3d 
1/*
2 * Copyright 2012, 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 MEDIA_CODEC_H_
18
19#define MEDIA_CODEC_H_
20
21#include <gui/IGraphicBufferProducer.h>
22#include <media/hardware/CryptoAPI.h>
23#include <media/stagefright/foundation/AHandler.h>
24#include <utils/Vector.h>
25
26namespace android {
27
28struct ABuffer;
29struct ACodec;
30struct AMessage;
31struct AString;
32struct ICrypto;
33struct SoftwareRenderer;
34struct SurfaceTextureClient;
35
36struct MediaCodec : public AHandler {
37    enum ConfigureFlags {
38        CONFIGURE_FLAG_ENCODE   = 1,
39    };
40
41    enum BufferFlags {
42        BUFFER_FLAG_SYNCFRAME   = 1,
43        BUFFER_FLAG_CODECCONFIG = 2,
44        BUFFER_FLAG_EOS         = 4,
45    };
46
47    static sp<MediaCodec> CreateByType(
48            const sp<ALooper> &looper, const char *mime, bool encoder);
49
50    static sp<MediaCodec> CreateByComponentName(
51            const sp<ALooper> &looper, const char *name);
52
53    status_t configure(
54            const sp<AMessage> &format,
55            const sp<SurfaceTextureClient> &nativeWindow,
56            const sp<ICrypto> &crypto,
57            uint32_t flags);
58
59    status_t start();
60
61    // Returns to a state in which the component remains allocated but
62    // unconfigured.
63    status_t stop();
64
65    // Client MUST call release before releasing final reference to this
66    // object.
67    status_t release();
68
69    status_t flush();
70
71    status_t queueInputBuffer(
72            size_t index,
73            size_t offset,
74            size_t size,
75            int64_t presentationTimeUs,
76            uint32_t flags,
77            AString *errorDetailMsg = NULL);
78
79    status_t queueSecureInputBuffer(
80            size_t index,
81            size_t offset,
82            const CryptoPlugin::SubSample *subSamples,
83            size_t numSubSamples,
84            const uint8_t key[16],
85            const uint8_t iv[16],
86            CryptoPlugin::Mode mode,
87            int64_t presentationTimeUs,
88            uint32_t flags,
89            AString *errorDetailMsg = NULL);
90
91    status_t dequeueInputBuffer(size_t *index, int64_t timeoutUs = 0ll);
92
93    status_t dequeueOutputBuffer(
94            size_t *index,
95            size_t *offset,
96            size_t *size,
97            int64_t *presentationTimeUs,
98            uint32_t *flags,
99            int64_t timeoutUs = 0ll);
100
101    status_t renderOutputBufferAndRelease(size_t index);
102    status_t releaseOutputBuffer(size_t index);
103
104    status_t getOutputFormat(sp<AMessage> *format) const;
105
106    status_t getInputBuffers(Vector<sp<ABuffer> > *buffers) const;
107    status_t getOutputBuffers(Vector<sp<ABuffer> > *buffers) const;
108
109    status_t requestIDRFrame();
110
111    // Notification will be posted once there "is something to do", i.e.
112    // an input/output buffer has become available, a format change is
113    // pending, an error is pending.
114    void requestActivityNotification(const sp<AMessage> &notify);
115
116    status_t getName(AString *componentName) const;
117
118    status_t setParameters(const sp<AMessage> &params);
119
120protected:
121    virtual ~MediaCodec();
122    virtual void onMessageReceived(const sp<AMessage> &msg);
123
124private:
125    enum State {
126        UNINITIALIZED,
127        INITIALIZING,
128        INITIALIZED,
129        CONFIGURING,
130        CONFIGURED,
131        STARTING,
132        STARTED,
133        FLUSHING,
134        STOPPING,
135        RELEASING,
136    };
137
138    enum {
139        kPortIndexInput         = 0,
140        kPortIndexOutput        = 1,
141    };
142
143    enum {
144        kWhatInit                           = 'init',
145        kWhatConfigure                      = 'conf',
146        kWhatStart                          = 'strt',
147        kWhatStop                           = 'stop',
148        kWhatRelease                        = 'rele',
149        kWhatDequeueInputBuffer             = 'deqI',
150        kWhatQueueInputBuffer               = 'queI',
151        kWhatDequeueOutputBuffer            = 'deqO',
152        kWhatReleaseOutputBuffer            = 'relO',
153        kWhatGetBuffers                     = 'getB',
154        kWhatFlush                          = 'flus',
155        kWhatGetOutputFormat                = 'getO',
156        kWhatDequeueInputTimedOut           = 'dITO',
157        kWhatDequeueOutputTimedOut          = 'dOTO',
158        kWhatCodecNotify                    = 'codc',
159        kWhatRequestIDRFrame                = 'ridr',
160        kWhatRequestActivityNotification    = 'racN',
161        kWhatGetName                        = 'getN',
162        kWhatSetParameters                  = 'setP',
163    };
164
165    enum {
166        kFlagIsSoftwareCodec            = 1,
167        kFlagOutputFormatChanged        = 2,
168        kFlagOutputBuffersChanged       = 4,
169        kFlagStickyError                = 8,
170        kFlagDequeueInputPending        = 16,
171        kFlagDequeueOutputPending       = 32,
172        kFlagIsSecure                   = 64,
173    };
174
175    struct BufferInfo {
176        void *mBufferID;
177        sp<ABuffer> mData;
178        sp<ABuffer> mEncryptedData;
179        sp<AMessage> mNotify;
180        bool mOwnedByClient;
181    };
182
183    State mState;
184    sp<ALooper> mLooper;
185    sp<ALooper> mCodecLooper;
186    sp<ACodec> mCodec;
187    AString mComponentName;
188    uint32_t mReplyID;
189    uint32_t mFlags;
190    sp<SurfaceTextureClient> mNativeWindow;
191    SoftwareRenderer *mSoftRenderer;
192    sp<AMessage> mOutputFormat;
193
194    List<size_t> mAvailPortBuffers[2];
195    Vector<BufferInfo> mPortBuffers[2];
196
197    int32_t mDequeueInputTimeoutGeneration;
198    uint32_t mDequeueInputReplyID;
199
200    int32_t mDequeueOutputTimeoutGeneration;
201    uint32_t mDequeueOutputReplyID;
202
203    sp<ICrypto> mCrypto;
204
205    List<sp<ABuffer> > mCSD;
206
207    sp<AMessage> mActivityNotify;
208
209    MediaCodec(const sp<ALooper> &looper);
210
211    static status_t PostAndAwaitResponse(
212            const sp<AMessage> &msg, sp<AMessage> *response);
213
214    status_t init(const char *name, bool nameIsType, bool encoder);
215
216    void setState(State newState);
217    void returnBuffersToCodec();
218    void returnBuffersToCodecOnPort(int32_t portIndex);
219    size_t updateBuffers(int32_t portIndex, const sp<AMessage> &msg);
220    status_t onQueueInputBuffer(const sp<AMessage> &msg);
221    status_t onReleaseOutputBuffer(const sp<AMessage> &msg);
222    ssize_t dequeuePortBuffer(int32_t portIndex);
223
224    bool handleDequeueInputBuffer(uint32_t replyID, bool newRequest = false);
225    bool handleDequeueOutputBuffer(uint32_t replyID, bool newRequest = false);
226    void cancelPendingDequeueOperations();
227
228    void extractCSD(const sp<AMessage> &format);
229    status_t queueCSDInputBuffer(size_t bufferIndex);
230
231    status_t setNativeWindow(
232            const sp<SurfaceTextureClient> &surfaceTextureClient);
233
234    void postActivityNotificationIfPossible();
235
236    status_t onSetParameters(const sp<AMessage> &params);
237
238    DISALLOW_EVIL_CONSTRUCTORS(MediaCodec);
239};
240
241}  // namespace android
242
243#endif  // MEDIA_CODEC_H_
244