1 /* 2 * copyright (c) 2001 Fabrice Bellard 3 * 4 * This file is part of Libav. 5 * 6 * Libav is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * Libav is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with Libav; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21 #ifndef AVCODEC_AVCODEC_H 22 #define AVCODEC_AVCODEC_H 23 24 /** 25 * @file 26 * @ingroup libavc 27 * Libavcodec external API header 28 */ 29 30 #include <errno.h> 31 #include "libavutil/samplefmt.h" 32 #include "libavutil/attributes.h" 33 #include "libavutil/avutil.h" 34 #include "libavutil/buffer.h" 35 #include "libavutil/cpu.h" 36 #include "libavutil/dict.h" 37 #include "libavutil/frame.h" 38 #include "libavutil/log.h" 39 #include "libavutil/pixfmt.h" 40 #include "libavutil/rational.h" 41 42 #include "version.h" 43 44 #if FF_API_FAST_MALLOC 45 // to provide fast_*alloc 46 #include "libavutil/mem.h" 47 #endif 48 49 /** 50 * @defgroup libavc Encoding/Decoding Library 51 * @{ 52 * 53 * @defgroup lavc_decoding Decoding 54 * @{ 55 * @} 56 * 57 * @defgroup lavc_encoding Encoding 58 * @{ 59 * @} 60 * 61 * @defgroup lavc_codec Codecs 62 * @{ 63 * @defgroup lavc_codec_native Native Codecs 64 * @{ 65 * @} 66 * @defgroup lavc_codec_wrappers External library wrappers 67 * @{ 68 * @} 69 * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge 70 * @{ 71 * @} 72 * @} 73 * @defgroup lavc_internal Internal 74 * @{ 75 * @} 76 * @} 77 * 78 */ 79 80 /** 81 * @defgroup lavc_core Core functions/structures. 82 * @ingroup libavc 83 * 84 * Basic definitions, functions for querying libavcodec capabilities, 85 * allocating core structures, etc. 86 * @{ 87 */ 88 89 90 /** 91 * Identify the syntax and semantics of the bitstream. 92 * The principle is roughly: 93 * Two decoders with the same ID can decode the same streams. 94 * Two encoders with the same ID can encode compatible streams. 95 * There may be slight deviations from the principle due to implementation 96 * details. 97 * 98 * If you add a codec ID to this list, add it so that 99 * 1. no value of a existing codec ID changes (that would break ABI), 100 * 2. it is as close as possible to similar codecs. 101 * 102 * After adding new codec IDs, do not forget to add an entry to the codec 103 * descriptor list and bump libavcodec minor version. 104 */ 105 enum AVCodecID { 106 AV_CODEC_ID_NONE, 107 108 /* video codecs */ 109 AV_CODEC_ID_MPEG1VIDEO, 110 AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding 111 #if FF_API_XVMC 112 AV_CODEC_ID_MPEG2VIDEO_XVMC, 113 #endif /* FF_API_XVMC */ 114 AV_CODEC_ID_H261, 115 AV_CODEC_ID_H263, 116 AV_CODEC_ID_RV10, 117 AV_CODEC_ID_RV20, 118 AV_CODEC_ID_MJPEG, 119 AV_CODEC_ID_MJPEGB, 120 AV_CODEC_ID_LJPEG, 121 AV_CODEC_ID_SP5X, 122 AV_CODEC_ID_JPEGLS, 123 AV_CODEC_ID_MPEG4, 124 AV_CODEC_ID_RAWVIDEO, 125 AV_CODEC_ID_MSMPEG4V1, 126 AV_CODEC_ID_MSMPEG4V2, 127 AV_CODEC_ID_MSMPEG4V3, 128 AV_CODEC_ID_WMV1, 129 AV_CODEC_ID_WMV2, 130 AV_CODEC_ID_H263P, 131 AV_CODEC_ID_H263I, 132 AV_CODEC_ID_FLV1, 133 AV_CODEC_ID_SVQ1, 134 AV_CODEC_ID_SVQ3, 135 AV_CODEC_ID_DVVIDEO, 136 AV_CODEC_ID_HUFFYUV, 137 AV_CODEC_ID_CYUV, 138 AV_CODEC_ID_H264, 139 AV_CODEC_ID_INDEO3, 140 AV_CODEC_ID_VP3, 141 AV_CODEC_ID_THEORA, 142 AV_CODEC_ID_ASV1, 143 AV_CODEC_ID_ASV2, 144 AV_CODEC_ID_FFV1, 145 AV_CODEC_ID_4XM, 146 AV_CODEC_ID_VCR1, 147 AV_CODEC_ID_CLJR, 148 AV_CODEC_ID_MDEC, 149 AV_CODEC_ID_ROQ, 150 AV_CODEC_ID_INTERPLAY_VIDEO, 151 AV_CODEC_ID_XAN_WC3, 152 AV_CODEC_ID_XAN_WC4, 153 AV_CODEC_ID_RPZA, 154 AV_CODEC_ID_CINEPAK, 155 AV_CODEC_ID_WS_VQA, 156 AV_CODEC_ID_MSRLE, 157 AV_CODEC_ID_MSVIDEO1, 158 AV_CODEC_ID_IDCIN, 159 AV_CODEC_ID_8BPS, 160 AV_CODEC_ID_SMC, 161 AV_CODEC_ID_FLIC, 162 AV_CODEC_ID_TRUEMOTION1, 163 AV_CODEC_ID_VMDVIDEO, 164 AV_CODEC_ID_MSZH, 165 AV_CODEC_ID_ZLIB, 166 AV_CODEC_ID_QTRLE, 167 AV_CODEC_ID_TSCC, 168 AV_CODEC_ID_ULTI, 169 AV_CODEC_ID_QDRAW, 170 AV_CODEC_ID_VIXL, 171 AV_CODEC_ID_QPEG, 172 AV_CODEC_ID_PNG, 173 AV_CODEC_ID_PPM, 174 AV_CODEC_ID_PBM, 175 AV_CODEC_ID_PGM, 176 AV_CODEC_ID_PGMYUV, 177 AV_CODEC_ID_PAM, 178 AV_CODEC_ID_FFVHUFF, 179 AV_CODEC_ID_RV30, 180 AV_CODEC_ID_RV40, 181 AV_CODEC_ID_VC1, 182 AV_CODEC_ID_WMV3, 183 AV_CODEC_ID_LOCO, 184 AV_CODEC_ID_WNV1, 185 AV_CODEC_ID_AASC, 186 AV_CODEC_ID_INDEO2, 187 AV_CODEC_ID_FRAPS, 188 AV_CODEC_ID_TRUEMOTION2, 189 AV_CODEC_ID_BMP, 190 AV_CODEC_ID_CSCD, 191 AV_CODEC_ID_MMVIDEO, 192 AV_CODEC_ID_ZMBV, 193 AV_CODEC_ID_AVS, 194 AV_CODEC_ID_SMACKVIDEO, 195 AV_CODEC_ID_NUV, 196 AV_CODEC_ID_KMVC, 197 AV_CODEC_ID_FLASHSV, 198 AV_CODEC_ID_CAVS, 199 AV_CODEC_ID_JPEG2000, 200 AV_CODEC_ID_VMNC, 201 AV_CODEC_ID_VP5, 202 AV_CODEC_ID_VP6, 203 AV_CODEC_ID_VP6F, 204 AV_CODEC_ID_TARGA, 205 AV_CODEC_ID_DSICINVIDEO, 206 AV_CODEC_ID_TIERTEXSEQVIDEO, 207 AV_CODEC_ID_TIFF, 208 AV_CODEC_ID_GIF, 209 AV_CODEC_ID_DXA, 210 AV_CODEC_ID_DNXHD, 211 AV_CODEC_ID_THP, 212 AV_CODEC_ID_SGI, 213 AV_CODEC_ID_C93, 214 AV_CODEC_ID_BETHSOFTVID, 215 AV_CODEC_ID_PTX, 216 AV_CODEC_ID_TXD, 217 AV_CODEC_ID_VP6A, 218 AV_CODEC_ID_AMV, 219 AV_CODEC_ID_VB, 220 AV_CODEC_ID_PCX, 221 AV_CODEC_ID_SUNRAST, 222 AV_CODEC_ID_INDEO4, 223 AV_CODEC_ID_INDEO5, 224 AV_CODEC_ID_MIMIC, 225 AV_CODEC_ID_RL2, 226 AV_CODEC_ID_ESCAPE124, 227 AV_CODEC_ID_DIRAC, 228 AV_CODEC_ID_BFI, 229 AV_CODEC_ID_CMV, 230 AV_CODEC_ID_MOTIONPIXELS, 231 AV_CODEC_ID_TGV, 232 AV_CODEC_ID_TGQ, 233 AV_CODEC_ID_TQI, 234 AV_CODEC_ID_AURA, 235 AV_CODEC_ID_AURA2, 236 AV_CODEC_ID_V210X, 237 AV_CODEC_ID_TMV, 238 AV_CODEC_ID_V210, 239 AV_CODEC_ID_DPX, 240 AV_CODEC_ID_MAD, 241 AV_CODEC_ID_FRWU, 242 AV_CODEC_ID_FLASHSV2, 243 AV_CODEC_ID_CDGRAPHICS, 244 AV_CODEC_ID_R210, 245 AV_CODEC_ID_ANM, 246 AV_CODEC_ID_BINKVIDEO, 247 AV_CODEC_ID_IFF_ILBM, 248 AV_CODEC_ID_IFF_BYTERUN1, 249 AV_CODEC_ID_KGV1, 250 AV_CODEC_ID_YOP, 251 AV_CODEC_ID_VP8, 252 AV_CODEC_ID_PICTOR, 253 AV_CODEC_ID_ANSI, 254 AV_CODEC_ID_A64_MULTI, 255 AV_CODEC_ID_A64_MULTI5, 256 AV_CODEC_ID_R10K, 257 AV_CODEC_ID_MXPEG, 258 AV_CODEC_ID_LAGARITH, 259 AV_CODEC_ID_PRORES, 260 AV_CODEC_ID_JV, 261 AV_CODEC_ID_DFA, 262 AV_CODEC_ID_WMV3IMAGE, 263 AV_CODEC_ID_VC1IMAGE, 264 AV_CODEC_ID_UTVIDEO, 265 AV_CODEC_ID_BMV_VIDEO, 266 AV_CODEC_ID_VBLE, 267 AV_CODEC_ID_DXTORY, 268 AV_CODEC_ID_V410, 269 AV_CODEC_ID_XWD, 270 AV_CODEC_ID_CDXL, 271 AV_CODEC_ID_XBM, 272 AV_CODEC_ID_ZEROCODEC, 273 AV_CODEC_ID_MSS1, 274 AV_CODEC_ID_MSA1, 275 AV_CODEC_ID_TSCC2, 276 AV_CODEC_ID_MTS2, 277 AV_CODEC_ID_CLLC, 278 AV_CODEC_ID_MSS2, 279 AV_CODEC_ID_VP9, 280 AV_CODEC_ID_AIC, 281 AV_CODEC_ID_ESCAPE130, 282 AV_CODEC_ID_G2M, 283 AV_CODEC_ID_WEBP, 284 AV_CODEC_ID_HNM4_VIDEO, 285 AV_CODEC_ID_HEVC, 286 AV_CODEC_ID_FIC, 287 288 /* various PCM "codecs" */ 289 AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs 290 AV_CODEC_ID_PCM_S16LE = 0x10000, 291 AV_CODEC_ID_PCM_S16BE, 292 AV_CODEC_ID_PCM_U16LE, 293 AV_CODEC_ID_PCM_U16BE, 294 AV_CODEC_ID_PCM_S8, 295 AV_CODEC_ID_PCM_U8, 296 AV_CODEC_ID_PCM_MULAW, 297 AV_CODEC_ID_PCM_ALAW, 298 AV_CODEC_ID_PCM_S32LE, 299 AV_CODEC_ID_PCM_S32BE, 300 AV_CODEC_ID_PCM_U32LE, 301 AV_CODEC_ID_PCM_U32BE, 302 AV_CODEC_ID_PCM_S24LE, 303 AV_CODEC_ID_PCM_S24BE, 304 AV_CODEC_ID_PCM_U24LE, 305 AV_CODEC_ID_PCM_U24BE, 306 AV_CODEC_ID_PCM_S24DAUD, 307 AV_CODEC_ID_PCM_ZORK, 308 AV_CODEC_ID_PCM_S16LE_PLANAR, 309 AV_CODEC_ID_PCM_DVD, 310 AV_CODEC_ID_PCM_F32BE, 311 AV_CODEC_ID_PCM_F32LE, 312 AV_CODEC_ID_PCM_F64BE, 313 AV_CODEC_ID_PCM_F64LE, 314 AV_CODEC_ID_PCM_BLURAY, 315 AV_CODEC_ID_PCM_LXF, 316 AV_CODEC_ID_S302M, 317 AV_CODEC_ID_PCM_S8_PLANAR, 318 AV_CODEC_ID_PCM_S24LE_PLANAR, 319 AV_CODEC_ID_PCM_S32LE_PLANAR, 320 321 /* various ADPCM codecs */ 322 AV_CODEC_ID_ADPCM_IMA_QT = 0x11000, 323 AV_CODEC_ID_ADPCM_IMA_WAV, 324 AV_CODEC_ID_ADPCM_IMA_DK3, 325 AV_CODEC_ID_ADPCM_IMA_DK4, 326 AV_CODEC_ID_ADPCM_IMA_WS, 327 AV_CODEC_ID_ADPCM_IMA_SMJPEG, 328 AV_CODEC_ID_ADPCM_MS, 329 AV_CODEC_ID_ADPCM_4XM, 330 AV_CODEC_ID_ADPCM_XA, 331 AV_CODEC_ID_ADPCM_ADX, 332 AV_CODEC_ID_ADPCM_EA, 333 AV_CODEC_ID_ADPCM_G726, 334 AV_CODEC_ID_ADPCM_CT, 335 AV_CODEC_ID_ADPCM_SWF, 336 AV_CODEC_ID_ADPCM_YAMAHA, 337 AV_CODEC_ID_ADPCM_SBPRO_4, 338 AV_CODEC_ID_ADPCM_SBPRO_3, 339 AV_CODEC_ID_ADPCM_SBPRO_2, 340 AV_CODEC_ID_ADPCM_THP, 341 AV_CODEC_ID_ADPCM_IMA_AMV, 342 AV_CODEC_ID_ADPCM_EA_R1, 343 AV_CODEC_ID_ADPCM_EA_R3, 344 AV_CODEC_ID_ADPCM_EA_R2, 345 AV_CODEC_ID_ADPCM_IMA_EA_SEAD, 346 AV_CODEC_ID_ADPCM_IMA_EA_EACS, 347 AV_CODEC_ID_ADPCM_EA_XAS, 348 AV_CODEC_ID_ADPCM_EA_MAXIS_XA, 349 AV_CODEC_ID_ADPCM_IMA_ISS, 350 AV_CODEC_ID_ADPCM_G722, 351 AV_CODEC_ID_ADPCM_IMA_APC, 352 353 /* AMR */ 354 AV_CODEC_ID_AMR_NB = 0x12000, 355 AV_CODEC_ID_AMR_WB, 356 357 /* RealAudio codecs*/ 358 AV_CODEC_ID_RA_144 = 0x13000, 359 AV_CODEC_ID_RA_288, 360 361 /* various DPCM codecs */ 362 AV_CODEC_ID_ROQ_DPCM = 0x14000, 363 AV_CODEC_ID_INTERPLAY_DPCM, 364 AV_CODEC_ID_XAN_DPCM, 365 AV_CODEC_ID_SOL_DPCM, 366 367 /* audio codecs */ 368 AV_CODEC_ID_MP2 = 0x15000, 369 AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3 370 AV_CODEC_ID_AAC, 371 AV_CODEC_ID_AC3, 372 AV_CODEC_ID_DTS, 373 AV_CODEC_ID_VORBIS, 374 AV_CODEC_ID_DVAUDIO, 375 AV_CODEC_ID_WMAV1, 376 AV_CODEC_ID_WMAV2, 377 AV_CODEC_ID_MACE3, 378 AV_CODEC_ID_MACE6, 379 AV_CODEC_ID_VMDAUDIO, 380 AV_CODEC_ID_FLAC, 381 AV_CODEC_ID_MP3ADU, 382 AV_CODEC_ID_MP3ON4, 383 AV_CODEC_ID_SHORTEN, 384 AV_CODEC_ID_ALAC, 385 AV_CODEC_ID_WESTWOOD_SND1, 386 AV_CODEC_ID_GSM, ///< as in Berlin toast format 387 AV_CODEC_ID_QDM2, 388 AV_CODEC_ID_COOK, 389 AV_CODEC_ID_TRUESPEECH, 390 AV_CODEC_ID_TTA, 391 AV_CODEC_ID_SMACKAUDIO, 392 AV_CODEC_ID_QCELP, 393 AV_CODEC_ID_WAVPACK, 394 AV_CODEC_ID_DSICINAUDIO, 395 AV_CODEC_ID_IMC, 396 AV_CODEC_ID_MUSEPACK7, 397 AV_CODEC_ID_MLP, 398 AV_CODEC_ID_GSM_MS, /* as found in WAV */ 399 AV_CODEC_ID_ATRAC3, 400 #if FF_API_VOXWARE 401 AV_CODEC_ID_VOXWARE, 402 #endif 403 AV_CODEC_ID_APE, 404 AV_CODEC_ID_NELLYMOSER, 405 AV_CODEC_ID_MUSEPACK8, 406 AV_CODEC_ID_SPEEX, 407 AV_CODEC_ID_WMAVOICE, 408 AV_CODEC_ID_WMAPRO, 409 AV_CODEC_ID_WMALOSSLESS, 410 AV_CODEC_ID_ATRAC3P, 411 AV_CODEC_ID_EAC3, 412 AV_CODEC_ID_SIPR, 413 AV_CODEC_ID_MP1, 414 AV_CODEC_ID_TWINVQ, 415 AV_CODEC_ID_TRUEHD, 416 AV_CODEC_ID_MP4ALS, 417 AV_CODEC_ID_ATRAC1, 418 AV_CODEC_ID_BINKAUDIO_RDFT, 419 AV_CODEC_ID_BINKAUDIO_DCT, 420 AV_CODEC_ID_AAC_LATM, 421 AV_CODEC_ID_QDMC, 422 AV_CODEC_ID_CELT, 423 AV_CODEC_ID_G723_1, 424 AV_CODEC_ID_G729, 425 AV_CODEC_ID_8SVX_EXP, 426 AV_CODEC_ID_8SVX_FIB, 427 AV_CODEC_ID_BMV_AUDIO, 428 AV_CODEC_ID_RALF, 429 AV_CODEC_ID_IAC, 430 AV_CODEC_ID_ILBC, 431 AV_CODEC_ID_OPUS, 432 AV_CODEC_ID_COMFORT_NOISE, 433 AV_CODEC_ID_TAK, 434 AV_CODEC_ID_METASOUND, 435 436 /* subtitle codecs */ 437 AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs. 438 AV_CODEC_ID_DVD_SUBTITLE = 0x17000, 439 AV_CODEC_ID_DVB_SUBTITLE, 440 AV_CODEC_ID_TEXT, ///< raw UTF-8 text 441 AV_CODEC_ID_XSUB, 442 AV_CODEC_ID_SSA, 443 AV_CODEC_ID_MOV_TEXT, 444 AV_CODEC_ID_HDMV_PGS_SUBTITLE, 445 AV_CODEC_ID_DVB_TELETEXT, 446 AV_CODEC_ID_SRT, 447 448 /* other specific kind of codecs (generally used for attachments) */ 449 AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs. 450 AV_CODEC_ID_TTF = 0x18000, 451 452 AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it 453 454 AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS 455 * stream (only used by libavformat) */ 456 AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems 457 * stream (only used by libavformat) */ 458 AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information. 459 }; 460 461 /** 462 * This struct describes the properties of a single codec described by an 463 * AVCodecID. 464 * @see avcodec_get_descriptor() 465 */ 466 typedef struct AVCodecDescriptor { 467 enum AVCodecID id; 468 enum AVMediaType type; 469 /** 470 * Name of the codec described by this descriptor. It is non-empty and 471 * unique for each codec descriptor. It should contain alphanumeric 472 * characters and '_' only. 473 */ 474 const char *name; 475 /** 476 * A more descriptive name for this codec. May be NULL. 477 */ 478 const char *long_name; 479 /** 480 * Codec properties, a combination of AV_CODEC_PROP_* flags. 481 */ 482 int props; 483 } AVCodecDescriptor; 484 485 /** 486 * Codec uses only intra compression. 487 * Video codecs only. 488 */ 489 #define AV_CODEC_PROP_INTRA_ONLY (1 << 0) 490 /** 491 * Codec supports lossy compression. Audio and video codecs only. 492 * @note a codec may support both lossy and lossless 493 * compression modes 494 */ 495 #define AV_CODEC_PROP_LOSSY (1 << 1) 496 /** 497 * Codec supports lossless compression. Audio and video codecs only. 498 */ 499 #define AV_CODEC_PROP_LOSSLESS (1 << 2) 500 501 /** 502 * @ingroup lavc_decoding 503 * Required number of additionally allocated bytes at the end of the input bitstream for decoding. 504 * This is mainly needed because some optimized bitstream readers read 505 * 32 or 64 bit at once and could read over the end.<br> 506 * Note: If the first 23 bits of the additional bytes are not 0, then damaged 507 * MPEG bitstreams could cause overread and segfault. 508 */ 509 #define FF_INPUT_BUFFER_PADDING_SIZE 8 510 511 /** 512 * @ingroup lavc_encoding 513 * minimum encoding buffer size 514 * Used to avoid some checks during header writing. 515 */ 516 #define FF_MIN_BUFFER_SIZE 16384 517 518 519 /** 520 * @ingroup lavc_encoding 521 * motion estimation type. 522 */ 523 enum Motion_Est_ID { 524 ME_ZERO = 1, ///< no search, that is use 0,0 vector whenever one is needed 525 ME_FULL, 526 ME_LOG, 527 ME_PHODS, 528 ME_EPZS, ///< enhanced predictive zonal search 529 ME_X1, ///< reserved for experiments 530 ME_HEX, ///< hexagon based search 531 ME_UMH, ///< uneven multi-hexagon search 532 ME_TESA, ///< transformed exhaustive search algorithm 533 }; 534 535 /** 536 * @ingroup lavc_decoding 537 */ 538 enum AVDiscard{ 539 /* We leave some space between them for extensions (drop some 540 * keyframes for intra-only or drop just some bidir frames). */ 541 AVDISCARD_NONE =-16, ///< discard nothing 542 AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi 543 AVDISCARD_NONREF = 8, ///< discard all non reference 544 AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames 545 AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes 546 AVDISCARD_ALL = 48, ///< discard all 547 }; 548 549 enum AVColorPrimaries{ 550 AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B 551 AVCOL_PRI_UNSPECIFIED = 2, 552 AVCOL_PRI_BT470M = 4, 553 AVCOL_PRI_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM 554 AVCOL_PRI_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC 555 AVCOL_PRI_SMPTE240M = 7, ///< functionally identical to above 556 AVCOL_PRI_FILM = 8, 557 AVCOL_PRI_BT2020 = 9, ///< ITU-R BT2020 558 AVCOL_PRI_NB , ///< Not part of ABI 559 }; 560 561 enum AVColorTransferCharacteristic{ 562 AVCOL_TRC_BT709 = 1, ///< also ITU-R BT1361 563 AVCOL_TRC_UNSPECIFIED = 2, 564 AVCOL_TRC_GAMMA22 = 4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM 565 AVCOL_TRC_GAMMA28 = 5, ///< also ITU-R BT470BG 566 AVCOL_TRC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC 567 AVCOL_TRC_SMPTE240M = 7, 568 AVCOL_TRC_LINEAR = 8, ///< "Linear transfer characteristics" 569 AVCOL_TRC_LOG = 9, ///< "Logarithmic transfer characteristic (100:1 range)" 570 AVCOL_TRC_LOG_SQRT = 10, ///< "Logarithmic transfer characteristic (100 * Sqrt( 10 ) : 1 range)" 571 AVCOL_TRC_IEC61966_2_4 = 11, ///< IEC 61966-2-4 572 AVCOL_TRC_BT1361_ECG = 12, ///< ITU-R BT1361 Extended Colour Gamut 573 AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC) 574 AVCOL_TRC_BT2020_10 = 14, ///< ITU-R BT2020 for 10 bit system 575 AVCOL_TRC_BT2020_12 = 15, ///< ITU-R BT2020 for 12 bit system 576 AVCOL_TRC_NB , ///< Not part of ABI 577 }; 578 579 enum AVColorSpace{ 580 AVCOL_SPC_RGB = 0, 581 AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B 582 AVCOL_SPC_UNSPECIFIED = 2, 583 AVCOL_SPC_FCC = 4, 584 AVCOL_SPC_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 585 AVCOL_SPC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above 586 AVCOL_SPC_SMPTE240M = 7, 587 AVCOL_SPC_YCOCG = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16 588 AVCOL_SPC_BT2020_NCL = 9, ///< ITU-R BT2020 non-constant luminance system 589 AVCOL_SPC_BT2020_CL = 10, ///< ITU-R BT2020 constant luminance system 590 AVCOL_SPC_NB , ///< Not part of ABI 591 }; 592 593 enum AVColorRange{ 594 AVCOL_RANGE_UNSPECIFIED = 0, 595 AVCOL_RANGE_MPEG = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges 596 AVCOL_RANGE_JPEG = 2, ///< the normal 2^n-1 "JPEG" YUV ranges 597 AVCOL_RANGE_NB , ///< Not part of ABI 598 }; 599 600 /** 601 * X X 3 4 X X are luma samples, 602 * 1 2 1-6 are possible chroma positions 603 * X X 5 6 X 0 is undefined/unknown position 604 */ 605 enum AVChromaLocation{ 606 AVCHROMA_LOC_UNSPECIFIED = 0, 607 AVCHROMA_LOC_LEFT = 1, ///< mpeg2/4, h264 default 608 AVCHROMA_LOC_CENTER = 2, ///< mpeg1, jpeg, h263 609 AVCHROMA_LOC_TOPLEFT = 3, ///< DV 610 AVCHROMA_LOC_TOP = 4, 611 AVCHROMA_LOC_BOTTOMLEFT = 5, 612 AVCHROMA_LOC_BOTTOM = 6, 613 AVCHROMA_LOC_NB , ///< Not part of ABI 614 }; 615 616 enum AVAudioServiceType { 617 AV_AUDIO_SERVICE_TYPE_MAIN = 0, 618 AV_AUDIO_SERVICE_TYPE_EFFECTS = 1, 619 AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2, 620 AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3, 621 AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4, 622 AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5, 623 AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6, 624 AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7, 625 AV_AUDIO_SERVICE_TYPE_KARAOKE = 8, 626 AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI 627 }; 628 629 /** 630 * @ingroup lavc_encoding 631 */ 632 typedef struct RcOverride{ 633 int start_frame; 634 int end_frame; 635 int qscale; // If this is 0 then quality_factor will be used instead. 636 float quality_factor; 637 } RcOverride; 638 639 #if FF_API_MAX_BFRAMES 640 /** 641 * @deprecated there is no libavcodec-wide limit on the number of B-frames 642 */ 643 #define FF_MAX_B_FRAMES 16 644 #endif 645 646 /* encoding support 647 These flags can be passed in AVCodecContext.flags before initialization. 648 Note: Not everything is supported yet. 649 */ 650 651 /** 652 * Allow decoders to produce frames with data planes that are not aligned 653 * to CPU requirements (e.g. due to cropping). 654 */ 655 #define CODEC_FLAG_UNALIGNED 0x0001 656 #define CODEC_FLAG_QSCALE 0x0002 ///< Use fixed qscale. 657 #define CODEC_FLAG_4MV 0x0004 ///< 4 MV per MB allowed / advanced prediction for H.263. 658 #define CODEC_FLAG_OUTPUT_CORRUPT 0x0008 ///< Output even those frames that might be corrupted 659 #define CODEC_FLAG_QPEL 0x0010 ///< Use qpel MC. 660 #define CODEC_FLAG_GMC 0x0020 ///< Use GMC. 661 #define CODEC_FLAG_MV0 0x0040 ///< Always try a MB with MV=<0,0>. 662 /** 663 * The parent program guarantees that the input for B-frames containing 664 * streams is not written to for at least s->max_b_frames+1 frames, if 665 * this is not set the input will be copied. 666 */ 667 #define CODEC_FLAG_INPUT_PRESERVED 0x0100 668 #define CODEC_FLAG_PASS1 0x0200 ///< Use internal 2pass ratecontrol in first pass mode. 669 #define CODEC_FLAG_PASS2 0x0400 ///< Use internal 2pass ratecontrol in second pass mode. 670 #define CODEC_FLAG_GRAY 0x2000 ///< Only decode/encode grayscale. 671 #if FF_API_EMU_EDGE 672 /** 673 * @deprecated edges are not used/required anymore. I.e. this flag is now always 674 * set. 675 */ 676 #define CODEC_FLAG_EMU_EDGE 0x4000 677 #endif 678 #define CODEC_FLAG_PSNR 0x8000 ///< error[?] variables will be set during encoding. 679 #define CODEC_FLAG_TRUNCATED 0x00010000 /** Input bitstream might be truncated at a random 680 location instead of only at frame boundaries. */ 681 #define CODEC_FLAG_NORMALIZE_AQP 0x00020000 ///< Normalize adaptive quantization. 682 #define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< Use interlaced DCT. 683 #define CODEC_FLAG_LOW_DELAY 0x00080000 ///< Force low delay. 684 #define CODEC_FLAG_GLOBAL_HEADER 0x00400000 ///< Place global headers in extradata instead of every keyframe. 685 #define CODEC_FLAG_BITEXACT 0x00800000 ///< Use only bitexact stuff (except (I)DCT). 686 /* Fx : Flag for h263+ extra options */ 687 #define CODEC_FLAG_AC_PRED 0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction 688 #define CODEC_FLAG_LOOP_FILTER 0x00000800 ///< loop filter 689 #define CODEC_FLAG_INTERLACED_ME 0x20000000 ///< interlaced motion estimation 690 #define CODEC_FLAG_CLOSED_GOP 0x80000000 691 #define CODEC_FLAG2_FAST 0x00000001 ///< Allow non spec compliant speedup tricks. 692 #define CODEC_FLAG2_NO_OUTPUT 0x00000004 ///< Skip bitstream encoding. 693 #define CODEC_FLAG2_LOCAL_HEADER 0x00000008 ///< Place global headers at every keyframe instead of in extradata. 694 #define CODEC_FLAG2_IGNORE_CROP 0x00010000 ///< Discard cropping information from SPS. 695 696 #define CODEC_FLAG2_CHUNKS 0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries. 697 698 /* Unsupported options : 699 * Syntax Arithmetic coding (SAC) 700 * Reference Picture Selection 701 * Independent Segment Decoding */ 702 /* /Fx */ 703 /* codec capabilities */ 704 705 #define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< Decoder can use draw_horiz_band callback. 706 /** 707 * Codec uses get_buffer() for allocating buffers and supports custom allocators. 708 * If not set, it might not use get_buffer() at all or use operations that 709 * assume the buffer was allocated by avcodec_default_get_buffer. 710 */ 711 #define CODEC_CAP_DR1 0x0002 712 #define CODEC_CAP_TRUNCATED 0x0008 713 #if FF_API_XVMC 714 /* Codec can export data for HW decoding (XvMC). */ 715 #define CODEC_CAP_HWACCEL 0x0010 716 #endif /* FF_API_XVMC */ 717 /** 718 * Encoder or decoder requires flushing with NULL input at the end in order to 719 * give the complete and correct output. 720 * 721 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with 722 * with NULL data. The user can still send NULL data to the public encode 723 * or decode function, but libavcodec will not pass it along to the codec 724 * unless this flag is set. 725 * 726 * Decoders: 727 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL, 728 * avpkt->size=0 at the end to get the delayed data until the decoder no longer 729 * returns frames. 730 * 731 * Encoders: 732 * The encoder needs to be fed with NULL data at the end of encoding until the 733 * encoder no longer returns data. 734 * 735 * NOTE: For encoders implementing the AVCodec.encode2() function, setting this 736 * flag also means that the encoder must set the pts and duration for 737 * each output packet. If this flag is not set, the pts and duration will 738 * be determined by libavcodec from the input frame. 739 */ 740 #define CODEC_CAP_DELAY 0x0020 741 /** 742 * Codec can be fed a final frame with a smaller size. 743 * This can be used to prevent truncation of the last audio samples. 744 */ 745 #define CODEC_CAP_SMALL_LAST_FRAME 0x0040 746 #if FF_API_CAP_VDPAU 747 /** 748 * Codec can export data for HW decoding (VDPAU). 749 */ 750 #define CODEC_CAP_HWACCEL_VDPAU 0x0080 751 #endif 752 /** 753 * Codec can output multiple frames per AVPacket 754 * Normally demuxers return one frame at a time, demuxers which do not do 755 * are connected to a parser to split what they return into proper frames. 756 * This flag is reserved to the very rare category of codecs which have a 757 * bitstream that cannot be split into frames without timeconsuming 758 * operations like full decoding. Demuxers carring such bitstreams thus 759 * may return multiple frames in a packet. This has many disadvantages like 760 * prohibiting stream copy in many cases thus it should only be considered 761 * as a last resort. 762 */ 763 #define CODEC_CAP_SUBFRAMES 0x0100 764 /** 765 * Codec is experimental and is thus avoided in favor of non experimental 766 * encoders 767 */ 768 #define CODEC_CAP_EXPERIMENTAL 0x0200 769 /** 770 * Codec should fill in channel configuration and samplerate instead of container 771 */ 772 #define CODEC_CAP_CHANNEL_CONF 0x0400 773 #if FF_API_NEG_LINESIZES 774 /** 775 * @deprecated no codecs use this capability 776 */ 777 #define CODEC_CAP_NEG_LINESIZES 0x0800 778 #endif 779 /** 780 * Codec supports frame-level multithreading. 781 */ 782 #define CODEC_CAP_FRAME_THREADS 0x1000 783 /** 784 * Codec supports slice-based (or partition-based) multithreading. 785 */ 786 #define CODEC_CAP_SLICE_THREADS 0x2000 787 /** 788 * Codec supports changed parameters at any point. 789 */ 790 #define CODEC_CAP_PARAM_CHANGE 0x4000 791 /** 792 * Codec supports avctx->thread_count == 0 (auto). 793 */ 794 #define CODEC_CAP_AUTO_THREADS 0x8000 795 /** 796 * Audio encoder supports receiving a different number of samples in each call. 797 */ 798 #define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000 799 800 #if FF_API_MB_TYPE 801 //The following defines may change, don't expect compatibility if you use them. 802 #define MB_TYPE_INTRA4x4 0x0001 803 #define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific 804 #define MB_TYPE_INTRA_PCM 0x0004 //FIXME H.264-specific 805 #define MB_TYPE_16x16 0x0008 806 #define MB_TYPE_16x8 0x0010 807 #define MB_TYPE_8x16 0x0020 808 #define MB_TYPE_8x8 0x0040 809 #define MB_TYPE_INTERLACED 0x0080 810 #define MB_TYPE_DIRECT2 0x0100 //FIXME 811 #define MB_TYPE_ACPRED 0x0200 812 #define MB_TYPE_GMC 0x0400 813 #define MB_TYPE_SKIP 0x0800 814 #define MB_TYPE_P0L0 0x1000 815 #define MB_TYPE_P1L0 0x2000 816 #define MB_TYPE_P0L1 0x4000 817 #define MB_TYPE_P1L1 0x8000 818 #define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0) 819 #define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1) 820 #define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1) 821 #define MB_TYPE_QUANT 0x00010000 822 #define MB_TYPE_CBP 0x00020000 823 //Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...) 824 #endif 825 826 /** 827 * Pan Scan area. 828 * This specifies the area which should be displayed. 829 * Note there may be multiple such areas for one frame. 830 */ 831 typedef struct AVPanScan{ 832 /** 833 * id 834 * - encoding: Set by user. 835 * - decoding: Set by libavcodec. 836 */ 837 int id; 838 839 /** 840 * width and height in 1/16 pel 841 * - encoding: Set by user. 842 * - decoding: Set by libavcodec. 843 */ 844 int width; 845 int height; 846 847 /** 848 * position of the top left corner in 1/16 pel for up to 3 fields/frames 849 * - encoding: Set by user. 850 * - decoding: Set by libavcodec. 851 */ 852 int16_t position[3][2]; 853 }AVPanScan; 854 855 #if FF_API_QSCALE_TYPE 856 #define FF_QSCALE_TYPE_MPEG1 0 857 #define FF_QSCALE_TYPE_MPEG2 1 858 #define FF_QSCALE_TYPE_H264 2 859 #define FF_QSCALE_TYPE_VP56 3 860 #endif 861 862 #if FF_API_GET_BUFFER 863 #define FF_BUFFER_TYPE_INTERNAL 1 864 #define FF_BUFFER_TYPE_USER 2 ///< direct rendering buffers (image is (de)allocated by user) 865 #define FF_BUFFER_TYPE_SHARED 4 ///< Buffer from somewhere else; don't deallocate image (data/base), all other tables are not shared. 866 #define FF_BUFFER_TYPE_COPY 8 ///< Just a (modified) copy of some other buffer, don't deallocate anything. 867 868 #define FF_BUFFER_HINTS_VALID 0x01 // Buffer hints value is meaningful (if 0 ignore). 869 #define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer. 870 #define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content. 871 #define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update). 872 #endif 873 874 /** 875 * The decoder will keep a reference to the frame and may reuse it later. 876 */ 877 #define AV_GET_BUFFER_FLAG_REF (1 << 0) 878 879 /** 880 * @defgroup lavc_packet AVPacket 881 * 882 * Types and functions for working with AVPacket. 883 * @{ 884 */ 885 enum AVPacketSideDataType { 886 AV_PKT_DATA_PALETTE, 887 AV_PKT_DATA_NEW_EXTRADATA, 888 889 /** 890 * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows: 891 * @code 892 * u32le param_flags 893 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) 894 * s32le channel_count 895 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) 896 * u64le channel_layout 897 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) 898 * s32le sample_rate 899 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) 900 * s32le width 901 * s32le height 902 * @endcode 903 */ 904 AV_PKT_DATA_PARAM_CHANGE, 905 906 /** 907 * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of 908 * structures with info about macroblocks relevant to splitting the 909 * packet into smaller packets on macroblock edges (e.g. as for RFC 2190). 910 * That is, it does not necessarily contain info about all macroblocks, 911 * as long as the distance between macroblocks in the info is smaller 912 * than the target payload size. 913 * Each MB info structure is 12 bytes, and is laid out as follows: 914 * @code 915 * u32le bit offset from the start of the packet 916 * u8 current quantizer at the start of the macroblock 917 * u8 GOB number 918 * u16le macroblock address within the GOB 919 * u8 horizontal MV predictor 920 * u8 vertical MV predictor 921 * u8 horizontal MV predictor for block number 3 922 * u8 vertical MV predictor for block number 3 923 * @endcode 924 */ 925 AV_PKT_DATA_H263_MB_INFO, 926 }; 927 928 /** 929 * This structure stores compressed data. It is typically exported by demuxers 930 * and then passed as input to decoders, or received as output from encoders and 931 * then passed to muxers. 932 * 933 * For video, it should typically contain one compressed frame. For audio it may 934 * contain several compressed frames. 935 * 936 * AVPacket is one of the few structs in Libav, whose size is a part of public 937 * ABI. Thus it may be allocated on stack and no new fields can be added to it 938 * without libavcodec and libavformat major bump. 939 * 940 * The semantics of data ownership depends on the buf or destruct (deprecated) 941 * fields. If either is set, the packet data is dynamically allocated and is 942 * valid indefinitely until av_free_packet() is called (which in turn calls 943 * av_buffer_unref()/the destruct callback to free the data). If neither is set, 944 * the packet data is typically backed by some static buffer somewhere and is 945 * only valid for a limited time (e.g. until the next read call when demuxing). 946 * 947 * The side data is always allocated with av_malloc() and is freed in 948 * av_free_packet(). 949 */ 950 typedef struct AVPacket { 951 /** 952 * A reference to the reference-counted buffer where the packet data is 953 * stored. 954 * May be NULL, then the packet data is not reference-counted. 955 */ 956 AVBufferRef *buf; 957 /** 958 * Presentation timestamp in AVStream->time_base units; the time at which 959 * the decompressed packet will be presented to the user. 960 * Can be AV_NOPTS_VALUE if it is not stored in the file. 961 * pts MUST be larger or equal to dts as presentation cannot happen before 962 * decompression, unless one wants to view hex dumps. Some formats misuse 963 * the terms dts and pts/cts to mean something different. Such timestamps 964 * must be converted to true pts/dts before they are stored in AVPacket. 965 */ 966 int64_t pts; 967 /** 968 * Decompression timestamp in AVStream->time_base units; the time at which 969 * the packet is decompressed. 970 * Can be AV_NOPTS_VALUE if it is not stored in the file. 971 */ 972 int64_t dts; 973 uint8_t *data; 974 int size; 975 int stream_index; 976 /** 977 * A combination of AV_PKT_FLAG values 978 */ 979 int flags; 980 /** 981 * Additional packet data that can be provided by the container. 982 * Packet can contain several types of side information. 983 */ 984 struct { 985 uint8_t *data; 986 int size; 987 enum AVPacketSideDataType type; 988 } *side_data; 989 int side_data_elems; 990 991 /** 992 * Duration of this packet in AVStream->time_base units, 0 if unknown. 993 * Equals next_pts - this_pts in presentation order. 994 */ 995 int duration; 996 #if FF_API_DESTRUCT_PACKET 997 attribute_deprecated 998 void (*destruct)(struct AVPacket *); 999 attribute_deprecated 1000 void *priv; 1001 #endif 1002 int64_t pos; ///< byte position in stream, -1 if unknown 1003 1004 /** 1005 * Time difference in AVStream->time_base units from the pts of this 1006 * packet to the point at which the output from the decoder has converged 1007 * independent from the availability of previous frames. That is, the 1008 * frames are virtually identical no matter if decoding started from 1009 * the very first frame or from this keyframe. 1010 * Is AV_NOPTS_VALUE if unknown. 1011 * This field is not the display duration of the current packet. 1012 * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY 1013 * set. 1014 * 1015 * The purpose of this field is to allow seeking in streams that have no 1016 * keyframes in the conventional sense. It corresponds to the 1017 * recovery point SEI in H.264 and match_time_delta in NUT. It is also 1018 * essential for some types of subtitle streams to ensure that all 1019 * subtitles are correctly displayed after seeking. 1020 */ 1021 int64_t convergence_duration; 1022 } AVPacket; 1023 #define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe 1024 #define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted 1025 1026 enum AVSideDataParamChangeFlags { 1027 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001, 1028 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002, 1029 AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004, 1030 AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008, 1031 }; 1032 /** 1033 * @} 1034 */ 1035 1036 struct AVCodecInternal; 1037 1038 enum AVFieldOrder { 1039 AV_FIELD_UNKNOWN, 1040 AV_FIELD_PROGRESSIVE, 1041 AV_FIELD_TT, //< Top coded_first, top displayed first 1042 AV_FIELD_BB, //< Bottom coded first, bottom displayed first 1043 AV_FIELD_TB, //< Top coded first, bottom displayed first 1044 AV_FIELD_BT, //< Bottom coded first, top displayed first 1045 }; 1046 1047 /** 1048 * main external API structure. 1049 * New fields can be added to the end with minor version bumps. 1050 * Removal, reordering and changes to existing fields require a major 1051 * version bump. 1052 * sizeof(AVCodecContext) must not be used outside libav*. 1053 */ 1054 typedef struct AVCodecContext { 1055 /** 1056 * information on struct for av_log 1057 * - set by avcodec_alloc_context3 1058 */ 1059 const AVClass *av_class; 1060 int log_level_offset; 1061 1062 enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */ 1063 const struct AVCodec *codec; 1064 char codec_name[32]; 1065 enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */ 1066 1067 /** 1068 * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). 1069 * This is used to work around some encoder bugs. 1070 * A demuxer should set this to what is stored in the field used to identify the codec. 1071 * If there are multiple such fields in a container then the demuxer should choose the one 1072 * which maximizes the information about the used codec. 1073 * If the codec tag field in a container is larger than 32 bits then the demuxer should 1074 * remap the longer ID to 32 bits with a table or other structure. Alternatively a new 1075 * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated 1076 * first. 1077 * - encoding: Set by user, if not then the default based on codec_id will be used. 1078 * - decoding: Set by user, will be converted to uppercase by libavcodec during init. 1079 */ 1080 unsigned int codec_tag; 1081 1082 /** 1083 * fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). 1084 * This is used to work around some encoder bugs. 1085 * - encoding: unused 1086 * - decoding: Set by user, will be converted to uppercase by libavcodec during init. 1087 */ 1088 unsigned int stream_codec_tag; 1089 1090 void *priv_data; 1091 1092 /** 1093 * Private context used for internal data. 1094 * 1095 * Unlike priv_data, this is not codec-specific. It is used in general 1096 * libavcodec functions. 1097 */ 1098 struct AVCodecInternal *internal; 1099 1100 /** 1101 * Private data of the user, can be used to carry app specific stuff. 1102 * - encoding: Set by user. 1103 * - decoding: Set by user. 1104 */ 1105 void *opaque; 1106 1107 /** 1108 * the average bitrate 1109 * - encoding: Set by user; unused for constant quantizer encoding. 1110 * - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream. 1111 */ 1112 int bit_rate; 1113 1114 /** 1115 * number of bits the bitstream is allowed to diverge from the reference. 1116 * the reference can be CBR (for CBR pass1) or VBR (for pass2) 1117 * - encoding: Set by user; unused for constant quantizer encoding. 1118 * - decoding: unused 1119 */ 1120 int bit_rate_tolerance; 1121 1122 /** 1123 * Global quality for codecs which cannot change it per frame. 1124 * This should be proportional to MPEG-1/2/4 qscale. 1125 * - encoding: Set by user. 1126 * - decoding: unused 1127 */ 1128 int global_quality; 1129 1130 /** 1131 * - encoding: Set by user. 1132 * - decoding: unused 1133 */ 1134 int compression_level; 1135 #define FF_COMPRESSION_DEFAULT -1 1136 1137 /** 1138 * CODEC_FLAG_*. 1139 * - encoding: Set by user. 1140 * - decoding: Set by user. 1141 */ 1142 int flags; 1143 1144 /** 1145 * CODEC_FLAG2_* 1146 * - encoding: Set by user. 1147 * - decoding: Set by user. 1148 */ 1149 int flags2; 1150 1151 /** 1152 * some codecs need / can use extradata like Huffman tables. 1153 * mjpeg: Huffman tables 1154 * rv10: additional flags 1155 * mpeg4: global headers (they can be in the bitstream or here) 1156 * The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger 1157 * than extradata_size to avoid prolems if it is read with the bitstream reader. 1158 * The bytewise contents of extradata must not depend on the architecture or CPU endianness. 1159 * - encoding: Set/allocated/freed by libavcodec. 1160 * - decoding: Set/allocated/freed by user. 1161 */ 1162 uint8_t *extradata; 1163 int extradata_size; 1164 1165 /** 1166 * This is the fundamental unit of time (in seconds) in terms 1167 * of which frame timestamps are represented. For fixed-fps content, 1168 * timebase should be 1/framerate and timestamp increments should be 1169 * identically 1. 1170 * - encoding: MUST be set by user. 1171 * - decoding: Set by libavcodec. 1172 */ 1173 AVRational time_base; 1174 1175 /** 1176 * For some codecs, the time base is closer to the field rate than the frame rate. 1177 * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration 1178 * if no telecine is used ... 1179 * 1180 * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2. 1181 */ 1182 int ticks_per_frame; 1183 1184 /** 1185 * Codec delay. 1186 * 1187 * Video: 1188 * Number of frames the decoded output will be delayed relative to the 1189 * encoded input. 1190 * 1191 * Audio: 1192 * For encoding, this is the number of "priming" samples added to the 1193 * beginning of the stream. The decoded output will be delayed by this 1194 * many samples relative to the input to the encoder. Note that this 1195 * field is purely informational and does not directly affect the pts 1196 * output by the encoder, which should always be based on the actual 1197 * presentation time, including any delay. 1198 * For decoding, this is the number of samples the decoder needs to 1199 * output before the decoder's output is valid. When seeking, you should 1200 * start decoding this many samples prior to your desired seek point. 1201 * 1202 * - encoding: Set by libavcodec. 1203 * - decoding: Set by libavcodec. 1204 */ 1205 int delay; 1206 1207 1208 /* video only */ 1209 /** 1210 * picture width / height. 1211 * - encoding: MUST be set by user. 1212 * - decoding: May be set by the user before opening the decoder if known e.g. 1213 * from the container. Some decoders will require the dimensions 1214 * to be set by the caller. During decoding, the decoder may 1215 * overwrite those values as required. 1216 */ 1217 int width, height; 1218 1219 /** 1220 * Bitstream width / height, may be different from width/height e.g. when 1221 * the decoded frame is cropped before being output. 1222 * - encoding: unused 1223 * - decoding: May be set by the user before opening the decoder if known 1224 * e.g. from the container. During decoding, the decoder may 1225 * overwrite those values as required. 1226 */ 1227 int coded_width, coded_height; 1228 1229 #if FF_API_ASPECT_EXTENDED 1230 #define FF_ASPECT_EXTENDED 15 1231 #endif 1232 1233 /** 1234 * the number of pictures in a group of pictures, or 0 for intra_only 1235 * - encoding: Set by user. 1236 * - decoding: unused 1237 */ 1238 int gop_size; 1239 1240 /** 1241 * Pixel format, see AV_PIX_FMT_xxx. 1242 * May be set by the demuxer if known from headers. 1243 * May be overriden by the decoder if it knows better. 1244 * - encoding: Set by user. 1245 * - decoding: Set by user if known, overridden by libavcodec if known 1246 */ 1247 enum AVPixelFormat pix_fmt; 1248 1249 /** 1250 * Motion estimation algorithm used for video coding. 1251 * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex), 1252 * 8 (umh), 10 (tesa) [7, 8, 10 are x264 specific] 1253 * - encoding: MUST be set by user. 1254 * - decoding: unused 1255 */ 1256 int me_method; 1257 1258 /** 1259 * If non NULL, 'draw_horiz_band' is called by the libavcodec 1260 * decoder to draw a horizontal band. It improves cache usage. Not 1261 * all codecs can do that. You must check the codec capabilities 1262 * beforehand. 1263 * When multithreading is used, it may be called from multiple threads 1264 * at the same time; threads might draw different parts of the same AVFrame, 1265 * or multiple AVFrames, and there is no guarantee that slices will be drawn 1266 * in order. 1267 * The function is also used by hardware acceleration APIs. 1268 * It is called at least once during frame decoding to pass 1269 * the data needed for hardware render. 1270 * In that mode instead of pixel data, AVFrame points to 1271 * a structure specific to the acceleration API. The application 1272 * reads the structure and can change some fields to indicate progress 1273 * or mark state. 1274 * - encoding: unused 1275 * - decoding: Set by user. 1276 * @param height the height of the slice 1277 * @param y the y position of the slice 1278 * @param type 1->top field, 2->bottom field, 3->frame 1279 * @param offset offset into the AVFrame.data from which the slice should be read 1280 */ 1281 void (*draw_horiz_band)(struct AVCodecContext *s, 1282 const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], 1283 int y, int type, int height); 1284 1285 /** 1286 * callback to negotiate the pixelFormat 1287 * @param fmt is the list of formats which are supported by the codec, 1288 * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality. 1289 * The first is always the native one. 1290 * @return the chosen format 1291 * - encoding: unused 1292 * - decoding: Set by user, if not set the native format will be chosen. 1293 */ 1294 enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt); 1295 1296 /** 1297 * maximum number of B-frames between non-B-frames 1298 * Note: The output will be delayed by max_b_frames+1 relative to the input. 1299 * - encoding: Set by user. 1300 * - decoding: unused 1301 */ 1302 int max_b_frames; 1303 1304 /** 1305 * qscale factor between IP and B-frames 1306 * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset). 1307 * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). 1308 * - encoding: Set by user. 1309 * - decoding: unused 1310 */ 1311 float b_quant_factor; 1312 1313 /** obsolete FIXME remove */ 1314 int rc_strategy; 1315 #define FF_RC_STRATEGY_XVID 1 1316 1317 int b_frame_strategy; 1318 1319 /** 1320 * qscale offset between IP and B-frames 1321 * - encoding: Set by user. 1322 * - decoding: unused 1323 */ 1324 float b_quant_offset; 1325 1326 /** 1327 * Size of the frame reordering buffer in the decoder. 1328 * For MPEG-2 it is 1 IPB or 0 low delay IP. 1329 * - encoding: Set by libavcodec. 1330 * - decoding: Set by libavcodec. 1331 */ 1332 int has_b_frames; 1333 1334 /** 1335 * 0-> h263 quant 1-> mpeg quant 1336 * - encoding: Set by user. 1337 * - decoding: unused 1338 */ 1339 int mpeg_quant; 1340 1341 /** 1342 * qscale factor between P and I-frames 1343 * If > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset). 1344 * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). 1345 * - encoding: Set by user. 1346 * - decoding: unused 1347 */ 1348 float i_quant_factor; 1349 1350 /** 1351 * qscale offset between P and I-frames 1352 * - encoding: Set by user. 1353 * - decoding: unused 1354 */ 1355 float i_quant_offset; 1356 1357 /** 1358 * luminance masking (0-> disabled) 1359 * - encoding: Set by user. 1360 * - decoding: unused 1361 */ 1362 float lumi_masking; 1363 1364 /** 1365 * temporary complexity masking (0-> disabled) 1366 * - encoding: Set by user. 1367 * - decoding: unused 1368 */ 1369 float temporal_cplx_masking; 1370 1371 /** 1372 * spatial complexity masking (0-> disabled) 1373 * - encoding: Set by user. 1374 * - decoding: unused 1375 */ 1376 float spatial_cplx_masking; 1377 1378 /** 1379 * p block masking (0-> disabled) 1380 * - encoding: Set by user. 1381 * - decoding: unused 1382 */ 1383 float p_masking; 1384 1385 /** 1386 * darkness masking (0-> disabled) 1387 * - encoding: Set by user. 1388 * - decoding: unused 1389 */ 1390 float dark_masking; 1391 1392 /** 1393 * slice count 1394 * - encoding: Set by libavcodec. 1395 * - decoding: Set by user (or 0). 1396 */ 1397 int slice_count; 1398 /** 1399 * prediction method (needed for huffyuv) 1400 * - encoding: Set by user. 1401 * - decoding: unused 1402 */ 1403 int prediction_method; 1404 #define FF_PRED_LEFT 0 1405 #define FF_PRED_PLANE 1 1406 #define FF_PRED_MEDIAN 2 1407 1408 /** 1409 * slice offsets in the frame in bytes 1410 * - encoding: Set/allocated by libavcodec. 1411 * - decoding: Set/allocated by user (or NULL). 1412 */ 1413 int *slice_offset; 1414 1415 /** 1416 * sample aspect ratio (0 if unknown) 1417 * That is the width of a pixel divided by the height of the pixel. 1418 * Numerator and denominator must be relatively prime and smaller than 256 for some video standards. 1419 * - encoding: Set by user. 1420 * - decoding: Set by libavcodec. 1421 */ 1422 AVRational sample_aspect_ratio; 1423 1424 /** 1425 * motion estimation comparison function 1426 * - encoding: Set by user. 1427 * - decoding: unused 1428 */ 1429 int me_cmp; 1430 /** 1431 * subpixel motion estimation comparison function 1432 * - encoding: Set by user. 1433 * - decoding: unused 1434 */ 1435 int me_sub_cmp; 1436 /** 1437 * macroblock comparison function (not supported yet) 1438 * - encoding: Set by user. 1439 * - decoding: unused 1440 */ 1441 int mb_cmp; 1442 /** 1443 * interlaced DCT comparison function 1444 * - encoding: Set by user. 1445 * - decoding: unused 1446 */ 1447 int ildct_cmp; 1448 #define FF_CMP_SAD 0 1449 #define FF_CMP_SSE 1 1450 #define FF_CMP_SATD 2 1451 #define FF_CMP_DCT 3 1452 #define FF_CMP_PSNR 4 1453 #define FF_CMP_BIT 5 1454 #define FF_CMP_RD 6 1455 #define FF_CMP_ZERO 7 1456 #define FF_CMP_VSAD 8 1457 #define FF_CMP_VSSE 9 1458 #define FF_CMP_NSSE 10 1459 #define FF_CMP_DCTMAX 13 1460 #define FF_CMP_DCT264 14 1461 #define FF_CMP_CHROMA 256 1462 1463 /** 1464 * ME diamond size & shape 1465 * - encoding: Set by user. 1466 * - decoding: unused 1467 */ 1468 int dia_size; 1469 1470 /** 1471 * amount of previous MV predictors (2a+1 x 2a+1 square) 1472 * - encoding: Set by user. 1473 * - decoding: unused 1474 */ 1475 int last_predictor_count; 1476 1477 /** 1478 * prepass for motion estimation 1479 * - encoding: Set by user. 1480 * - decoding: unused 1481 */ 1482 int pre_me; 1483 1484 /** 1485 * motion estimation prepass comparison function 1486 * - encoding: Set by user. 1487 * - decoding: unused 1488 */ 1489 int me_pre_cmp; 1490 1491 /** 1492 * ME prepass diamond size & shape 1493 * - encoding: Set by user. 1494 * - decoding: unused 1495 */ 1496 int pre_dia_size; 1497 1498 /** 1499 * subpel ME quality 1500 * - encoding: Set by user. 1501 * - decoding: unused 1502 */ 1503 int me_subpel_quality; 1504 1505 /** 1506 * DTG active format information (additional aspect ratio 1507 * information only used in DVB MPEG-2 transport streams) 1508 * 0 if not set. 1509 * 1510 * - encoding: unused 1511 * - decoding: Set by decoder. 1512 */ 1513 int dtg_active_format; 1514 #define FF_DTG_AFD_SAME 8 1515 #define FF_DTG_AFD_4_3 9 1516 #define FF_DTG_AFD_16_9 10 1517 #define FF_DTG_AFD_14_9 11 1518 #define FF_DTG_AFD_4_3_SP_14_9 13 1519 #define FF_DTG_AFD_16_9_SP_14_9 14 1520 #define FF_DTG_AFD_SP_4_3 15 1521 1522 /** 1523 * maximum motion estimation search range in subpel units 1524 * If 0 then no limit. 1525 * 1526 * - encoding: Set by user. 1527 * - decoding: unused 1528 */ 1529 int me_range; 1530 1531 /** 1532 * intra quantizer bias 1533 * - encoding: Set by user. 1534 * - decoding: unused 1535 */ 1536 int intra_quant_bias; 1537 #define FF_DEFAULT_QUANT_BIAS 999999 1538 1539 /** 1540 * inter quantizer bias 1541 * - encoding: Set by user. 1542 * - decoding: unused 1543 */ 1544 int inter_quant_bias; 1545 1546 /** 1547 * slice flags 1548 * - encoding: unused 1549 * - decoding: Set by user. 1550 */ 1551 int slice_flags; 1552 #define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display 1553 #define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG2 field pics) 1554 #define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1) 1555 1556 #if FF_API_XVMC 1557 /** 1558 * XVideo Motion Acceleration 1559 * - encoding: forbidden 1560 * - decoding: set by decoder 1561 * @deprecated XvMC support is slated for removal. 1562 */ 1563 attribute_deprecated int xvmc_acceleration; 1564 #endif /* FF_API_XVMC */ 1565 1566 /** 1567 * macroblock decision mode 1568 * - encoding: Set by user. 1569 * - decoding: unused 1570 */ 1571 int mb_decision; 1572 #define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp 1573 #define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits 1574 #define FF_MB_DECISION_RD 2 ///< rate distortion 1575 1576 /** 1577 * custom intra quantization matrix 1578 * - encoding: Set by user, can be NULL. 1579 * - decoding: Set by libavcodec. 1580 */ 1581 uint16_t *intra_matrix; 1582 1583 /** 1584 * custom inter quantization matrix 1585 * - encoding: Set by user, can be NULL. 1586 * - decoding: Set by libavcodec. 1587 */ 1588 uint16_t *inter_matrix; 1589 1590 /** 1591 * scene change detection threshold 1592 * 0 is default, larger means fewer detected scene changes. 1593 * - encoding: Set by user. 1594 * - decoding: unused 1595 */ 1596 int scenechange_threshold; 1597 1598 /** 1599 * noise reduction strength 1600 * - encoding: Set by user. 1601 * - decoding: unused 1602 */ 1603 int noise_reduction; 1604 1605 /** 1606 * Motion estimation threshold below which no motion estimation is 1607 * performed, but instead the user specified motion vectors are used. 1608 * 1609 * - encoding: Set by user. 1610 * - decoding: unused 1611 */ 1612 int me_threshold; 1613 1614 /** 1615 * Macroblock threshold below which the user specified macroblock types will be used. 1616 * - encoding: Set by user. 1617 * - decoding: unused 1618 */ 1619 int mb_threshold; 1620 1621 /** 1622 * precision of the intra DC coefficient - 8 1623 * - encoding: Set by user. 1624 * - decoding: unused 1625 */ 1626 int intra_dc_precision; 1627 1628 /** 1629 * Number of macroblock rows at the top which are skipped. 1630 * - encoding: unused 1631 * - decoding: Set by user. 1632 */ 1633 int skip_top; 1634 1635 /** 1636 * Number of macroblock rows at the bottom which are skipped. 1637 * - encoding: unused 1638 * - decoding: Set by user. 1639 */ 1640 int skip_bottom; 1641 1642 /** 1643 * Border processing masking, raises the quantizer for mbs on the borders 1644 * of the picture. 1645 * - encoding: Set by user. 1646 * - decoding: unused 1647 */ 1648 float border_masking; 1649 1650 /** 1651 * minimum MB lagrange multipler 1652 * - encoding: Set by user. 1653 * - decoding: unused 1654 */ 1655 int mb_lmin; 1656 1657 /** 1658 * maximum MB lagrange multipler 1659 * - encoding: Set by user. 1660 * - decoding: unused 1661 */ 1662 int mb_lmax; 1663 1664 /** 1665 * 1666 * - encoding: Set by user. 1667 * - decoding: unused 1668 */ 1669 int me_penalty_compensation; 1670 1671 /** 1672 * 1673 * - encoding: Set by user. 1674 * - decoding: unused 1675 */ 1676 int bidir_refine; 1677 1678 /** 1679 * 1680 * - encoding: Set by user. 1681 * - decoding: unused 1682 */ 1683 int brd_scale; 1684 1685 /** 1686 * minimum GOP size 1687 * - encoding: Set by user. 1688 * - decoding: unused 1689 */ 1690 int keyint_min; 1691 1692 /** 1693 * number of reference frames 1694 * - encoding: Set by user. 1695 * - decoding: Set by lavc. 1696 */ 1697 int refs; 1698 1699 /** 1700 * chroma qp offset from luma 1701 * - encoding: Set by user. 1702 * - decoding: unused 1703 */ 1704 int chromaoffset; 1705 1706 /** 1707 * Multiplied by qscale for each frame and added to scene_change_score. 1708 * - encoding: Set by user. 1709 * - decoding: unused 1710 */ 1711 int scenechange_factor; 1712 1713 /** 1714 * 1715 * Note: Value depends upon the compare function used for fullpel ME. 1716 * - encoding: Set by user. 1717 * - decoding: unused 1718 */ 1719 int mv0_threshold; 1720 1721 /** 1722 * Adjust sensitivity of b_frame_strategy 1. 1723 * - encoding: Set by user. 1724 * - decoding: unused 1725 */ 1726 int b_sensitivity; 1727 1728 /** 1729 * Chromaticity coordinates of the source primaries. 1730 * - encoding: Set by user 1731 * - decoding: Set by libavcodec 1732 */ 1733 enum AVColorPrimaries color_primaries; 1734 1735 /** 1736 * Color Transfer Characteristic. 1737 * - encoding: Set by user 1738 * - decoding: Set by libavcodec 1739 */ 1740 enum AVColorTransferCharacteristic color_trc; 1741 1742 /** 1743 * YUV colorspace type. 1744 * - encoding: Set by user 1745 * - decoding: Set by libavcodec 1746 */ 1747 enum AVColorSpace colorspace; 1748 1749 /** 1750 * MPEG vs JPEG YUV range. 1751 * - encoding: Set by user 1752 * - decoding: Set by libavcodec 1753 */ 1754 enum AVColorRange color_range; 1755 1756 /** 1757 * This defines the location of chroma samples. 1758 * - encoding: Set by user 1759 * - decoding: Set by libavcodec 1760 */ 1761 enum AVChromaLocation chroma_sample_location; 1762 1763 /** 1764 * Number of slices. 1765 * Indicates number of picture subdivisions. Used for parallelized 1766 * decoding. 1767 * - encoding: Set by user 1768 * - decoding: unused 1769 */ 1770 int slices; 1771 1772 /** Field order 1773 * - encoding: set by libavcodec 1774 * - decoding: Set by libavcodec 1775 */ 1776 enum AVFieldOrder field_order; 1777 1778 /* audio only */ 1779 int sample_rate; ///< samples per second 1780 int channels; ///< number of audio channels 1781 1782 /** 1783 * audio sample format 1784 * - encoding: Set by user. 1785 * - decoding: Set by libavcodec. 1786 */ 1787 enum AVSampleFormat sample_fmt; ///< sample format 1788 1789 /* The following data should not be initialized. */ 1790 /** 1791 * Number of samples per channel in an audio frame. 1792 * 1793 * - encoding: set by libavcodec in avcodec_open2(). Each submitted frame 1794 * except the last must contain exactly frame_size samples per channel. 1795 * May be 0 when the codec has CODEC_CAP_VARIABLE_FRAME_SIZE set, then the 1796 * frame size is not restricted. 1797 * - decoding: may be set by some decoders to indicate constant frame size 1798 */ 1799 int frame_size; 1800 1801 /** 1802 * Frame counter, set by libavcodec. 1803 * 1804 * - decoding: total number of frames returned from the decoder so far. 1805 * - encoding: total number of frames passed to the encoder so far. 1806 * 1807 * @note the counter is not incremented if encoding/decoding resulted in 1808 * an error. 1809 */ 1810 int frame_number; 1811 1812 /** 1813 * number of bytes per packet if constant and known or 0 1814 * Used by some WAV based audio codecs. 1815 */ 1816 int block_align; 1817 1818 /** 1819 * Audio cutoff bandwidth (0 means "automatic") 1820 * - encoding: Set by user. 1821 * - decoding: unused 1822 */ 1823 int cutoff; 1824 1825 #if FF_API_REQUEST_CHANNELS 1826 /** 1827 * Decoder should decode to this many channels if it can (0 for default) 1828 * - encoding: unused 1829 * - decoding: Set by user. 1830 * @deprecated Deprecated in favor of request_channel_layout. 1831 */ 1832 attribute_deprecated int request_channels; 1833 #endif 1834 1835 /** 1836 * Audio channel layout. 1837 * - encoding: set by user. 1838 * - decoding: set by libavcodec. 1839 */ 1840 uint64_t channel_layout; 1841 1842 /** 1843 * Request decoder to use this channel layout if it can (0 for default) 1844 * - encoding: unused 1845 * - decoding: Set by user. 1846 */ 1847 uint64_t request_channel_layout; 1848 1849 /** 1850 * Type of service that the audio stream conveys. 1851 * - encoding: Set by user. 1852 * - decoding: Set by libavcodec. 1853 */ 1854 enum AVAudioServiceType audio_service_type; 1855 1856 /** 1857 * Used to request a sample format from the decoder. 1858 * - encoding: unused. 1859 * - decoding: Set by user. 1860 */ 1861 enum AVSampleFormat request_sample_fmt; 1862 1863 #if FF_API_GET_BUFFER 1864 /** 1865 * Called at the beginning of each frame to get a buffer for it. 1866 * 1867 * The function will set AVFrame.data[], AVFrame.linesize[]. 1868 * AVFrame.extended_data[] must also be set, but it should be the same as 1869 * AVFrame.data[] except for planar audio with more channels than can fit 1870 * in AVFrame.data[]. In that case, AVFrame.data[] shall still contain as 1871 * many data pointers as it can hold. 1872 * 1873 * if CODEC_CAP_DR1 is not set then get_buffer() must call 1874 * avcodec_default_get_buffer() instead of providing buffers allocated by 1875 * some other means. 1876 * 1877 * AVFrame.data[] should be 32- or 16-byte-aligned unless the CPU doesn't 1878 * need it. avcodec_default_get_buffer() aligns the output buffer properly, 1879 * but if get_buffer() is overridden then alignment considerations should 1880 * be taken into account. 1881 * 1882 * @see avcodec_default_get_buffer() 1883 * 1884 * Video: 1885 * 1886 * If pic.reference is set then the frame will be read later by libavcodec. 1887 * avcodec_align_dimensions2() should be used to find the required width and 1888 * height, as they normally need to be rounded up to the next multiple of 16. 1889 * 1890 * If frame multithreading is used and thread_safe_callbacks is set, 1891 * it may be called from a different thread, but not from more than one at 1892 * once. Does not need to be reentrant. 1893 * 1894 * @see release_buffer(), reget_buffer() 1895 * @see avcodec_align_dimensions2() 1896 * 1897 * Audio: 1898 * 1899 * Decoders request a buffer of a particular size by setting 1900 * AVFrame.nb_samples prior to calling get_buffer(). The decoder may, 1901 * however, utilize only part of the buffer by setting AVFrame.nb_samples 1902 * to a smaller value in the output frame. 1903 * 1904 * Decoders cannot use the buffer after returning from 1905 * avcodec_decode_audio4(), so they will not call release_buffer(), as it 1906 * is assumed to be released immediately upon return. In some rare cases, 1907 * a decoder may need to call get_buffer() more than once in a single 1908 * call to avcodec_decode_audio4(). In that case, when get_buffer() is 1909 * called again after it has already been called once, the previously 1910 * acquired buffer is assumed to be released at that time and may not be 1911 * reused by the decoder. 1912 * 1913 * As a convenience, av_samples_get_buffer_size() and 1914 * av_samples_fill_arrays() in libavutil may be used by custom get_buffer() 1915 * functions to find the required data size and to fill data pointers and 1916 * linesize. In AVFrame.linesize, only linesize[0] may be set for audio 1917 * since all planes must be the same size. 1918 * 1919 * @see av_samples_get_buffer_size(), av_samples_fill_arrays() 1920 * 1921 * - encoding: unused 1922 * - decoding: Set by libavcodec, user can override. 1923 * 1924 * @deprecated use get_buffer2() 1925 */ 1926 attribute_deprecated 1927 int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic); 1928 1929 /** 1930 * Called to release buffers which were allocated with get_buffer. 1931 * A released buffer can be reused in get_buffer(). 1932 * pic.data[*] must be set to NULL. 1933 * May be called from a different thread if frame multithreading is used, 1934 * but not by more than one thread at once, so does not need to be reentrant. 1935 * - encoding: unused 1936 * - decoding: Set by libavcodec, user can override. 1937 * 1938 * @deprecated custom freeing callbacks should be set from get_buffer2() 1939 */ 1940 attribute_deprecated 1941 void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic); 1942 1943 /** 1944 * Called at the beginning of a frame to get cr buffer for it. 1945 * Buffer type (size, hints) must be the same. libavcodec won't check it. 1946 * libavcodec will pass previous buffer in pic, function should return 1947 * same buffer or new buffer with old frame "painted" into it. 1948 * If pic.data[0] == NULL must behave like get_buffer(). 1949 * if CODEC_CAP_DR1 is not set then reget_buffer() must call 1950 * avcodec_default_reget_buffer() instead of providing buffers allocated by 1951 * some other means. 1952 * - encoding: unused 1953 * - decoding: Set by libavcodec, user can override. 1954 */ 1955 attribute_deprecated 1956 int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic); 1957 #endif 1958 1959 /** 1960 * This callback is called at the beginning of each frame to get data 1961 * buffer(s) for it. There may be one contiguous buffer for all the data or 1962 * there may be a buffer per each data plane or anything in between. What 1963 * this means is, you may set however many entries in buf[] you feel necessary. 1964 * Each buffer must be reference-counted using the AVBuffer API (see description 1965 * of buf[] below). 1966 * 1967 * The following fields will be set in the frame before this callback is 1968 * called: 1969 * - format 1970 * - width, height (video only) 1971 * - sample_rate, channel_layout, nb_samples (audio only) 1972 * Their values may differ from the corresponding values in 1973 * AVCodecContext. This callback must use the frame values, not the codec 1974 * context values, to calculate the required buffer size. 1975 * 1976 * This callback must fill the following fields in the frame: 1977 * - data[] 1978 * - linesize[] 1979 * - extended_data: 1980 * * if the data is planar audio with more than 8 channels, then this 1981 * callback must allocate and fill extended_data to contain all pointers 1982 * to all data planes. data[] must hold as many pointers as it can. 1983 * extended_data must be allocated with av_malloc() and will be freed in 1984 * av_frame_unref(). 1985 * * otherwise exended_data must point to data 1986 * - buf[] must contain one or more pointers to AVBufferRef structures. Each of 1987 * the frame's data and extended_data pointers must be contained in these. That 1988 * is, one AVBufferRef for each allocated chunk of memory, not necessarily one 1989 * AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(), 1990 * and av_buffer_ref(). 1991 * - extended_buf and nb_extended_buf must be allocated with av_malloc() by 1992 * this callback and filled with the extra buffers if there are more 1993 * buffers than buf[] can hold. extended_buf will be freed in 1994 * av_frame_unref(). 1995 * 1996 * If CODEC_CAP_DR1 is not set then get_buffer2() must call 1997 * avcodec_default_get_buffer2() instead of providing buffers allocated by 1998 * some other means. 1999 * 2000 * Each data plane must be aligned to the maximum required by the target 2001 * CPU. 2002 * 2003 * @see avcodec_default_get_buffer2() 2004 * 2005 * Video: 2006 * 2007 * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused 2008 * (read and/or written to if it is writable) later by libavcodec. 2009 * 2010 * avcodec_align_dimensions2() should be used to find the required width and 2011 * height, as they normally need to be rounded up to the next multiple of 16. 2012 * 2013 * If frame multithreading is used and thread_safe_callbacks is set, 2014 * this callback may be called from a different thread, but not from more 2015 * than one at once. Does not need to be reentrant. 2016 * 2017 * @see avcodec_align_dimensions2() 2018 * 2019 * Audio: 2020 * 2021 * Decoders request a buffer of a particular size by setting 2022 * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may, 2023 * however, utilize only part of the buffer by setting AVFrame.nb_samples 2024 * to a smaller value in the output frame. 2025 * 2026 * As a convenience, av_samples_get_buffer_size() and 2027 * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2() 2028 * functions to find the required data size and to fill data pointers and 2029 * linesize. In AVFrame.linesize, only linesize[0] may be set for audio 2030 * since all planes must be the same size. 2031 * 2032 * @see av_samples_get_buffer_size(), av_samples_fill_arrays() 2033 * 2034 * - encoding: unused 2035 * - decoding: Set by libavcodec, user can override. 2036 */ 2037 int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags); 2038 2039 /** 2040 * If non-zero, the decoded audio and video frames returned from 2041 * avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted 2042 * and are valid indefinitely. The caller must free them with 2043 * av_frame_unref() when they are not needed anymore. 2044 * Otherwise, the decoded frames must not be freed by the caller and are 2045 * only valid until the next decode call. 2046 * 2047 * - encoding: unused 2048 * - decoding: set by the caller before avcodec_open2(). 2049 */ 2050 int refcounted_frames; 2051 2052 /* - encoding parameters */ 2053 float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0) 2054 float qblur; ///< amount of qscale smoothing over time (0.0-1.0) 2055 2056 /** 2057 * minimum quantizer 2058 * - encoding: Set by user. 2059 * - decoding: unused 2060 */ 2061 int qmin; 2062 2063 /** 2064 * maximum quantizer 2065 * - encoding: Set by user. 2066 * - decoding: unused 2067 */ 2068 int qmax; 2069 2070 /** 2071 * maximum quantizer difference between frames 2072 * - encoding: Set by user. 2073 * - decoding: unused 2074 */ 2075 int max_qdiff; 2076 2077 /** 2078 * ratecontrol qmin qmax limiting method 2079 * 0-> clipping, 1-> use a nice continuous function to limit qscale wthin qmin/qmax. 2080 * - encoding: Set by user. 2081 * - decoding: unused 2082 */ 2083 float rc_qsquish; 2084 2085 float rc_qmod_amp; 2086 int rc_qmod_freq; 2087 2088 /** 2089 * decoder bitstream buffer size 2090 * - encoding: Set by user. 2091 * - decoding: unused 2092 */ 2093 int rc_buffer_size; 2094 2095 /** 2096 * ratecontrol override, see RcOverride 2097 * - encoding: Allocated/set/freed by user. 2098 * - decoding: unused 2099 */ 2100 int rc_override_count; 2101 RcOverride *rc_override; 2102 2103 /** 2104 * rate control equation 2105 * - encoding: Set by user 2106 * - decoding: unused 2107 */ 2108 const char *rc_eq; 2109 2110 /** 2111 * maximum bitrate 2112 * - encoding: Set by user. 2113 * - decoding: unused 2114 */ 2115 int rc_max_rate; 2116 2117 /** 2118 * minimum bitrate 2119 * - encoding: Set by user. 2120 * - decoding: unused 2121 */ 2122 int rc_min_rate; 2123 2124 float rc_buffer_aggressivity; 2125 2126 /** 2127 * initial complexity for pass1 ratecontrol 2128 * - encoding: Set by user. 2129 * - decoding: unused 2130 */ 2131 float rc_initial_cplx; 2132 2133 /** 2134 * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow. 2135 * - encoding: Set by user. 2136 * - decoding: unused. 2137 */ 2138 float rc_max_available_vbv_use; 2139 2140 /** 2141 * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow. 2142 * - encoding: Set by user. 2143 * - decoding: unused. 2144 */ 2145 float rc_min_vbv_overflow_use; 2146 2147 /** 2148 * Number of bits which should be loaded into the rc buffer before decoding starts. 2149 * - encoding: Set by user. 2150 * - decoding: unused 2151 */ 2152 int rc_initial_buffer_occupancy; 2153 2154 #define FF_CODER_TYPE_VLC 0 2155 #define FF_CODER_TYPE_AC 1 2156 #define FF_CODER_TYPE_RAW 2 2157 #define FF_CODER_TYPE_RLE 3 2158 #define FF_CODER_TYPE_DEFLATE 4 2159 /** 2160 * coder type 2161 * - encoding: Set by user. 2162 * - decoding: unused 2163 */ 2164 int coder_type; 2165 2166 /** 2167 * context model 2168 * - encoding: Set by user. 2169 * - decoding: unused 2170 */ 2171 int context_model; 2172 2173 /** 2174 * minimum Lagrange multipler 2175 * - encoding: Set by user. 2176 * - decoding: unused 2177 */ 2178 int lmin; 2179 2180 /** 2181 * maximum Lagrange multipler 2182 * - encoding: Set by user. 2183 * - decoding: unused 2184 */ 2185 int lmax; 2186 2187 /** 2188 * frame skip threshold 2189 * - encoding: Set by user. 2190 * - decoding: unused 2191 */ 2192 int frame_skip_threshold; 2193 2194 /** 2195 * frame skip factor 2196 * - encoding: Set by user. 2197 * - decoding: unused 2198 */ 2199 int frame_skip_factor; 2200 2201 /** 2202 * frame skip exponent 2203 * - encoding: Set by user. 2204 * - decoding: unused 2205 */ 2206 int frame_skip_exp; 2207 2208 /** 2209 * frame skip comparison function 2210 * - encoding: Set by user. 2211 * - decoding: unused 2212 */ 2213 int frame_skip_cmp; 2214 2215 /** 2216 * trellis RD quantization 2217 * - encoding: Set by user. 2218 * - decoding: unused 2219 */ 2220 int trellis; 2221 2222 /** 2223 * - encoding: Set by user. 2224 * - decoding: unused 2225 */ 2226 int min_prediction_order; 2227 2228 /** 2229 * - encoding: Set by user. 2230 * - decoding: unused 2231 */ 2232 int max_prediction_order; 2233 2234 /** 2235 * GOP timecode frame start number, in non drop frame format 2236 * - encoding: Set by user. 2237 * - decoding: unused 2238 */ 2239 int64_t timecode_frame_start; 2240 2241 /* The RTP callback: This function is called */ 2242 /* every time the encoder has a packet to send. */ 2243 /* It depends on the encoder if the data starts */ 2244 /* with a Start Code (it should). H.263 does. */ 2245 /* mb_nb contains the number of macroblocks */ 2246 /* encoded in the RTP payload. */ 2247 void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb); 2248 2249 int rtp_payload_size; /* The size of the RTP payload: the coder will */ 2250 /* do its best to deliver a chunk with size */ 2251 /* below rtp_payload_size, the chunk will start */ 2252 /* with a start code on some codecs like H.263. */ 2253 /* This doesn't take account of any particular */ 2254 /* headers inside the transmitted RTP payload. */ 2255 2256 /* statistics, used for 2-pass encoding */ 2257 int mv_bits; 2258 int header_bits; 2259 int i_tex_bits; 2260 int p_tex_bits; 2261 int i_count; 2262 int p_count; 2263 int skip_count; 2264 int misc_bits; 2265 2266 /** 2267 * number of bits used for the previously encoded frame 2268 * - encoding: Set by libavcodec. 2269 * - decoding: unused 2270 */ 2271 int frame_bits; 2272 2273 /** 2274 * pass1 encoding statistics output buffer 2275 * - encoding: Set by libavcodec. 2276 * - decoding: unused 2277 */ 2278 char *stats_out; 2279 2280 /** 2281 * pass2 encoding statistics input buffer 2282 * Concatenated stuff from stats_out of pass1 should be placed here. 2283 * - encoding: Allocated/set/freed by user. 2284 * - decoding: unused 2285 */ 2286 char *stats_in; 2287 2288 /** 2289 * Work around bugs in encoders which sometimes cannot be detected automatically. 2290 * - encoding: Set by user 2291 * - decoding: Set by user 2292 */ 2293 int workaround_bugs; 2294 #define FF_BUG_AUTODETECT 1 ///< autodetection 2295 #if FF_API_OLD_MSMPEG4 2296 #define FF_BUG_OLD_MSMPEG4 2 2297 #endif 2298 #define FF_BUG_XVID_ILACE 4 2299 #define FF_BUG_UMP4 8 2300 #define FF_BUG_NO_PADDING 16 2301 #define FF_BUG_AMV 32 2302 #if FF_API_AC_VLC 2303 #define FF_BUG_AC_VLC 0 ///< Will be removed, libavcodec can now handle these non-compliant files by default. 2304 #endif 2305 #define FF_BUG_QPEL_CHROMA 64 2306 #define FF_BUG_STD_QPEL 128 2307 #define FF_BUG_QPEL_CHROMA2 256 2308 #define FF_BUG_DIRECT_BLOCKSIZE 512 2309 #define FF_BUG_EDGE 1024 2310 #define FF_BUG_HPEL_CHROMA 2048 2311 #define FF_BUG_DC_CLIP 4096 2312 #define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders. 2313 #define FF_BUG_TRUNCATED 16384 2314 2315 /** 2316 * strictly follow the standard (MPEG4, ...). 2317 * - encoding: Set by user. 2318 * - decoding: Set by user. 2319 * Setting this to STRICT or higher means the encoder and decoder will 2320 * generally do stupid things, whereas setting it to unofficial or lower 2321 * will mean the encoder might produce output that is not supported by all 2322 * spec-compliant decoders. Decoders don't differentiate between normal, 2323 * unofficial and experimental (that is, they always try to decode things 2324 * when they can) unless they are explicitly asked to behave stupidly 2325 * (=strictly conform to the specs) 2326 */ 2327 int strict_std_compliance; 2328 #define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software. 2329 #define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences. 2330 #define FF_COMPLIANCE_NORMAL 0 2331 #define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions 2332 #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things. 2333 2334 /** 2335 * error concealment flags 2336 * - encoding: unused 2337 * - decoding: Set by user. 2338 */ 2339 int error_concealment; 2340 #define FF_EC_GUESS_MVS 1 2341 #define FF_EC_DEBLOCK 2 2342 2343 /** 2344 * debug 2345 * - encoding: Set by user. 2346 * - decoding: Set by user. 2347 */ 2348 int debug; 2349 #define FF_DEBUG_PICT_INFO 1 2350 #define FF_DEBUG_RC 2 2351 #define FF_DEBUG_BITSTREAM 4 2352 #define FF_DEBUG_MB_TYPE 8 2353 #define FF_DEBUG_QP 16 2354 #if FF_API_DEBUG_MV 2355 /** 2356 * @deprecated this option does nothing 2357 */ 2358 #define FF_DEBUG_MV 32 2359 #endif 2360 #define FF_DEBUG_DCT_COEFF 0x00000040 2361 #define FF_DEBUG_SKIP 0x00000080 2362 #define FF_DEBUG_STARTCODE 0x00000100 2363 #define FF_DEBUG_PTS 0x00000200 2364 #define FF_DEBUG_ER 0x00000400 2365 #define FF_DEBUG_MMCO 0x00000800 2366 #define FF_DEBUG_BUGS 0x00001000 2367 #if FF_API_DEBUG_MV 2368 #define FF_DEBUG_VIS_QP 0x00002000 2369 #define FF_DEBUG_VIS_MB_TYPE 0x00004000 2370 #endif 2371 #define FF_DEBUG_BUFFERS 0x00008000 2372 #define FF_DEBUG_THREADS 0x00010000 2373 2374 #if FF_API_DEBUG_MV 2375 /** 2376 * @deprecated this option does not have any effect 2377 */ 2378 attribute_deprecated 2379 int debug_mv; 2380 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames 2381 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames 2382 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames 2383 #endif 2384 2385 /** 2386 * Error recognition; may misdetect some more or less valid parts as errors. 2387 * - encoding: unused 2388 * - decoding: Set by user. 2389 */ 2390 int err_recognition; 2391 2392 /** 2393 * Verify checksums embedded in the bitstream (could be of either encoded or 2394 * decoded data, depending on the codec) and print an error message on mismatch. 2395 * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the 2396 * decoder returning an error. 2397 */ 2398 #define AV_EF_CRCCHECK (1<<0) 2399 #define AV_EF_BITSTREAM (1<<1) 2400 #define AV_EF_BUFFER (1<<2) 2401 #define AV_EF_EXPLODE (1<<3) 2402 2403 /** 2404 * opaque 64bit number (generally a PTS) that will be reordered and 2405 * output in AVFrame.reordered_opaque 2406 * @deprecated in favor of pkt_pts 2407 * - encoding: unused 2408 * - decoding: Set by user. 2409 */ 2410 int64_t reordered_opaque; 2411 2412 /** 2413 * Hardware accelerator in use 2414 * - encoding: unused. 2415 * - decoding: Set by libavcodec 2416 */ 2417 struct AVHWAccel *hwaccel; 2418 2419 /** 2420 * Hardware accelerator context. 2421 * For some hardware accelerators, a global context needs to be 2422 * provided by the user. In that case, this holds display-dependent 2423 * data Libav cannot instantiate itself. Please refer to the 2424 * Libav HW accelerator documentation to know how to fill this 2425 * is. e.g. for VA API, this is a struct vaapi_context. 2426 * - encoding: unused 2427 * - decoding: Set by user 2428 */ 2429 void *hwaccel_context; 2430 2431 /** 2432 * error 2433 * - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR. 2434 * - decoding: unused 2435 */ 2436 uint64_t error[AV_NUM_DATA_POINTERS]; 2437 2438 /** 2439 * DCT algorithm, see FF_DCT_* below 2440 * - encoding: Set by user. 2441 * - decoding: unused 2442 */ 2443 int dct_algo; 2444 #define FF_DCT_AUTO 0 2445 #define FF_DCT_FASTINT 1 2446 #define FF_DCT_INT 2 2447 #define FF_DCT_MMX 3 2448 #define FF_DCT_ALTIVEC 5 2449 #define FF_DCT_FAAN 6 2450 2451 /** 2452 * IDCT algorithm, see FF_IDCT_* below. 2453 * - encoding: Set by user. 2454 * - decoding: Set by user. 2455 */ 2456 int idct_algo; 2457 #define FF_IDCT_AUTO 0 2458 #define FF_IDCT_INT 1 2459 #define FF_IDCT_SIMPLE 2 2460 #define FF_IDCT_SIMPLEMMX 3 2461 #define FF_IDCT_ARM 7 2462 #define FF_IDCT_ALTIVEC 8 2463 #define FF_IDCT_SH4 9 2464 #define FF_IDCT_SIMPLEARM 10 2465 #define FF_IDCT_IPP 13 2466 #define FF_IDCT_XVIDMMX 14 2467 #define FF_IDCT_SIMPLEARMV5TE 16 2468 #define FF_IDCT_SIMPLEARMV6 17 2469 #define FF_IDCT_SIMPLEVIS 18 2470 #define FF_IDCT_FAAN 20 2471 #define FF_IDCT_SIMPLENEON 22 2472 #if FF_API_ARCH_ALPHA 2473 #define FF_IDCT_SIMPLEALPHA 23 2474 #endif 2475 2476 /** 2477 * bits per sample/pixel from the demuxer (needed for huffyuv). 2478 * - encoding: Set by libavcodec. 2479 * - decoding: Set by user. 2480 */ 2481 int bits_per_coded_sample; 2482 2483 /** 2484 * Bits per sample/pixel of internal libavcodec pixel/sample format. 2485 * - encoding: set by user. 2486 * - decoding: set by libavcodec. 2487 */ 2488 int bits_per_raw_sample; 2489 2490 #if FF_API_LOWRES 2491 /** 2492 * low resolution decoding, 1-> 1/2 size, 2->1/4 size 2493 * - encoding: unused 2494 * - decoding: Set by user. 2495 * 2496 * @deprecated use decoder private options instead 2497 */ 2498 attribute_deprecated int lowres; 2499 #endif 2500 2501 /** 2502 * the picture in the bitstream 2503 * - encoding: Set by libavcodec. 2504 * - decoding: unused 2505 */ 2506 AVFrame *coded_frame; 2507 2508 /** 2509 * thread count 2510 * is used to decide how many independent tasks should be passed to execute() 2511 * - encoding: Set by user. 2512 * - decoding: Set by user. 2513 */ 2514 int thread_count; 2515 2516 /** 2517 * Which multithreading methods to use. 2518 * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread, 2519 * so clients which cannot provide future frames should not use it. 2520 * 2521 * - encoding: Set by user, otherwise the default is used. 2522 * - decoding: Set by user, otherwise the default is used. 2523 */ 2524 int thread_type; 2525 #define FF_THREAD_FRAME 1 ///< Decode more than one frame at once 2526 #define FF_THREAD_SLICE 2 ///< Decode more than one part of a single frame at once 2527 2528 /** 2529 * Which multithreading methods are in use by the codec. 2530 * - encoding: Set by libavcodec. 2531 * - decoding: Set by libavcodec. 2532 */ 2533 int active_thread_type; 2534 2535 /** 2536 * Set by the client if its custom get_buffer() callback can be called 2537 * synchronously from another thread, which allows faster multithreaded decoding. 2538 * draw_horiz_band() will be called from other threads regardless of this setting. 2539 * Ignored if the default get_buffer() is used. 2540 * - encoding: Set by user. 2541 * - decoding: Set by user. 2542 */ 2543 int thread_safe_callbacks; 2544 2545 /** 2546 * The codec may call this to execute several independent things. 2547 * It will return only after finishing all tasks. 2548 * The user may replace this with some multithreaded implementation, 2549 * the default implementation will execute the parts serially. 2550 * @param count the number of things to execute 2551 * - encoding: Set by libavcodec, user can override. 2552 * - decoding: Set by libavcodec, user can override. 2553 */ 2554 int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size); 2555 2556 /** 2557 * The codec may call this to execute several independent things. 2558 * It will return only after finishing all tasks. 2559 * The user may replace this with some multithreaded implementation, 2560 * the default implementation will execute the parts serially. 2561 * Also see avcodec_thread_init and e.g. the --enable-pthread configure option. 2562 * @param c context passed also to func 2563 * @param count the number of things to execute 2564 * @param arg2 argument passed unchanged to func 2565 * @param ret return values of executed functions, must have space for "count" values. May be NULL. 2566 * @param func function that will be called count times, with jobnr from 0 to count-1. 2567 * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no 2568 * two instances of func executing at the same time will have the same threadnr. 2569 * @return always 0 currently, but code should handle a future improvement where when any call to func 2570 * returns < 0 no further calls to func may be done and < 0 is returned. 2571 * - encoding: Set by libavcodec, user can override. 2572 * - decoding: Set by libavcodec, user can override. 2573 */ 2574 int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count); 2575 2576 #if FF_API_THREAD_OPAQUE 2577 /** 2578 * @deprecated this field should not be used from outside of lavc 2579 */ 2580 attribute_deprecated 2581 void *thread_opaque; 2582 #endif 2583 2584 /** 2585 * noise vs. sse weight for the nsse comparsion function 2586 * - encoding: Set by user. 2587 * - decoding: unused 2588 */ 2589 int nsse_weight; 2590 2591 /** 2592 * profile 2593 * - encoding: Set by user. 2594 * - decoding: Set by libavcodec. 2595 */ 2596 int profile; 2597 #define FF_PROFILE_UNKNOWN -99 2598 #define FF_PROFILE_RESERVED -100 2599 2600 #define FF_PROFILE_AAC_MAIN 0 2601 #define FF_PROFILE_AAC_LOW 1 2602 #define FF_PROFILE_AAC_SSR 2 2603 #define FF_PROFILE_AAC_LTP 3 2604 #define FF_PROFILE_AAC_HE 4 2605 #define FF_PROFILE_AAC_HE_V2 28 2606 #define FF_PROFILE_AAC_LD 22 2607 #define FF_PROFILE_AAC_ELD 38 2608 #define FF_PROFILE_MPEG2_AAC_LOW 128 2609 #define FF_PROFILE_MPEG2_AAC_HE 131 2610 2611 #define FF_PROFILE_DTS 20 2612 #define FF_PROFILE_DTS_ES 30 2613 #define FF_PROFILE_DTS_96_24 40 2614 #define FF_PROFILE_DTS_HD_HRA 50 2615 #define FF_PROFILE_DTS_HD_MA 60 2616 2617 #define FF_PROFILE_MPEG2_422 0 2618 #define FF_PROFILE_MPEG2_HIGH 1 2619 #define FF_PROFILE_MPEG2_SS 2 2620 #define FF_PROFILE_MPEG2_SNR_SCALABLE 3 2621 #define FF_PROFILE_MPEG2_MAIN 4 2622 #define FF_PROFILE_MPEG2_SIMPLE 5 2623 2624 #define FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag 2625 #define FF_PROFILE_H264_INTRA (1<<11) // 8+3; constraint_set3_flag 2626 2627 #define FF_PROFILE_H264_BASELINE 66 2628 #define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED) 2629 #define FF_PROFILE_H264_MAIN 77 2630 #define FF_PROFILE_H264_EXTENDED 88 2631 #define FF_PROFILE_H264_HIGH 100 2632 #define FF_PROFILE_H264_HIGH_10 110 2633 #define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA) 2634 #define FF_PROFILE_H264_HIGH_422 122 2635 #define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA) 2636 #define FF_PROFILE_H264_HIGH_444 144 2637 #define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244 2638 #define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA) 2639 #define FF_PROFILE_H264_CAVLC_444 44 2640 2641 #define FF_PROFILE_VC1_SIMPLE 0 2642 #define FF_PROFILE_VC1_MAIN 1 2643 #define FF_PROFILE_VC1_COMPLEX 2 2644 #define FF_PROFILE_VC1_ADVANCED 3 2645 2646 #define FF_PROFILE_MPEG4_SIMPLE 0 2647 #define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1 2648 #define FF_PROFILE_MPEG4_CORE 2 2649 #define FF_PROFILE_MPEG4_MAIN 3 2650 #define FF_PROFILE_MPEG4_N_BIT 4 2651 #define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5 2652 #define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6 2653 #define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7 2654 #define FF_PROFILE_MPEG4_HYBRID 8 2655 #define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9 2656 #define FF_PROFILE_MPEG4_CORE_SCALABLE 10 2657 #define FF_PROFILE_MPEG4_ADVANCED_CODING 11 2658 #define FF_PROFILE_MPEG4_ADVANCED_CORE 12 2659 #define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13 2660 #define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14 2661 #define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15 2662 2663 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 0 2664 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 1 2665 #define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 2 2666 #define FF_PROFILE_JPEG2000_DCINEMA_2K 3 2667 #define FF_PROFILE_JPEG2000_DCINEMA_4K 4 2668 2669 2670 #define FF_PROFILE_HEVC_MAIN 1 2671 #define FF_PROFILE_HEVC_MAIN_10 2 2672 #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3 2673 2674 /** 2675 * level 2676 * - encoding: Set by user. 2677 * - decoding: Set by libavcodec. 2678 */ 2679 int level; 2680 #define FF_LEVEL_UNKNOWN -99 2681 2682 /** 2683 * 2684 * - encoding: unused 2685 * - decoding: Set by user. 2686 */ 2687 enum AVDiscard skip_loop_filter; 2688 2689 /** 2690 * 2691 * - encoding: unused 2692 * - decoding: Set by user. 2693 */ 2694 enum AVDiscard skip_idct; 2695 2696 /** 2697 * 2698 * - encoding: unused 2699 * - decoding: Set by user. 2700 */ 2701 enum AVDiscard skip_frame; 2702 2703 /** 2704 * Header containing style information for text subtitles. 2705 * For SUBTITLE_ASS subtitle type, it should contain the whole ASS 2706 * [Script Info] and [V4+ Styles] section, plus the [Events] line and 2707 * the Format line following. It shouldn't include any Dialogue line. 2708 * - encoding: Set/allocated/freed by user (before avcodec_open2()) 2709 * - decoding: Set/allocated/freed by libavcodec (by avcodec_open2()) 2710 */ 2711 uint8_t *subtitle_header; 2712 int subtitle_header_size; 2713 2714 #if FF_API_ERROR_RATE 2715 /** 2716 * @deprecated use the 'error_rate' private AVOption of the mpegvideo 2717 * encoders 2718 */ 2719 attribute_deprecated 2720 int error_rate; 2721 #endif 2722 2723 #if FF_API_CODEC_PKT 2724 /** 2725 * @deprecated this field is not supposed to be accessed from outside lavc 2726 */ 2727 attribute_deprecated 2728 AVPacket *pkt; 2729 #endif 2730 2731 /** 2732 * VBV delay coded in the last frame (in periods of a 27 MHz clock). 2733 * Used for compliant TS muxing. 2734 * - encoding: Set by libavcodec. 2735 * - decoding: unused. 2736 */ 2737 uint64_t vbv_delay; 2738 } AVCodecContext; 2739 2740 /** 2741 * AVProfile. 2742 */ 2743 typedef struct AVProfile { 2744 int profile; 2745 const char *name; ///< short name for the profile 2746 } AVProfile; 2747 2748 typedef struct AVCodecDefault AVCodecDefault; 2749 2750 struct AVSubtitle; 2751 2752 /** 2753 * AVCodec. 2754 */ 2755 typedef struct AVCodec { 2756 /** 2757 * Name of the codec implementation. 2758 * The name is globally unique among encoders and among decoders (but an 2759 * encoder and a decoder can share the same name). 2760 * This is the primary way to find a codec from the user perspective. 2761 */ 2762 const char *name; 2763 /** 2764 * Descriptive name for the codec, meant to be more human readable than name. 2765 * You should use the NULL_IF_CONFIG_SMALL() macro to define it. 2766 */ 2767 const char *long_name; 2768 enum AVMediaType type; 2769 enum AVCodecID id; 2770 /** 2771 * Codec capabilities. 2772 * see CODEC_CAP_* 2773 */ 2774 int capabilities; 2775 const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0} 2776 const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1 2777 const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0 2778 const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1 2779 const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0 2780 #if FF_API_LOWRES 2781 attribute_deprecated uint8_t max_lowres; ///< maximum value for lowres supported by the decoder 2782 #endif 2783 const AVClass *priv_class; ///< AVClass for the private context 2784 const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN} 2785 2786 /***************************************************************** 2787 * No fields below this line are part of the public API. They 2788 * may not be used outside of libavcodec and can be changed and 2789 * removed at will. 2790 * New public fields should be added right above. 2791 ***************************************************************** 2792 */ 2793 int priv_data_size; 2794 struct AVCodec *next; 2795 /** 2796 * @name Frame-level threading support functions 2797 * @{ 2798 */ 2799 /** 2800 * If defined, called on thread contexts when they are created. 2801 * If the codec allocates writable tables in init(), re-allocate them here. 2802 * priv_data will be set to a copy of the original. 2803 */ 2804 int (*init_thread_copy)(AVCodecContext *); 2805 /** 2806 * Copy necessary context variables from a previous thread context to the current one. 2807 * If not defined, the next thread will start automatically; otherwise, the codec 2808 * must call ff_thread_finish_setup(). 2809 * 2810 * dst and src will (rarely) point to the same context, in which case memcpy should be skipped. 2811 */ 2812 int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src); 2813 /** @} */ 2814 2815 /** 2816 * Private codec-specific defaults. 2817 */ 2818 const AVCodecDefault *defaults; 2819 2820 /** 2821 * Initialize codec static data, called from avcodec_register(). 2822 */ 2823 void (*init_static_data)(struct AVCodec *codec); 2824 2825 int (*init)(AVCodecContext *); 2826 int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size, 2827 const struct AVSubtitle *sub); 2828 /** 2829 * Encode data to an AVPacket. 2830 * 2831 * @param avctx codec context 2832 * @param avpkt output AVPacket (may contain a user-provided buffer) 2833 * @param[in] frame AVFrame containing the raw data to be encoded 2834 * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a 2835 * non-empty packet was returned in avpkt. 2836 * @return 0 on success, negative error code on failure 2837 */ 2838 int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, 2839 int *got_packet_ptr); 2840 int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt); 2841 int (*close)(AVCodecContext *); 2842 /** 2843 * Flush buffers. 2844 * Will be called when seeking 2845 */ 2846 void (*flush)(AVCodecContext *); 2847 } AVCodec; 2848 2849 /** 2850 * AVHWAccel. 2851 */ 2852 typedef struct AVHWAccel { 2853 /** 2854 * Name of the hardware accelerated codec. 2855 * The name is globally unique among encoders and among decoders (but an 2856 * encoder and a decoder can share the same name). 2857 */ 2858 const char *name; 2859 2860 /** 2861 * Type of codec implemented by the hardware accelerator. 2862 * 2863 * See AVMEDIA_TYPE_xxx 2864 */ 2865 enum AVMediaType type; 2866 2867 /** 2868 * Codec implemented by the hardware accelerator. 2869 * 2870 * See AV_CODEC_ID_xxx 2871 */ 2872 enum AVCodecID id; 2873 2874 /** 2875 * Supported pixel format. 2876 * 2877 * Only hardware accelerated formats are supported here. 2878 */ 2879 enum AVPixelFormat pix_fmt; 2880 2881 /** 2882 * Hardware accelerated codec capabilities. 2883 * see FF_HWACCEL_CODEC_CAP_* 2884 */ 2885 int capabilities; 2886 2887 struct AVHWAccel *next; 2888 2889 /** 2890 * Called at the beginning of each frame or field picture. 2891 * 2892 * Meaningful frame information (codec specific) is guaranteed to 2893 * be parsed at this point. This function is mandatory. 2894 * 2895 * Note that buf can be NULL along with buf_size set to 0. 2896 * Otherwise, this means the whole frame is available at this point. 2897 * 2898 * @param avctx the codec context 2899 * @param buf the frame data buffer base 2900 * @param buf_size the size of the frame in bytes 2901 * @return zero if successful, a negative value otherwise 2902 */ 2903 int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); 2904 2905 /** 2906 * Callback for each slice. 2907 * 2908 * Meaningful slice information (codec specific) is guaranteed to 2909 * be parsed at this point. This function is mandatory. 2910 * 2911 * @param avctx the codec context 2912 * @param buf the slice data buffer base 2913 * @param buf_size the size of the slice in bytes 2914 * @return zero if successful, a negative value otherwise 2915 */ 2916 int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); 2917 2918 /** 2919 * Called at the end of each frame or field picture. 2920 * 2921 * The whole picture is parsed at this point and can now be sent 2922 * to the hardware accelerator. This function is mandatory. 2923 * 2924 * @param avctx the codec context 2925 * @return zero if successful, a negative value otherwise 2926 */ 2927 int (*end_frame)(AVCodecContext *avctx); 2928 2929 /** 2930 * Size of HW accelerator private data. 2931 * 2932 * Private data is allocated with av_mallocz() before 2933 * AVCodecContext.get_buffer() and deallocated after 2934 * AVCodecContext.release_buffer(). 2935 */ 2936 int priv_data_size; 2937 } AVHWAccel; 2938 2939 /** 2940 * @defgroup lavc_picture AVPicture 2941 * 2942 * Functions for working with AVPicture 2943 * @{ 2944 */ 2945 2946 /** 2947 * four components are given, that's all. 2948 * the last component is alpha 2949 */ 2950 typedef struct AVPicture { 2951 uint8_t *data[AV_NUM_DATA_POINTERS]; 2952 int linesize[AV_NUM_DATA_POINTERS]; ///< number of bytes per line 2953 } AVPicture; 2954 2955 /** 2956 * @} 2957 */ 2958 2959 #define AVPALETTE_SIZE 1024 2960 #define AVPALETTE_COUNT 256 2961 2962 enum AVSubtitleType { 2963 SUBTITLE_NONE, 2964 2965 SUBTITLE_BITMAP, ///< A bitmap, pict will be set 2966 2967 /** 2968 * Plain text, the text field must be set by the decoder and is 2969 * authoritative. ass and pict fields may contain approximations. 2970 */ 2971 SUBTITLE_TEXT, 2972 2973 /** 2974 * Formatted text, the ass field must be set by the decoder and is 2975 * authoritative. pict and text fields may contain approximations. 2976 */ 2977 SUBTITLE_ASS, 2978 }; 2979 2980 #define AV_SUBTITLE_FLAG_FORCED 0x00000001 2981 2982 typedef struct AVSubtitleRect { 2983 int x; ///< top left corner of pict, undefined when pict is not set 2984 int y; ///< top left corner of pict, undefined when pict is not set 2985 int w; ///< width of pict, undefined when pict is not set 2986 int h; ///< height of pict, undefined when pict is not set 2987 int nb_colors; ///< number of colors in pict, undefined when pict is not set 2988 2989 /** 2990 * data+linesize for the bitmap of this subtitle. 2991 * can be set for text/ass as well once they where rendered 2992 */ 2993 AVPicture pict; 2994 enum AVSubtitleType type; 2995 2996 char *text; ///< 0 terminated plain UTF-8 text 2997 2998 /** 2999 * 0 terminated ASS/SSA compatible event line. 3000 * The pressentation of this is unaffected by the other values in this 3001 * struct. 3002 */ 3003 char *ass; 3004 int flags; 3005 } AVSubtitleRect; 3006 3007 typedef struct AVSubtitle { 3008 uint16_t format; /* 0 = graphics */ 3009 uint32_t start_display_time; /* relative to packet pts, in ms */ 3010 uint32_t end_display_time; /* relative to packet pts, in ms */ 3011 unsigned num_rects; 3012 AVSubtitleRect **rects; 3013 int64_t pts; ///< Same as packet pts, in AV_TIME_BASE 3014 } AVSubtitle; 3015 3016 /** 3017 * If c is NULL, returns the first registered codec, 3018 * if c is non-NULL, returns the next registered codec after c, 3019 * or NULL if c is the last one. 3020 */ 3021 AVCodec *av_codec_next(const AVCodec *c); 3022 3023 /** 3024 * Return the LIBAVCODEC_VERSION_INT constant. 3025 */ 3026 unsigned avcodec_version(void); 3027 3028 /** 3029 * Return the libavcodec build-time configuration. 3030 */ 3031 const char *avcodec_configuration(void); 3032 3033 /** 3034 * Return the libavcodec license. 3035 */ 3036 const char *avcodec_license(void); 3037 3038 /** 3039 * Register the codec codec and initialize libavcodec. 3040 * 3041 * @warning either this function or avcodec_register_all() must be called 3042 * before any other libavcodec functions. 3043 * 3044 * @see avcodec_register_all() 3045 */ 3046 void avcodec_register(AVCodec *codec); 3047 3048 /** 3049 * Register all the codecs, parsers and bitstream filters which were enabled at 3050 * configuration time. If you do not call this function you can select exactly 3051 * which formats you want to support, by using the individual registration 3052 * functions. 3053 * 3054 * @see avcodec_register 3055 * @see av_register_codec_parser 3056 * @see av_register_bitstream_filter 3057 */ 3058 void avcodec_register_all(void); 3059 3060 /** 3061 * Allocate an AVCodecContext and set its fields to default values. The 3062 * resulting struct can be deallocated by calling avcodec_close() on it followed 3063 * by av_free(). 3064 * 3065 * @param codec if non-NULL, allocate private data and initialize defaults 3066 * for the given codec. It is illegal to then call avcodec_open2() 3067 * with a different codec. 3068 * If NULL, then the codec-specific defaults won't be initialized, 3069 * which may result in suboptimal default settings (this is 3070 * important mainly for encoders, e.g. libx264). 3071 * 3072 * @return An AVCodecContext filled with default values or NULL on failure. 3073 * @see avcodec_get_context_defaults 3074 */ 3075 AVCodecContext *avcodec_alloc_context3(const AVCodec *codec); 3076 3077 /** 3078 * Set the fields of the given AVCodecContext to default values corresponding 3079 * to the given codec (defaults may be codec-dependent). 3080 * 3081 * Do not call this function if a non-NULL codec has been passed 3082 * to avcodec_alloc_context3() that allocated this AVCodecContext. 3083 * If codec is non-NULL, it is illegal to call avcodec_open2() with a 3084 * different codec on this AVCodecContext. 3085 */ 3086 int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec); 3087 3088 /** 3089 * Get the AVClass for AVCodecContext. It can be used in combination with 3090 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 3091 * 3092 * @see av_opt_find(). 3093 */ 3094 const AVClass *avcodec_get_class(void); 3095 3096 /** 3097 * Copy the settings of the source AVCodecContext into the destination 3098 * AVCodecContext. The resulting destination codec context will be 3099 * unopened, i.e. you are required to call avcodec_open2() before you 3100 * can use this AVCodecContext to decode/encode video/audio data. 3101 * 3102 * @param dest target codec context, should be initialized with 3103 * avcodec_alloc_context3(), but otherwise uninitialized 3104 * @param src source codec context 3105 * @return AVERROR() on error (e.g. memory allocation error), 0 on success 3106 */ 3107 int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src); 3108 3109 #if FF_API_AVFRAME_LAVC 3110 /** 3111 * @deprecated use av_frame_alloc() 3112 */ 3113 attribute_deprecated 3114 AVFrame *avcodec_alloc_frame(void); 3115 3116 /** 3117 * Set the fields of the given AVFrame to default values. 3118 * 3119 * @param frame The AVFrame of which the fields should be set to default values. 3120 * 3121 * @deprecated use av_frame_unref() 3122 */ 3123 attribute_deprecated 3124 void avcodec_get_frame_defaults(AVFrame *frame); 3125 3126 /** 3127 * Free the frame and any dynamically allocated objects in it, 3128 * e.g. extended_data. 3129 * 3130 * @param frame frame to be freed. The pointer will be set to NULL. 3131 * 3132 * @warning this function does NOT free the data buffers themselves 3133 * (it does not know how, since they might have been allocated with 3134 * a custom get_buffer()). 3135 * 3136 * @deprecated use av_frame_free() 3137 */ 3138 attribute_deprecated 3139 void avcodec_free_frame(AVFrame **frame); 3140 #endif 3141 3142 /** 3143 * Initialize the AVCodecContext to use the given AVCodec. Prior to using this 3144 * function the context has to be allocated with avcodec_alloc_context3(). 3145 * 3146 * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(), 3147 * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for 3148 * retrieving a codec. 3149 * 3150 * @warning This function is not thread safe! 3151 * 3152 * @code 3153 * avcodec_register_all(); 3154 * av_dict_set(&opts, "b", "2.5M", 0); 3155 * codec = avcodec_find_decoder(AV_CODEC_ID_H264); 3156 * if (!codec) 3157 * exit(1); 3158 * 3159 * context = avcodec_alloc_context3(codec); 3160 * 3161 * if (avcodec_open2(context, codec, opts) < 0) 3162 * exit(1); 3163 * @endcode 3164 * 3165 * @param avctx The context to initialize. 3166 * @param codec The codec to open this context for. If a non-NULL codec has been 3167 * previously passed to avcodec_alloc_context3() or 3168 * avcodec_get_context_defaults3() for this context, then this 3169 * parameter MUST be either NULL or equal to the previously passed 3170 * codec. 3171 * @param options A dictionary filled with AVCodecContext and codec-private options. 3172 * On return this object will be filled with options that were not found. 3173 * 3174 * @return zero on success, a negative value on error 3175 * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(), 3176 * av_dict_set(), av_opt_find(). 3177 */ 3178 int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options); 3179 3180 /** 3181 * Close a given AVCodecContext and free all the data associated with it 3182 * (but not the AVCodecContext itself). 3183 * 3184 * Calling this function on an AVCodecContext that hasn't been opened will free 3185 * the codec-specific data allocated in avcodec_alloc_context3() / 3186 * avcodec_get_context_defaults3() with a non-NULL codec. Subsequent calls will 3187 * do nothing. 3188 */ 3189 int avcodec_close(AVCodecContext *avctx); 3190 3191 /** 3192 * Free all allocated data in the given subtitle struct. 3193 * 3194 * @param sub AVSubtitle to free. 3195 */ 3196 void avsubtitle_free(AVSubtitle *sub); 3197 3198 /** 3199 * @} 3200 */ 3201 3202 /** 3203 * @addtogroup lavc_packet 3204 * @{ 3205 */ 3206 3207 #if FF_API_DESTRUCT_PACKET 3208 /** 3209 * Default packet destructor. 3210 * @deprecated use the AVBuffer API instead 3211 */ 3212 attribute_deprecated 3213 void av_destruct_packet(AVPacket *pkt); 3214 #endif 3215 3216 /** 3217 * Initialize optional fields of a packet with default values. 3218 * 3219 * Note, this does not touch the data and size members, which have to be 3220 * initialized separately. 3221 * 3222 * @param pkt packet 3223 */ 3224 void av_init_packet(AVPacket *pkt); 3225 3226 /** 3227 * Allocate the payload of a packet and initialize its fields with 3228 * default values. 3229 * 3230 * @param pkt packet 3231 * @param size wanted payload size 3232 * @return 0 if OK, AVERROR_xxx otherwise 3233 */ 3234 int av_new_packet(AVPacket *pkt, int size); 3235 3236 /** 3237 * Reduce packet size, correctly zeroing padding 3238 * 3239 * @param pkt packet 3240 * @param size new size 3241 */ 3242 void av_shrink_packet(AVPacket *pkt, int size); 3243 3244 /** 3245 * Increase packet size, correctly zeroing padding 3246 * 3247 * @param pkt packet 3248 * @param grow_by number of bytes by which to increase the size of the packet 3249 */ 3250 int av_grow_packet(AVPacket *pkt, int grow_by); 3251 3252 /** 3253 * Initialize a reference-counted packet from av_malloc()ed data. 3254 * 3255 * @param pkt packet to be initialized. This function will set the data, size, 3256 * buf and destruct fields, all others are left untouched. 3257 * @param data Data allocated by av_malloc() to be used as packet data. If this 3258 * function returns successfully, the data is owned by the underlying AVBuffer. 3259 * The caller may not access the data through other means. 3260 * @param size size of data in bytes, without the padding. I.e. the full buffer 3261 * size is assumed to be size + FF_INPUT_BUFFER_PADDING_SIZE. 3262 * 3263 * @return 0 on success, a negative AVERROR on error 3264 */ 3265 int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size); 3266 3267 /** 3268 * @warning This is a hack - the packet memory allocation stuff is broken. The 3269 * packet is allocated if it was not really allocated. 3270 */ 3271 int av_dup_packet(AVPacket *pkt); 3272 3273 /** 3274 * Free a packet. 3275 * 3276 * @param pkt packet to free 3277 */ 3278 void av_free_packet(AVPacket *pkt); 3279 3280 /** 3281 * Allocate new information of a packet. 3282 * 3283 * @param pkt packet 3284 * @param type side information type 3285 * @param size side information size 3286 * @return pointer to fresh allocated data or NULL otherwise 3287 */ 3288 uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 3289 int size); 3290 3291 /** 3292 * Shrink the already allocated side data buffer 3293 * 3294 * @param pkt packet 3295 * @param type side information type 3296 * @param size new side information size 3297 * @return 0 on success, < 0 on failure 3298 */ 3299 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 3300 int size); 3301 3302 /** 3303 * Get side information from packet. 3304 * 3305 * @param pkt packet 3306 * @param type desired side information type 3307 * @param size pointer for side information size to store (optional) 3308 * @return pointer to data if present or NULL otherwise 3309 */ 3310 uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 3311 int *size); 3312 3313 /** 3314 * Convenience function to free all the side data stored. 3315 * All the other fields stay untouched. 3316 * 3317 * @param pkt packet 3318 */ 3319 void av_packet_free_side_data(AVPacket *pkt); 3320 3321 /** 3322 * Setup a new reference to the data described by a given packet 3323 * 3324 * If src is reference-counted, setup dst as a new reference to the 3325 * buffer in src. Otherwise allocate a new buffer in dst and copy the 3326 * data from src into it. 3327 * 3328 * All the other fields are copied from src. 3329 * 3330 * @see av_packet_unref 3331 * 3332 * @param dst Destination packet 3333 * @param src Source packet 3334 * 3335 * @return 0 on success, a negative AVERROR on error. 3336 */ 3337 int av_packet_ref(AVPacket *dst, AVPacket *src); 3338 3339 /** 3340 * Wipe the packet. 3341 * 3342 * Unreference the buffer referenced by the packet and reset the 3343 * remaining packet fields to their default values. 3344 * 3345 * @param pkt The packet to be unreferenced. 3346 */ 3347 void av_packet_unref(AVPacket *pkt); 3348 3349 /** 3350 * Move every field in src to dst and reset src. 3351 * 3352 * @see av_packet_unref 3353 * 3354 * @param src Source packet, will be reset 3355 * @param dst Destination packet 3356 */ 3357 void av_packet_move_ref(AVPacket *dst, AVPacket *src); 3358 3359 /** 3360 * Copy only "properties" fields from src to dst. 3361 * 3362 * Properties for the purpose of this function are all the fields 3363 * beside those related to the packet data (buf, data, size) 3364 * 3365 * @param dst Destination packet 3366 * @param src Source packet 3367 * 3368 * @return 0 on success AVERROR on failure. 3369 * 3370 */ 3371 int av_packet_copy_props(AVPacket *dst, const AVPacket *src); 3372 3373 /** 3374 * @} 3375 */ 3376 3377 /** 3378 * @addtogroup lavc_decoding 3379 * @{ 3380 */ 3381 3382 /** 3383 * Find a registered decoder with a matching codec ID. 3384 * 3385 * @param id AVCodecID of the requested decoder 3386 * @return A decoder if one was found, NULL otherwise. 3387 */ 3388 AVCodec *avcodec_find_decoder(enum AVCodecID id); 3389 3390 /** 3391 * Find a registered decoder with the specified name. 3392 * 3393 * @param name name of the requested decoder 3394 * @return A decoder if one was found, NULL otherwise. 3395 */ 3396 AVCodec *avcodec_find_decoder_by_name(const char *name); 3397 3398 #if FF_API_GET_BUFFER 3399 attribute_deprecated int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic); 3400 attribute_deprecated void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic); 3401 attribute_deprecated int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic); 3402 #endif 3403 3404 /** 3405 * The default callback for AVCodecContext.get_buffer2(). It is made public so 3406 * it can be called by custom get_buffer2() implementations for decoders without 3407 * CODEC_CAP_DR1 set. 3408 */ 3409 int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags); 3410 3411 #if FF_API_EMU_EDGE 3412 /** 3413 * Return the amount of padding in pixels which the get_buffer callback must 3414 * provide around the edge of the image for codecs which do not have the 3415 * CODEC_FLAG_EMU_EDGE flag. 3416 * 3417 * @return Required padding in pixels. 3418 * 3419 * @deprecated CODEC_FLAG_EMU_EDGE is deprecated, so this function is no longer 3420 * needed 3421 */ 3422 attribute_deprecated 3423 unsigned avcodec_get_edge_width(void); 3424 #endif 3425 3426 /** 3427 * Modify width and height values so that they will result in a memory 3428 * buffer that is acceptable for the codec if you do not use any horizontal 3429 * padding. 3430 * 3431 * May only be used if a codec with CODEC_CAP_DR1 has been opened. 3432 */ 3433 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height); 3434 3435 /** 3436 * Modify width and height values so that they will result in a memory 3437 * buffer that is acceptable for the codec if you also ensure that all 3438 * line sizes are a multiple of the respective linesize_align[i]. 3439 * 3440 * May only be used if a codec with CODEC_CAP_DR1 has been opened. 3441 */ 3442 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, 3443 int linesize_align[AV_NUM_DATA_POINTERS]); 3444 3445 /** 3446 * Decode the audio frame of size avpkt->size from avpkt->data into frame. 3447 * 3448 * Some decoders may support multiple frames in a single AVPacket. Such 3449 * decoders would then just decode the first frame and the return value would be 3450 * less than the packet size. In this case, avcodec_decode_audio4 has to be 3451 * called again with an AVPacket containing the remaining data in order to 3452 * decode the second frame, etc... Even if no frames are returned, the packet 3453 * needs to be fed to the decoder with remaining data until it is completely 3454 * consumed or an error occurs. 3455 * 3456 * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input 3457 * and output. This means that for some packets they will not immediately 3458 * produce decoded output and need to be flushed at the end of decoding to get 3459 * all the decoded data. Flushing is done by calling this function with packets 3460 * with avpkt->data set to NULL and avpkt->size set to 0 until it stops 3461 * returning samples. It is safe to flush even those decoders that are not 3462 * marked with CODEC_CAP_DELAY, then no samples will be returned. 3463 * 3464 * @warning The input buffer, avpkt->data must be FF_INPUT_BUFFER_PADDING_SIZE 3465 * larger than the actual read bytes because some optimized bitstream 3466 * readers read 32 or 64 bits at once and could read over the end. 3467 * 3468 * @param avctx the codec context 3469 * @param[out] frame The AVFrame in which to store decoded audio samples. 3470 * The decoder will allocate a buffer for the decoded frame by 3471 * calling the AVCodecContext.get_buffer2() callback. 3472 * When AVCodecContext.refcounted_frames is set to 1, the frame is 3473 * reference counted and the returned reference belongs to the 3474 * caller. The caller must release the frame using av_frame_unref() 3475 * when the frame is no longer needed. The caller may safely write 3476 * to the frame if av_frame_is_writable() returns 1. 3477 * When AVCodecContext.refcounted_frames is set to 0, the returned 3478 * reference belongs to the decoder and is valid only until the 3479 * next call to this function or until closing or flushing the 3480 * decoder. The caller may not write to it. 3481 * @param[out] got_frame_ptr Zero if no frame could be decoded, otherwise it is 3482 * non-zero. Note that this field being set to zero 3483 * does not mean that an error has occurred. For 3484 * decoders with CODEC_CAP_DELAY set, no given decode 3485 * call is guaranteed to produce a frame. 3486 * @param[in] avpkt The input AVPacket containing the input buffer. 3487 * At least avpkt->data and avpkt->size should be set. Some 3488 * decoders might also require additional fields to be set. 3489 * @return A negative error code is returned if an error occurred during 3490 * decoding, otherwise the number of bytes consumed from the input 3491 * AVPacket is returned. 3492 */ 3493 int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, 3494 int *got_frame_ptr, AVPacket *avpkt); 3495 3496 /** 3497 * Decode the video frame of size avpkt->size from avpkt->data into picture. 3498 * Some decoders may support multiple frames in a single AVPacket, such 3499 * decoders would then just decode the first frame. 3500 * 3501 * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than 3502 * the actual read bytes because some optimized bitstream readers read 32 or 64 3503 * bits at once and could read over the end. 3504 * 3505 * @warning The end of the input buffer buf should be set to 0 to ensure that 3506 * no overreading happens for damaged MPEG streams. 3507 * 3508 * @note Codecs which have the CODEC_CAP_DELAY capability set have a delay 3509 * between input and output, these need to be fed with avpkt->data=NULL, 3510 * avpkt->size=0 at the end to return the remaining frames. 3511 * 3512 * @param avctx the codec context 3513 * @param[out] picture The AVFrame in which the decoded video frame will be stored. 3514 * Use av_frame_alloc() to get an AVFrame. The codec will 3515 * allocate memory for the actual bitmap by calling the 3516 * AVCodecContext.get_buffer2() callback. 3517 * When AVCodecContext.refcounted_frames is set to 1, the frame is 3518 * reference counted and the returned reference belongs to the 3519 * caller. The caller must release the frame using av_frame_unref() 3520 * when the frame is no longer needed. The caller may safely write 3521 * to the frame if av_frame_is_writable() returns 1. 3522 * When AVCodecContext.refcounted_frames is set to 0, the returned 3523 * reference belongs to the decoder and is valid only until the 3524 * next call to this function or until closing or flushing the 3525 * decoder. The caller may not write to it. 3526 * 3527 * @param[in] avpkt The input AVpacket containing the input buffer. 3528 * You can create such packet with av_init_packet() and by then setting 3529 * data and size, some decoders might in addition need other fields like 3530 * flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least 3531 * fields possible. 3532 * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero. 3533 * @return On error a negative value is returned, otherwise the number of bytes 3534 * used or zero if no frame could be decompressed. 3535 */ 3536 int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, 3537 int *got_picture_ptr, 3538 AVPacket *avpkt); 3539 3540 /** 3541 * Decode a subtitle message. 3542 * Return a negative value on error, otherwise return the number of bytes used. 3543 * If no subtitle could be decompressed, got_sub_ptr is zero. 3544 * Otherwise, the subtitle is stored in *sub. 3545 * Note that CODEC_CAP_DR1 is not available for subtitle codecs. This is for 3546 * simplicity, because the performance difference is expect to be negligible 3547 * and reusing a get_buffer written for video codecs would probably perform badly 3548 * due to a potentially very different allocation pattern. 3549 * 3550 * @param avctx the codec context 3551 * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored, must be 3552 freed with avsubtitle_free if *got_sub_ptr is set. 3553 * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero. 3554 * @param[in] avpkt The input AVPacket containing the input buffer. 3555 */ 3556 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, 3557 int *got_sub_ptr, 3558 AVPacket *avpkt); 3559 3560 /** 3561 * @defgroup lavc_parsing Frame parsing 3562 * @{ 3563 */ 3564 3565 enum AVPictureStructure { 3566 AV_PICTURE_STRUCTURE_UNKNOWN, //< unknown 3567 AV_PICTURE_STRUCTURE_TOP_FIELD, //< coded as top field 3568 AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field 3569 AV_PICTURE_STRUCTURE_FRAME, //< coded as frame 3570 }; 3571 3572 typedef struct AVCodecParserContext { 3573 void *priv_data; 3574 struct AVCodecParser *parser; 3575 int64_t frame_offset; /* offset of the current frame */ 3576 int64_t cur_offset; /* current offset 3577 (incremented by each av_parser_parse()) */ 3578 int64_t next_frame_offset; /* offset of the next frame */ 3579 /* video info */ 3580 int pict_type; /* XXX: Put it back in AVCodecContext. */ 3581 /** 3582 * This field is used for proper frame duration computation in lavf. 3583 * It signals, how much longer the frame duration of the current frame 3584 * is compared to normal frame duration. 3585 * 3586 * frame_duration = (1 + repeat_pict) * time_base 3587 * 3588 * It is used by codecs like H.264 to display telecined material. 3589 */ 3590 int repeat_pict; /* XXX: Put it back in AVCodecContext. */ 3591 int64_t pts; /* pts of the current frame */ 3592 int64_t dts; /* dts of the current frame */ 3593 3594 /* private data */ 3595 int64_t last_pts; 3596 int64_t last_dts; 3597 int fetch_timestamp; 3598 3599 #define AV_PARSER_PTS_NB 4 3600 int cur_frame_start_index; 3601 int64_t cur_frame_offset[AV_PARSER_PTS_NB]; 3602 int64_t cur_frame_pts[AV_PARSER_PTS_NB]; 3603 int64_t cur_frame_dts[AV_PARSER_PTS_NB]; 3604 3605 int flags; 3606 #define PARSER_FLAG_COMPLETE_FRAMES 0x0001 3607 #define PARSER_FLAG_ONCE 0x0002 3608 /// Set if the parser has a valid file offset 3609 #define PARSER_FLAG_FETCHED_OFFSET 0x0004 3610 3611 int64_t offset; ///< byte offset from starting packet start 3612 int64_t cur_frame_end[AV_PARSER_PTS_NB]; 3613 3614 /** 3615 * Set by parser to 1 for key frames and 0 for non-key frames. 3616 * It is initialized to -1, so if the parser doesn't set this flag, 3617 * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames 3618 * will be used. 3619 */ 3620 int key_frame; 3621 3622 /** 3623 * Time difference in stream time base units from the pts of this 3624 * packet to the point at which the output from the decoder has converged 3625 * independent from the availability of previous frames. That is, the 3626 * frames are virtually identical no matter if decoding started from 3627 * the very first frame or from this keyframe. 3628 * Is AV_NOPTS_VALUE if unknown. 3629 * This field is not the display duration of the current frame. 3630 * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY 3631 * set. 3632 * 3633 * The purpose of this field is to allow seeking in streams that have no 3634 * keyframes in the conventional sense. It corresponds to the 3635 * recovery point SEI in H.264 and match_time_delta in NUT. It is also 3636 * essential for some types of subtitle streams to ensure that all 3637 * subtitles are correctly displayed after seeking. 3638 */ 3639 int64_t convergence_duration; 3640 3641 // Timestamp generation support: 3642 /** 3643 * Synchronization point for start of timestamp generation. 3644 * 3645 * Set to >0 for sync point, 0 for no sync point and <0 for undefined 3646 * (default). 3647 * 3648 * For example, this corresponds to presence of H.264 buffering period 3649 * SEI message. 3650 */ 3651 int dts_sync_point; 3652 3653 /** 3654 * Offset of the current timestamp against last timestamp sync point in 3655 * units of AVCodecContext.time_base. 3656 * 3657 * Set to INT_MIN when dts_sync_point unused. Otherwise, it must 3658 * contain a valid timestamp offset. 3659 * 3660 * Note that the timestamp of sync point has usually a nonzero 3661 * dts_ref_dts_delta, which refers to the previous sync point. Offset of 3662 * the next frame after timestamp sync point will be usually 1. 3663 * 3664 * For example, this corresponds to H.264 cpb_removal_delay. 3665 */ 3666 int dts_ref_dts_delta; 3667 3668 /** 3669 * Presentation delay of current frame in units of AVCodecContext.time_base. 3670 * 3671 * Set to INT_MIN when dts_sync_point unused. Otherwise, it must 3672 * contain valid non-negative timestamp delta (presentation time of a frame 3673 * must not lie in the past). 3674 * 3675 * This delay represents the difference between decoding and presentation 3676 * time of the frame. 3677 * 3678 * For example, this corresponds to H.264 dpb_output_delay. 3679 */ 3680 int pts_dts_delta; 3681 3682 /** 3683 * Position of the packet in file. 3684 * 3685 * Analogous to cur_frame_pts/dts 3686 */ 3687 int64_t cur_frame_pos[AV_PARSER_PTS_NB]; 3688 3689 /** 3690 * Byte position of currently parsed frame in stream. 3691 */ 3692 int64_t pos; 3693 3694 /** 3695 * Previous frame byte position. 3696 */ 3697 int64_t last_pos; 3698 3699 /** 3700 * Duration of the current frame. 3701 * For audio, this is in units of 1 / AVCodecContext.sample_rate. 3702 * For all other types, this is in units of AVCodecContext.time_base. 3703 */ 3704 int duration; 3705 3706 enum AVFieldOrder field_order; 3707 3708 /** 3709 * Indicate whether a picture is coded as a frame, top field or bottom field. 3710 * 3711 * For example, H.264 field_pic_flag equal to 0 corresponds to 3712 * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag 3713 * equal to 1 and bottom_field_flag equal to 0 corresponds to 3714 * AV_PICTURE_STRUCTURE_TOP_FIELD. 3715 */ 3716 enum AVPictureStructure picture_structure; 3717 3718 /** 3719 * Picture number incremented in presentation or output order. 3720 * This field may be reinitialized at the first picture of a new sequence. 3721 * 3722 * For example, this corresponds to H.264 PicOrderCnt. 3723 */ 3724 int output_picture_number; 3725 } AVCodecParserContext; 3726 3727 typedef struct AVCodecParser { 3728 int codec_ids[5]; /* several codec IDs are permitted */ 3729 int priv_data_size; 3730 int (*parser_init)(AVCodecParserContext *s); 3731 int (*parser_parse)(AVCodecParserContext *s, 3732 AVCodecContext *avctx, 3733 const uint8_t **poutbuf, int *poutbuf_size, 3734 const uint8_t *buf, int buf_size); 3735 void (*parser_close)(AVCodecParserContext *s); 3736 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size); 3737 struct AVCodecParser *next; 3738 } AVCodecParser; 3739 3740 AVCodecParser *av_parser_next(AVCodecParser *c); 3741 3742 void av_register_codec_parser(AVCodecParser *parser); 3743 AVCodecParserContext *av_parser_init(int codec_id); 3744 3745 /** 3746 * Parse a packet. 3747 * 3748 * @param s parser context. 3749 * @param avctx codec context. 3750 * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished. 3751 * @param poutbuf_size set to size of parsed buffer or zero if not yet finished. 3752 * @param buf input buffer. 3753 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output). 3754 * @param pts input presentation timestamp. 3755 * @param dts input decoding timestamp. 3756 * @param pos input byte position in stream. 3757 * @return the number of bytes of the input bitstream used. 3758 * 3759 * Example: 3760 * @code 3761 * while(in_len){ 3762 * len = av_parser_parse2(myparser, AVCodecContext, &data, &size, 3763 * in_data, in_len, 3764 * pts, dts, pos); 3765 * in_data += len; 3766 * in_len -= len; 3767 * 3768 * if(size) 3769 * decode_frame(data, size); 3770 * } 3771 * @endcode 3772 */ 3773 int av_parser_parse2(AVCodecParserContext *s, 3774 AVCodecContext *avctx, 3775 uint8_t **poutbuf, int *poutbuf_size, 3776 const uint8_t *buf, int buf_size, 3777 int64_t pts, int64_t dts, 3778 int64_t pos); 3779 3780 /** 3781 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed 3782 * @deprecated use AVBitstreamFilter 3783 */ 3784 int av_parser_change(AVCodecParserContext *s, 3785 AVCodecContext *avctx, 3786 uint8_t **poutbuf, int *poutbuf_size, 3787 const uint8_t *buf, int buf_size, int keyframe); 3788 void av_parser_close(AVCodecParserContext *s); 3789 3790 /** 3791 * @} 3792 * @} 3793 */ 3794 3795 /** 3796 * @addtogroup lavc_encoding 3797 * @{ 3798 */ 3799 3800 /** 3801 * Find a registered encoder with a matching codec ID. 3802 * 3803 * @param id AVCodecID of the requested encoder 3804 * @return An encoder if one was found, NULL otherwise. 3805 */ 3806 AVCodec *avcodec_find_encoder(enum AVCodecID id); 3807 3808 /** 3809 * Find a registered encoder with the specified name. 3810 * 3811 * @param name name of the requested encoder 3812 * @return An encoder if one was found, NULL otherwise. 3813 */ 3814 AVCodec *avcodec_find_encoder_by_name(const char *name); 3815 3816 /** 3817 * Encode a frame of audio. 3818 * 3819 * Takes input samples from frame and writes the next output packet, if 3820 * available, to avpkt. The output packet does not necessarily contain data for 3821 * the most recent frame, as encoders can delay, split, and combine input frames 3822 * internally as needed. 3823 * 3824 * @param avctx codec context 3825 * @param avpkt output AVPacket. 3826 * The user can supply an output buffer by setting 3827 * avpkt->data and avpkt->size prior to calling the 3828 * function, but if the size of the user-provided data is not 3829 * large enough, encoding will fail. All other AVPacket fields 3830 * will be reset by the encoder using av_init_packet(). If 3831 * avpkt->data is NULL, the encoder will allocate it. 3832 * The encoder will set avpkt->size to the size of the 3833 * output packet. 3834 * 3835 * If this function fails or produces no output, avpkt will be 3836 * freed using av_free_packet() (i.e. avpkt->destruct will be 3837 * called to free the user supplied buffer). 3838 * @param[in] frame AVFrame containing the raw audio data to be encoded. 3839 * May be NULL when flushing an encoder that has the 3840 * CODEC_CAP_DELAY capability set. 3841 * If CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame 3842 * can have any number of samples. 3843 * If it is not set, frame->nb_samples must be equal to 3844 * avctx->frame_size for all frames except the last. 3845 * The final frame may be smaller than avctx->frame_size. 3846 * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the 3847 * output packet is non-empty, and to 0 if it is 3848 * empty. If the function returns an error, the 3849 * packet can be assumed to be invalid, and the 3850 * value of got_packet_ptr is undefined and should 3851 * not be used. 3852 * @return 0 on success, negative error code on failure 3853 */ 3854 int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, 3855 const AVFrame *frame, int *got_packet_ptr); 3856 3857 /** 3858 * Encode a frame of video. 3859 * 3860 * Takes input raw video data from frame and writes the next output packet, if 3861 * available, to avpkt. The output packet does not necessarily contain data for 3862 * the most recent frame, as encoders can delay and reorder input frames 3863 * internally as needed. 3864 * 3865 * @param avctx codec context 3866 * @param avpkt output AVPacket. 3867 * The user can supply an output buffer by setting 3868 * avpkt->data and avpkt->size prior to calling the 3869 * function, but if the size of the user-provided data is not 3870 * large enough, encoding will fail. All other AVPacket fields 3871 * will be reset by the encoder using av_init_packet(). If 3872 * avpkt->data is NULL, the encoder will allocate it. 3873 * The encoder will set avpkt->size to the size of the 3874 * output packet. The returned data (if any) belongs to the 3875 * caller, he is responsible for freeing it. 3876 * 3877 * If this function fails or produces no output, avpkt will be 3878 * freed using av_free_packet() (i.e. avpkt->destruct will be 3879 * called to free the user supplied buffer). 3880 * @param[in] frame AVFrame containing the raw video data to be encoded. 3881 * May be NULL when flushing an encoder that has the 3882 * CODEC_CAP_DELAY capability set. 3883 * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the 3884 * output packet is non-empty, and to 0 if it is 3885 * empty. If the function returns an error, the 3886 * packet can be assumed to be invalid, and the 3887 * value of got_packet_ptr is undefined and should 3888 * not be used. 3889 * @return 0 on success, negative error code on failure 3890 */ 3891 int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, 3892 const AVFrame *frame, int *got_packet_ptr); 3893 3894 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, 3895 const AVSubtitle *sub); 3896 3897 3898 /** 3899 * @} 3900 */ 3901 3902 /** 3903 * @addtogroup lavc_picture 3904 * @{ 3905 */ 3906 3907 /** 3908 * Allocate memory for a picture. Call avpicture_free() to free it. 3909 * 3910 * @see avpicture_fill() 3911 * 3912 * @param picture the picture to be filled in 3913 * @param pix_fmt the format of the picture 3914 * @param width the width of the picture 3915 * @param height the height of the picture 3916 * @return zero if successful, a negative value if not 3917 */ 3918 int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height); 3919 3920 /** 3921 * Free a picture previously allocated by avpicture_alloc(). 3922 * The data buffer used by the AVPicture is freed, but the AVPicture structure 3923 * itself is not. 3924 * 3925 * @param picture the AVPicture to be freed 3926 */ 3927 void avpicture_free(AVPicture *picture); 3928 3929 /** 3930 * Fill in the AVPicture fields. 3931 * The fields of the given AVPicture are filled in by using the 'ptr' address 3932 * which points to the image data buffer. Depending on the specified picture 3933 * format, one or multiple image data pointers and line sizes will be set. 3934 * If a planar format is specified, several pointers will be set pointing to 3935 * the different picture planes and the line sizes of the different planes 3936 * will be stored in the lines_sizes array. 3937 * Call with ptr == NULL to get the required size for the ptr buffer. 3938 * 3939 * To allocate the buffer and fill in the AVPicture fields in one call, 3940 * use avpicture_alloc(). 3941 * 3942 * @param picture AVPicture whose fields are to be filled in 3943 * @param ptr Buffer which will contain or contains the actual image data 3944 * @param pix_fmt The format in which the picture data is stored. 3945 * @param width the width of the image in pixels 3946 * @param height the height of the image in pixels 3947 * @return size of the image data in bytes 3948 */ 3949 int avpicture_fill(AVPicture *picture, uint8_t *ptr, 3950 enum AVPixelFormat pix_fmt, int width, int height); 3951 3952 /** 3953 * Copy pixel data from an AVPicture into a buffer. 3954 * The data is stored compactly, without any gaps for alignment or padding 3955 * which may be applied by avpicture_fill(). 3956 * 3957 * @see avpicture_get_size() 3958 * 3959 * @param[in] src AVPicture containing image data 3960 * @param[in] pix_fmt The format in which the picture data is stored. 3961 * @param[in] width the width of the image in pixels. 3962 * @param[in] height the height of the image in pixels. 3963 * @param[out] dest A buffer into which picture data will be copied. 3964 * @param[in] dest_size The size of 'dest'. 3965 * @return The number of bytes written to dest, or a negative value (error code) on error. 3966 */ 3967 int avpicture_layout(const AVPicture* src, enum AVPixelFormat pix_fmt, 3968 int width, int height, 3969 unsigned char *dest, int dest_size); 3970 3971 /** 3972 * Calculate the size in bytes that a picture of the given width and height 3973 * would occupy if stored in the given picture format. 3974 * Note that this returns the size of a compact representation as generated 3975 * by avpicture_layout(), which can be smaller than the size required for e.g. 3976 * avpicture_fill(). 3977 * 3978 * @param pix_fmt the given picture format 3979 * @param width the width of the image 3980 * @param height the height of the image 3981 * @return Image data size in bytes or -1 on error (e.g. too large dimensions). 3982 */ 3983 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height); 3984 3985 #if FF_API_DEINTERLACE 3986 /** 3987 * deinterlace - if not supported return -1 3988 * 3989 * @deprecated - use yadif (in libavfilter) instead 3990 */ 3991 attribute_deprecated 3992 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src, 3993 enum AVPixelFormat pix_fmt, int width, int height); 3994 #endif 3995 /** 3996 * Copy image src to dst. Wraps av_picture_data_copy() above. 3997 */ 3998 void av_picture_copy(AVPicture *dst, const AVPicture *src, 3999 enum AVPixelFormat pix_fmt, int width, int height); 4000 4001 /** 4002 * Crop image top and left side. 4003 */ 4004 int av_picture_crop(AVPicture *dst, const AVPicture *src, 4005 enum AVPixelFormat pix_fmt, int top_band, int left_band); 4006 4007 /** 4008 * Pad image. 4009 */ 4010 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt, 4011 int padtop, int padbottom, int padleft, int padright, int *color); 4012 4013 /** 4014 * @} 4015 */ 4016 4017 /** 4018 * @defgroup lavc_misc Utility functions 4019 * @ingroup libavc 4020 * 4021 * Miscellaneous utility functions related to both encoding and decoding 4022 * (or neither). 4023 * @{ 4024 */ 4025 4026 /** 4027 * @defgroup lavc_misc_pixfmt Pixel formats 4028 * 4029 * Functions for working with pixel formats. 4030 * @{ 4031 */ 4032 4033 /** 4034 * @deprecated Use av_pix_fmt_get_chroma_sub_sample 4035 */ 4036 4037 void attribute_deprecated avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift); 4038 4039 /** 4040 * Return a value representing the fourCC code associated to the 4041 * pixel format pix_fmt, or 0 if no associated fourCC code can be 4042 * found. 4043 */ 4044 unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt); 4045 4046 #define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */ 4047 #define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */ 4048 #define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */ 4049 #define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */ 4050 #define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */ 4051 #define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */ 4052 4053 /** 4054 * Compute what kind of losses will occur when converting from one specific 4055 * pixel format to another. 4056 * When converting from one pixel format to another, information loss may occur. 4057 * For example, when converting from RGB24 to GRAY, the color information will 4058 * be lost. Similarly, other losses occur when converting from some formats to 4059 * other formats. These losses can involve loss of chroma, but also loss of 4060 * resolution, loss of color depth, loss due to the color space conversion, loss 4061 * of the alpha bits or loss due to color quantization. 4062 * avcodec_get_fix_fmt_loss() informs you about the various types of losses 4063 * which will occur when converting from one pixel format to another. 4064 * 4065 * @param[in] dst_pix_fmt destination pixel format 4066 * @param[in] src_pix_fmt source pixel format 4067 * @param[in] has_alpha Whether the source pixel format alpha channel is used. 4068 * @return Combination of flags informing you what kind of losses will occur. 4069 */ 4070 int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt, 4071 int has_alpha); 4072 4073 /** 4074 * Find the best pixel format to convert to given a certain source pixel 4075 * format. When converting from one pixel format to another, information loss 4076 * may occur. For example, when converting from RGB24 to GRAY, the color 4077 * information will be lost. Similarly, other losses occur when converting from 4078 * some formats to other formats. avcodec_find_best_pix_fmt2() searches which of 4079 * the given pixel formats should be used to suffer the least amount of loss. 4080 * The pixel formats from which it chooses one, are determined by the 4081 * pix_fmt_list parameter. 4082 * 4083 * 4084 * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from 4085 * @param[in] src_pix_fmt source pixel format 4086 * @param[in] has_alpha Whether the source pixel format alpha channel is used. 4087 * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur. 4088 * @return The best pixel format to convert to or -1 if none was found. 4089 */ 4090 enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat *pix_fmt_list, 4091 enum AVPixelFormat src_pix_fmt, 4092 int has_alpha, int *loss_ptr); 4093 4094 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt); 4095 4096 /** 4097 * @} 4098 */ 4099 4100 #if FF_API_SET_DIMENSIONS 4101 /** 4102 * @deprecated this function is not supposed to be used from outside of lavc 4103 */ 4104 attribute_deprecated 4105 void avcodec_set_dimensions(AVCodecContext *s, int width, int height); 4106 #endif 4107 4108 /** 4109 * Put a string representing the codec tag codec_tag in buf. 4110 * 4111 * @param buf buffer to place codec tag in 4112 * @param buf_size size in bytes of buf 4113 * @param codec_tag codec tag to assign 4114 * @return the length of the string that would have been generated if 4115 * enough space had been available, excluding the trailing null 4116 */ 4117 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag); 4118 4119 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode); 4120 4121 /** 4122 * Return a name for the specified profile, if available. 4123 * 4124 * @param codec the codec that is searched for the given profile 4125 * @param profile the profile value for which a name is requested 4126 * @return A name for the profile if found, NULL otherwise. 4127 */ 4128 const char *av_get_profile_name(const AVCodec *codec, int profile); 4129 4130 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size); 4131 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count); 4132 //FIXME func typedef 4133 4134 /** 4135 * Fill audio frame data and linesize. 4136 * AVFrame extended_data channel pointers are allocated if necessary for 4137 * planar audio. 4138 * 4139 * @param frame the AVFrame 4140 * frame->nb_samples must be set prior to calling the 4141 * function. This function fills in frame->data, 4142 * frame->extended_data, frame->linesize[0]. 4143 * @param nb_channels channel count 4144 * @param sample_fmt sample format 4145 * @param buf buffer to use for frame data 4146 * @param buf_size size of buffer 4147 * @param align plane size sample alignment (0 = default) 4148 * @return 0 on success, negative error code on failure 4149 */ 4150 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, 4151 enum AVSampleFormat sample_fmt, const uint8_t *buf, 4152 int buf_size, int align); 4153 4154 /** 4155 * Reset the internal decoder state / flush internal buffers. Should be called 4156 * e.g. when seeking or when switching to a different stream. 4157 * 4158 * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0), 4159 * this invalidates the frames previously returned from the decoder. When 4160 * refcounted frames are used, the decoder just releases any references it might 4161 * keep internally, but the caller's reference remains valid. 4162 */ 4163 void avcodec_flush_buffers(AVCodecContext *avctx); 4164 4165 /** 4166 * Return codec bits per sample. 4167 * 4168 * @param[in] codec_id the codec 4169 * @return Number of bits per sample or zero if unknown for the given codec. 4170 */ 4171 int av_get_bits_per_sample(enum AVCodecID codec_id); 4172 4173 /** 4174 * Return codec bits per sample. 4175 * Only return non-zero if the bits per sample is exactly correct, not an 4176 * approximation. 4177 * 4178 * @param[in] codec_id the codec 4179 * @return Number of bits per sample or zero if unknown for the given codec. 4180 */ 4181 int av_get_exact_bits_per_sample(enum AVCodecID codec_id); 4182 4183 /** 4184 * Return audio frame duration. 4185 * 4186 * @param avctx codec context 4187 * @param frame_bytes size of the frame, or 0 if unknown 4188 * @return frame duration, in samples, if known. 0 if not able to 4189 * determine. 4190 */ 4191 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes); 4192 4193 4194 typedef struct AVBitStreamFilterContext { 4195 void *priv_data; 4196 struct AVBitStreamFilter *filter; 4197 AVCodecParserContext *parser; 4198 struct AVBitStreamFilterContext *next; 4199 } AVBitStreamFilterContext; 4200 4201 4202 typedef struct AVBitStreamFilter { 4203 const char *name; 4204 int priv_data_size; 4205 int (*filter)(AVBitStreamFilterContext *bsfc, 4206 AVCodecContext *avctx, const char *args, 4207 uint8_t **poutbuf, int *poutbuf_size, 4208 const uint8_t *buf, int buf_size, int keyframe); 4209 void (*close)(AVBitStreamFilterContext *bsfc); 4210 struct AVBitStreamFilter *next; 4211 } AVBitStreamFilter; 4212 4213 void av_register_bitstream_filter(AVBitStreamFilter *bsf); 4214 AVBitStreamFilterContext *av_bitstream_filter_init(const char *name); 4215 int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, 4216 AVCodecContext *avctx, const char *args, 4217 uint8_t **poutbuf, int *poutbuf_size, 4218 const uint8_t *buf, int buf_size, int keyframe); 4219 void av_bitstream_filter_close(AVBitStreamFilterContext *bsf); 4220 4221 AVBitStreamFilter *av_bitstream_filter_next(AVBitStreamFilter *f); 4222 4223 /* memory */ 4224 4225 /** 4226 * Allocate a buffer with padding, reusing the given one if large enough. 4227 * 4228 * Same behaviour av_fast_malloc but the buffer has additional 4229 * FF_INPUT_PADDING_SIZE at the end which will always memset to 0. 4230 * 4231 */ 4232 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size); 4233 4234 /** 4235 * Encode extradata length to a buffer. Used by xiph codecs. 4236 * 4237 * @param s buffer to write to; must be at least (v/255+1) bytes long 4238 * @param v size of extradata in bytes 4239 * @return number of bytes written to the buffer. 4240 */ 4241 unsigned int av_xiphlacing(unsigned char *s, unsigned int v); 4242 4243 #if FF_API_MISSING_SAMPLE 4244 /** 4245 * Log a generic warning message about a missing feature. This function is 4246 * intended to be used internally by Libav (libavcodec, libavformat, etc.) 4247 * only, and would normally not be used by applications. 4248 * @param[in] avc a pointer to an arbitrary struct of which the first field is 4249 * a pointer to an AVClass struct 4250 * @param[in] feature string containing the name of the missing feature 4251 * @param[in] want_sample indicates if samples are wanted which exhibit this feature. 4252 * If want_sample is non-zero, additional verbage will be added to the log 4253 * message which tells the user how to report samples to the development 4254 * mailing list. 4255 * @deprecated Use avpriv_report_missing_feature() instead. 4256 */ 4257 attribute_deprecated 4258 void av_log_missing_feature(void *avc, const char *feature, int want_sample); 4259 4260 /** 4261 * Log a generic warning message asking for a sample. This function is 4262 * intended to be used internally by Libav (libavcodec, libavformat, etc.) 4263 * only, and would normally not be used by applications. 4264 * @param[in] avc a pointer to an arbitrary struct of which the first field is 4265 * a pointer to an AVClass struct 4266 * @param[in] msg string containing an optional message, or NULL if no message 4267 * @deprecated Use avpriv_request_sample() instead. 4268 */ 4269 attribute_deprecated 4270 void av_log_ask_for_sample(void *avc, const char *msg, ...) av_printf_format(2, 3); 4271 #endif /* FF_API_MISSING_SAMPLE */ 4272 4273 /** 4274 * Register the hardware accelerator hwaccel. 4275 */ 4276 void av_register_hwaccel(AVHWAccel *hwaccel); 4277 4278 /** 4279 * If hwaccel is NULL, returns the first registered hardware accelerator, 4280 * if hwaccel is non-NULL, returns the next registered hardware accelerator 4281 * after hwaccel, or NULL if hwaccel is the last one. 4282 */ 4283 AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel); 4284 4285 4286 /** 4287 * Lock operation used by lockmgr 4288 */ 4289 enum AVLockOp { 4290 AV_LOCK_CREATE, ///< Create a mutex 4291 AV_LOCK_OBTAIN, ///< Lock the mutex 4292 AV_LOCK_RELEASE, ///< Unlock the mutex 4293 AV_LOCK_DESTROY, ///< Free mutex resources 4294 }; 4295 4296 /** 4297 * Register a user provided lock manager supporting the operations 4298 * specified by AVLockOp. mutex points to a (void *) where the 4299 * lockmgr should store/get a pointer to a user allocated mutex. It's 4300 * NULL upon AV_LOCK_CREATE and != NULL for all other ops. 4301 * 4302 * @param cb User defined callback. Note: Libav may invoke calls to this 4303 * callback during the call to av_lockmgr_register(). 4304 * Thus, the application must be prepared to handle that. 4305 * If cb is set to NULL the lockmgr will be unregistered. 4306 * Also note that during unregistration the previously registered 4307 * lockmgr callback may also be invoked. 4308 */ 4309 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op)); 4310 4311 /** 4312 * Get the type of the given codec. 4313 */ 4314 enum AVMediaType avcodec_get_type(enum AVCodecID codec_id); 4315 4316 /** 4317 * @return a positive value if s is open (i.e. avcodec_open2() was called on it 4318 * with no corresponding avcodec_close()), 0 otherwise. 4319 */ 4320 int avcodec_is_open(AVCodecContext *s); 4321 4322 /** 4323 * @return a non-zero number if codec is an encoder, zero otherwise 4324 */ 4325 int av_codec_is_encoder(const AVCodec *codec); 4326 4327 /** 4328 * @return a non-zero number if codec is a decoder, zero otherwise 4329 */ 4330 int av_codec_is_decoder(const AVCodec *codec); 4331 4332 /** 4333 * @return descriptor for given codec ID or NULL if no descriptor exists. 4334 */ 4335 const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id); 4336 4337 /** 4338 * Iterate over all codec descriptors known to libavcodec. 4339 * 4340 * @param prev previous descriptor. NULL to get the first descriptor. 4341 * 4342 * @return next descriptor or NULL after the last descriptor 4343 */ 4344 const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev); 4345 4346 /** 4347 * @return codec descriptor with the given name or NULL if no such descriptor 4348 * exists. 4349 */ 4350 const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name); 4351 4352 /** 4353 * @} 4354 */ 4355 4356 #endif /* AVCODEC_AVCODEC_H */ 4357