• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/SkipCutBuffer.h>
26 #include <OMX_Audio.h>
27 
28 namespace android {
29 
30 struct ABuffer;
31 struct MemoryDealer;
32 
33 struct ACodec : public AHierarchicalStateMachine {
34     enum {
35         kWhatFillThisBuffer      = 'fill',
36         kWhatDrainThisBuffer     = 'drai',
37         kWhatEOS                 = 'eos ',
38         kWhatShutdownCompleted   = 'scom',
39         kWhatFlushCompleted      = 'fcom',
40         kWhatOutputFormatChanged = 'outC',
41         kWhatError               = 'erro',
42         kWhatComponentAllocated  = 'cAll',
43         kWhatComponentConfigured = 'cCon',
44         kWhatBuffersAllocated    = 'allc',
45     };
46 
47     ACodec();
48 
49     void setNotificationMessage(const sp<AMessage> &msg);
50     void initiateSetup(const sp<AMessage> &msg);
51     void signalFlush();
52     void signalResume();
53     void initiateShutdown(bool keepComponentAllocated = false);
54 
55     void initiateAllocateComponent(const sp<AMessage> &msg);
56     void initiateConfigureComponent(const sp<AMessage> &msg);
57     void initiateStart();
58 
59     struct PortDescription : public RefBase {
60         size_t countBuffers();
61         IOMX::buffer_id bufferIDAt(size_t index) const;
62         sp<ABuffer> bufferAt(size_t index) const;
63 
64     private:
65         friend struct ACodec;
66 
67         Vector<IOMX::buffer_id> mBufferIDs;
68         Vector<sp<ABuffer> > mBuffers;
69 
70         PortDescription();
71         void addBuffer(IOMX::buffer_id id, const sp<ABuffer> &buffer);
72 
73         DISALLOW_EVIL_CONSTRUCTORS(PortDescription);
74     };
75 
76 protected:
77     virtual ~ACodec();
78 
79 private:
80     struct BaseState;
81     struct UninitializedState;
82     struct LoadedState;
83     struct LoadedToIdleState;
84     struct IdleToExecutingState;
85     struct ExecutingState;
86     struct OutputPortSettingsChangedState;
87     struct ExecutingToIdleState;
88     struct IdleToLoadedState;
89     struct FlushingState;
90 
91     enum {
92         kWhatSetup                   = 'setu',
93         kWhatOMXMessage              = 'omx ',
94         kWhatInputBufferFilled       = 'inpF',
95         kWhatOutputBufferDrained     = 'outD',
96         kWhatShutdown                = 'shut',
97         kWhatFlush                   = 'flus',
98         kWhatResume                  = 'resm',
99         kWhatDrainDeferredMessages   = 'drai',
100         kWhatAllocateComponent       = 'allo',
101         kWhatConfigureComponent      = 'conf',
102         kWhatStart                   = 'star',
103     };
104 
105     enum {
106         kPortIndexInput  = 0,
107         kPortIndexOutput = 1
108     };
109 
110     enum {
111         kFlagIsSecure   = 1,
112     };
113 
114     struct BufferInfo {
115         enum Status {
116             OWNED_BY_US,
117             OWNED_BY_COMPONENT,
118             OWNED_BY_UPSTREAM,
119             OWNED_BY_DOWNSTREAM,
120             OWNED_BY_NATIVE_WINDOW,
121         };
122 
123         IOMX::buffer_id mBufferID;
124         Status mStatus;
125 
126         sp<ABuffer> mData;
127         sp<GraphicBuffer> mGraphicBuffer;
128     };
129 
130     sp<AMessage> mNotify;
131 
132     sp<UninitializedState> mUninitializedState;
133     sp<LoadedState> mLoadedState;
134     sp<LoadedToIdleState> mLoadedToIdleState;
135     sp<IdleToExecutingState> mIdleToExecutingState;
136     sp<ExecutingState> mExecutingState;
137     sp<OutputPortSettingsChangedState> mOutputPortSettingsChangedState;
138     sp<ExecutingToIdleState> mExecutingToIdleState;
139     sp<IdleToLoadedState> mIdleToLoadedState;
140     sp<FlushingState> mFlushingState;
141     sp<SkipCutBuffer> mSkipCutBuffer;
142 
143     AString mComponentName;
144     uint32_t mFlags;
145     uint32_t mQuirks;
146     sp<IOMX> mOMX;
147     IOMX::node_id mNode;
148     sp<MemoryDealer> mDealer[2];
149 
150     sp<ANativeWindow> mNativeWindow;
151 
152     Vector<BufferInfo> mBuffers[2];
153     bool mPortEOS[2];
154     status_t mInputEOSResult;
155 
156     List<sp<AMessage> > mDeferredQueue;
157 
158     bool mSentFormat;
159     bool mIsEncoder;
160 
161     bool mShutdownInProgress;
162 
163     // If "mKeepComponentAllocated" we only transition back to Loaded state
164     // and do not release the component instance.
165     bool mKeepComponentAllocated;
166 
167     int32_t mEncoderDelay;
168     int32_t mEncoderPadding;
169 
170     bool mChannelMaskPresent;
171     int32_t mChannelMask;
172 
173     status_t allocateBuffersOnPort(OMX_U32 portIndex);
174     status_t freeBuffersOnPort(OMX_U32 portIndex);
175     status_t freeBuffer(OMX_U32 portIndex, size_t i);
176 
177     status_t allocateOutputBuffersFromNativeWindow();
178     status_t cancelBufferToNativeWindow(BufferInfo *info);
179     status_t freeOutputBuffersNotOwnedByComponent();
180     BufferInfo *dequeueBufferFromNativeWindow();
181 
182     BufferInfo *findBufferByID(
183             uint32_t portIndex, IOMX::buffer_id bufferID,
184             ssize_t *index = NULL);
185 
186     status_t setComponentRole(bool isEncoder, const char *mime);
187     status_t configureCodec(const char *mime, const sp<AMessage> &msg);
188 
189     status_t setVideoPortFormatType(
190             OMX_U32 portIndex,
191             OMX_VIDEO_CODINGTYPE compressionFormat,
192             OMX_COLOR_FORMATTYPE colorFormat);
193 
194     status_t setSupportedOutputFormat();
195 
196     status_t setupVideoDecoder(
197             const char *mime, int32_t width, int32_t height);
198 
199     status_t setupVideoEncoder(
200             const char *mime, const sp<AMessage> &msg);
201 
202     status_t setVideoFormatOnPort(
203             OMX_U32 portIndex,
204             int32_t width, int32_t height,
205             OMX_VIDEO_CODINGTYPE compressionFormat);
206 
207     status_t setupAACCodec(
208             bool encoder,
209             int32_t numChannels, int32_t sampleRate, int32_t bitRate,
210             int32_t aacProfile, bool isADTS);
211 
212     status_t selectAudioPortFormat(
213             OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE desiredFormat);
214 
215     status_t setupAMRCodec(bool encoder, bool isWAMR, int32_t bitRate);
216     status_t setupG711Codec(bool encoder, int32_t numChannels);
217 
218     status_t setupFlacCodec(
219             bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel);
220 
221     status_t setupRawAudioFormat(
222             OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels);
223 
224     status_t setMinBufferSize(OMX_U32 portIndex, size_t size);
225 
226     status_t setupMPEG4EncoderParameters(const sp<AMessage> &msg);
227     status_t setupH263EncoderParameters(const sp<AMessage> &msg);
228     status_t setupAVCEncoderParameters(const sp<AMessage> &msg);
229 
230     status_t verifySupportForProfileAndLevel(int32_t profile, int32_t level);
231     status_t configureBitrate(int32_t bitrate);
232     status_t setupErrorCorrectionParameters();
233 
234     status_t initNativeWindow();
235 
236     status_t pushBlankBuffersToNativeWindow();
237 
238     // Returns true iff all buffers on the given port have status OWNED_BY_US.
239     bool allYourBuffersAreBelongToUs(OMX_U32 portIndex);
240 
241     bool allYourBuffersAreBelongToUs();
242 
243     size_t countBuffersOwnedByComponent(OMX_U32 portIndex) const;
244 
245     void deferMessage(const sp<AMessage> &msg);
246     void processDeferredMessages();
247 
248     void sendFormatChange();
249 
250     void signalError(
251             OMX_ERRORTYPE error = OMX_ErrorUndefined,
252             status_t internalError = UNKNOWN_ERROR);
253 
254     DISALLOW_EVIL_CONSTRUCTORS(ACodec);
255 };
256 
257 }  // namespace android
258 
259 #endif  // A_CODEC_H_
260