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