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