1 /* 2 * Copyright (C) 2014 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 /** 18 * @addtogroup Media 19 * @{ 20 */ 21 22 /** 23 * @file NdkMediaCodec.h 24 */ 25 26 /* 27 * This file defines an NDK API. 28 * Do not remove methods. 29 * Do not change method signatures. 30 * Do not change the value of constants. 31 * Do not change the size of any of the classes defined in here. 32 * Do not reference types that are not part of the NDK. 33 * Do not #include files that aren't part of the NDK. 34 */ 35 36 #ifndef _NDK_MEDIA_CODEC_H 37 #define _NDK_MEDIA_CODEC_H 38 39 #include <stdint.h> 40 #include <sys/cdefs.h> 41 42 #include "NdkMediaCrypto.h" 43 #include "NdkMediaError.h" 44 #include "NdkMediaFormat.h" 45 46 __BEGIN_DECLS 47 48 struct ANativeWindow; 49 typedef struct ANativeWindow ANativeWindow; 50 51 52 struct AMediaCodec; 53 typedef struct AMediaCodec AMediaCodec; 54 55 struct AMediaCodecBufferInfo { 56 int32_t offset; 57 int32_t size; 58 int64_t presentationTimeUs; 59 uint32_t flags; 60 }; 61 typedef struct AMediaCodecBufferInfo AMediaCodecBufferInfo; 62 typedef struct AMediaCodecCryptoInfo AMediaCodecCryptoInfo; 63 64 enum { 65 AMEDIACODEC_BUFFER_FLAG_CODEC_CONFIG = 2, 66 AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM = 4, 67 AMEDIACODEC_BUFFER_FLAG_PARTIAL_FRAME = 8, 68 69 AMEDIACODEC_CONFIGURE_FLAG_ENCODE = 1, 70 AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED = -3, 71 AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED = -2, 72 AMEDIACODEC_INFO_TRY_AGAIN_LATER = -1, 73 }; 74 75 /** 76 * Called when an input buffer becomes available. 77 * The specified index is the index of the available input buffer. 78 */ 79 typedef void (*AMediaCodecOnAsyncInputAvailable)( 80 AMediaCodec *codec, 81 void *userdata, 82 int32_t index); 83 /** 84 * Called when an output buffer becomes available. 85 * The specified index is the index of the available output buffer. 86 * The specified bufferInfo contains information regarding the available output buffer. 87 */ 88 typedef void (*AMediaCodecOnAsyncOutputAvailable)( 89 AMediaCodec *codec, 90 void *userdata, 91 int32_t index, 92 AMediaCodecBufferInfo *bufferInfo); 93 /** 94 * Called when the output format has changed. 95 * The specified format contains the new output format. 96 */ 97 typedef void (*AMediaCodecOnAsyncFormatChanged)( 98 AMediaCodec *codec, 99 void *userdata, 100 AMediaFormat *format); 101 /** 102 * Called when the MediaCodec encountered an error. 103 * The specified actionCode indicates the possible actions that client can take, 104 * and it can be checked by calling AMediaCodecActionCode_isRecoverable or 105 * AMediaCodecActionCode_isTransient. If both AMediaCodecActionCode_isRecoverable() 106 * and AMediaCodecActionCode_isTransient() return false, then the codec error is fatal 107 * and the codec must be deleted. 108 * The specified detail may contain more detailed messages about this error. 109 */ 110 typedef void (*AMediaCodecOnAsyncError)( 111 AMediaCodec *codec, 112 void *userdata, 113 media_status_t error, 114 int32_t actionCode, 115 const char *detail); 116 117 struct AMediaCodecOnAsyncNotifyCallback { 118 AMediaCodecOnAsyncInputAvailable onAsyncInputAvailable; 119 AMediaCodecOnAsyncOutputAvailable onAsyncOutputAvailable; 120 AMediaCodecOnAsyncFormatChanged onAsyncFormatChanged; 121 AMediaCodecOnAsyncError onAsyncError; 122 }; 123 124 #if __ANDROID_API__ >= 21 125 126 /** 127 * Create codec by name. Use this if you know the exact codec you want to use. 128 * When configuring, you will need to specify whether to use the codec as an 129 * encoder or decoder. 130 */ 131 AMediaCodec* AMediaCodec_createCodecByName(const char *name) __INTRODUCED_IN(21); 132 133 /** 134 * Create codec by mime type. Most applications will use this, specifying a 135 * mime type obtained from media extractor. 136 */ 137 AMediaCodec* AMediaCodec_createDecoderByType(const char *mime_type) __INTRODUCED_IN(21); 138 139 /** 140 * Create encoder by name. 141 */ 142 AMediaCodec* AMediaCodec_createEncoderByType(const char *mime_type) __INTRODUCED_IN(21); 143 144 /** 145 * delete the codec and free its resources 146 */ 147 media_status_t AMediaCodec_delete(AMediaCodec*) __INTRODUCED_IN(21); 148 149 /** 150 * Configure the codec. For decoding you would typically get the format from an extractor. 151 */ 152 media_status_t AMediaCodec_configure( 153 AMediaCodec*, 154 const AMediaFormat* format, 155 ANativeWindow* surface, 156 AMediaCrypto *crypto, 157 uint32_t flags) __INTRODUCED_IN(21); 158 159 /** 160 * Start the codec. A codec must be configured before it can be started, and must be started 161 * before buffers can be sent to it. 162 */ 163 media_status_t AMediaCodec_start(AMediaCodec*) __INTRODUCED_IN(21); 164 165 /** 166 * Stop the codec. 167 */ 168 media_status_t AMediaCodec_stop(AMediaCodec*) __INTRODUCED_IN(21); 169 170 /* 171 * Flush the codec's input and output. All indices previously returned from calls to 172 * AMediaCodec_dequeueInputBuffer and AMediaCodec_dequeueOutputBuffer become invalid. 173 */ 174 media_status_t AMediaCodec_flush(AMediaCodec*) __INTRODUCED_IN(21); 175 176 /** 177 * Get an input buffer. The specified buffer index must have been previously obtained from 178 * dequeueInputBuffer, and not yet queued. 179 */ 180 uint8_t* AMediaCodec_getInputBuffer(AMediaCodec*, size_t idx, size_t *out_size) __INTRODUCED_IN(21); 181 182 /** 183 * Get an output buffer. The specified buffer index must have been previously obtained from 184 * dequeueOutputBuffer, and not yet queued. 185 */ 186 uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec*, size_t idx, size_t *out_size) __INTRODUCED_IN(21); 187 188 /** 189 * Get the index of the next available input buffer. An app will typically use this with 190 * getInputBuffer() to get a pointer to the buffer, then copy the data to be encoded or decoded 191 * into the buffer before passing it to the codec. 192 */ 193 ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec*, int64_t timeoutUs) __INTRODUCED_IN(21); 194 195 /* 196 * __USE_FILE_OFFSET64 changes the type of off_t in LP32, which changes the ABI 197 * of these declarations to not match the platform. In that case, define these 198 * APIs in terms of int32_t instead. Passing an off_t in this situation will 199 * result in silent truncation unless the user builds with -Wconversion, but the 200 * only alternative it to not expose them at all for this configuration, which 201 * makes the whole API unusable. 202 * 203 * https://github.com/android-ndk/ndk/issues/459 204 */ 205 #if defined(__USE_FILE_OFFSET64) && !defined(__LP64__) 206 #define _off_t_compat int32_t 207 #else 208 #define _off_t_compat off_t 209 #endif /* defined(__USE_FILE_OFFSET64) && !defined(__LP64__) */ 210 211 #if (defined(__cplusplus) && __cplusplus >= 201103L) || \ 212 __STDC_VERSION__ >= 201112L 213 #include <assert.h> 214 static_assert(sizeof(_off_t_compat) == sizeof(long), 215 "_off_t_compat does not match the NDK ABI. See " 216 "https://github.com/android-ndk/ndk/issues/459."); 217 #endif 218 219 /** 220 * Send the specified buffer to the codec for processing. 221 */ 222 media_status_t AMediaCodec_queueInputBuffer(AMediaCodec*, size_t idx, 223 _off_t_compat offset, size_t size, 224 uint64_t time, uint32_t flags) __INTRODUCED_IN(21); 225 226 /** 227 * Send the specified buffer to the codec for processing. 228 */ 229 media_status_t AMediaCodec_queueSecureInputBuffer(AMediaCodec*, size_t idx, 230 _off_t_compat offset, 231 AMediaCodecCryptoInfo*, 232 uint64_t time, uint32_t flags) __INTRODUCED_IN(21); 233 234 #undef _off_t_compat 235 236 /** 237 * Get the index of the next available buffer of processed data. 238 */ 239 ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec*, AMediaCodecBufferInfo *info, 240 int64_t timeoutUs) __INTRODUCED_IN(21); 241 AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec*) __INTRODUCED_IN(21); 242 243 /** 244 * If you are done with a buffer, use this call to return the buffer to 245 * the codec. If you previously specified a surface when configuring this 246 * video decoder you can optionally render the buffer. 247 */ 248 media_status_t AMediaCodec_releaseOutputBuffer(AMediaCodec*, size_t idx, bool render) __INTRODUCED_IN(21); 249 250 /** 251 * Dynamically sets the output surface of a codec. 252 * 253 * This can only be used if the codec was configured with an output surface. The 254 * new output surface should have a compatible usage type to the original output surface. 255 * E.g. codecs may not support switching from a SurfaceTexture (GPU readable) output 256 * to ImageReader (software readable) output. 257 * 258 * For more details, see the Java documentation for MediaCodec.setOutputSurface. 259 */ 260 media_status_t AMediaCodec_setOutputSurface(AMediaCodec*, ANativeWindow* surface) __INTRODUCED_IN(21); 261 262 /** 263 * If you are done with a buffer, use this call to update its surface timestamp 264 * and return it to the codec to render it on the output surface. If you 265 * have not specified an output surface when configuring this video codec, 266 * this call will simply return the buffer to the codec. 267 * 268 * For more details, see the Java documentation for MediaCodec.releaseOutputBuffer. 269 */ 270 media_status_t AMediaCodec_releaseOutputBufferAtTime( 271 AMediaCodec *mData, size_t idx, int64_t timestampNs) __INTRODUCED_IN(21); 272 273 #if __ANDROID_API__ >= 26 274 275 /** 276 * Creates a Surface that can be used as the input to encoder, in place of input buffers 277 * 278 * This can only be called after the codec has been configured via 279 * AMediaCodec_configure(..); and before AMediaCodec_start() has been called. 280 * 281 * The application is responsible for releasing the surface by calling 282 * ANativeWindow_release() when done. 283 * 284 * For more details, see the Java documentation for MediaCodec.createInputSurface. 285 */ 286 media_status_t AMediaCodec_createInputSurface( 287 AMediaCodec *mData, ANativeWindow **surface) __INTRODUCED_IN(26); 288 289 /** 290 * Creates a persistent Surface that can be used as the input to encoder 291 * 292 * Persistent surface can be reused by MediaCodec instances and can be set 293 * on a new instance via AMediaCodec_setInputSurface(). 294 * A persistent surface can be connected to at most one instance of MediaCodec 295 * at any point in time. 296 * 297 * The application is responsible for releasing the surface by calling 298 * ANativeWindow_release() when done. 299 * 300 * For more details, see the Java documentation for MediaCodec.createPersistentInputSurface. 301 */ 302 media_status_t AMediaCodec_createPersistentInputSurface( 303 ANativeWindow **surface) __INTRODUCED_IN(26); 304 305 /** 306 * Set a persistent-surface that can be used as the input to encoder, in place of input buffers 307 * 308 * The surface provided *must* be a persistent surface created via 309 * AMediaCodec_createPersistentInputSurface() 310 * This can only be called after the codec has been configured by calling 311 * AMediaCodec_configure(..); and before AMediaCodec_start() has been called. 312 * 313 * For more details, see the Java documentation for MediaCodec.setInputSurface. 314 */ 315 media_status_t AMediaCodec_setInputSurface( 316 AMediaCodec *mData, ANativeWindow *surface) __INTRODUCED_IN(26); 317 318 /** 319 * Signal additional parameters to the codec instance. 320 * 321 * Parameters can be communicated only when the codec is running, i.e 322 * after AMediaCodec_start() has been called. 323 * 324 * NOTE: Some of these parameter changes may silently fail to apply. 325 */ 326 media_status_t AMediaCodec_setParameters( 327 AMediaCodec *mData, const AMediaFormat* params) __INTRODUCED_IN(26); 328 329 /** 330 * Signals end-of-stream on input. Equivalent to submitting an empty buffer with 331 * AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM set. 332 * 333 * Returns AMEDIA_ERROR_INVALID_OPERATION when used with an encoder not in executing state 334 * or not receiving input from a Surface created by AMediaCodec_createInputSurface or 335 * AMediaCodec_createPersistentInputSurface. 336 * 337 * Returns the previous codec error if one exists. 338 * 339 * Returns AMEDIA_OK when completed succesfully. 340 * 341 * For more details, see the Java documentation for MediaCodec.signalEndOfInputStream. 342 */ 343 media_status_t AMediaCodec_signalEndOfInputStream(AMediaCodec *mData) __INTRODUCED_IN(26); 344 345 #endif /* __ANDROID_API__ >= 26 */ 346 347 #if __ANDROID_API__ >= 28 348 349 /** 350 * Get format of the buffer. The specified buffer index must have been previously obtained from 351 * dequeueOutputBuffer. 352 */ 353 AMediaFormat* AMediaCodec_getBufferFormat(AMediaCodec*, size_t index) __INTRODUCED_IN(28); 354 355 /** 356 * Get the component name. If the codec was created by createDecoderByType 357 * or createEncoderByType, what component is chosen is not known beforehand. 358 * Caller shall call AMediaCodec_releaseName to free the returned pointer. 359 */ 360 media_status_t AMediaCodec_getName(AMediaCodec*, char** out_name) __INTRODUCED_IN(28); 361 362 /** 363 * Free the memory pointed by name which is returned by AMediaCodec_getName. 364 */ 365 void AMediaCodec_releaseName(AMediaCodec*, char* name) __INTRODUCED_IN(28); 366 367 /** 368 * Set an asynchronous callback for actionable AMediaCodec events. 369 * When asynchronous callback is enabled, the client should not call 370 * AMediaCodec_getInputBuffers(), AMediaCodec_getOutputBuffers(), 371 * AMediaCodec_dequeueInputBuffer() or AMediaCodec_dequeueOutputBuffer(). 372 * 373 * Also, AMediaCodec_flush() behaves differently in asynchronous mode. 374 * After calling AMediaCodec_flush(), you must call AMediaCodec_start() to 375 * "resume" receiving input buffers, even if an input surface was created. 376 * 377 * Refer to the definition of AMediaCodecOnAsyncNotifyCallback on how each 378 * callback function is called and what are specified. 379 * The specified userdata is the pointer used when those callback functions are 380 * called. 381 * 382 * All callbacks are fired on one NDK internal thread. 383 * AMediaCodec_setAsyncNotifyCallback should not be called on the callback thread. 384 * No heavy duty task should be performed on callback thread. 385 */ 386 media_status_t AMediaCodec_setAsyncNotifyCallback( 387 AMediaCodec*, 388 AMediaCodecOnAsyncNotifyCallback callback, 389 void *userdata) __INTRODUCED_IN(28); 390 391 /** 392 * Release the crypto if applicable. 393 */ 394 media_status_t AMediaCodec_releaseCrypto(AMediaCodec*) __INTRODUCED_IN(28); 395 396 /** 397 * Call this after AMediaCodec_configure() returns successfully to get the input 398 * format accepted by the codec. Do this to determine what optional configuration 399 * parameters were supported by the codec. 400 */ 401 AMediaFormat* AMediaCodec_getInputFormat(AMediaCodec*) __INTRODUCED_IN(28); 402 403 /** 404 * Returns true if the codec cannot proceed further, but can be recovered by stopping, 405 * configuring, and starting again. 406 */ 407 bool AMediaCodecActionCode_isRecoverable(int32_t actionCode) __INTRODUCED_IN(28); 408 409 /** 410 * Returns true if the codec error is a transient issue, perhaps due to 411 * resource constraints, and that the method (or encoding/decoding) may be 412 * retried at a later time. 413 */ 414 bool AMediaCodecActionCode_isTransient(int32_t actionCode) __INTRODUCED_IN(28); 415 416 #endif /* __ANDROID_API__ >= 28 */ 417 418 typedef enum { 419 AMEDIACODECRYPTOINFO_MODE_CLEAR = 0, 420 AMEDIACODECRYPTOINFO_MODE_AES_CTR = 1, 421 AMEDIACODECRYPTOINFO_MODE_AES_WV = 2, 422 AMEDIACODECRYPTOINFO_MODE_AES_CBC = 3 423 } cryptoinfo_mode_t; 424 425 typedef struct { 426 int32_t encryptBlocks; 427 int32_t skipBlocks; 428 } cryptoinfo_pattern_t; 429 430 /** 431 * Create an AMediaCodecCryptoInfo from scratch. Use this if you need to use custom 432 * crypto info, rather than one obtained from AMediaExtractor. 433 * 434 * AMediaCodecCryptoInfo describes the structure of an (at least 435 * partially) encrypted input sample. 436 * A buffer's data is considered to be partitioned into "subsamples", 437 * each subsample starts with a (potentially empty) run of plain, 438 * unencrypted bytes followed by a (also potentially empty) run of 439 * encrypted bytes. 440 * numBytesOfClearData can be null to indicate that all data is encrypted. 441 * This information encapsulates per-sample metadata as outlined in 442 * ISO/IEC FDIS 23001-7:2011 "Common encryption in ISO base media file format files". 443 */ 444 AMediaCodecCryptoInfo *AMediaCodecCryptoInfo_new( 445 int numsubsamples, 446 uint8_t key[16], 447 uint8_t iv[16], 448 cryptoinfo_mode_t mode, 449 size_t *clearbytes, 450 size_t *encryptedbytes) __INTRODUCED_IN(21); 451 452 /** 453 * delete an AMediaCodecCryptoInfo created previously with AMediaCodecCryptoInfo_new, or 454 * obtained from AMediaExtractor 455 */ 456 media_status_t AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo*) __INTRODUCED_IN(21); 457 458 /** 459 * Set the crypto pattern on an AMediaCryptoInfo object 460 */ 461 void AMediaCodecCryptoInfo_setPattern( 462 AMediaCodecCryptoInfo *info, 463 cryptoinfo_pattern_t *pattern) __INTRODUCED_IN(21); 464 465 /** 466 * The number of subsamples that make up the buffer's contents. 467 */ 468 size_t AMediaCodecCryptoInfo_getNumSubSamples(AMediaCodecCryptoInfo*) __INTRODUCED_IN(21); 469 470 /** 471 * A 16-byte opaque key 472 */ 473 media_status_t AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo*, uint8_t *dst) __INTRODUCED_IN(21); 474 475 /** 476 * A 16-byte initialization vector 477 */ 478 media_status_t AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo*, uint8_t *dst) __INTRODUCED_IN(21); 479 480 /** 481 * The type of encryption that has been applied, 482 * one of AMEDIACODECRYPTOINFO_MODE_CLEAR or AMEDIACODECRYPTOINFO_MODE_AES_CTR. 483 */ 484 cryptoinfo_mode_t AMediaCodecCryptoInfo_getMode(AMediaCodecCryptoInfo*) __INTRODUCED_IN(21); 485 486 /** 487 * The number of leading unencrypted bytes in each subsample. 488 */ 489 media_status_t AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo*, size_t *dst) __INTRODUCED_IN(21); 490 491 /** 492 * The number of trailing encrypted bytes in each subsample. 493 */ 494 media_status_t AMediaCodecCryptoInfo_getEncryptedBytes(AMediaCodecCryptoInfo*, size_t *dst) __INTRODUCED_IN(21); 495 496 #endif /* __ANDROID_API__ >= 21 */ 497 498 __END_DECLS 499 500 #endif //_NDK_MEDIA_CODEC_H 501 502 /** @} */ 503