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 typedef struct AMediaCodecOnAsyncNotifyCallback { 118 AMediaCodecOnAsyncInputAvailable onAsyncInputAvailable; 119 AMediaCodecOnAsyncOutputAvailable onAsyncOutputAvailable; 120 AMediaCodecOnAsyncFormatChanged onAsyncFormatChanged; 121 AMediaCodecOnAsyncError onAsyncError; 122 } AMediaCodecOnAsyncNotifyCallback; 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 * Available since API level 21. 132 */ 133 AMediaCodec* AMediaCodec_createCodecByName(const char *name) __INTRODUCED_IN(21); 134 135 /** 136 * Create codec by mime type. Most applications will use this, specifying a 137 * mime type obtained from media extractor. 138 * 139 * Available since API level 21. 140 */ 141 AMediaCodec* AMediaCodec_createDecoderByType(const char *mime_type) __INTRODUCED_IN(21); 142 143 /** 144 * Create encoder by name. 145 * 146 * Available since API level 21. 147 */ 148 AMediaCodec* AMediaCodec_createEncoderByType(const char *mime_type) __INTRODUCED_IN(21); 149 150 /** 151 * Delete the codec and free its resources. 152 * 153 * Available since API level 21. 154 */ 155 media_status_t AMediaCodec_delete(AMediaCodec*) __INTRODUCED_IN(21); 156 157 /** 158 * Configure the codec. For decoding you would typically get the format from an extractor. 159 * 160 * Available since API level 21. 161 */ 162 media_status_t AMediaCodec_configure( 163 AMediaCodec*, 164 const AMediaFormat* format, 165 ANativeWindow* surface, 166 AMediaCrypto *crypto, 167 uint32_t flags) __INTRODUCED_IN(21); 168 169 /** 170 * Start the codec. A codec must be configured before it can be started, and must be started 171 * before buffers can be sent to it. 172 * 173 * Available since API level 21. 174 */ 175 media_status_t AMediaCodec_start(AMediaCodec*) __INTRODUCED_IN(21); 176 177 /** 178 * Stop the codec. 179 * 180 * Available since API level 21. 181 */ 182 media_status_t AMediaCodec_stop(AMediaCodec*) __INTRODUCED_IN(21); 183 184 /* 185 * Flush the codec's input and output. All indices previously returned from calls to 186 * AMediaCodec_dequeueInputBuffer and AMediaCodec_dequeueOutputBuffer become invalid. 187 * 188 * Available since API level 21. 189 */ 190 media_status_t AMediaCodec_flush(AMediaCodec*) __INTRODUCED_IN(21); 191 192 /** 193 * Get an input buffer. The specified buffer index must have been previously obtained from 194 * dequeueInputBuffer, and not yet queued. 195 * 196 * Available since API level 21. 197 */ 198 uint8_t* AMediaCodec_getInputBuffer(AMediaCodec*, size_t idx, size_t *out_size) __INTRODUCED_IN(21); 199 200 /** 201 * Get an output buffer. The specified buffer index must have been previously obtained from 202 * dequeueOutputBuffer, and not yet queued. 203 * 204 * Available since API level 21. 205 */ 206 uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec*, size_t idx, size_t *out_size) __INTRODUCED_IN(21); 207 208 /** 209 * Get the index of the next available input buffer. An app will typically use this with 210 * getInputBuffer() to get a pointer to the buffer, then copy the data to be encoded or decoded 211 * into the buffer before passing it to the codec. 212 * 213 * Available since API level 21. 214 */ 215 ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec*, int64_t timeoutUs) __INTRODUCED_IN(21); 216 217 /* 218 * __USE_FILE_OFFSET64 changes the type of off_t in LP32, which changes the ABI 219 * of these declarations to not match the platform. In that case, define these 220 * APIs in terms of int32_t instead. Passing an off_t in this situation will 221 * result in silent truncation unless the user builds with -Wconversion, but the 222 * only alternative it to not expose them at all for this configuration, which 223 * makes the whole API unusable. 224 * 225 * https://github.com/android-ndk/ndk/issues/459 226 */ 227 #if defined(__USE_FILE_OFFSET64) && !defined(__LP64__) 228 #define _off_t_compat int32_t 229 #else 230 #define _off_t_compat off_t 231 #endif /* defined(__USE_FILE_OFFSET64) && !defined(__LP64__) */ 232 233 #if (defined(__cplusplus) && __cplusplus >= 201103L) || \ 234 __STDC_VERSION__ >= 201112L 235 #include <assert.h> 236 static_assert(sizeof(_off_t_compat) == sizeof(long), 237 "_off_t_compat does not match the NDK ABI. See " 238 "https://github.com/android-ndk/ndk/issues/459."); 239 #endif 240 241 /** 242 * Send the specified buffer to the codec for processing. 243 * 244 * Available since API level 21. 245 */ 246 media_status_t AMediaCodec_queueInputBuffer(AMediaCodec*, size_t idx, 247 _off_t_compat offset, size_t size, 248 uint64_t time, uint32_t flags) __INTRODUCED_IN(21); 249 250 /** 251 * Send the specified buffer to the codec for processing. 252 * 253 * Available since API level 21. 254 */ 255 media_status_t AMediaCodec_queueSecureInputBuffer(AMediaCodec*, size_t idx, 256 _off_t_compat offset, 257 AMediaCodecCryptoInfo*, 258 uint64_t time, uint32_t flags) __INTRODUCED_IN(21); 259 260 #undef _off_t_compat 261 262 /** 263 * Get the index of the next available buffer of processed data. 264 * 265 * Available since API level 21. 266 */ 267 ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec*, AMediaCodecBufferInfo *info, 268 int64_t timeoutUs) __INTRODUCED_IN(21); 269 270 /** 271 * Returns the format of the codec's output. 272 * The caller must free the returned format. 273 * 274 * Available since API level 21. 275 */ 276 AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec*) __INTRODUCED_IN(21); 277 278 /** 279 * If you are done with a buffer, use this call to return the buffer to 280 * the codec. If you previously specified a surface when configuring this 281 * video decoder you can optionally render the buffer. 282 * 283 * Available since API level 21. 284 */ 285 media_status_t AMediaCodec_releaseOutputBuffer(AMediaCodec*, size_t idx, bool render) __INTRODUCED_IN(21); 286 287 /** 288 * Dynamically sets the output surface of a codec. 289 * 290 * This can only be used if the codec was configured with an output surface. The 291 * new output surface should have a compatible usage type to the original output surface. 292 * E.g. codecs may not support switching from a SurfaceTexture (GPU readable) output 293 * to ImageReader (software readable) output. 294 * 295 * For more details, see the Java documentation for MediaCodec.setOutputSurface. 296 * 297 * Available since API level 21. 298 */ 299 media_status_t AMediaCodec_setOutputSurface(AMediaCodec*, ANativeWindow* surface) __INTRODUCED_IN(21); 300 301 /** 302 * If you are done with a buffer, use this call to update its surface timestamp 303 * and return it to the codec to render it on the output surface. If you 304 * have not specified an output surface when configuring this video codec, 305 * this call will simply return the buffer to the codec. 306 * 307 * For more details, see the Java documentation for MediaCodec.releaseOutputBuffer. 308 * 309 * Available since API level 21. 310 */ 311 media_status_t AMediaCodec_releaseOutputBufferAtTime( 312 AMediaCodec *mData, size_t idx, int64_t timestampNs) __INTRODUCED_IN(21); 313 314 #if __ANDROID_API__ >= 26 315 316 /** 317 * Creates a Surface that can be used as the input to encoder, in place of input buffers 318 * 319 * This can only be called after the codec has been configured via 320 * AMediaCodec_configure(..); and before AMediaCodec_start() has been called. 321 * 322 * The application is responsible for releasing the surface by calling 323 * ANativeWindow_release() when done. 324 * 325 * For more details, see the Java documentation for MediaCodec.createInputSurface. 326 * 327 * Available since API level 26. 328 */ 329 media_status_t AMediaCodec_createInputSurface( 330 AMediaCodec *mData, ANativeWindow **surface) __INTRODUCED_IN(26); 331 332 /** 333 * Creates a persistent Surface that can be used as the input to encoder 334 * 335 * Persistent surface can be reused by MediaCodec instances and can be set 336 * on a new instance via AMediaCodec_setInputSurface(). 337 * A persistent surface can be connected to at most one instance of MediaCodec 338 * at any point in time. 339 * 340 * The application is responsible for releasing the surface by calling 341 * ANativeWindow_release() when done. 342 * 343 * For more details, see the Java documentation for MediaCodec.createPersistentInputSurface. 344 * 345 * Available since API level 26. 346 */ 347 media_status_t AMediaCodec_createPersistentInputSurface( 348 ANativeWindow **surface) __INTRODUCED_IN(26); 349 350 /** 351 * Set a persistent-surface that can be used as the input to encoder, in place of input buffers 352 * 353 * The surface provided *must* be a persistent surface created via 354 * AMediaCodec_createPersistentInputSurface() 355 * This can only be called after the codec has been configured by calling 356 * AMediaCodec_configure(..); and before AMediaCodec_start() has been called. 357 * 358 * For more details, see the Java documentation for MediaCodec.setInputSurface. 359 * 360 * Available since API level 26. 361 */ 362 media_status_t AMediaCodec_setInputSurface( 363 AMediaCodec *mData, ANativeWindow *surface) __INTRODUCED_IN(26); 364 365 /** 366 * Signal additional parameters to the codec instance. 367 * 368 * Parameters can be communicated only when the codec is running, i.e 369 * after AMediaCodec_start() has been called. 370 * 371 * NOTE: Some of these parameter changes may silently fail to apply. 372 * 373 * Available since API level 26. 374 */ 375 media_status_t AMediaCodec_setParameters( 376 AMediaCodec *mData, const AMediaFormat* params) __INTRODUCED_IN(26); 377 378 /** 379 * Signals end-of-stream on input. Equivalent to submitting an empty buffer with 380 * AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM set. 381 * 382 * Returns AMEDIA_ERROR_INVALID_OPERATION when used with an encoder not in executing state 383 * or not receiving input from a Surface created by AMediaCodec_createInputSurface or 384 * AMediaCodec_createPersistentInputSurface. 385 * 386 * Returns the previous codec error if one exists. 387 * 388 * Returns AMEDIA_OK when completed succesfully. 389 * 390 * For more details, see the Java documentation for MediaCodec.signalEndOfInputStream. 391 * 392 * Available since API level 26. 393 */ 394 media_status_t AMediaCodec_signalEndOfInputStream(AMediaCodec *mData) __INTRODUCED_IN(26); 395 396 #endif /* __ANDROID_API__ >= 26 */ 397 398 #if __ANDROID_API__ >= 28 399 400 /** 401 * Get format of the buffer. The specified buffer index must have been previously obtained from 402 * dequeueOutputBuffer. 403 * The caller must free the returned format. 404 * 405 * Available since API level 28. 406 */ 407 AMediaFormat* AMediaCodec_getBufferFormat(AMediaCodec*, size_t index) __INTRODUCED_IN(28); 408 409 /** 410 * Get the component name. If the codec was created by createDecoderByType 411 * or createEncoderByType, what component is chosen is not known beforehand. 412 * Caller shall call AMediaCodec_releaseName to free the returned pointer. 413 * 414 * Available since API level 28. 415 */ 416 media_status_t AMediaCodec_getName(AMediaCodec*, char** out_name) __INTRODUCED_IN(28); 417 418 /** 419 * Free the memory pointed by name which is returned by AMediaCodec_getName. 420 * 421 * Available since API level 28. 422 */ 423 void AMediaCodec_releaseName(AMediaCodec*, char* name) __INTRODUCED_IN(28); 424 425 /** 426 * Set an asynchronous callback for actionable AMediaCodec events. 427 * When asynchronous callback is enabled, the client should not call 428 * AMediaCodec_getInputBuffers(), AMediaCodec_getOutputBuffers(), 429 * AMediaCodec_dequeueInputBuffer() or AMediaCodec_dequeueOutputBuffer(). 430 * 431 * Also, AMediaCodec_flush() behaves differently in asynchronous mode. 432 * After calling AMediaCodec_flush(), you must call AMediaCodec_start() to 433 * "resume" receiving input buffers, even if an input surface was created. 434 * 435 * Refer to the definition of AMediaCodecOnAsyncNotifyCallback on how each 436 * callback function is called and what are specified. 437 * The specified userdata is the pointer used when those callback functions are 438 * called. 439 * 440 * All callbacks are fired on one NDK internal thread. 441 * AMediaCodec_setAsyncNotifyCallback should not be called on the callback thread. 442 * No heavy duty task should be performed on callback thread. 443 * 444 * Available since API level 28. 445 */ 446 media_status_t AMediaCodec_setAsyncNotifyCallback( 447 AMediaCodec*, 448 AMediaCodecOnAsyncNotifyCallback callback, 449 void *userdata) __INTRODUCED_IN(28); 450 451 /** 452 * Release the crypto if applicable. 453 * 454 * Available since API level 28. 455 */ 456 media_status_t AMediaCodec_releaseCrypto(AMediaCodec*) __INTRODUCED_IN(28); 457 458 /** 459 * Call this after AMediaCodec_configure() returns successfully to get the input 460 * format accepted by the codec. Do this to determine what optional configuration 461 * parameters were supported by the codec. 462 * The caller must free the returned format. 463 * 464 * Available since API level 28. 465 */ 466 AMediaFormat* AMediaCodec_getInputFormat(AMediaCodec*) __INTRODUCED_IN(28); 467 468 /** 469 * Returns true if the codec cannot proceed further, but can be recovered by stopping, 470 * configuring, and starting again. 471 * 472 * Available since API level 28. 473 */ 474 bool AMediaCodecActionCode_isRecoverable(int32_t actionCode) __INTRODUCED_IN(28); 475 476 /** 477 * Returns true if the codec error is a transient issue, perhaps due to 478 * resource constraints, and that the method (or encoding/decoding) may be 479 * retried at a later time. 480 * 481 * Available since API level 28. 482 */ 483 bool AMediaCodecActionCode_isTransient(int32_t actionCode) __INTRODUCED_IN(28); 484 485 #endif /* __ANDROID_API__ >= 28 */ 486 487 typedef enum { 488 AMEDIACODECRYPTOINFO_MODE_CLEAR = 0, 489 AMEDIACODECRYPTOINFO_MODE_AES_CTR = 1, 490 AMEDIACODECRYPTOINFO_MODE_AES_WV = 2, 491 AMEDIACODECRYPTOINFO_MODE_AES_CBC = 3 492 } cryptoinfo_mode_t; 493 494 typedef struct { 495 int32_t encryptBlocks; 496 int32_t skipBlocks; 497 } cryptoinfo_pattern_t; 498 499 /** 500 * Create an AMediaCodecCryptoInfo from scratch. Use this if you need to use custom 501 * crypto info, rather than one obtained from AMediaExtractor. 502 * 503 * AMediaCodecCryptoInfo describes the structure of an (at least 504 * partially) encrypted input sample. 505 * A buffer's data is considered to be partitioned into "subsamples", 506 * each subsample starts with a (potentially empty) run of plain, 507 * unencrypted bytes followed by a (also potentially empty) run of 508 * encrypted bytes. 509 * numBytesOfClearData can be null to indicate that all data is encrypted. 510 * This information encapsulates per-sample metadata as outlined in 511 * ISO/IEC FDIS 23001-7:2011 "Common encryption in ISO base media file format files". 512 * 513 * Available since API level 21. 514 */ 515 AMediaCodecCryptoInfo *AMediaCodecCryptoInfo_new( 516 int numsubsamples, 517 uint8_t key[16], 518 uint8_t iv[16], 519 cryptoinfo_mode_t mode, 520 size_t *clearbytes, 521 size_t *encryptedbytes) __INTRODUCED_IN(21); 522 523 /** 524 * Delete an AMediaCodecCryptoInfo created previously with AMediaCodecCryptoInfo_new, or 525 * obtained from AMediaExtractor. 526 * 527 * Available since API level 21. 528 */ 529 media_status_t AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo*) __INTRODUCED_IN(21); 530 531 /** 532 * Set the crypto pattern on an AMediaCryptoInfo object. 533 * 534 * Available since API level 21. 535 */ 536 void AMediaCodecCryptoInfo_setPattern( 537 AMediaCodecCryptoInfo *info, 538 cryptoinfo_pattern_t *pattern) __INTRODUCED_IN(21); 539 540 /** 541 * The number of subsamples that make up the buffer's contents. 542 * 543 * Available since API level 21. 544 */ 545 size_t AMediaCodecCryptoInfo_getNumSubSamples(AMediaCodecCryptoInfo*) __INTRODUCED_IN(21); 546 547 /** 548 * A 16-byte opaque key. 549 * 550 * Available since API level 21. 551 */ 552 media_status_t AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo*, uint8_t *dst) __INTRODUCED_IN(21); 553 554 /** 555 * A 16-byte initialization vector. 556 * 557 * Available since API level 21. 558 */ 559 media_status_t AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo*, uint8_t *dst) __INTRODUCED_IN(21); 560 561 /** 562 * The type of encryption that has been applied, 563 * one of AMEDIACODECRYPTOINFO_MODE_CLEAR or AMEDIACODECRYPTOINFO_MODE_AES_CTR. 564 * 565 * Available since API level 21. 566 */ 567 cryptoinfo_mode_t AMediaCodecCryptoInfo_getMode(AMediaCodecCryptoInfo*) __INTRODUCED_IN(21); 568 569 /** 570 * The number of leading unencrypted bytes in each subsample. 571 * 572 * Available since API level 21. 573 */ 574 media_status_t AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo*, size_t *dst) __INTRODUCED_IN(21); 575 576 /** 577 * The number of trailing encrypted bytes in each subsample. 578 * 579 * Available since API level 21. 580 */ 581 media_status_t AMediaCodecCryptoInfo_getEncryptedBytes(AMediaCodecCryptoInfo*, size_t *dst) __INTRODUCED_IN(21); 582 583 #endif /* __ANDROID_API__ >= 21 */ 584 585 __END_DECLS 586 587 #endif //_NDK_MEDIA_CODEC_H 588 589 /** @} */ 590