MediaCodec.h revision 55c3bd0cacfb6e1601cd03fdba814be544a34326
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/MediaResource.h> 24#include <media/stagefright/foundation/AHandler.h> 25#include <utils/Vector.h> 26 27namespace android { 28 29struct ABuffer; 30struct AMessage; 31struct AReplyToken; 32struct AString; 33struct CodecBase; 34struct IBatteryStats; 35struct ICrypto; 36class IMemory; 37struct MemoryDealer; 38class IResourceManagerClient; 39class IResourceManagerService; 40struct PersistentSurface; 41struct SoftwareRenderer; 42struct Surface; 43 44struct MediaCodec : public AHandler { 45 enum ConfigureFlags { 46 CONFIGURE_FLAG_ENCODE = 1, 47 }; 48 49 enum BufferFlags { 50 BUFFER_FLAG_SYNCFRAME = 1, 51 BUFFER_FLAG_CODECCONFIG = 2, 52 BUFFER_FLAG_EOS = 4, 53 }; 54 55 enum { 56 CB_INPUT_AVAILABLE = 1, 57 CB_OUTPUT_AVAILABLE = 2, 58 CB_ERROR = 3, 59 CB_OUTPUT_FORMAT_CHANGED = 4, 60 CB_RESOURCE_RECLAIMED = 5, 61 }; 62 63 struct BatteryNotifier; 64 65 static sp<MediaCodec> CreateByType( 66 const sp<ALooper> &looper, const char *mime, bool encoder, status_t *err = NULL); 67 68 static sp<MediaCodec> CreateByComponentName( 69 const sp<ALooper> &looper, const char *name, status_t *err = NULL); 70 71 static sp<PersistentSurface> CreatePersistentInputSurface(); 72 73 status_t configure( 74 const sp<AMessage> &format, 75 const sp<Surface> &nativeWindow, 76 const sp<ICrypto> &crypto, 77 uint32_t flags); 78 79 status_t setCallback(const sp<AMessage> &callback); 80 81 status_t createInputSurface(sp<IGraphicBufferProducer>* bufferProducer); 82 83 status_t setInputSurface(const sp<PersistentSurface> &surface); 84 85 status_t start(); 86 87 // Returns to a state in which the component remains allocated but 88 // unconfigured. 89 status_t stop(); 90 91 // Resets the codec to the INITIALIZED state. Can be called after an error 92 // has occured to make the codec usable. 93 status_t reset(); 94 95 // Client MUST call release before releasing final reference to this 96 // object. 97 status_t release(); 98 99 status_t flush(); 100 101 status_t queueInputBuffer( 102 size_t index, 103 size_t offset, 104 size_t size, 105 int64_t presentationTimeUs, 106 uint32_t flags, 107 AString *errorDetailMsg = NULL); 108 109 status_t queueSecureInputBuffer( 110 size_t index, 111 size_t offset, 112 const CryptoPlugin::SubSample *subSamples, 113 size_t numSubSamples, 114 const uint8_t key[16], 115 const uint8_t iv[16], 116 CryptoPlugin::Mode mode, 117 int64_t presentationTimeUs, 118 uint32_t flags, 119 AString *errorDetailMsg = NULL); 120 121 status_t dequeueInputBuffer(size_t *index, int64_t timeoutUs = 0ll); 122 123 status_t dequeueOutputBuffer( 124 size_t *index, 125 size_t *offset, 126 size_t *size, 127 int64_t *presentationTimeUs, 128 uint32_t *flags, 129 int64_t timeoutUs = 0ll); 130 131 status_t renderOutputBufferAndRelease(size_t index, int64_t timestampNs); 132 status_t renderOutputBufferAndRelease(size_t index); 133 status_t releaseOutputBuffer(size_t index); 134 135 status_t signalEndOfInputStream(); 136 137 status_t getOutputFormat(sp<AMessage> *format) const; 138 status_t getInputFormat(sp<AMessage> *format) const; 139 140 status_t getWidevineLegacyBuffers(Vector<sp<ABuffer> > *buffers) const; 141 142 status_t getInputBuffers(Vector<sp<ABuffer> > *buffers) const; 143 status_t getOutputBuffers(Vector<sp<ABuffer> > *buffers) const; 144 145 status_t getOutputBuffer(size_t index, sp<ABuffer> *buffer); 146 status_t getOutputFormat(size_t index, sp<AMessage> *format); 147 status_t getInputBuffer(size_t index, sp<ABuffer> *buffer); 148 149 status_t setSurface(const sp<Surface> &nativeWindow); 150 151 status_t requestIDRFrame(); 152 153 // Notification will be posted once there "is something to do", i.e. 154 // an input/output buffer has become available, a format change is 155 // pending, an error is pending. 156 void requestActivityNotification(const sp<AMessage> ¬ify); 157 158 status_t getName(AString *componentName) const; 159 160 status_t setParameters(const sp<AMessage> ¶ms); 161 162protected: 163 virtual ~MediaCodec(); 164 virtual void onMessageReceived(const sp<AMessage> &msg); 165 166private: 167 // used by ResourceManagerClient 168 status_t reclaim(); 169 friend struct ResourceManagerClient; 170 171private: 172 enum State { 173 UNINITIALIZED, 174 INITIALIZING, 175 INITIALIZED, 176 CONFIGURING, 177 CONFIGURED, 178 STARTING, 179 STARTED, 180 FLUSHING, 181 FLUSHED, 182 STOPPING, 183 RELEASING, 184 }; 185 186 enum { 187 kPortIndexInput = 0, 188 kPortIndexOutput = 1, 189 }; 190 191 enum { 192 kWhatInit = 'init', 193 kWhatConfigure = 'conf', 194 kWhatSetSurface = 'sSur', 195 kWhatCreateInputSurface = 'cisf', 196 kWhatSetInputSurface = 'sisf', 197 kWhatStart = 'strt', 198 kWhatStop = 'stop', 199 kWhatRelease = 'rele', 200 kWhatDequeueInputBuffer = 'deqI', 201 kWhatQueueInputBuffer = 'queI', 202 kWhatDequeueOutputBuffer = 'deqO', 203 kWhatReleaseOutputBuffer = 'relO', 204 kWhatSignalEndOfInputStream = 'eois', 205 kWhatGetBuffers = 'getB', 206 kWhatFlush = 'flus', 207 kWhatGetOutputFormat = 'getO', 208 kWhatGetInputFormat = 'getI', 209 kWhatDequeueInputTimedOut = 'dITO', 210 kWhatDequeueOutputTimedOut = 'dOTO', 211 kWhatCodecNotify = 'codc', 212 kWhatRequestIDRFrame = 'ridr', 213 kWhatRequestActivityNotification = 'racN', 214 kWhatGetName = 'getN', 215 kWhatSetParameters = 'setP', 216 kWhatSetCallback = 'setC', 217 }; 218 219 enum { 220 kFlagUsesSoftwareRenderer = 1, 221 kFlagOutputFormatChanged = 2, 222 kFlagOutputBuffersChanged = 4, 223 kFlagStickyError = 8, 224 kFlagDequeueInputPending = 16, 225 kFlagDequeueOutputPending = 32, 226 kFlagIsSecure = 64, 227 kFlagSawMediaServerDie = 128, 228 kFlagIsEncoder = 256, 229 kFlagGatherCodecSpecificData = 512, 230 kFlagIsAsync = 1024, 231 kFlagIsComponentAllocated = 2048, 232 kFlagPushBlankBuffersOnShutdown = 4096, 233 }; 234 235 struct BufferInfo { 236 uint32_t mBufferID; 237 sp<ABuffer> mData; 238 sp<ABuffer> mEncryptedData; 239 sp<IMemory> mSharedEncryptedBuffer; 240 sp<AMessage> mNotify; 241 sp<AMessage> mFormat; 242 bool mOwnedByClient; 243 }; 244 245 struct ResourceManagerServiceProxy : public IBinder::DeathRecipient { 246 ResourceManagerServiceProxy(); 247 ~ResourceManagerServiceProxy(); 248 249 void init(); 250 251 // implements DeathRecipient 252 virtual void binderDied(const wp<IBinder>& /*who*/); 253 254 void addResource( 255 int pid, 256 int64_t clientId, 257 const sp<IResourceManagerClient> client, 258 const Vector<MediaResource> &resources); 259 260 void removeResource(int64_t clientId); 261 262 bool reclaimResource(int callingPid, const Vector<MediaResource> &resources); 263 264 private: 265 Mutex mLock; 266 sp<IResourceManagerService> mService; 267 }; 268 269 State mState; 270 bool mReleasedByResourceManager; 271 sp<ALooper> mLooper; 272 sp<ALooper> mCodecLooper; 273 sp<CodecBase> mCodec; 274 AString mComponentName; 275 sp<AReplyToken> mReplyID; 276 uint32_t mFlags; 277 status_t mStickyError; 278 sp<Surface> mSurface; 279 SoftwareRenderer *mSoftRenderer; 280 sp<AMessage> mOutputFormat; 281 sp<AMessage> mInputFormat; 282 sp<AMessage> mCallback; 283 sp<MemoryDealer> mDealer; 284 285 sp<IResourceManagerClient> mResourceManagerClient; 286 sp<ResourceManagerServiceProxy> mResourceManagerService; 287 288 bool mBatteryStatNotified; 289 bool mIsVideo; 290 int32_t mVideoWidth; 291 int32_t mVideoHeight; 292 293 // initial create parameters 294 AString mInitName; 295 bool mInitNameIsType; 296 bool mInitIsEncoder; 297 298 // configure parameter 299 sp<AMessage> mConfigureMsg; 300 301 // Used only to synchronize asynchronous getBufferAndFormat 302 // across all the other (synchronous) buffer state change 303 // operations, such as de/queueIn/OutputBuffer, start and 304 // stop/flush/reset/release. 305 Mutex mBufferLock; 306 307 List<size_t> mAvailPortBuffers[2]; 308 Vector<BufferInfo> mPortBuffers[2]; 309 310 int32_t mDequeueInputTimeoutGeneration; 311 sp<AReplyToken> mDequeueInputReplyID; 312 313 int32_t mDequeueOutputTimeoutGeneration; 314 sp<AReplyToken> mDequeueOutputReplyID; 315 316 sp<ICrypto> mCrypto; 317 318 List<sp<ABuffer> > mCSD; 319 320 sp<AMessage> mActivityNotify; 321 322 bool mHaveInputSurface; 323 bool mHavePendingInputBuffers; 324 325 MediaCodec(const sp<ALooper> &looper); 326 327 static status_t PostAndAwaitResponse( 328 const sp<AMessage> &msg, sp<AMessage> *response); 329 330 void PostReplyWithError(const sp<AReplyToken> &replyID, int32_t err); 331 332 status_t init(const AString &name, bool nameIsType, bool encoder); 333 334 void setState(State newState); 335 void returnBuffersToCodec(); 336 void returnBuffersToCodecOnPort(int32_t portIndex); 337 size_t updateBuffers(int32_t portIndex, const sp<AMessage> &msg); 338 status_t onQueueInputBuffer(const sp<AMessage> &msg); 339 status_t onReleaseOutputBuffer(const sp<AMessage> &msg); 340 ssize_t dequeuePortBuffer(int32_t portIndex); 341 342 status_t getBufferAndFormat( 343 size_t portIndex, size_t index, 344 sp<ABuffer> *buffer, sp<AMessage> *format); 345 346 bool handleDequeueInputBuffer(const sp<AReplyToken> &replyID, bool newRequest = false); 347 bool handleDequeueOutputBuffer(const sp<AReplyToken> &replyID, bool newRequest = false); 348 void cancelPendingDequeueOperations(); 349 350 void extractCSD(const sp<AMessage> &format); 351 status_t queueCSDInputBuffer(size_t bufferIndex); 352 353 status_t handleSetSurface(const sp<Surface> &surface); 354 status_t connectToSurface(const sp<Surface> &surface); 355 status_t disconnectFromSurface(); 356 357 void postActivityNotificationIfPossible(); 358 359 void onInputBufferAvailable(); 360 void onOutputBufferAvailable(); 361 void onError(status_t err, int32_t actionCode, const char *detail = NULL); 362 void onOutputFormatChanged(); 363 364 status_t onSetParameters(const sp<AMessage> ¶ms); 365 366 status_t amendOutputFormatWithCodecSpecificData(const sp<ABuffer> &buffer); 367 void updateBatteryStat(); 368 bool isExecuting() const; 369 370 uint64_t getGraphicBufferSize(); 371 void addResource(const String8 &type, const String8 &subtype, uint64_t value); 372 373 /* called to get the last codec error when the sticky flag is set. 374 * if no such codec error is found, returns UNKNOWN_ERROR. 375 */ 376 inline status_t getStickyError() const { 377 return mStickyError != 0 ? mStickyError : UNKNOWN_ERROR; 378 } 379 380 inline void setStickyError(status_t err) { 381 mFlags |= kFlagStickyError; 382 mStickyError = err; 383 } 384 385 DISALLOW_EVIL_CONSTRUCTORS(MediaCodec); 386}; 387 388} // namespace android 389 390#endif // MEDIA_CODEC_H_ 391