Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2009 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 OMX_CODEC_H_ |
| 18 | |
| 19 | #define OMX_CODEC_H_ |
| 20 | |
Jamie Gennis | 58a36ad | 2010-10-07 14:08:38 -0700 | [diff] [blame] | 21 | #include <android/native_window.h> |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 22 | #include <media/IOMX.h> |
| 23 | #include <media/stagefright/MediaBuffer.h> |
| 24 | #include <media/stagefright/MediaSource.h> |
| 25 | #include <utils/threads.h> |
| 26 | |
| 27 | namespace android { |
| 28 | |
Andreas Huber | 3d3864f | 2012-02-29 15:47:17 -0800 | [diff] [blame] | 29 | struct MediaCodecList; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 30 | class MemoryDealer; |
| 31 | struct OMXCodecObserver; |
James Dong | 81c929a | 2010-07-01 15:02:14 -0700 | [diff] [blame] | 32 | struct CodecProfileLevel; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 33 | |
| 34 | struct OMXCodec : public MediaSource, |
| 35 | public MediaBufferObserver { |
Andreas Huber | e13526a | 2009-10-22 10:43:34 -0700 | [diff] [blame] | 36 | enum CreationFlags { |
Andreas Huber | 4c19bf9 | 2010-09-08 14:32:20 -0700 | [diff] [blame] | 37 | kPreferSoftwareCodecs = 1, |
Andreas Huber | 5a40e39 | 2010-10-18 09:57:42 -0700 | [diff] [blame] | 38 | kIgnoreCodecSpecificData = 2, |
| 39 | |
| 40 | // The client wants to access the output buffer's video |
| 41 | // data for example for thumbnail extraction. |
| 42 | kClientNeedsFramebuffer = 4, |
James Dong | 170a929 | 2010-10-22 17:28:15 -0700 | [diff] [blame] | 43 | |
| 44 | // Request for software or hardware codecs. If request |
| 45 | // can not be fullfilled, Create() returns NULL. |
| 46 | kSoftwareCodecsOnly = 8, |
| 47 | kHardwareCodecsOnly = 16, |
James Dong | 05c2fd5 | 2010-11-02 13:20:11 -0700 | [diff] [blame] | 48 | |
| 49 | // Store meta data in video buffers |
| 50 | kStoreMetaDataInVideoBuffers = 32, |
James Dong | 5f3ab06 | 2011-01-25 16:31:28 -0800 | [diff] [blame] | 51 | |
| 52 | // Only submit one input buffer at one time. |
| 53 | kOnlySubmitOneInputBufferAtOneTime = 64, |
Glenn Kasten | b8763f6 | 2011-01-28 12:37:51 -0800 | [diff] [blame] | 54 | |
| 55 | // Enable GRALLOC_USAGE_PROTECTED for output buffers from native window |
| 56 | kEnableGrallocUsageProtected = 128, |
Andreas Huber | 42fb5d6 | 2011-06-29 15:53:28 -0700 | [diff] [blame] | 57 | |
| 58 | // Secure decoding mode |
| 59 | kUseSecureInputBuffers = 256, |
Andreas Huber | e13526a | 2009-10-22 10:43:34 -0700 | [diff] [blame] | 60 | }; |
Andreas Huber | 91eb035 | 2009-12-07 09:43:00 -0800 | [diff] [blame] | 61 | static sp<MediaSource> Create( |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 62 | const sp<IOMX> &omx, |
| 63 | const sp<MetaData> &meta, bool createEncoder, |
Andreas Huber | e6c4096 | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 64 | const sp<MediaSource> &source, |
Andreas Huber | e13526a | 2009-10-22 10:43:34 -0700 | [diff] [blame] | 65 | const char *matchComponentName = NULL, |
Jamie Gennis | 58a36ad | 2010-10-07 14:08:38 -0700 | [diff] [blame] | 66 | uint32_t flags = 0, |
| 67 | const sp<ANativeWindow> &nativeWindow = NULL); |
Andreas Huber | e6c4096 | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 68 | |
| 69 | static void setComponentRole( |
| 70 | const sp<IOMX> &omx, IOMX::node_id node, bool isEncoder, |
| 71 | const char *mime); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 72 | |
| 73 | virtual status_t start(MetaData *params = NULL); |
| 74 | virtual status_t stop(); |
| 75 | |
| 76 | virtual sp<MetaData> getFormat(); |
| 77 | |
| 78 | virtual status_t read( |
| 79 | MediaBuffer **buffer, const ReadOptions *options = NULL); |
| 80 | |
Andreas Huber | 1f24b30 | 2010-06-10 11:12:39 -0700 | [diff] [blame] | 81 | virtual status_t pause(); |
| 82 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 83 | // from MediaBufferObserver |
| 84 | virtual void signalBufferReturned(MediaBuffer *buffer); |
| 85 | |
Andreas Huber | 3d3864f | 2012-02-29 15:47:17 -0800 | [diff] [blame] | 86 | enum Quirks { |
| 87 | kNeedsFlushBeforeDisable = 1, |
| 88 | kWantsNALFragments = 2, |
| 89 | kRequiresLoadedToIdleAfterAllocation = 4, |
| 90 | kRequiresAllocateBufferOnInputPorts = 8, |
| 91 | kRequiresFlushCompleteEmulation = 16, |
| 92 | kRequiresAllocateBufferOnOutputPorts = 32, |
| 93 | kRequiresFlushBeforeShutdown = 64, |
| 94 | kDefersOutputBufferAllocation = 128, |
| 95 | kDecoderLiesAboutNumberOfChannels = 256, |
| 96 | kInputBufferSizesAreBogus = 512, |
| 97 | kSupportsMultipleFramesPerInputBuffer = 1024, |
| 98 | kAvoidMemcopyInputRecordingFrames = 2048, |
| 99 | kRequiresLargerEncoderOutputBuffer = 4096, |
| 100 | kOutputBuffersAreUnreadable = 8192, |
| 101 | }; |
| 102 | |
Andreas Huber | e366f52 | 2011-06-28 10:51:41 -0700 | [diff] [blame] | 103 | // for use by ACodec |
| 104 | static void findMatchingCodecs( |
| 105 | const char *mime, |
| 106 | bool createEncoder, const char *matchComponentName, |
| 107 | uint32_t flags, |
Andreas Huber | 3d3864f | 2012-02-29 15:47:17 -0800 | [diff] [blame] | 108 | Vector<String8> *matchingCodecs, |
| 109 | Vector<uint32_t> *matchingCodecQuirks = NULL); |
| 110 | |
| 111 | static uint32_t getComponentQuirks( |
| 112 | const MediaCodecList *list, size_t index); |
| 113 | |
| 114 | static bool findCodecQuirks(const char *componentName, uint32_t *quirks); |
Andreas Huber | e366f52 | 2011-06-28 10:51:41 -0700 | [diff] [blame] | 115 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 116 | protected: |
| 117 | virtual ~OMXCodec(); |
| 118 | |
| 119 | private: |
James Dong | 681e89c | 2011-01-10 08:55:02 -0800 | [diff] [blame] | 120 | |
| 121 | // Make sure mLock is accessible to OMXCodecObserver |
| 122 | friend class OMXCodecObserver; |
| 123 | |
| 124 | // Call this with mLock hold |
| 125 | void on_message(const omx_message &msg); |
| 126 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 127 | enum State { |
| 128 | DEAD, |
| 129 | LOADED, |
| 130 | LOADED_TO_IDLE, |
| 131 | IDLE_TO_EXECUTING, |
| 132 | EXECUTING, |
| 133 | EXECUTING_TO_IDLE, |
| 134 | IDLE_TO_LOADED, |
| 135 | RECONFIGURING, |
| 136 | ERROR |
| 137 | }; |
| 138 | |
| 139 | enum { |
| 140 | kPortIndexInput = 0, |
| 141 | kPortIndexOutput = 1 |
| 142 | }; |
| 143 | |
| 144 | enum PortStatus { |
| 145 | ENABLED, |
| 146 | DISABLING, |
| 147 | DISABLED, |
| 148 | ENABLING, |
| 149 | SHUTTING_DOWN, |
| 150 | }; |
| 151 | |
Andreas Huber | bbbcf65 | 2010-12-07 14:25:54 -0800 | [diff] [blame] | 152 | enum BufferStatus { |
| 153 | OWNED_BY_US, |
| 154 | OWNED_BY_COMPONENT, |
| 155 | OWNED_BY_NATIVE_WINDOW, |
| 156 | OWNED_BY_CLIENT, |
| 157 | }; |
| 158 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 159 | struct BufferInfo { |
| 160 | IOMX::buffer_id mBuffer; |
Andreas Huber | bbbcf65 | 2010-12-07 14:25:54 -0800 | [diff] [blame] | 161 | BufferStatus mStatus; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 162 | sp<IMemory> mMem; |
Andreas Huber | c712b9f | 2010-01-20 15:05:46 -0800 | [diff] [blame] | 163 | size_t mSize; |
| 164 | void *mData; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 165 | MediaBuffer *mMediaBuffer; |
| 166 | }; |
| 167 | |
| 168 | struct CodecSpecificData { |
| 169 | size_t mSize; |
| 170 | uint8_t mData[1]; |
| 171 | }; |
| 172 | |
| 173 | sp<IOMX> mOMX; |
Andreas Huber | f1fe064 | 2010-01-15 15:28:19 -0800 | [diff] [blame] | 174 | bool mOMXLivesLocally; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 175 | IOMX::node_id mNode; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 176 | uint32_t mQuirks; |
Andreas Huber | 42fb5d6 | 2011-06-29 15:53:28 -0700 | [diff] [blame] | 177 | |
| 178 | // Flags specified in the creation of the codec. |
| 179 | uint32_t mFlags; |
| 180 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 181 | bool mIsEncoder; |
Andreas Huber | afe02df | 2012-01-26 14:39:50 -0800 | [diff] [blame] | 182 | bool mIsVideo; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 183 | char *mMIME; |
| 184 | char *mComponentName; |
| 185 | sp<MetaData> mOutputFormat; |
| 186 | sp<MediaSource> mSource; |
| 187 | Vector<CodecSpecificData *> mCodecSpecificData; |
| 188 | size_t mCodecSpecificDataIndex; |
| 189 | |
Andreas Huber | 5c0a913 | 2009-08-20 11:16:40 -0700 | [diff] [blame] | 190 | sp<MemoryDealer> mDealer[2]; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 191 | |
| 192 | State mState; |
| 193 | Vector<BufferInfo> mPortBuffers[2]; |
| 194 | PortStatus mPortStatus[2]; |
Andreas Huber | 42978e5 | 2009-08-27 10:08:39 -0700 | [diff] [blame] | 195 | bool mInitialBufferSubmit; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 196 | bool mSignalledEOS; |
Andreas Huber | d7d22eb | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 197 | status_t mFinalStatus; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 198 | bool mNoMoreOutputData; |
Andreas Huber | cfd5557 | 2009-10-09 14:11:28 -0700 | [diff] [blame] | 199 | bool mOutputPortSettingsHaveChanged; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 200 | int64_t mSeekTimeUs; |
Andreas Huber | 6624c9f | 2010-07-20 15:04:28 -0700 | [diff] [blame] | 201 | ReadOptions::SeekMode mSeekMode; |
| 202 | int64_t mTargetTimeUs; |
Andreas Huber | b928983 | 2011-02-08 13:10:25 -0800 | [diff] [blame] | 203 | bool mOutputPortSettingsChangedPending; |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 204 | |
Andreas Huber | a4357ad | 2010-04-02 12:49:54 -0700 | [diff] [blame] | 205 | MediaBuffer *mLeftOverBuffer; |
| 206 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 207 | Mutex mLock; |
| 208 | Condition mAsyncCompletion; |
| 209 | |
Andreas Huber | 1f24b30 | 2010-06-10 11:12:39 -0700 | [diff] [blame] | 210 | bool mPaused; |
| 211 | |
Jamie Gennis | 58a36ad | 2010-10-07 14:08:38 -0700 | [diff] [blame] | 212 | sp<ANativeWindow> mNativeWindow; |
| 213 | |
| 214 | // The index in each of the mPortBuffers arrays of the buffer that will be |
| 215 | // submitted to OMX next. This only applies when using buffers from a |
| 216 | // native window. |
| 217 | size_t mNextNativeBufferIndex[2]; |
| 218 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 219 | // A list of indices into mPortStatus[kPortIndexOutput] filled with data. |
| 220 | List<size_t> mFilledBuffers; |
| 221 | Condition mBufferFilled; |
| 222 | |
James Dong | 4108b1ed | 2011-06-07 19:45:54 -0700 | [diff] [blame] | 223 | // Used to record the decoding time for an output picture from |
| 224 | // a video encoder. |
| 225 | List<int64_t> mDecodingTimeList; |
| 226 | |
Andreas Huber | 42fb5d6 | 2011-06-29 15:53:28 -0700 | [diff] [blame] | 227 | OMXCodec(const sp<IOMX> &omx, IOMX::node_id node, |
| 228 | uint32_t quirks, uint32_t flags, |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 229 | bool isEncoder, const char *mime, const char *componentName, |
Jamie Gennis | 58a36ad | 2010-10-07 14:08:38 -0700 | [diff] [blame] | 230 | const sp<MediaSource> &source, |
| 231 | const sp<ANativeWindow> &nativeWindow); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 232 | |
| 233 | void addCodecSpecificData(const void *data, size_t size); |
| 234 | void clearCodecSpecificData(); |
| 235 | |
Andreas Huber | 4c48342 | 2009-09-02 16:05:36 -0700 | [diff] [blame] | 236 | void setComponentRole(); |
| 237 | |
James Dong | 17299ab | 2010-05-14 15:45:22 -0700 | [diff] [blame] | 238 | void setAMRFormat(bool isWAMR, int32_t bitRate); |
Gilles-Arnaud Bleu-Laine | 9a6ed36 | 2011-09-15 21:30:13 -0500 | [diff] [blame] | 239 | status_t setAACFormat(int32_t numChannels, int32_t sampleRate, int32_t bitRate); |
Andreas Huber | 4b3913a | 2011-05-11 14:13:42 -0700 | [diff] [blame] | 240 | void setG711Format(int32_t numChannels); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 241 | |
| 242 | status_t setVideoPortFormatType( |
| 243 | OMX_U32 portIndex, |
| 244 | OMX_VIDEO_CODINGTYPE compressionFormat, |
| 245 | OMX_COLOR_FORMATTYPE colorFormat); |
| 246 | |
| 247 | void setVideoInputFormat( |
James Dong | 1244eab | 2010-06-08 11:58:53 -0700 | [diff] [blame] | 248 | const char *mime, const sp<MetaData>& meta); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 249 | |
James Dong | c0ab2a6 | 2010-06-29 16:29:19 -0700 | [diff] [blame] | 250 | status_t setupBitRate(int32_t bitRate); |
| 251 | status_t setupErrorCorrectionParameters(); |
| 252 | status_t setupH263EncoderParameters(const sp<MetaData>& meta); |
James Dong | 1244eab | 2010-06-08 11:58:53 -0700 | [diff] [blame] | 253 | status_t setupMPEG4EncoderParameters(const sp<MetaData>& meta); |
| 254 | status_t setupAVCEncoderParameters(const sp<MetaData>& meta); |
James Dong | afd97e8 | 2010-08-03 17:19:23 -0700 | [diff] [blame] | 255 | status_t findTargetColorFormat( |
| 256 | const sp<MetaData>& meta, OMX_COLOR_FORMATTYPE *colorFormat); |
| 257 | |
| 258 | status_t isColorFormatSupported( |
| 259 | OMX_COLOR_FORMATTYPE colorFormat, int portIndex); |
Andreas Huber | b482ce8 | 2009-10-29 12:02:48 -0700 | [diff] [blame] | 260 | |
James Dong | 81c929a | 2010-07-01 15:02:14 -0700 | [diff] [blame] | 261 | // If profile/level is set in the meta data, its value in the meta |
| 262 | // data will be used; otherwise, the default value will be used. |
| 263 | status_t getVideoProfileLevel(const sp<MetaData>& meta, |
| 264 | const CodecProfileLevel& defaultProfileLevel, |
| 265 | CodecProfileLevel& profileLevel); |
| 266 | |
Andreas Huber | 2a09c7e | 2010-03-16 11:44:07 -0700 | [diff] [blame] | 267 | status_t setVideoOutputFormat( |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 268 | const char *mime, OMX_U32 width, OMX_U32 height); |
| 269 | |
| 270 | void setImageOutputFormat( |
| 271 | OMX_COLOR_FORMATTYPE format, OMX_U32 width, OMX_U32 height); |
| 272 | |
Andreas Huber | 5c0a913 | 2009-08-20 11:16:40 -0700 | [diff] [blame] | 273 | void setJPEGInputFormat( |
| 274 | OMX_U32 width, OMX_U32 height, OMX_U32 compressedSize); |
| 275 | |
Andreas Huber | da050cf2 | 2009-09-02 14:01:43 -0700 | [diff] [blame] | 276 | void setMinBufferSize(OMX_U32 portIndex, OMX_U32 size); |
| 277 | |
| 278 | void setRawAudioFormat( |
| 279 | OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels); |
| 280 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 281 | status_t allocateBuffers(); |
| 282 | status_t allocateBuffersOnPort(OMX_U32 portIndex); |
Jamie Gennis | 58a36ad | 2010-10-07 14:08:38 -0700 | [diff] [blame] | 283 | status_t allocateOutputBuffersFromNativeWindow(); |
| 284 | |
| 285 | status_t queueBufferToNativeWindow(BufferInfo *info); |
| 286 | status_t cancelBufferToNativeWindow(BufferInfo *info); |
| 287 | BufferInfo* dequeueBufferFromNativeWindow(); |
Jamie Gennis | c0e4293 | 2011-10-25 14:50:16 -0700 | [diff] [blame] | 288 | status_t pushBlankBuffersToNativeWindow(); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 289 | |
| 290 | status_t freeBuffersOnPort( |
| 291 | OMX_U32 portIndex, bool onlyThoseWeOwn = false); |
| 292 | |
Jamie Gennis | f0c5c1e | 2010-11-01 16:04:31 -0700 | [diff] [blame] | 293 | status_t freeBuffer(OMX_U32 portIndex, size_t bufIndex); |
| 294 | |
Andreas Huber | bbbcf65 | 2010-12-07 14:25:54 -0800 | [diff] [blame] | 295 | bool drainInputBuffer(IOMX::buffer_id buffer); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 296 | void fillOutputBuffer(IOMX::buffer_id buffer); |
Andreas Huber | bbbcf65 | 2010-12-07 14:25:54 -0800 | [diff] [blame] | 297 | bool drainInputBuffer(BufferInfo *info); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 298 | void fillOutputBuffer(BufferInfo *info); |
| 299 | |
| 300 | void drainInputBuffers(); |
| 301 | void fillOutputBuffers(); |
| 302 | |
Andreas Huber | 42fb5d6 | 2011-06-29 15:53:28 -0700 | [diff] [blame] | 303 | bool drainAnyInputBuffer(); |
| 304 | BufferInfo *findInputBufferByDataPointer(void *ptr); |
| 305 | BufferInfo *findEmptyInputBuffer(); |
| 306 | |
Andreas Huber | 404cc41 | 2009-08-25 14:26:05 -0700 | [diff] [blame] | 307 | // Returns true iff a flush was initiated and a completion event is |
| 308 | // upcoming, false otherwise (A flush was not necessary as we own all |
| 309 | // the buffers on that port). |
| 310 | // This method will ONLY ever return false for a component with quirk |
| 311 | // "kRequiresFlushCompleteEmulation". |
| 312 | bool flushPortAsync(OMX_U32 portIndex); |
| 313 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 314 | void disablePortAsync(OMX_U32 portIndex); |
James Dong | 0209da1 | 2011-09-12 19:56:23 -0700 | [diff] [blame] | 315 | status_t enablePortAsync(OMX_U32 portIndex); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 316 | |
| 317 | static size_t countBuffersWeOwn(const Vector<BufferInfo> &buffers); |
| 318 | static bool isIntermediateState(State state); |
| 319 | |
| 320 | void onEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); |
| 321 | void onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data); |
| 322 | void onStateChange(OMX_STATETYPE newState); |
| 323 | void onPortSettingsChanged(OMX_U32 portIndex); |
| 324 | |
| 325 | void setState(State newState); |
| 326 | |
| 327 | status_t init(); |
| 328 | void initOutputFormat(const sp<MetaData> &inputFormat); |
Jamie Gennis | 58a36ad | 2010-10-07 14:08:38 -0700 | [diff] [blame] | 329 | status_t initNativeWindow(); |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 330 | |
Lakshman Gowda | db62a24 | 2011-09-29 17:47:35 -0700 | [diff] [blame] | 331 | void initNativeWindowCrop(); |
| 332 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 333 | void dumpPortStatus(OMX_U32 portIndex); |
| 334 | |
Andreas Huber | 42fb5d6 | 2011-06-29 15:53:28 -0700 | [diff] [blame] | 335 | status_t configureCodec(const sp<MetaData> &meta); |
Andreas Huber | 2a09c7e | 2010-03-16 11:44:07 -0700 | [diff] [blame] | 336 | |
James Dong | 31b9375f | 2010-11-10 21:11:41 -0800 | [diff] [blame] | 337 | void restorePatchedDataPointer(BufferInfo *info); |
| 338 | |
Andreas Huber | 5e9dc94 | 2011-01-21 14:32:31 -0800 | [diff] [blame] | 339 | status_t applyRotation(); |
James Dong | d9ac621 | 2011-07-15 15:25:36 -0700 | [diff] [blame] | 340 | status_t waitForBufferFilled_l(); |
Andreas Huber | 5e9dc94 | 2011-01-21 14:32:31 -0800 | [diff] [blame] | 341 | |
James Dong | 7251673 | 2012-02-06 23:46:37 -0800 | [diff] [blame] | 342 | int64_t getDecodingTimeUs(); |
James Dong | 4108b1ed | 2011-06-07 19:45:54 -0700 | [diff] [blame] | 343 | |
Andreas Huber | 0ba8660 | 2011-11-18 12:22:59 -0800 | [diff] [blame] | 344 | status_t parseAVCCodecSpecificData( |
| 345 | const void *data, size_t size, |
| 346 | unsigned *profile, unsigned *level); |
| 347 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 348 | OMXCodec(const OMXCodec &); |
| 349 | OMXCodec &operator=(const OMXCodec &); |
| 350 | }; |
| 351 | |
Andreas Huber | e6c4096 | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 352 | struct CodecCapabilities { |
| 353 | String8 mComponentName; |
| 354 | Vector<CodecProfileLevel> mProfileLevels; |
James Dong | d781089 | 2010-11-11 00:33:05 -0800 | [diff] [blame] | 355 | Vector<OMX_U32> mColorFormats; |
Andreas Huber | e6c4096 | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 356 | }; |
| 357 | |
| 358 | // Return a vector of componentNames with supported profile/level pairs |
| 359 | // supporting the given mime type, if queryDecoders==true, returns components |
| 360 | // that decode content of the given type, otherwise returns components |
| 361 | // that encode content of the given type. |
| 362 | // profile and level indications only make sense for h.263, mpeg4 and avc |
| 363 | // video. |
Jean-Michel Trivi | a05f099 | 2011-07-22 09:52:39 -0700 | [diff] [blame] | 364 | // If hwCodecOnly==true, only returns hardware-based components, software and |
| 365 | // hardware otherwise. |
Andreas Huber | e6c4096 | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 366 | // The profile/level values correspond to |
| 367 | // OMX_VIDEO_H263PROFILETYPE, OMX_VIDEO_MPEG4PROFILETYPE, |
| 368 | // OMX_VIDEO_AVCPROFILETYPE, OMX_VIDEO_H263LEVELTYPE, OMX_VIDEO_MPEG4LEVELTYPE |
| 369 | // and OMX_VIDEO_AVCLEVELTYPE respectively. |
| 370 | |
| 371 | status_t QueryCodecs( |
| 372 | const sp<IOMX> &omx, |
Jean-Michel Trivi | 56a37b0 | 2011-07-17 16:35:11 -0700 | [diff] [blame] | 373 | const char *mimeType, bool queryDecoders, bool hwCodecOnly, |
Andreas Huber | e6c4096 | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 374 | Vector<CodecCapabilities> *results); |
| 375 | |
Jean-Michel Trivi | a05f099 | 2011-07-22 09:52:39 -0700 | [diff] [blame] | 376 | status_t QueryCodecs( |
| 377 | const sp<IOMX> &omx, |
| 378 | const char *mimeType, bool queryDecoders, |
| 379 | Vector<CodecCapabilities> *results); |
| 380 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 381 | } // namespace android |
| 382 | |
| 383 | #endif // OMX_CODEC_H_ |