1 /* 2 * copyright (c) 2001 Fabrice Bellard 3 * 4 * This file is part of FFmpeg. 5 * 6 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21 #ifndef AVCODEC_AVCODEC_H 22 #define AVCODEC_AVCODEC_H 23 24 /** 25 * @file 26 * @ingroup libavc 27 * Libavcodec external API header 28 */ 29 30 #include <errno.h> 31 #include "libavutil/samplefmt.h" 32 #include "libavutil/attributes.h" 33 #include "libavutil/avutil.h" 34 #include "libavutil/buffer.h" 35 #include "libavutil/cpu.h" 36 #include "libavutil/channel_layout.h" 37 #include "libavutil/dict.h" 38 #include "libavutil/frame.h" 39 #include "libavutil/log.h" 40 #include "libavutil/pixfmt.h" 41 #include "libavutil/rational.h" 42 43 #include "version.h" 44 45 /** 46 * @defgroup libavc Encoding/Decoding Library 47 * @{ 48 * 49 * @defgroup lavc_decoding Decoding 50 * @{ 51 * @} 52 * 53 * @defgroup lavc_encoding Encoding 54 * @{ 55 * @} 56 * 57 * @defgroup lavc_codec Codecs 58 * @{ 59 * @defgroup lavc_codec_native Native Codecs 60 * @{ 61 * @} 62 * @defgroup lavc_codec_wrappers External library wrappers 63 * @{ 64 * @} 65 * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge 66 * @{ 67 * @} 68 * @} 69 * @defgroup lavc_internal Internal 70 * @{ 71 * @} 72 * @} 73 * 74 */ 75 76 /** 77 * @defgroup lavc_core Core functions/structures. 78 * @ingroup libavc 79 * 80 * Basic definitions, functions for querying libavcodec capabilities, 81 * allocating core structures, etc. 82 * @{ 83 */ 84 85 86 /** 87 * Identify the syntax and semantics of the bitstream. 88 * The principle is roughly: 89 * Two decoders with the same ID can decode the same streams. 90 * Two encoders with the same ID can encode compatible streams. 91 * There may be slight deviations from the principle due to implementation 92 * details. 93 * 94 * If you add a codec ID to this list, add it so that 95 * 1. no value of a existing codec ID changes (that would break ABI), 96 * 2. it is as close as possible to similar codecs 97 * 98 * After adding new codec IDs, do not forget to add an entry to the codec 99 * descriptor list and bump libavcodec minor version. 100 */ 101 enum AVCodecID { 102 AV_CODEC_ID_NONE, 103 104 /* video codecs */ 105 AV_CODEC_ID_MPEG1VIDEO, 106 AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding 107 #if FF_API_XVMC 108 AV_CODEC_ID_MPEG2VIDEO_XVMC, 109 #endif /* FF_API_XVMC */ 110 AV_CODEC_ID_H261, 111 AV_CODEC_ID_H263, 112 AV_CODEC_ID_RV10, 113 AV_CODEC_ID_RV20, 114 AV_CODEC_ID_MJPEG, 115 AV_CODEC_ID_MJPEGB, 116 AV_CODEC_ID_LJPEG, 117 AV_CODEC_ID_SP5X, 118 AV_CODEC_ID_JPEGLS, 119 AV_CODEC_ID_MPEG4, 120 AV_CODEC_ID_RAWVIDEO, 121 AV_CODEC_ID_MSMPEG4V1, 122 AV_CODEC_ID_MSMPEG4V2, 123 AV_CODEC_ID_MSMPEG4V3, 124 AV_CODEC_ID_WMV1, 125 AV_CODEC_ID_WMV2, 126 AV_CODEC_ID_H263P, 127 AV_CODEC_ID_H263I, 128 AV_CODEC_ID_FLV1, 129 AV_CODEC_ID_SVQ1, 130 AV_CODEC_ID_SVQ3, 131 AV_CODEC_ID_DVVIDEO, 132 AV_CODEC_ID_HUFFYUV, 133 AV_CODEC_ID_CYUV, 134 AV_CODEC_ID_H264, 135 AV_CODEC_ID_INDEO3, 136 AV_CODEC_ID_VP3, 137 AV_CODEC_ID_THEORA, 138 AV_CODEC_ID_ASV1, 139 AV_CODEC_ID_ASV2, 140 AV_CODEC_ID_FFV1, 141 AV_CODEC_ID_4XM, 142 AV_CODEC_ID_VCR1, 143 AV_CODEC_ID_CLJR, 144 AV_CODEC_ID_MDEC, 145 AV_CODEC_ID_ROQ, 146 AV_CODEC_ID_INTERPLAY_VIDEO, 147 AV_CODEC_ID_XAN_WC3, 148 AV_CODEC_ID_XAN_WC4, 149 AV_CODEC_ID_RPZA, 150 AV_CODEC_ID_CINEPAK, 151 AV_CODEC_ID_WS_VQA, 152 AV_CODEC_ID_MSRLE, 153 AV_CODEC_ID_MSVIDEO1, 154 AV_CODEC_ID_IDCIN, 155 AV_CODEC_ID_8BPS, 156 AV_CODEC_ID_SMC, 157 AV_CODEC_ID_FLIC, 158 AV_CODEC_ID_TRUEMOTION1, 159 AV_CODEC_ID_VMDVIDEO, 160 AV_CODEC_ID_MSZH, 161 AV_CODEC_ID_ZLIB, 162 AV_CODEC_ID_QTRLE, 163 AV_CODEC_ID_TSCC, 164 AV_CODEC_ID_ULTI, 165 AV_CODEC_ID_QDRAW, 166 AV_CODEC_ID_VIXL, 167 AV_CODEC_ID_QPEG, 168 AV_CODEC_ID_PNG, 169 AV_CODEC_ID_PPM, 170 AV_CODEC_ID_PBM, 171 AV_CODEC_ID_PGM, 172 AV_CODEC_ID_PGMYUV, 173 AV_CODEC_ID_PAM, 174 AV_CODEC_ID_FFVHUFF, 175 AV_CODEC_ID_RV30, 176 AV_CODEC_ID_RV40, 177 AV_CODEC_ID_VC1, 178 AV_CODEC_ID_WMV3, 179 AV_CODEC_ID_LOCO, 180 AV_CODEC_ID_WNV1, 181 AV_CODEC_ID_AASC, 182 AV_CODEC_ID_INDEO2, 183 AV_CODEC_ID_FRAPS, 184 AV_CODEC_ID_TRUEMOTION2, 185 AV_CODEC_ID_BMP, 186 AV_CODEC_ID_CSCD, 187 AV_CODEC_ID_MMVIDEO, 188 AV_CODEC_ID_ZMBV, 189 AV_CODEC_ID_AVS, 190 AV_CODEC_ID_SMACKVIDEO, 191 AV_CODEC_ID_NUV, 192 AV_CODEC_ID_KMVC, 193 AV_CODEC_ID_FLASHSV, 194 AV_CODEC_ID_CAVS, 195 AV_CODEC_ID_JPEG2000, 196 AV_CODEC_ID_VMNC, 197 AV_CODEC_ID_VP5, 198 AV_CODEC_ID_VP6, 199 AV_CODEC_ID_VP6F, 200 AV_CODEC_ID_TARGA, 201 AV_CODEC_ID_DSICINVIDEO, 202 AV_CODEC_ID_TIERTEXSEQVIDEO, 203 AV_CODEC_ID_TIFF, 204 AV_CODEC_ID_GIF, 205 AV_CODEC_ID_DXA, 206 AV_CODEC_ID_DNXHD, 207 AV_CODEC_ID_THP, 208 AV_CODEC_ID_SGI, 209 AV_CODEC_ID_C93, 210 AV_CODEC_ID_BETHSOFTVID, 211 AV_CODEC_ID_PTX, 212 AV_CODEC_ID_TXD, 213 AV_CODEC_ID_VP6A, 214 AV_CODEC_ID_AMV, 215 AV_CODEC_ID_VB, 216 AV_CODEC_ID_PCX, 217 AV_CODEC_ID_SUNRAST, 218 AV_CODEC_ID_INDEO4, 219 AV_CODEC_ID_INDEO5, 220 AV_CODEC_ID_MIMIC, 221 AV_CODEC_ID_RL2, 222 AV_CODEC_ID_ESCAPE124, 223 AV_CODEC_ID_DIRAC, 224 AV_CODEC_ID_BFI, 225 AV_CODEC_ID_CMV, 226 AV_CODEC_ID_MOTIONPIXELS, 227 AV_CODEC_ID_TGV, 228 AV_CODEC_ID_TGQ, 229 AV_CODEC_ID_TQI, 230 AV_CODEC_ID_AURA, 231 AV_CODEC_ID_AURA2, 232 AV_CODEC_ID_V210X, 233 AV_CODEC_ID_TMV, 234 AV_CODEC_ID_V210, 235 AV_CODEC_ID_DPX, 236 AV_CODEC_ID_MAD, 237 AV_CODEC_ID_FRWU, 238 AV_CODEC_ID_FLASHSV2, 239 AV_CODEC_ID_CDGRAPHICS, 240 AV_CODEC_ID_R210, 241 AV_CODEC_ID_ANM, 242 AV_CODEC_ID_BINKVIDEO, 243 AV_CODEC_ID_IFF_ILBM, 244 #define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM 245 AV_CODEC_ID_KGV1, 246 AV_CODEC_ID_YOP, 247 AV_CODEC_ID_VP8, 248 AV_CODEC_ID_PICTOR, 249 AV_CODEC_ID_ANSI, 250 AV_CODEC_ID_A64_MULTI, 251 AV_CODEC_ID_A64_MULTI5, 252 AV_CODEC_ID_R10K, 253 AV_CODEC_ID_MXPEG, 254 AV_CODEC_ID_LAGARITH, 255 AV_CODEC_ID_PRORES, 256 AV_CODEC_ID_JV, 257 AV_CODEC_ID_DFA, 258 AV_CODEC_ID_WMV3IMAGE, 259 AV_CODEC_ID_VC1IMAGE, 260 AV_CODEC_ID_UTVIDEO, 261 AV_CODEC_ID_BMV_VIDEO, 262 AV_CODEC_ID_VBLE, 263 AV_CODEC_ID_DXTORY, 264 AV_CODEC_ID_V410, 265 AV_CODEC_ID_XWD, 266 AV_CODEC_ID_CDXL, 267 AV_CODEC_ID_XBM, 268 AV_CODEC_ID_ZEROCODEC, 269 AV_CODEC_ID_MSS1, 270 AV_CODEC_ID_MSA1, 271 AV_CODEC_ID_TSCC2, 272 AV_CODEC_ID_MTS2, 273 AV_CODEC_ID_CLLC, 274 AV_CODEC_ID_MSS2, 275 AV_CODEC_ID_VP9, 276 AV_CODEC_ID_AIC, 277 AV_CODEC_ID_ESCAPE130, 278 AV_CODEC_ID_G2M, 279 AV_CODEC_ID_WEBP, 280 AV_CODEC_ID_HNM4_VIDEO, 281 AV_CODEC_ID_HEVC, 282 #define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC 283 AV_CODEC_ID_FIC, 284 AV_CODEC_ID_ALIAS_PIX, 285 AV_CODEC_ID_BRENDER_PIX, 286 AV_CODEC_ID_PAF_VIDEO, 287 AV_CODEC_ID_EXR, 288 AV_CODEC_ID_VP7, 289 AV_CODEC_ID_SANM, 290 AV_CODEC_ID_SGIRLE, 291 AV_CODEC_ID_MVC1, 292 AV_CODEC_ID_MVC2, 293 AV_CODEC_ID_HQX, 294 AV_CODEC_ID_TDSC, 295 AV_CODEC_ID_HQ_HQA, 296 AV_CODEC_ID_HAP, 297 AV_CODEC_ID_DDS, 298 AV_CODEC_ID_DXV, 299 AV_CODEC_ID_SCREENPRESSO, 300 AV_CODEC_ID_RSCC, 301 302 AV_CODEC_ID_Y41P = 0x8000, 303 AV_CODEC_ID_AVRP, 304 AV_CODEC_ID_012V, 305 AV_CODEC_ID_AVUI, 306 AV_CODEC_ID_AYUV, 307 AV_CODEC_ID_TARGA_Y216, 308 AV_CODEC_ID_V308, 309 AV_CODEC_ID_V408, 310 AV_CODEC_ID_YUV4, 311 AV_CODEC_ID_AVRN, 312 AV_CODEC_ID_CPIA, 313 AV_CODEC_ID_XFACE, 314 AV_CODEC_ID_SNOW, 315 AV_CODEC_ID_SMVJPEG, 316 AV_CODEC_ID_APNG, 317 AV_CODEC_ID_DAALA, 318 AV_CODEC_ID_CFHD, 319 320 /* various PCM "codecs" */ 321 AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs 322 AV_CODEC_ID_PCM_S16LE = 0x10000, 323 AV_CODEC_ID_PCM_S16BE, 324 AV_CODEC_ID_PCM_U16LE, 325 AV_CODEC_ID_PCM_U16BE, 326 AV_CODEC_ID_PCM_S8, 327 AV_CODEC_ID_PCM_U8, 328 AV_CODEC_ID_PCM_MULAW, 329 AV_CODEC_ID_PCM_ALAW, 330 AV_CODEC_ID_PCM_S32LE, 331 AV_CODEC_ID_PCM_S32BE, 332 AV_CODEC_ID_PCM_U32LE, 333 AV_CODEC_ID_PCM_U32BE, 334 AV_CODEC_ID_PCM_S24LE, 335 AV_CODEC_ID_PCM_S24BE, 336 AV_CODEC_ID_PCM_U24LE, 337 AV_CODEC_ID_PCM_U24BE, 338 AV_CODEC_ID_PCM_S24DAUD, 339 AV_CODEC_ID_PCM_ZORK, 340 AV_CODEC_ID_PCM_S16LE_PLANAR, 341 AV_CODEC_ID_PCM_DVD, 342 AV_CODEC_ID_PCM_F32BE, 343 AV_CODEC_ID_PCM_F32LE, 344 AV_CODEC_ID_PCM_F64BE, 345 AV_CODEC_ID_PCM_F64LE, 346 AV_CODEC_ID_PCM_BLURAY, 347 AV_CODEC_ID_PCM_LXF, 348 AV_CODEC_ID_S302M, 349 AV_CODEC_ID_PCM_S8_PLANAR, 350 AV_CODEC_ID_PCM_S24LE_PLANAR, 351 AV_CODEC_ID_PCM_S32LE_PLANAR, 352 AV_CODEC_ID_PCM_S16BE_PLANAR, 353 /* new PCM "codecs" should be added right below this line starting with 354 * an explicit value of for example 0x10800 355 */ 356 357 /* various ADPCM codecs */ 358 AV_CODEC_ID_ADPCM_IMA_QT = 0x11000, 359 AV_CODEC_ID_ADPCM_IMA_WAV, 360 AV_CODEC_ID_ADPCM_IMA_DK3, 361 AV_CODEC_ID_ADPCM_IMA_DK4, 362 AV_CODEC_ID_ADPCM_IMA_WS, 363 AV_CODEC_ID_ADPCM_IMA_SMJPEG, 364 AV_CODEC_ID_ADPCM_MS, 365 AV_CODEC_ID_ADPCM_4XM, 366 AV_CODEC_ID_ADPCM_XA, 367 AV_CODEC_ID_ADPCM_ADX, 368 AV_CODEC_ID_ADPCM_EA, 369 AV_CODEC_ID_ADPCM_G726, 370 AV_CODEC_ID_ADPCM_CT, 371 AV_CODEC_ID_ADPCM_SWF, 372 AV_CODEC_ID_ADPCM_YAMAHA, 373 AV_CODEC_ID_ADPCM_SBPRO_4, 374 AV_CODEC_ID_ADPCM_SBPRO_3, 375 AV_CODEC_ID_ADPCM_SBPRO_2, 376 AV_CODEC_ID_ADPCM_THP, 377 AV_CODEC_ID_ADPCM_IMA_AMV, 378 AV_CODEC_ID_ADPCM_EA_R1, 379 AV_CODEC_ID_ADPCM_EA_R3, 380 AV_CODEC_ID_ADPCM_EA_R2, 381 AV_CODEC_ID_ADPCM_IMA_EA_SEAD, 382 AV_CODEC_ID_ADPCM_IMA_EA_EACS, 383 AV_CODEC_ID_ADPCM_EA_XAS, 384 AV_CODEC_ID_ADPCM_EA_MAXIS_XA, 385 AV_CODEC_ID_ADPCM_IMA_ISS, 386 AV_CODEC_ID_ADPCM_G722, 387 AV_CODEC_ID_ADPCM_IMA_APC, 388 AV_CODEC_ID_ADPCM_VIMA, 389 #if FF_API_VIMA_DECODER 390 AV_CODEC_ID_VIMA = AV_CODEC_ID_ADPCM_VIMA, 391 #endif 392 393 AV_CODEC_ID_ADPCM_AFC = 0x11800, 394 AV_CODEC_ID_ADPCM_IMA_OKI, 395 AV_CODEC_ID_ADPCM_DTK, 396 AV_CODEC_ID_ADPCM_IMA_RAD, 397 AV_CODEC_ID_ADPCM_G726LE, 398 AV_CODEC_ID_ADPCM_THP_LE, 399 AV_CODEC_ID_ADPCM_PSX, 400 AV_CODEC_ID_ADPCM_AICA, 401 402 /* AMR */ 403 AV_CODEC_ID_AMR_NB = 0x12000, 404 AV_CODEC_ID_AMR_WB, 405 406 /* RealAudio codecs*/ 407 AV_CODEC_ID_RA_144 = 0x13000, 408 AV_CODEC_ID_RA_288, 409 410 /* various DPCM codecs */ 411 AV_CODEC_ID_ROQ_DPCM = 0x14000, 412 AV_CODEC_ID_INTERPLAY_DPCM, 413 AV_CODEC_ID_XAN_DPCM, 414 AV_CODEC_ID_SOL_DPCM, 415 416 AV_CODEC_ID_SDX2_DPCM = 0x14800, 417 418 /* audio codecs */ 419 AV_CODEC_ID_MP2 = 0x15000, 420 AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3 421 AV_CODEC_ID_AAC, 422 AV_CODEC_ID_AC3, 423 AV_CODEC_ID_DTS, 424 AV_CODEC_ID_VORBIS, 425 AV_CODEC_ID_DVAUDIO, 426 AV_CODEC_ID_WMAV1, 427 AV_CODEC_ID_WMAV2, 428 AV_CODEC_ID_MACE3, 429 AV_CODEC_ID_MACE6, 430 AV_CODEC_ID_VMDAUDIO, 431 AV_CODEC_ID_FLAC, 432 AV_CODEC_ID_MP3ADU, 433 AV_CODEC_ID_MP3ON4, 434 AV_CODEC_ID_SHORTEN, 435 AV_CODEC_ID_ALAC, 436 AV_CODEC_ID_WESTWOOD_SND1, 437 AV_CODEC_ID_GSM, ///< as in Berlin toast format 438 AV_CODEC_ID_QDM2, 439 AV_CODEC_ID_COOK, 440 AV_CODEC_ID_TRUESPEECH, 441 AV_CODEC_ID_TTA, 442 AV_CODEC_ID_SMACKAUDIO, 443 AV_CODEC_ID_QCELP, 444 AV_CODEC_ID_WAVPACK, 445 AV_CODEC_ID_DSICINAUDIO, 446 AV_CODEC_ID_IMC, 447 AV_CODEC_ID_MUSEPACK7, 448 AV_CODEC_ID_MLP, 449 AV_CODEC_ID_GSM_MS, /* as found in WAV */ 450 AV_CODEC_ID_ATRAC3, 451 #if FF_API_VOXWARE 452 AV_CODEC_ID_VOXWARE, 453 #endif 454 AV_CODEC_ID_APE, 455 AV_CODEC_ID_NELLYMOSER, 456 AV_CODEC_ID_MUSEPACK8, 457 AV_CODEC_ID_SPEEX, 458 AV_CODEC_ID_WMAVOICE, 459 AV_CODEC_ID_WMAPRO, 460 AV_CODEC_ID_WMALOSSLESS, 461 AV_CODEC_ID_ATRAC3P, 462 AV_CODEC_ID_EAC3, 463 AV_CODEC_ID_SIPR, 464 AV_CODEC_ID_MP1, 465 AV_CODEC_ID_TWINVQ, 466 AV_CODEC_ID_TRUEHD, 467 AV_CODEC_ID_MP4ALS, 468 AV_CODEC_ID_ATRAC1, 469 AV_CODEC_ID_BINKAUDIO_RDFT, 470 AV_CODEC_ID_BINKAUDIO_DCT, 471 AV_CODEC_ID_AAC_LATM, 472 AV_CODEC_ID_QDMC, 473 AV_CODEC_ID_CELT, 474 AV_CODEC_ID_G723_1, 475 AV_CODEC_ID_G729, 476 AV_CODEC_ID_8SVX_EXP, 477 AV_CODEC_ID_8SVX_FIB, 478 AV_CODEC_ID_BMV_AUDIO, 479 AV_CODEC_ID_RALF, 480 AV_CODEC_ID_IAC, 481 AV_CODEC_ID_ILBC, 482 AV_CODEC_ID_OPUS, 483 AV_CODEC_ID_COMFORT_NOISE, 484 AV_CODEC_ID_TAK, 485 AV_CODEC_ID_METASOUND, 486 AV_CODEC_ID_PAF_AUDIO, 487 AV_CODEC_ID_ON2AVC, 488 AV_CODEC_ID_DSS_SP, 489 490 AV_CODEC_ID_FFWAVESYNTH = 0x15800, 491 AV_CODEC_ID_SONIC, 492 AV_CODEC_ID_SONIC_LS, 493 AV_CODEC_ID_EVRC, 494 AV_CODEC_ID_SMV, 495 AV_CODEC_ID_DSD_LSBF, 496 AV_CODEC_ID_DSD_MSBF, 497 AV_CODEC_ID_DSD_LSBF_PLANAR, 498 AV_CODEC_ID_DSD_MSBF_PLANAR, 499 AV_CODEC_ID_4GV, 500 AV_CODEC_ID_INTERPLAY_ACM, 501 AV_CODEC_ID_XMA1, 502 AV_CODEC_ID_XMA2, 503 504 /* subtitle codecs */ 505 AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs. 506 AV_CODEC_ID_DVD_SUBTITLE = 0x17000, 507 AV_CODEC_ID_DVB_SUBTITLE, 508 AV_CODEC_ID_TEXT, ///< raw UTF-8 text 509 AV_CODEC_ID_XSUB, 510 AV_CODEC_ID_SSA, 511 AV_CODEC_ID_MOV_TEXT, 512 AV_CODEC_ID_HDMV_PGS_SUBTITLE, 513 AV_CODEC_ID_DVB_TELETEXT, 514 AV_CODEC_ID_SRT, 515 516 AV_CODEC_ID_MICRODVD = 0x17800, 517 AV_CODEC_ID_EIA_608, 518 AV_CODEC_ID_JACOSUB, 519 AV_CODEC_ID_SAMI, 520 AV_CODEC_ID_REALTEXT, 521 AV_CODEC_ID_STL, 522 AV_CODEC_ID_SUBVIEWER1, 523 AV_CODEC_ID_SUBVIEWER, 524 AV_CODEC_ID_SUBRIP, 525 AV_CODEC_ID_WEBVTT, 526 AV_CODEC_ID_MPL2, 527 AV_CODEC_ID_VPLAYER, 528 AV_CODEC_ID_PJS, 529 AV_CODEC_ID_ASS, 530 AV_CODEC_ID_HDMV_TEXT_SUBTITLE, 531 532 /* other specific kind of codecs (generally used for attachments) */ 533 AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs. 534 AV_CODEC_ID_TTF = 0x18000, 535 536 AV_CODEC_ID_BINTEXT = 0x18800, 537 AV_CODEC_ID_XBIN, 538 AV_CODEC_ID_IDF, 539 AV_CODEC_ID_OTF, 540 AV_CODEC_ID_SMPTE_KLV, 541 AV_CODEC_ID_DVD_NAV, 542 AV_CODEC_ID_TIMED_ID3, 543 AV_CODEC_ID_BIN_DATA, 544 545 546 AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it 547 548 AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS 549 * stream (only used by libavformat) */ 550 AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems 551 * stream (only used by libavformat) */ 552 AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information. 553 AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket 554 }; 555 556 /** 557 * This struct describes the properties of a single codec described by an 558 * AVCodecID. 559 * @see avcodec_descriptor_get() 560 */ 561 typedef struct AVCodecDescriptor { 562 enum AVCodecID id; 563 enum AVMediaType type; 564 /** 565 * Name of the codec described by this descriptor. It is non-empty and 566 * unique for each codec descriptor. It should contain alphanumeric 567 * characters and '_' only. 568 */ 569 const char *name; 570 /** 571 * A more descriptive name for this codec. May be NULL. 572 */ 573 const char *long_name; 574 /** 575 * Codec properties, a combination of AV_CODEC_PROP_* flags. 576 */ 577 int props; 578 /** 579 * MIME type(s) associated with the codec. 580 * May be NULL; if not, a NULL-terminated array of MIME types. 581 * The first item is always non-NULL and is the preferred MIME type. 582 */ 583 const char *const *mime_types; 584 /** 585 * If non-NULL, an array of profiles recognized for this codec. 586 * Terminated with FF_PROFILE_UNKNOWN. 587 */ 588 const struct AVProfile *profiles; 589 } AVCodecDescriptor; 590 591 /** 592 * Codec uses only intra compression. 593 * Video codecs only. 594 */ 595 #define AV_CODEC_PROP_INTRA_ONLY (1 << 0) 596 /** 597 * Codec supports lossy compression. Audio and video codecs only. 598 * @note a codec may support both lossy and lossless 599 * compression modes 600 */ 601 #define AV_CODEC_PROP_LOSSY (1 << 1) 602 /** 603 * Codec supports lossless compression. Audio and video codecs only. 604 */ 605 #define AV_CODEC_PROP_LOSSLESS (1 << 2) 606 /** 607 * Codec supports frame reordering. That is, the coded order (the order in which 608 * the encoded packets are output by the encoders / stored / input to the 609 * decoders) may be different from the presentation order of the corresponding 610 * frames. 611 * 612 * For codecs that do not have this property set, PTS and DTS should always be 613 * equal. 614 */ 615 #define AV_CODEC_PROP_REORDER (1 << 3) 616 /** 617 * Subtitle codec is bitmap based 618 * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field. 619 */ 620 #define AV_CODEC_PROP_BITMAP_SUB (1 << 16) 621 /** 622 * Subtitle codec is text based. 623 * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field. 624 */ 625 #define AV_CODEC_PROP_TEXT_SUB (1 << 17) 626 627 /** 628 * @ingroup lavc_decoding 629 * Required number of additionally allocated bytes at the end of the input bitstream for decoding. 630 * This is mainly needed because some optimized bitstream readers read 631 * 32 or 64 bit at once and could read over the end.<br> 632 * Note: If the first 23 bits of the additional bytes are not 0, then damaged 633 * MPEG bitstreams could cause overread and segfault. 634 */ 635 #define AV_INPUT_BUFFER_PADDING_SIZE 32 636 637 /** 638 * @ingroup lavc_encoding 639 * minimum encoding buffer size 640 * Used to avoid some checks during header writing. 641 */ 642 #define AV_INPUT_BUFFER_MIN_SIZE 16384 643 644 #if FF_API_WITHOUT_PREFIX 645 /** 646 * @deprecated use AV_INPUT_BUFFER_PADDING_SIZE instead 647 */ 648 #define FF_INPUT_BUFFER_PADDING_SIZE 32 649 650 /** 651 * @deprecated use AV_INPUT_BUFFER_MIN_SIZE instead 652 */ 653 #define FF_MIN_BUFFER_SIZE 16384 654 #endif /* FF_API_WITHOUT_PREFIX */ 655 656 /** 657 * @ingroup lavc_encoding 658 * motion estimation type. 659 * @deprecated use codec private option instead 660 */ 661 #if FF_API_MOTION_EST 662 enum Motion_Est_ID { 663 ME_ZERO = 1, ///< no search, that is use 0,0 vector whenever one is needed 664 ME_FULL, 665 ME_LOG, 666 ME_PHODS, 667 ME_EPZS, ///< enhanced predictive zonal search 668 ME_X1, ///< reserved for experiments 669 ME_HEX, ///< hexagon based search 670 ME_UMH, ///< uneven multi-hexagon search 671 ME_TESA, ///< transformed exhaustive search algorithm 672 ME_ITER=50, ///< iterative search 673 }; 674 #endif 675 676 /** 677 * @ingroup lavc_decoding 678 */ 679 enum AVDiscard{ 680 /* We leave some space between them for extensions (drop some 681 * keyframes for intra-only or drop just some bidir frames). */ 682 AVDISCARD_NONE =-16, ///< discard nothing 683 AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi 684 AVDISCARD_NONREF = 8, ///< discard all non reference 685 AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames 686 AVDISCARD_NONINTRA= 24, ///< discard all non intra frames 687 AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes 688 AVDISCARD_ALL = 48, ///< discard all 689 }; 690 691 enum AVAudioServiceType { 692 AV_AUDIO_SERVICE_TYPE_MAIN = 0, 693 AV_AUDIO_SERVICE_TYPE_EFFECTS = 1, 694 AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2, 695 AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3, 696 AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4, 697 AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5, 698 AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6, 699 AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7, 700 AV_AUDIO_SERVICE_TYPE_KARAOKE = 8, 701 AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI 702 }; 703 704 /** 705 * @ingroup lavc_encoding 706 */ 707 typedef struct RcOverride{ 708 int start_frame; 709 int end_frame; 710 int qscale; // If this is 0 then quality_factor will be used instead. 711 float quality_factor; 712 } RcOverride; 713 714 #if FF_API_MAX_BFRAMES 715 /** 716 * @deprecated there is no libavcodec-wide limit on the number of B-frames 717 */ 718 #define FF_MAX_B_FRAMES 16 719 #endif 720 721 /* encoding support 722 These flags can be passed in AVCodecContext.flags before initialization. 723 Note: Not everything is supported yet. 724 */ 725 726 /** 727 * Allow decoders to produce frames with data planes that are not aligned 728 * to CPU requirements (e.g. due to cropping). 729 */ 730 #define AV_CODEC_FLAG_UNALIGNED (1 << 0) 731 /** 732 * Use fixed qscale. 733 */ 734 #define AV_CODEC_FLAG_QSCALE (1 << 1) 735 /** 736 * 4 MV per MB allowed / advanced prediction for H.263. 737 */ 738 #define AV_CODEC_FLAG_4MV (1 << 2) 739 /** 740 * Output even those frames that might be corrupted. 741 */ 742 #define AV_CODEC_FLAG_OUTPUT_CORRUPT (1 << 3) 743 /** 744 * Use qpel MC. 745 */ 746 #define AV_CODEC_FLAG_QPEL (1 << 4) 747 /** 748 * Use internal 2pass ratecontrol in first pass mode. 749 */ 750 #define AV_CODEC_FLAG_PASS1 (1 << 9) 751 /** 752 * Use internal 2pass ratecontrol in second pass mode. 753 */ 754 #define AV_CODEC_FLAG_PASS2 (1 << 10) 755 /** 756 * loop filter. 757 */ 758 #define AV_CODEC_FLAG_LOOP_FILTER (1 << 11) 759 /** 760 * Only decode/encode grayscale. 761 */ 762 #define AV_CODEC_FLAG_GRAY (1 << 13) 763 /** 764 * error[?] variables will be set during encoding. 765 */ 766 #define AV_CODEC_FLAG_PSNR (1 << 15) 767 /** 768 * Input bitstream might be truncated at a random location 769 * instead of only at frame boundaries. 770 */ 771 #define AV_CODEC_FLAG_TRUNCATED (1 << 16) 772 /** 773 * Use interlaced DCT. 774 */ 775 #define AV_CODEC_FLAG_INTERLACED_DCT (1 << 18) 776 /** 777 * Force low delay. 778 */ 779 #define AV_CODEC_FLAG_LOW_DELAY (1 << 19) 780 /** 781 * Place global headers in extradata instead of every keyframe. 782 */ 783 #define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22) 784 /** 785 * Use only bitexact stuff (except (I)DCT). 786 */ 787 #define AV_CODEC_FLAG_BITEXACT (1 << 23) 788 /* Fx : Flag for h263+ extra options */ 789 /** 790 * H.263 advanced intra coding / MPEG-4 AC prediction 791 */ 792 #define AV_CODEC_FLAG_AC_PRED (1 << 24) 793 /** 794 * interlaced motion estimation 795 */ 796 #define AV_CODEC_FLAG_INTERLACED_ME (1 << 29) 797 #define AV_CODEC_FLAG_CLOSED_GOP (1U << 31) 798 799 /** 800 * Allow non spec compliant speedup tricks. 801 */ 802 #define AV_CODEC_FLAG2_FAST (1 << 0) 803 /** 804 * Skip bitstream encoding. 805 */ 806 #define AV_CODEC_FLAG2_NO_OUTPUT (1 << 2) 807 /** 808 * Place global headers at every keyframe instead of in extradata. 809 */ 810 #define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3) 811 812 /** 813 * timecode is in drop frame format. DEPRECATED!!!! 814 */ 815 #define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13) 816 817 /** 818 * Input bitstream might be truncated at a packet boundaries 819 * instead of only at frame boundaries. 820 */ 821 #define AV_CODEC_FLAG2_CHUNKS (1 << 15) 822 /** 823 * Discard cropping information from SPS. 824 */ 825 #define AV_CODEC_FLAG2_IGNORE_CROP (1 << 16) 826 827 /** 828 * Show all frames before the first keyframe 829 */ 830 #define AV_CODEC_FLAG2_SHOW_ALL (1 << 22) 831 /** 832 * Export motion vectors through frame side data 833 */ 834 #define AV_CODEC_FLAG2_EXPORT_MVS (1 << 28) 835 /** 836 * Do not skip samples and export skip information as frame side data 837 */ 838 #define AV_CODEC_FLAG2_SKIP_MANUAL (1 << 29) 839 840 /* Unsupported options : 841 * Syntax Arithmetic coding (SAC) 842 * Reference Picture Selection 843 * Independent Segment Decoding */ 844 /* /Fx */ 845 /* codec capabilities */ 846 847 /** 848 * Decoder can use draw_horiz_band callback. 849 */ 850 #define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0) 851 /** 852 * Codec uses get_buffer() for allocating buffers and supports custom allocators. 853 * If not set, it might not use get_buffer() at all or use operations that 854 * assume the buffer was allocated by avcodec_default_get_buffer. 855 */ 856 #define AV_CODEC_CAP_DR1 (1 << 1) 857 #define AV_CODEC_CAP_TRUNCATED (1 << 3) 858 /** 859 * Encoder or decoder requires flushing with NULL input at the end in order to 860 * give the complete and correct output. 861 * 862 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with 863 * with NULL data. The user can still send NULL data to the public encode 864 * or decode function, but libavcodec will not pass it along to the codec 865 * unless this flag is set. 866 * 867 * Decoders: 868 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL, 869 * avpkt->size=0 at the end to get the delayed data until the decoder no longer 870 * returns frames. 871 * 872 * Encoders: 873 * The encoder needs to be fed with NULL data at the end of encoding until the 874 * encoder no longer returns data. 875 * 876 * NOTE: For encoders implementing the AVCodec.encode2() function, setting this 877 * flag also means that the encoder must set the pts and duration for 878 * each output packet. If this flag is not set, the pts and duration will 879 * be determined by libavcodec from the input frame. 880 */ 881 #define AV_CODEC_CAP_DELAY (1 << 5) 882 /** 883 * Codec can be fed a final frame with a smaller size. 884 * This can be used to prevent truncation of the last audio samples. 885 */ 886 #define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6) 887 888 #if FF_API_CAP_VDPAU 889 /** 890 * Codec can export data for HW decoding (VDPAU). 891 */ 892 #define AV_CODEC_CAP_HWACCEL_VDPAU (1 << 7) 893 #endif 894 895 /** 896 * Codec can output multiple frames per AVPacket 897 * Normally demuxers return one frame at a time, demuxers which do not do 898 * are connected to a parser to split what they return into proper frames. 899 * This flag is reserved to the very rare category of codecs which have a 900 * bitstream that cannot be split into frames without timeconsuming 901 * operations like full decoding. Demuxers carring such bitstreams thus 902 * may return multiple frames in a packet. This has many disadvantages like 903 * prohibiting stream copy in many cases thus it should only be considered 904 * as a last resort. 905 */ 906 #define AV_CODEC_CAP_SUBFRAMES (1 << 8) 907 /** 908 * Codec is experimental and is thus avoided in favor of non experimental 909 * encoders 910 */ 911 #define AV_CODEC_CAP_EXPERIMENTAL (1 << 9) 912 /** 913 * Codec should fill in channel configuration and samplerate instead of container 914 */ 915 #define AV_CODEC_CAP_CHANNEL_CONF (1 << 10) 916 /** 917 * Codec supports frame-level multithreading. 918 */ 919 #define AV_CODEC_CAP_FRAME_THREADS (1 << 12) 920 /** 921 * Codec supports slice-based (or partition-based) multithreading. 922 */ 923 #define AV_CODEC_CAP_SLICE_THREADS (1 << 13) 924 /** 925 * Codec supports changed parameters at any point. 926 */ 927 #define AV_CODEC_CAP_PARAM_CHANGE (1 << 14) 928 /** 929 * Codec supports avctx->thread_count == 0 (auto). 930 */ 931 #define AV_CODEC_CAP_AUTO_THREADS (1 << 15) 932 /** 933 * Audio encoder supports receiving a different number of samples in each call. 934 */ 935 #define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16) 936 /** 937 * Codec is intra only. 938 */ 939 #define AV_CODEC_CAP_INTRA_ONLY 0x40000000 940 /** 941 * Codec is lossless. 942 */ 943 #define AV_CODEC_CAP_LOSSLESS 0x80000000 944 945 946 #if FF_API_WITHOUT_PREFIX 947 /** 948 * Allow decoders to produce frames with data planes that are not aligned 949 * to CPU requirements (e.g. due to cropping). 950 */ 951 #define CODEC_FLAG_UNALIGNED AV_CODEC_FLAG_UNALIGNED 952 #define CODEC_FLAG_QSCALE AV_CODEC_FLAG_QSCALE 953 #define CODEC_FLAG_4MV AV_CODEC_FLAG_4MV 954 #define CODEC_FLAG_OUTPUT_CORRUPT AV_CODEC_FLAG_OUTPUT_CORRUPT 955 #define CODEC_FLAG_QPEL AV_CODEC_FLAG_QPEL 956 #if FF_API_GMC 957 /** 958 * @deprecated use the "gmc" private option of the libxvid encoder 959 */ 960 #define CODEC_FLAG_GMC 0x0020 ///< Use GMC. 961 #endif 962 #if FF_API_MV0 963 /** 964 * @deprecated use the flag "mv0" in the "mpv_flags" private option of the 965 * mpegvideo encoders 966 */ 967 #define CODEC_FLAG_MV0 0x0040 968 #endif 969 #if FF_API_INPUT_PRESERVED 970 /** 971 * @deprecated passing reference-counted frames to the encoders replaces this 972 * flag 973 */ 974 #define CODEC_FLAG_INPUT_PRESERVED 0x0100 975 #endif 976 #define CODEC_FLAG_PASS1 AV_CODEC_FLAG_PASS1 977 #define CODEC_FLAG_PASS2 AV_CODEC_FLAG_PASS2 978 #define CODEC_FLAG_GRAY AV_CODEC_FLAG_GRAY 979 #if FF_API_EMU_EDGE 980 /** 981 * @deprecated edges are not used/required anymore. I.e. this flag is now always 982 * set. 983 */ 984 #define CODEC_FLAG_EMU_EDGE 0x4000 985 #endif 986 #define CODEC_FLAG_PSNR AV_CODEC_FLAG_PSNR 987 #define CODEC_FLAG_TRUNCATED AV_CODEC_FLAG_TRUNCATED 988 989 #if FF_API_NORMALIZE_AQP 990 /** 991 * @deprecated use the flag "naq" in the "mpv_flags" private option of the 992 * mpegvideo encoders 993 */ 994 #define CODEC_FLAG_NORMALIZE_AQP 0x00020000 995 #endif 996 #define CODEC_FLAG_INTERLACED_DCT AV_CODEC_FLAG_INTERLACED_DCT 997 #define CODEC_FLAG_LOW_DELAY AV_CODEC_FLAG_LOW_DELAY 998 #define CODEC_FLAG_GLOBAL_HEADER AV_CODEC_FLAG_GLOBAL_HEADER 999 #define CODEC_FLAG_BITEXACT AV_CODEC_FLAG_BITEXACT 1000 #define CODEC_FLAG_AC_PRED AV_CODEC_FLAG_AC_PRED 1001 #define CODEC_FLAG_LOOP_FILTER AV_CODEC_FLAG_LOOP_FILTER 1002 #define CODEC_FLAG_INTERLACED_ME AV_CODEC_FLAG_INTERLACED_ME 1003 #define CODEC_FLAG_CLOSED_GOP AV_CODEC_FLAG_CLOSED_GOP 1004 #define CODEC_FLAG2_FAST AV_CODEC_FLAG2_FAST 1005 #define CODEC_FLAG2_NO_OUTPUT AV_CODEC_FLAG2_NO_OUTPUT 1006 #define CODEC_FLAG2_LOCAL_HEADER AV_CODEC_FLAG2_LOCAL_HEADER 1007 #define CODEC_FLAG2_DROP_FRAME_TIMECODE AV_CODEC_FLAG2_DROP_FRAME_TIMECODE 1008 #define CODEC_FLAG2_IGNORE_CROP AV_CODEC_FLAG2_IGNORE_CROP 1009 1010 #define CODEC_FLAG2_CHUNKS AV_CODEC_FLAG2_CHUNKS 1011 #define CODEC_FLAG2_SHOW_ALL AV_CODEC_FLAG2_SHOW_ALL 1012 #define CODEC_FLAG2_EXPORT_MVS AV_CODEC_FLAG2_EXPORT_MVS 1013 #define CODEC_FLAG2_SKIP_MANUAL AV_CODEC_FLAG2_SKIP_MANUAL 1014 1015 /* Unsupported options : 1016 * Syntax Arithmetic coding (SAC) 1017 * Reference Picture Selection 1018 * Independent Segment Decoding */ 1019 /* /Fx */ 1020 /* codec capabilities */ 1021 1022 #define CODEC_CAP_DRAW_HORIZ_BAND AV_CODEC_CAP_DRAW_HORIZ_BAND ///< Decoder can use draw_horiz_band callback. 1023 /** 1024 * Codec uses get_buffer() for allocating buffers and supports custom allocators. 1025 * If not set, it might not use get_buffer() at all or use operations that 1026 * assume the buffer was allocated by avcodec_default_get_buffer. 1027 */ 1028 #define CODEC_CAP_DR1 AV_CODEC_CAP_DR1 1029 #define CODEC_CAP_TRUNCATED AV_CODEC_CAP_TRUNCATED 1030 #if FF_API_XVMC 1031 /* Codec can export data for HW decoding. This flag indicates that 1032 * the codec would call get_format() with list that might contain HW accelerated 1033 * pixel formats (XvMC, VDPAU, VAAPI, etc). The application can pick any of them 1034 * including raw image format. 1035 * The application can use the passed context to determine bitstream version, 1036 * chroma format, resolution etc. 1037 */ 1038 #define CODEC_CAP_HWACCEL 0x0010 1039 #endif /* FF_API_XVMC */ 1040 /** 1041 * Encoder or decoder requires flushing with NULL input at the end in order to 1042 * give the complete and correct output. 1043 * 1044 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with 1045 * with NULL data. The user can still send NULL data to the public encode 1046 * or decode function, but libavcodec will not pass it along to the codec 1047 * unless this flag is set. 1048 * 1049 * Decoders: 1050 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL, 1051 * avpkt->size=0 at the end to get the delayed data until the decoder no longer 1052 * returns frames. 1053 * 1054 * Encoders: 1055 * The encoder needs to be fed with NULL data at the end of encoding until the 1056 * encoder no longer returns data. 1057 * 1058 * NOTE: For encoders implementing the AVCodec.encode2() function, setting this 1059 * flag also means that the encoder must set the pts and duration for 1060 * each output packet. If this flag is not set, the pts and duration will 1061 * be determined by libavcodec from the input frame. 1062 */ 1063 #define CODEC_CAP_DELAY AV_CODEC_CAP_DELAY 1064 /** 1065 * Codec can be fed a final frame with a smaller size. 1066 * This can be used to prevent truncation of the last audio samples. 1067 */ 1068 #define CODEC_CAP_SMALL_LAST_FRAME AV_CODEC_CAP_SMALL_LAST_FRAME 1069 #if FF_API_CAP_VDPAU 1070 /** 1071 * Codec can export data for HW decoding (VDPAU). 1072 */ 1073 #define CODEC_CAP_HWACCEL_VDPAU AV_CODEC_CAP_HWACCEL_VDPAU 1074 #endif 1075 /** 1076 * Codec can output multiple frames per AVPacket 1077 * Normally demuxers return one frame at a time, demuxers which do not do 1078 * are connected to a parser to split what they return into proper frames. 1079 * This flag is reserved to the very rare category of codecs which have a 1080 * bitstream that cannot be split into frames without timeconsuming 1081 * operations like full decoding. Demuxers carring such bitstreams thus 1082 * may return multiple frames in a packet. This has many disadvantages like 1083 * prohibiting stream copy in many cases thus it should only be considered 1084 * as a last resort. 1085 */ 1086 #define CODEC_CAP_SUBFRAMES AV_CODEC_CAP_SUBFRAMES 1087 /** 1088 * Codec is experimental and is thus avoided in favor of non experimental 1089 * encoders 1090 */ 1091 #define CODEC_CAP_EXPERIMENTAL AV_CODEC_CAP_EXPERIMENTAL 1092 /** 1093 * Codec should fill in channel configuration and samplerate instead of container 1094 */ 1095 #define CODEC_CAP_CHANNEL_CONF AV_CODEC_CAP_CHANNEL_CONF 1096 #if FF_API_NEG_LINESIZES 1097 /** 1098 * @deprecated no codecs use this capability 1099 */ 1100 #define CODEC_CAP_NEG_LINESIZES 0x0800 1101 #endif 1102 /** 1103 * Codec supports frame-level multithreading. 1104 */ 1105 #define CODEC_CAP_FRAME_THREADS AV_CODEC_CAP_FRAME_THREADS 1106 /** 1107 * Codec supports slice-based (or partition-based) multithreading. 1108 */ 1109 #define CODEC_CAP_SLICE_THREADS AV_CODEC_CAP_SLICE_THREADS 1110 /** 1111 * Codec supports changed parameters at any point. 1112 */ 1113 #define CODEC_CAP_PARAM_CHANGE AV_CODEC_CAP_PARAM_CHANGE 1114 /** 1115 * Codec supports avctx->thread_count == 0 (auto). 1116 */ 1117 #define CODEC_CAP_AUTO_THREADS AV_CODEC_CAP_AUTO_THREADS 1118 /** 1119 * Audio encoder supports receiving a different number of samples in each call. 1120 */ 1121 #define CODEC_CAP_VARIABLE_FRAME_SIZE AV_CODEC_CAP_VARIABLE_FRAME_SIZE 1122 /** 1123 * Codec is intra only. 1124 */ 1125 #define CODEC_CAP_INTRA_ONLY AV_CODEC_CAP_INTRA_ONLY 1126 /** 1127 * Codec is lossless. 1128 */ 1129 #define CODEC_CAP_LOSSLESS AV_CODEC_CAP_LOSSLESS 1130 1131 /** 1132 * HWAccel is experimental and is thus avoided in favor of non experimental 1133 * codecs 1134 */ 1135 #define HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200 1136 #endif /* FF_API_WITHOUT_PREFIX */ 1137 1138 #if FF_API_MB_TYPE 1139 //The following defines may change, don't expect compatibility if you use them. 1140 #define MB_TYPE_INTRA4x4 0x0001 1141 #define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific 1142 #define MB_TYPE_INTRA_PCM 0x0004 //FIXME H.264-specific 1143 #define MB_TYPE_16x16 0x0008 1144 #define MB_TYPE_16x8 0x0010 1145 #define MB_TYPE_8x16 0x0020 1146 #define MB_TYPE_8x8 0x0040 1147 #define MB_TYPE_INTERLACED 0x0080 1148 #define MB_TYPE_DIRECT2 0x0100 //FIXME 1149 #define MB_TYPE_ACPRED 0x0200 1150 #define MB_TYPE_GMC 0x0400 1151 #define MB_TYPE_SKIP 0x0800 1152 #define MB_TYPE_P0L0 0x1000 1153 #define MB_TYPE_P1L0 0x2000 1154 #define MB_TYPE_P0L1 0x4000 1155 #define MB_TYPE_P1L1 0x8000 1156 #define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0) 1157 #define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1) 1158 #define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1) 1159 #define MB_TYPE_QUANT 0x00010000 1160 #define MB_TYPE_CBP 0x00020000 1161 //Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...) 1162 #endif 1163 1164 /** 1165 * Pan Scan area. 1166 * This specifies the area which should be displayed. 1167 * Note there may be multiple such areas for one frame. 1168 */ 1169 typedef struct AVPanScan{ 1170 /** 1171 * id 1172 * - encoding: Set by user. 1173 * - decoding: Set by libavcodec. 1174 */ 1175 int id; 1176 1177 /** 1178 * width and height in 1/16 pel 1179 * - encoding: Set by user. 1180 * - decoding: Set by libavcodec. 1181 */ 1182 int width; 1183 int height; 1184 1185 /** 1186 * position of the top left corner in 1/16 pel for up to 3 fields/frames 1187 * - encoding: Set by user. 1188 * - decoding: Set by libavcodec. 1189 */ 1190 int16_t position[3][2]; 1191 }AVPanScan; 1192 1193 /** 1194 * This structure describes the bitrate properties of an encoded bitstream. It 1195 * roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD 1196 * parameters for H.264/HEVC. 1197 */ 1198 typedef struct AVCPBProperties { 1199 /** 1200 * Maximum bitrate of the stream, in bits per second. 1201 * Zero if unknown or unspecified. 1202 */ 1203 int max_bitrate; 1204 /** 1205 * Minimum bitrate of the stream, in bits per second. 1206 * Zero if unknown or unspecified. 1207 */ 1208 int min_bitrate; 1209 /** 1210 * Average bitrate of the stream, in bits per second. 1211 * Zero if unknown or unspecified. 1212 */ 1213 int avg_bitrate; 1214 1215 /** 1216 * The size of the buffer to which the ratecontrol is applied, in bits. 1217 * Zero if unknown or unspecified. 1218 */ 1219 int buffer_size; 1220 1221 /** 1222 * The delay between the time the packet this structure is associated with 1223 * is received and the time when it should be decoded, in periods of a 27MHz 1224 * clock. 1225 * 1226 * UINT64_MAX when unknown or unspecified. 1227 */ 1228 uint64_t vbv_delay; 1229 } AVCPBProperties; 1230 1231 #if FF_API_QSCALE_TYPE 1232 #define FF_QSCALE_TYPE_MPEG1 0 1233 #define FF_QSCALE_TYPE_MPEG2 1 1234 #define FF_QSCALE_TYPE_H264 2 1235 #define FF_QSCALE_TYPE_VP56 3 1236 #endif 1237 1238 /** 1239 * The decoder will keep a reference to the frame and may reuse it later. 1240 */ 1241 #define AV_GET_BUFFER_FLAG_REF (1 << 0) 1242 1243 /** 1244 * @defgroup lavc_packet AVPacket 1245 * 1246 * Types and functions for working with AVPacket. 1247 * @{ 1248 */ 1249 enum AVPacketSideDataType { 1250 AV_PKT_DATA_PALETTE, 1251 AV_PKT_DATA_NEW_EXTRADATA, 1252 1253 /** 1254 * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows: 1255 * @code 1256 * u32le param_flags 1257 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) 1258 * s32le channel_count 1259 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) 1260 * u64le channel_layout 1261 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) 1262 * s32le sample_rate 1263 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) 1264 * s32le width 1265 * s32le height 1266 * @endcode 1267 */ 1268 AV_PKT_DATA_PARAM_CHANGE, 1269 1270 /** 1271 * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of 1272 * structures with info about macroblocks relevant to splitting the 1273 * packet into smaller packets on macroblock edges (e.g. as for RFC 2190). 1274 * That is, it does not necessarily contain info about all macroblocks, 1275 * as long as the distance between macroblocks in the info is smaller 1276 * than the target payload size. 1277 * Each MB info structure is 12 bytes, and is laid out as follows: 1278 * @code 1279 * u32le bit offset from the start of the packet 1280 * u8 current quantizer at the start of the macroblock 1281 * u8 GOB number 1282 * u16le macroblock address within the GOB 1283 * u8 horizontal MV predictor 1284 * u8 vertical MV predictor 1285 * u8 horizontal MV predictor for block number 3 1286 * u8 vertical MV predictor for block number 3 1287 * @endcode 1288 */ 1289 AV_PKT_DATA_H263_MB_INFO, 1290 1291 /** 1292 * This side data should be associated with an audio stream and contains 1293 * ReplayGain information in form of the AVReplayGain struct. 1294 */ 1295 AV_PKT_DATA_REPLAYGAIN, 1296 1297 /** 1298 * This side data contains a 3x3 transformation matrix describing an affine 1299 * transformation that needs to be applied to the decoded video frames for 1300 * correct presentation. 1301 * 1302 * See libavutil/display.h for a detailed description of the data. 1303 */ 1304 AV_PKT_DATA_DISPLAYMATRIX, 1305 1306 /** 1307 * This side data should be associated with a video stream and contains 1308 * Stereoscopic 3D information in form of the AVStereo3D struct. 1309 */ 1310 AV_PKT_DATA_STEREO3D, 1311 1312 /** 1313 * This side data should be associated with an audio stream and corresponds 1314 * to enum AVAudioServiceType. 1315 */ 1316 AV_PKT_DATA_AUDIO_SERVICE_TYPE, 1317 1318 /** 1319 * This side data contains quality related information from the encoder. 1320 * @code 1321 * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad). 1322 * u8 picture type 1323 * u8 error count 1324 * u16 reserved 1325 * u64le[error count] sum of squared differences between encoder in and output 1326 * @endcode 1327 */ 1328 AV_PKT_DATA_QUALITY_STATS, 1329 1330 /** 1331 * This side data contains an integer value representing the stream index 1332 * of a "fallback" track. A fallback track indicates an alternate 1333 * track to use when the current track can not be decoded for some reason. 1334 * e.g. no decoder available for codec. 1335 */ 1336 AV_PKT_DATA_FALLBACK_TRACK, 1337 1338 /** 1339 * This side data corresponds to the AVCPBProperties struct. 1340 */ 1341 AV_PKT_DATA_CPB_PROPERTIES, 1342 1343 /** 1344 * Recommmends skipping the specified number of samples 1345 * @code 1346 * u32le number of samples to skip from start of this packet 1347 * u32le number of samples to skip from end of this packet 1348 * u8 reason for start skip 1349 * u8 reason for end skip (0=padding silence, 1=convergence) 1350 * @endcode 1351 */ 1352 AV_PKT_DATA_SKIP_SAMPLES=70, 1353 1354 /** 1355 * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that 1356 * the packet may contain "dual mono" audio specific to Japanese DTV 1357 * and if it is true, recommends only the selected channel to be used. 1358 * @code 1359 * u8 selected channels (0=mail/left, 1=sub/right, 2=both) 1360 * @endcode 1361 */ 1362 AV_PKT_DATA_JP_DUALMONO, 1363 1364 /** 1365 * A list of zero terminated key/value strings. There is no end marker for 1366 * the list, so it is required to rely on the side data size to stop. 1367 */ 1368 AV_PKT_DATA_STRINGS_METADATA, 1369 1370 /** 1371 * Subtitle event position 1372 * @code 1373 * u32le x1 1374 * u32le y1 1375 * u32le x2 1376 * u32le y2 1377 * @endcode 1378 */ 1379 AV_PKT_DATA_SUBTITLE_POSITION, 1380 1381 /** 1382 * Data found in BlockAdditional element of matroska container. There is 1383 * no end marker for the data, so it is required to rely on the side data 1384 * size to recognize the end. 8 byte id (as found in BlockAddId) followed 1385 * by data. 1386 */ 1387 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, 1388 1389 /** 1390 * The optional first identifier line of a WebVTT cue. 1391 */ 1392 AV_PKT_DATA_WEBVTT_IDENTIFIER, 1393 1394 /** 1395 * The optional settings (rendering instructions) that immediately 1396 * follow the timestamp specifier of a WebVTT cue. 1397 */ 1398 AV_PKT_DATA_WEBVTT_SETTINGS, 1399 1400 /** 1401 * A list of zero terminated key/value strings. There is no end marker for 1402 * the list, so it is required to rely on the side data size to stop. This 1403 * side data includes updated metadata which appeared in the stream. 1404 */ 1405 AV_PKT_DATA_METADATA_UPDATE, 1406 }; 1407 1408 #define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED 1409 1410 typedef struct AVPacketSideData { 1411 uint8_t *data; 1412 int size; 1413 enum AVPacketSideDataType type; 1414 } AVPacketSideData; 1415 1416 /** 1417 * This structure stores compressed data. It is typically exported by demuxers 1418 * and then passed as input to decoders, or received as output from encoders and 1419 * then passed to muxers. 1420 * 1421 * For video, it should typically contain one compressed frame. For audio it may 1422 * contain several compressed frames. Encoders are allowed to output empty 1423 * packets, with no compressed data, containing only side data 1424 * (e.g. to update some stream parameters at the end of encoding). 1425 * 1426 * AVPacket is one of the few structs in FFmpeg, whose size is a part of public 1427 * ABI. Thus it may be allocated on stack and no new fields can be added to it 1428 * without libavcodec and libavformat major bump. 1429 * 1430 * The semantics of data ownership depends on the buf field. 1431 * If it is set, the packet data is dynamically allocated and is 1432 * valid indefinitely until a call to av_packet_unref() reduces the 1433 * reference count to 0. 1434 * 1435 * If the buf field is not set av_packet_ref() would make a copy instead 1436 * of increasing the reference count. 1437 * 1438 * The side data is always allocated with av_malloc(), copied by 1439 * av_packet_ref() and freed by av_packet_unref(). 1440 * 1441 * @see av_packet_ref 1442 * @see av_packet_unref 1443 */ 1444 typedef struct AVPacket { 1445 /** 1446 * A reference to the reference-counted buffer where the packet data is 1447 * stored. 1448 * May be NULL, then the packet data is not reference-counted. 1449 */ 1450 AVBufferRef *buf; 1451 /** 1452 * Presentation timestamp in AVStream->time_base units; the time at which 1453 * the decompressed packet will be presented to the user. 1454 * Can be AV_NOPTS_VALUE if it is not stored in the file. 1455 * pts MUST be larger or equal to dts as presentation cannot happen before 1456 * decompression, unless one wants to view hex dumps. Some formats misuse 1457 * the terms dts and pts/cts to mean something different. Such timestamps 1458 * must be converted to true pts/dts before they are stored in AVPacket. 1459 */ 1460 int64_t pts; 1461 /** 1462 * Decompression timestamp in AVStream->time_base units; the time at which 1463 * the packet is decompressed. 1464 * Can be AV_NOPTS_VALUE if it is not stored in the file. 1465 */ 1466 int64_t dts; 1467 uint8_t *data; 1468 int size; 1469 int stream_index; 1470 /** 1471 * A combination of AV_PKT_FLAG values 1472 */ 1473 int flags; 1474 /** 1475 * Additional packet data that can be provided by the container. 1476 * Packet can contain several types of side information. 1477 */ 1478 AVPacketSideData *side_data; 1479 int side_data_elems; 1480 1481 /** 1482 * Duration of this packet in AVStream->time_base units, 0 if unknown. 1483 * Equals next_pts - this_pts in presentation order. 1484 */ 1485 int64_t duration; 1486 1487 int64_t pos; ///< byte position in stream, -1 if unknown 1488 1489 #if FF_API_CONVERGENCE_DURATION 1490 /** 1491 * @deprecated Same as the duration field, but as int64_t. This was required 1492 * for Matroska subtitles, whose duration values could overflow when the 1493 * duration field was still an int. 1494 */ 1495 attribute_deprecated 1496 int64_t convergence_duration; 1497 #endif 1498 } AVPacket; 1499 #define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe 1500 #define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted 1501 1502 enum AVSideDataParamChangeFlags { 1503 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001, 1504 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002, 1505 AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004, 1506 AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008, 1507 }; 1508 /** 1509 * @} 1510 */ 1511 1512 struct AVCodecInternal; 1513 1514 enum AVFieldOrder { 1515 AV_FIELD_UNKNOWN, 1516 AV_FIELD_PROGRESSIVE, 1517 AV_FIELD_TT, //< Top coded_first, top displayed first 1518 AV_FIELD_BB, //< Bottom coded first, bottom displayed first 1519 AV_FIELD_TB, //< Top coded first, bottom displayed first 1520 AV_FIELD_BT, //< Bottom coded first, top displayed first 1521 }; 1522 1523 /** 1524 * main external API structure. 1525 * New fields can be added to the end with minor version bumps. 1526 * Removal, reordering and changes to existing fields require a major 1527 * version bump. 1528 * Please use AVOptions (av_opt* / av_set/get*()) to access these fields from user 1529 * applications. 1530 * sizeof(AVCodecContext) must not be used outside libav*. 1531 */ 1532 typedef struct AVCodecContext { 1533 /** 1534 * information on struct for av_log 1535 * - set by avcodec_alloc_context3 1536 */ 1537 const AVClass *av_class; 1538 int log_level_offset; 1539 1540 enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */ 1541 const struct AVCodec *codec; 1542 #if FF_API_CODEC_NAME 1543 /** 1544 * @deprecated this field is not used for anything in libavcodec 1545 */ 1546 attribute_deprecated 1547 char codec_name[32]; 1548 #endif 1549 enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */ 1550 1551 /** 1552 * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). 1553 * This is used to work around some encoder bugs. 1554 * A demuxer should set this to what is stored in the field used to identify the codec. 1555 * If there are multiple such fields in a container then the demuxer should choose the one 1556 * which maximizes the information about the used codec. 1557 * If the codec tag field in a container is larger than 32 bits then the demuxer should 1558 * remap the longer ID to 32 bits with a table or other structure. Alternatively a new 1559 * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated 1560 * first. 1561 * - encoding: Set by user, if not then the default based on codec_id will be used. 1562 * - decoding: Set by user, will be converted to uppercase by libavcodec during init. 1563 */ 1564 unsigned int codec_tag; 1565 1566 #if FF_API_STREAM_CODEC_TAG 1567 /** 1568 * @deprecated this field is unused 1569 */ 1570 attribute_deprecated 1571 unsigned int stream_codec_tag; 1572 #endif 1573 1574 void *priv_data; 1575 1576 /** 1577 * Private context used for internal data. 1578 * 1579 * Unlike priv_data, this is not codec-specific. It is used in general 1580 * libavcodec functions. 1581 */ 1582 struct AVCodecInternal *internal; 1583 1584 /** 1585 * Private data of the user, can be used to carry app specific stuff. 1586 * - encoding: Set by user. 1587 * - decoding: Set by user. 1588 */ 1589 void *opaque; 1590 1591 /** 1592 * the average bitrate 1593 * - encoding: Set by user; unused for constant quantizer encoding. 1594 * - decoding: Set by user, may be overwritten by libavcodec 1595 * if this info is available in the stream 1596 */ 1597 int64_t bit_rate; 1598 1599 /** 1600 * number of bits the bitstream is allowed to diverge from the reference. 1601 * the reference can be CBR (for CBR pass1) or VBR (for pass2) 1602 * - encoding: Set by user; unused for constant quantizer encoding. 1603 * - decoding: unused 1604 */ 1605 int bit_rate_tolerance; 1606 1607 /** 1608 * Global quality for codecs which cannot change it per frame. 1609 * This should be proportional to MPEG-1/2/4 qscale. 1610 * - encoding: Set by user. 1611 * - decoding: unused 1612 */ 1613 int global_quality; 1614 1615 /** 1616 * - encoding: Set by user. 1617 * - decoding: unused 1618 */ 1619 int compression_level; 1620 #define FF_COMPRESSION_DEFAULT -1 1621 1622 /** 1623 * AV_CODEC_FLAG_*. 1624 * - encoding: Set by user. 1625 * - decoding: Set by user. 1626 */ 1627 int flags; 1628 1629 /** 1630 * AV_CODEC_FLAG2_* 1631 * - encoding: Set by user. 1632 * - decoding: Set by user. 1633 */ 1634 int flags2; 1635 1636 /** 1637 * some codecs need / can use extradata like Huffman tables. 1638 * mjpeg: Huffman tables 1639 * rv10: additional flags 1640 * mpeg4: global headers (they can be in the bitstream or here) 1641 * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger 1642 * than extradata_size to avoid problems if it is read with the bitstream reader. 1643 * The bytewise contents of extradata must not depend on the architecture or CPU endianness. 1644 * - encoding: Set/allocated/freed by libavcodec. 1645 * - decoding: Set/allocated/freed by user. 1646 */ 1647 uint8_t *extradata; 1648 int extradata_size; 1649 1650 /** 1651 * This is the fundamental unit of time (in seconds) in terms 1652 * of which frame timestamps are represented. For fixed-fps content, 1653 * timebase should be 1/framerate and timestamp increments should be 1654 * identically 1. 1655 * This often, but not always is the inverse of the frame rate or field rate 1656 * for video. 1657 * - encoding: MUST be set by user. 1658 * - decoding: the use of this field for decoding is deprecated. 1659 * Use framerate instead. 1660 */ 1661 AVRational time_base; 1662 1663 /** 1664 * For some codecs, the time base is closer to the field rate than the frame rate. 1665 * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration 1666 * if no telecine is used ... 1667 * 1668 * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2. 1669 */ 1670 int ticks_per_frame; 1671 1672 /** 1673 * Codec delay. 1674 * 1675 * Encoding: Number of frames delay there will be from the encoder input to 1676 * the decoder output. (we assume the decoder matches the spec) 1677 * Decoding: Number of frames delay in addition to what a standard decoder 1678 * as specified in the spec would produce. 1679 * 1680 * Video: 1681 * Number of frames the decoded output will be delayed relative to the 1682 * encoded input. 1683 * 1684 * Audio: 1685 * For encoding, this field is unused (see initial_padding). 1686 * 1687 * For decoding, this is the number of samples the decoder needs to 1688 * output before the decoder's output is valid. When seeking, you should 1689 * start decoding this many samples prior to your desired seek point. 1690 * 1691 * - encoding: Set by libavcodec. 1692 * - decoding: Set by libavcodec. 1693 */ 1694 int delay; 1695 1696 1697 /* video only */ 1698 /** 1699 * picture width / height. 1700 * 1701 * @note Those fields may not match the values of the last 1702 * AVFrame outputted by avcodec_decode_video2 due frame 1703 * reordering. 1704 * 1705 * - encoding: MUST be set by user. 1706 * - decoding: May be set by the user before opening the decoder if known e.g. 1707 * from the container. Some decoders will require the dimensions 1708 * to be set by the caller. During decoding, the decoder may 1709 * overwrite those values as required while parsing the data. 1710 */ 1711 int width, height; 1712 1713 /** 1714 * Bitstream width / height, may be different from width/height e.g. when 1715 * the decoded frame is cropped before being output or lowres is enabled. 1716 * 1717 * @note Those field may not match the value of the last 1718 * AVFrame outputted by avcodec_decode_video2 due frame 1719 * reordering. 1720 * 1721 * - encoding: unused 1722 * - decoding: May be set by the user before opening the decoder if known 1723 * e.g. from the container. During decoding, the decoder may 1724 * overwrite those values as required while parsing the data. 1725 */ 1726 int coded_width, coded_height; 1727 1728 #if FF_API_ASPECT_EXTENDED 1729 #define FF_ASPECT_EXTENDED 15 1730 #endif 1731 1732 /** 1733 * the number of pictures in a group of pictures, or 0 for intra_only 1734 * - encoding: Set by user. 1735 * - decoding: unused 1736 */ 1737 int gop_size; 1738 1739 /** 1740 * Pixel format, see AV_PIX_FMT_xxx. 1741 * May be set by the demuxer if known from headers. 1742 * May be overridden by the decoder if it knows better. 1743 * 1744 * @note This field may not match the value of the last 1745 * AVFrame outputted by avcodec_decode_video2 due frame 1746 * reordering. 1747 * 1748 * - encoding: Set by user. 1749 * - decoding: Set by user if known, overridden by libavcodec while 1750 * parsing the data. 1751 */ 1752 enum AVPixelFormat pix_fmt; 1753 1754 #if FF_API_MOTION_EST 1755 /** 1756 * This option does nothing 1757 * @deprecated use codec private options instead 1758 */ 1759 attribute_deprecated int me_method; 1760 #endif 1761 1762 /** 1763 * If non NULL, 'draw_horiz_band' is called by the libavcodec 1764 * decoder to draw a horizontal band. It improves cache usage. Not 1765 * all codecs can do that. You must check the codec capabilities 1766 * beforehand. 1767 * When multithreading is used, it may be called from multiple threads 1768 * at the same time; threads might draw different parts of the same AVFrame, 1769 * or multiple AVFrames, and there is no guarantee that slices will be drawn 1770 * in order. 1771 * The function is also used by hardware acceleration APIs. 1772 * It is called at least once during frame decoding to pass 1773 * the data needed for hardware render. 1774 * In that mode instead of pixel data, AVFrame points to 1775 * a structure specific to the acceleration API. The application 1776 * reads the structure and can change some fields to indicate progress 1777 * or mark state. 1778 * - encoding: unused 1779 * - decoding: Set by user. 1780 * @param height the height of the slice 1781 * @param y the y position of the slice 1782 * @param type 1->top field, 2->bottom field, 3->frame 1783 * @param offset offset into the AVFrame.data from which the slice should be read 1784 */ 1785 void (*draw_horiz_band)(struct AVCodecContext *s, 1786 const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], 1787 int y, int type, int height); 1788 1789 /** 1790 * callback to negotiate the pixelFormat 1791 * @param fmt is the list of formats which are supported by the codec, 1792 * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality. 1793 * The first is always the native one. 1794 * @note The callback may be called again immediately if initialization for 1795 * the selected (hardware-accelerated) pixel format failed. 1796 * @warning Behavior is undefined if the callback returns a value not 1797 * in the fmt list of formats. 1798 * @return the chosen format 1799 * - encoding: unused 1800 * - decoding: Set by user, if not set the native format will be chosen. 1801 */ 1802 enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt); 1803 1804 /** 1805 * maximum number of B-frames between non-B-frames 1806 * Note: The output will be delayed by max_b_frames+1 relative to the input. 1807 * - encoding: Set by user. 1808 * - decoding: unused 1809 */ 1810 int max_b_frames; 1811 1812 /** 1813 * qscale factor between IP and B-frames 1814 * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset). 1815 * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). 1816 * - encoding: Set by user. 1817 * - decoding: unused 1818 */ 1819 float b_quant_factor; 1820 1821 #if FF_API_RC_STRATEGY 1822 /** @deprecated use codec private option instead */ 1823 attribute_deprecated int rc_strategy; 1824 #define FF_RC_STRATEGY_XVID 1 1825 #endif 1826 1827 #if FF_API_PRIVATE_OPT 1828 /** @deprecated use encoder private options instead */ 1829 attribute_deprecated 1830 int b_frame_strategy; 1831 #endif 1832 1833 /** 1834 * qscale offset between IP and B-frames 1835 * - encoding: Set by user. 1836 * - decoding: unused 1837 */ 1838 float b_quant_offset; 1839 1840 /** 1841 * Size of the frame reordering buffer in the decoder. 1842 * For MPEG-2 it is 1 IPB or 0 low delay IP. 1843 * - encoding: Set by libavcodec. 1844 * - decoding: Set by libavcodec. 1845 */ 1846 int has_b_frames; 1847 1848 #if FF_API_PRIVATE_OPT 1849 /** @deprecated use encoder private options instead */ 1850 attribute_deprecated 1851 int mpeg_quant; 1852 #endif 1853 1854 /** 1855 * qscale factor between P and I-frames 1856 * If > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset). 1857 * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). 1858 * - encoding: Set by user. 1859 * - decoding: unused 1860 */ 1861 float i_quant_factor; 1862 1863 /** 1864 * qscale offset between P and I-frames 1865 * - encoding: Set by user. 1866 * - decoding: unused 1867 */ 1868 float i_quant_offset; 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 * slice count 1907 * - encoding: Set by libavcodec. 1908 * - decoding: Set by user (or 0). 1909 */ 1910 int slice_count; 1911 1912 #if FF_API_PRIVATE_OPT 1913 /** @deprecated use encoder private options instead */ 1914 attribute_deprecated 1915 int prediction_method; 1916 #define FF_PRED_LEFT 0 1917 #define FF_PRED_PLANE 1 1918 #define FF_PRED_MEDIAN 2 1919 #endif 1920 1921 /** 1922 * slice offsets in the frame in bytes 1923 * - encoding: Set/allocated by libavcodec. 1924 * - decoding: Set/allocated by user (or NULL). 1925 */ 1926 int *slice_offset; 1927 1928 /** 1929 * sample aspect ratio (0 if unknown) 1930 * That is the width of a pixel divided by the height of the pixel. 1931 * Numerator and denominator must be relatively prime and smaller than 256 for some video standards. 1932 * - encoding: Set by user. 1933 * - decoding: Set by libavcodec. 1934 */ 1935 AVRational sample_aspect_ratio; 1936 1937 /** 1938 * motion estimation comparison function 1939 * - encoding: Set by user. 1940 * - decoding: unused 1941 */ 1942 int me_cmp; 1943 /** 1944 * subpixel motion estimation comparison function 1945 * - encoding: Set by user. 1946 * - decoding: unused 1947 */ 1948 int me_sub_cmp; 1949 /** 1950 * macroblock comparison function (not supported yet) 1951 * - encoding: Set by user. 1952 * - decoding: unused 1953 */ 1954 int mb_cmp; 1955 /** 1956 * interlaced DCT comparison function 1957 * - encoding: Set by user. 1958 * - decoding: unused 1959 */ 1960 int ildct_cmp; 1961 #define FF_CMP_SAD 0 1962 #define FF_CMP_SSE 1 1963 #define FF_CMP_SATD 2 1964 #define FF_CMP_DCT 3 1965 #define FF_CMP_PSNR 4 1966 #define FF_CMP_BIT 5 1967 #define FF_CMP_RD 6 1968 #define FF_CMP_ZERO 7 1969 #define FF_CMP_VSAD 8 1970 #define FF_CMP_VSSE 9 1971 #define FF_CMP_NSSE 10 1972 #define FF_CMP_W53 11 1973 #define FF_CMP_W97 12 1974 #define FF_CMP_DCTMAX 13 1975 #define FF_CMP_DCT264 14 1976 #define FF_CMP_CHROMA 256 1977 1978 /** 1979 * ME diamond size & shape 1980 * - encoding: Set by user. 1981 * - decoding: unused 1982 */ 1983 int dia_size; 1984 1985 /** 1986 * amount of previous MV predictors (2a+1 x 2a+1 square) 1987 * - encoding: Set by user. 1988 * - decoding: unused 1989 */ 1990 int last_predictor_count; 1991 1992 #if FF_API_PRIVATE_OPT 1993 /** @deprecated use encoder private options instead */ 1994 attribute_deprecated 1995 int pre_me; 1996 #endif 1997 1998 /** 1999 * motion estimation prepass comparison function 2000 * - encoding: Set by user. 2001 * - decoding: unused 2002 */ 2003 int me_pre_cmp; 2004 2005 /** 2006 * ME prepass diamond size & shape 2007 * - encoding: Set by user. 2008 * - decoding: unused 2009 */ 2010 int pre_dia_size; 2011 2012 /** 2013 * subpel ME quality 2014 * - encoding: Set by user. 2015 * - decoding: unused 2016 */ 2017 int me_subpel_quality; 2018 2019 #if FF_API_AFD 2020 /** 2021 * DTG active format information (additional aspect ratio 2022 * information only used in DVB MPEG-2 transport streams) 2023 * 0 if not set. 2024 * 2025 * - encoding: unused 2026 * - decoding: Set by decoder. 2027 * @deprecated Deprecated in favor of AVSideData 2028 */ 2029 attribute_deprecated int dtg_active_format; 2030 #define FF_DTG_AFD_SAME 8 2031 #define FF_DTG_AFD_4_3 9 2032 #define FF_DTG_AFD_16_9 10 2033 #define FF_DTG_AFD_14_9 11 2034 #define FF_DTG_AFD_4_3_SP_14_9 13 2035 #define FF_DTG_AFD_16_9_SP_14_9 14 2036 #define FF_DTG_AFD_SP_4_3 15 2037 #endif /* FF_API_AFD */ 2038 2039 /** 2040 * maximum motion estimation search range in subpel units 2041 * If 0 then no limit. 2042 * 2043 * - encoding: Set by user. 2044 * - decoding: unused 2045 */ 2046 int me_range; 2047 2048 #if FF_API_QUANT_BIAS 2049 /** 2050 * @deprecated use encoder private option instead 2051 */ 2052 attribute_deprecated int intra_quant_bias; 2053 #define FF_DEFAULT_QUANT_BIAS 999999 2054 2055 /** 2056 * @deprecated use encoder private option instead 2057 */ 2058 attribute_deprecated int inter_quant_bias; 2059 #endif 2060 2061 /** 2062 * slice flags 2063 * - encoding: unused 2064 * - decoding: Set by user. 2065 */ 2066 int slice_flags; 2067 #define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display 2068 #define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG2 field pics) 2069 #define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1) 2070 2071 #if FF_API_XVMC 2072 /** 2073 * XVideo Motion Acceleration 2074 * - encoding: forbidden 2075 * - decoding: set by decoder 2076 * @deprecated XvMC doesn't need it anymore. 2077 */ 2078 attribute_deprecated int xvmc_acceleration; 2079 #endif /* FF_API_XVMC */ 2080 2081 /** 2082 * macroblock decision mode 2083 * - encoding: Set by user. 2084 * - decoding: unused 2085 */ 2086 int mb_decision; 2087 #define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp 2088 #define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits 2089 #define FF_MB_DECISION_RD 2 ///< rate distortion 2090 2091 /** 2092 * custom intra quantization matrix 2093 * - encoding: Set by user, can be NULL. 2094 * - decoding: Set by libavcodec. 2095 */ 2096 uint16_t *intra_matrix; 2097 2098 /** 2099 * custom inter quantization matrix 2100 * - encoding: Set by user, can be NULL. 2101 * - decoding: Set by libavcodec. 2102 */ 2103 uint16_t *inter_matrix; 2104 2105 #if FF_API_PRIVATE_OPT 2106 /** @deprecated use encoder private options instead */ 2107 attribute_deprecated 2108 int scenechange_threshold; 2109 2110 /** @deprecated use encoder private options instead */ 2111 attribute_deprecated 2112 int noise_reduction; 2113 #endif 2114 2115 #if FF_API_MPV_OPT 2116 /** 2117 * @deprecated this field is unused 2118 */ 2119 attribute_deprecated 2120 int me_threshold; 2121 2122 /** 2123 * @deprecated this field is unused 2124 */ 2125 attribute_deprecated 2126 int mb_threshold; 2127 #endif 2128 2129 /** 2130 * precision of the intra DC coefficient - 8 2131 * - encoding: Set by user. 2132 * - decoding: Set by libavcodec 2133 */ 2134 int intra_dc_precision; 2135 2136 /** 2137 * Number of macroblock rows at the top which are skipped. 2138 * - encoding: unused 2139 * - decoding: Set by user. 2140 */ 2141 int skip_top; 2142 2143 /** 2144 * Number of macroblock rows at the bottom which are skipped. 2145 * - encoding: unused 2146 * - decoding: Set by user. 2147 */ 2148 int skip_bottom; 2149 2150 #if FF_API_MPV_OPT 2151 /** 2152 * @deprecated use encoder private options instead 2153 */ 2154 attribute_deprecated 2155 float border_masking; 2156 #endif 2157 2158 /** 2159 * minimum MB lagrange multipler 2160 * - encoding: Set by user. 2161 * - decoding: unused 2162 */ 2163 int mb_lmin; 2164 2165 /** 2166 * maximum MB lagrange multipler 2167 * - encoding: Set by user. 2168 * - decoding: unused 2169 */ 2170 int mb_lmax; 2171 2172 #if FF_API_PRIVATE_OPT 2173 /** 2174 * @deprecated use encoder private options instead 2175 */ 2176 attribute_deprecated 2177 int me_penalty_compensation; 2178 #endif 2179 2180 /** 2181 * 2182 * - encoding: Set by user. 2183 * - decoding: unused 2184 */ 2185 int bidir_refine; 2186 2187 #if FF_API_PRIVATE_OPT 2188 /** @deprecated use encoder private options instead */ 2189 attribute_deprecated 2190 int brd_scale; 2191 #endif 2192 2193 /** 2194 * minimum GOP size 2195 * - encoding: Set by user. 2196 * - decoding: unused 2197 */ 2198 int keyint_min; 2199 2200 /** 2201 * number of reference frames 2202 * - encoding: Set by user. 2203 * - decoding: Set by lavc. 2204 */ 2205 int refs; 2206 2207 #if FF_API_PRIVATE_OPT 2208 /** @deprecated use encoder private options instead */ 2209 attribute_deprecated 2210 int chromaoffset; 2211 #endif 2212 2213 #if FF_API_UNUSED_MEMBERS 2214 /** 2215 * Multiplied by qscale for each frame and added to scene_change_score. 2216 * - encoding: Set by user. 2217 * - decoding: unused 2218 */ 2219 attribute_deprecated int scenechange_factor; 2220 #endif 2221 2222 /** 2223 * 2224 * Note: Value depends upon the compare function used for fullpel ME. 2225 * - encoding: Set by user. 2226 * - decoding: unused 2227 */ 2228 int mv0_threshold; 2229 2230 #if FF_API_PRIVATE_OPT 2231 /** @deprecated use encoder private options instead */ 2232 attribute_deprecated 2233 int b_sensitivity; 2234 #endif 2235 2236 /** 2237 * Chromaticity coordinates of the source primaries. 2238 * - encoding: Set by user 2239 * - decoding: Set by libavcodec 2240 */ 2241 enum AVColorPrimaries color_primaries; 2242 2243 /** 2244 * Color Transfer Characteristic. 2245 * - encoding: Set by user 2246 * - decoding: Set by libavcodec 2247 */ 2248 enum AVColorTransferCharacteristic color_trc; 2249 2250 /** 2251 * YUV colorspace type. 2252 * - encoding: Set by user 2253 * - decoding: Set by libavcodec 2254 */ 2255 enum AVColorSpace colorspace; 2256 2257 /** 2258 * MPEG vs JPEG YUV range. 2259 * - encoding: Set by user 2260 * - decoding: Set by libavcodec 2261 */ 2262 enum AVColorRange color_range; 2263 2264 /** 2265 * This defines the location of chroma samples. 2266 * - encoding: Set by user 2267 * - decoding: Set by libavcodec 2268 */ 2269 enum AVChromaLocation chroma_sample_location; 2270 2271 /** 2272 * Number of slices. 2273 * Indicates number of picture subdivisions. Used for parallelized 2274 * decoding. 2275 * - encoding: Set by user 2276 * - decoding: unused 2277 */ 2278 int slices; 2279 2280 /** Field order 2281 * - encoding: set by libavcodec 2282 * - decoding: Set by user. 2283 */ 2284 enum AVFieldOrder field_order; 2285 2286 /* audio only */ 2287 int sample_rate; ///< samples per second 2288 int channels; ///< number of audio channels 2289 2290 /** 2291 * audio sample format 2292 * - encoding: Set by user. 2293 * - decoding: Set by libavcodec. 2294 */ 2295 enum AVSampleFormat sample_fmt; ///< sample format 2296 2297 /* The following data should not be initialized. */ 2298 /** 2299 * Number of samples per channel in an audio frame. 2300 * 2301 * - encoding: set by libavcodec in avcodec_open2(). Each submitted frame 2302 * except the last must contain exactly frame_size samples per channel. 2303 * May be 0 when the codec has AV_CODEC_CAP_VARIABLE_FRAME_SIZE set, then the 2304 * frame size is not restricted. 2305 * - decoding: may be set by some decoders to indicate constant frame size 2306 */ 2307 int frame_size; 2308 2309 /** 2310 * Frame counter, set by libavcodec. 2311 * 2312 * - decoding: total number of frames returned from the decoder so far. 2313 * - encoding: total number of frames passed to the encoder so far. 2314 * 2315 * @note the counter is not incremented if encoding/decoding resulted in 2316 * an error. 2317 */ 2318 int frame_number; 2319 2320 /** 2321 * number of bytes per packet if constant and known or 0 2322 * Used by some WAV based audio codecs. 2323 */ 2324 int block_align; 2325 2326 /** 2327 * Audio cutoff bandwidth (0 means "automatic") 2328 * - encoding: Set by user. 2329 * - decoding: unused 2330 */ 2331 int cutoff; 2332 2333 /** 2334 * Audio channel layout. 2335 * - encoding: set by user. 2336 * - decoding: set by user, may be overwritten by libavcodec. 2337 */ 2338 uint64_t channel_layout; 2339 2340 /** 2341 * Request decoder to use this channel layout if it can (0 for default) 2342 * - encoding: unused 2343 * - decoding: Set by user. 2344 */ 2345 uint64_t request_channel_layout; 2346 2347 /** 2348 * Type of service that the audio stream conveys. 2349 * - encoding: Set by user. 2350 * - decoding: Set by libavcodec. 2351 */ 2352 enum AVAudioServiceType audio_service_type; 2353 2354 /** 2355 * desired sample format 2356 * - encoding: Not used. 2357 * - decoding: Set by user. 2358 * Decoder will decode to this format if it can. 2359 */ 2360 enum AVSampleFormat request_sample_fmt; 2361 2362 /** 2363 * This callback is called at the beginning of each frame to get data 2364 * buffer(s) for it. There may be one contiguous buffer for all the data or 2365 * there may be a buffer per each data plane or anything in between. What 2366 * this means is, you may set however many entries in buf[] you feel necessary. 2367 * Each buffer must be reference-counted using the AVBuffer API (see description 2368 * of buf[] below). 2369 * 2370 * The following fields will be set in the frame before this callback is 2371 * called: 2372 * - format 2373 * - width, height (video only) 2374 * - sample_rate, channel_layout, nb_samples (audio only) 2375 * Their values may differ from the corresponding values in 2376 * AVCodecContext. This callback must use the frame values, not the codec 2377 * context values, to calculate the required buffer size. 2378 * 2379 * This callback must fill the following fields in the frame: 2380 * - data[] 2381 * - linesize[] 2382 * - extended_data: 2383 * * if the data is planar audio with more than 8 channels, then this 2384 * callback must allocate and fill extended_data to contain all pointers 2385 * to all data planes. data[] must hold as many pointers as it can. 2386 * extended_data must be allocated with av_malloc() and will be freed in 2387 * av_frame_unref(). 2388 * * otherwise exended_data must point to data 2389 * - buf[] must contain one or more pointers to AVBufferRef structures. Each of 2390 * the frame's data and extended_data pointers must be contained in these. That 2391 * is, one AVBufferRef for each allocated chunk of memory, not necessarily one 2392 * AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(), 2393 * and av_buffer_ref(). 2394 * - extended_buf and nb_extended_buf must be allocated with av_malloc() by 2395 * this callback and filled with the extra buffers if there are more 2396 * buffers than buf[] can hold. extended_buf will be freed in 2397 * av_frame_unref(). 2398 * 2399 * If AV_CODEC_CAP_DR1 is not set then get_buffer2() must call 2400 * avcodec_default_get_buffer2() instead of providing buffers allocated by 2401 * some other means. 2402 * 2403 * Each data plane must be aligned to the maximum required by the target 2404 * CPU. 2405 * 2406 * @see avcodec_default_get_buffer2() 2407 * 2408 * Video: 2409 * 2410 * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused 2411 * (read and/or written to if it is writable) later by libavcodec. 2412 * 2413 * avcodec_align_dimensions2() should be used to find the required width and 2414 * height, as they normally need to be rounded up to the next multiple of 16. 2415 * 2416 * Some decoders do not support linesizes changing between frames. 2417 * 2418 * If frame multithreading is used and thread_safe_callbacks is set, 2419 * this callback may be called from a different thread, but not from more 2420 * than one at once. Does not need to be reentrant. 2421 * 2422 * @see avcodec_align_dimensions2() 2423 * 2424 * Audio: 2425 * 2426 * Decoders request a buffer of a particular size by setting 2427 * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may, 2428 * however, utilize only part of the buffer by setting AVFrame.nb_samples 2429 * to a smaller value in the output frame. 2430 * 2431 * As a convenience, av_samples_get_buffer_size() and 2432 * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2() 2433 * functions to find the required data size and to fill data pointers and 2434 * linesize. In AVFrame.linesize, only linesize[0] may be set for audio 2435 * since all planes must be the same size. 2436 * 2437 * @see av_samples_get_buffer_size(), av_samples_fill_arrays() 2438 * 2439 * - encoding: unused 2440 * - decoding: Set by libavcodec, user can override. 2441 */ 2442 int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags); 2443 2444 /** 2445 * If non-zero, the decoded audio and video frames returned from 2446 * avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted 2447 * and are valid indefinitely. The caller must free them with 2448 * av_frame_unref() when they are not needed anymore. 2449 * Otherwise, the decoded frames must not be freed by the caller and are 2450 * only valid until the next decode call. 2451 * 2452 * - encoding: unused 2453 * - decoding: set by the caller before avcodec_open2(). 2454 */ 2455 int refcounted_frames; 2456 2457 /* - encoding parameters */ 2458 float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0) 2459 float qblur; ///< amount of qscale smoothing over time (0.0-1.0) 2460 2461 /** 2462 * minimum quantizer 2463 * - encoding: Set by user. 2464 * - decoding: unused 2465 */ 2466 int qmin; 2467 2468 /** 2469 * maximum quantizer 2470 * - encoding: Set by user. 2471 * - decoding: unused 2472 */ 2473 int qmax; 2474 2475 /** 2476 * maximum quantizer difference between frames 2477 * - encoding: Set by user. 2478 * - decoding: unused 2479 */ 2480 int max_qdiff; 2481 2482 #if FF_API_MPV_OPT 2483 /** 2484 * @deprecated use encoder private options instead 2485 */ 2486 attribute_deprecated 2487 float rc_qsquish; 2488 2489 attribute_deprecated 2490 float rc_qmod_amp; 2491 attribute_deprecated 2492 int rc_qmod_freq; 2493 #endif 2494 2495 /** 2496 * decoder bitstream buffer size 2497 * - encoding: Set by user. 2498 * - decoding: unused 2499 */ 2500 int rc_buffer_size; 2501 2502 /** 2503 * ratecontrol override, see RcOverride 2504 * - encoding: Allocated/set/freed by user. 2505 * - decoding: unused 2506 */ 2507 int rc_override_count; 2508 RcOverride *rc_override; 2509 2510 #if FF_API_MPV_OPT 2511 /** 2512 * @deprecated use encoder private options instead 2513 */ 2514 attribute_deprecated 2515 const char *rc_eq; 2516 #endif 2517 2518 /** 2519 * maximum bitrate 2520 * - encoding: Set by user. 2521 * - decoding: Set by user, may be overwritten by libavcodec. 2522 */ 2523 int64_t rc_max_rate; 2524 2525 /** 2526 * minimum bitrate 2527 * - encoding: Set by user. 2528 * - decoding: unused 2529 */ 2530 int64_t rc_min_rate; 2531 2532 #if FF_API_MPV_OPT 2533 /** 2534 * @deprecated use encoder private options instead 2535 */ 2536 attribute_deprecated 2537 float rc_buffer_aggressivity; 2538 2539 attribute_deprecated 2540 float rc_initial_cplx; 2541 #endif 2542 2543 /** 2544 * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow. 2545 * - encoding: Set by user. 2546 * - decoding: unused. 2547 */ 2548 float rc_max_available_vbv_use; 2549 2550 /** 2551 * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow. 2552 * - encoding: Set by user. 2553 * - decoding: unused. 2554 */ 2555 float rc_min_vbv_overflow_use; 2556 2557 /** 2558 * Number of bits which should be loaded into the rc buffer before decoding starts. 2559 * - encoding: Set by user. 2560 * - decoding: unused 2561 */ 2562 int rc_initial_buffer_occupancy; 2563 2564 #if FF_API_CODER_TYPE 2565 #define FF_CODER_TYPE_VLC 0 2566 #define FF_CODER_TYPE_AC 1 2567 #define FF_CODER_TYPE_RAW 2 2568 #define FF_CODER_TYPE_RLE 3 2569 #if FF_API_UNUSED_MEMBERS 2570 #define FF_CODER_TYPE_DEFLATE 4 2571 #endif /* FF_API_UNUSED_MEMBERS */ 2572 /** 2573 * @deprecated use encoder private options instead 2574 */ 2575 attribute_deprecated 2576 int coder_type; 2577 #endif /* FF_API_CODER_TYPE */ 2578 2579 #if FF_API_PRIVATE_OPT 2580 /** @deprecated use encoder private options instead */ 2581 attribute_deprecated 2582 int context_model; 2583 #endif 2584 2585 #if FF_API_MPV_OPT 2586 /** 2587 * @deprecated use encoder private options instead 2588 */ 2589 attribute_deprecated 2590 int lmin; 2591 2592 /** 2593 * @deprecated use encoder private options instead 2594 */ 2595 attribute_deprecated 2596 int lmax; 2597 #endif 2598 2599 #if FF_API_PRIVATE_OPT 2600 /** @deprecated use encoder private options instead */ 2601 attribute_deprecated 2602 int frame_skip_threshold; 2603 2604 /** @deprecated use encoder private options instead */ 2605 attribute_deprecated 2606 int frame_skip_factor; 2607 2608 /** @deprecated use encoder private options instead */ 2609 attribute_deprecated 2610 int frame_skip_exp; 2611 2612 /** @deprecated use encoder private options instead */ 2613 attribute_deprecated 2614 int frame_skip_cmp; 2615 #endif /* FF_API_PRIVATE_OPT */ 2616 2617 /** 2618 * trellis RD quantization 2619 * - encoding: Set by user. 2620 * - decoding: unused 2621 */ 2622 int trellis; 2623 2624 #if FF_API_PRIVATE_OPT 2625 /** @deprecated use encoder private options instead */ 2626 attribute_deprecated 2627 int min_prediction_order; 2628 2629 /** @deprecated use encoder private options instead */ 2630 attribute_deprecated 2631 int max_prediction_order; 2632 2633 /** @deprecated use encoder private options instead */ 2634 attribute_deprecated 2635 int64_t timecode_frame_start; 2636 #endif 2637 2638 #if FF_API_RTP_CALLBACK 2639 /** 2640 * @deprecated unused 2641 */ 2642 /* The RTP callback: This function is called */ 2643 /* every time the encoder has a packet to send. */ 2644 /* It depends on the encoder if the data starts */ 2645 /* with a Start Code (it should). H.263 does. */ 2646 /* mb_nb contains the number of macroblocks */ 2647 /* encoded in the RTP payload. */ 2648 attribute_deprecated 2649 void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb); 2650 #endif 2651 2652 #if FF_API_PRIVATE_OPT 2653 /** @deprecated use encoder private options instead */ 2654 attribute_deprecated 2655 int rtp_payload_size; /* The size of the RTP payload: the coder will */ 2656 /* do its best to deliver a chunk with size */ 2657 /* below rtp_payload_size, the chunk will start */ 2658 /* with a start code on some codecs like H.263. */ 2659 /* This doesn't take account of any particular */ 2660 /* headers inside the transmitted RTP payload. */ 2661 #endif 2662 2663 #if FF_API_STAT_BITS 2664 /* statistics, used for 2-pass encoding */ 2665 attribute_deprecated 2666 int mv_bits; 2667 attribute_deprecated 2668 int header_bits; 2669 attribute_deprecated 2670 int i_tex_bits; 2671 attribute_deprecated 2672 int p_tex_bits; 2673 attribute_deprecated 2674 int i_count; 2675 attribute_deprecated 2676 int p_count; 2677 attribute_deprecated 2678 int skip_count; 2679 attribute_deprecated 2680 int misc_bits; 2681 2682 /** @deprecated this field is unused */ 2683 attribute_deprecated 2684 int frame_bits; 2685 #endif 2686 2687 /** 2688 * pass1 encoding statistics output buffer 2689 * - encoding: Set by libavcodec. 2690 * - decoding: unused 2691 */ 2692 char *stats_out; 2693 2694 /** 2695 * pass2 encoding statistics input buffer 2696 * Concatenated stuff from stats_out of pass1 should be placed here. 2697 * - encoding: Allocated/set/freed by user. 2698 * - decoding: unused 2699 */ 2700 char *stats_in; 2701 2702 /** 2703 * Work around bugs in encoders which sometimes cannot be detected automatically. 2704 * - encoding: Set by user 2705 * - decoding: Set by user 2706 */ 2707 int workaround_bugs; 2708 #define FF_BUG_AUTODETECT 1 ///< autodetection 2709 #if FF_API_OLD_MSMPEG4 2710 #define FF_BUG_OLD_MSMPEG4 2 2711 #endif 2712 #define FF_BUG_XVID_ILACE 4 2713 #define FF_BUG_UMP4 8 2714 #define FF_BUG_NO_PADDING 16 2715 #define FF_BUG_AMV 32 2716 #if FF_API_AC_VLC 2717 #define FF_BUG_AC_VLC 0 ///< Will be removed, libavcodec can now handle these non-compliant files by default. 2718 #endif 2719 #define FF_BUG_QPEL_CHROMA 64 2720 #define FF_BUG_STD_QPEL 128 2721 #define FF_BUG_QPEL_CHROMA2 256 2722 #define FF_BUG_DIRECT_BLOCKSIZE 512 2723 #define FF_BUG_EDGE 1024 2724 #define FF_BUG_HPEL_CHROMA 2048 2725 #define FF_BUG_DC_CLIP 4096 2726 #define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders. 2727 #define FF_BUG_TRUNCATED 16384 2728 2729 /** 2730 * strictly follow the standard (MPEG4, ...). 2731 * - encoding: Set by user. 2732 * - decoding: Set by user. 2733 * Setting this to STRICT or higher means the encoder and decoder will 2734 * generally do stupid things, whereas setting it to unofficial or lower 2735 * will mean the encoder might produce output that is not supported by all 2736 * spec-compliant decoders. Decoders don't differentiate between normal, 2737 * unofficial and experimental (that is, they always try to decode things 2738 * when they can) unless they are explicitly asked to behave stupidly 2739 * (=strictly conform to the specs) 2740 */ 2741 int strict_std_compliance; 2742 #define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software. 2743 #define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences. 2744 #define FF_COMPLIANCE_NORMAL 0 2745 #define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions 2746 #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things. 2747 2748 /** 2749 * error concealment flags 2750 * - encoding: unused 2751 * - decoding: Set by user. 2752 */ 2753 int error_concealment; 2754 #define FF_EC_GUESS_MVS 1 2755 #define FF_EC_DEBLOCK 2 2756 #define FF_EC_FAVOR_INTER 256 2757 2758 /** 2759 * debug 2760 * - encoding: Set by user. 2761 * - decoding: Set by user. 2762 */ 2763 int debug; 2764 #define FF_DEBUG_PICT_INFO 1 2765 #define FF_DEBUG_RC 2 2766 #define FF_DEBUG_BITSTREAM 4 2767 #define FF_DEBUG_MB_TYPE 8 2768 #define FF_DEBUG_QP 16 2769 #if FF_API_DEBUG_MV 2770 /** 2771 * @deprecated this option does nothing 2772 */ 2773 #define FF_DEBUG_MV 32 2774 #endif 2775 #define FF_DEBUG_DCT_COEFF 0x00000040 2776 #define FF_DEBUG_SKIP 0x00000080 2777 #define FF_DEBUG_STARTCODE 0x00000100 2778 #if FF_API_UNUSED_MEMBERS 2779 #define FF_DEBUG_PTS 0x00000200 2780 #endif /* FF_API_UNUSED_MEMBERS */ 2781 #define FF_DEBUG_ER 0x00000400 2782 #define FF_DEBUG_MMCO 0x00000800 2783 #define FF_DEBUG_BUGS 0x00001000 2784 #if FF_API_DEBUG_MV 2785 #define FF_DEBUG_VIS_QP 0x00002000 ///< only access through AVOptions from outside libavcodec 2786 #define FF_DEBUG_VIS_MB_TYPE 0x00004000 ///< only access through AVOptions from outside libavcodec 2787 #endif 2788 #define FF_DEBUG_BUFFERS 0x00008000 2789 #define FF_DEBUG_THREADS 0x00010000 2790 #define FF_DEBUG_GREEN_MD 0x00800000 2791 #define FF_DEBUG_NOMC 0x01000000 2792 2793 #if FF_API_DEBUG_MV 2794 /** 2795 * debug 2796 * Code outside libavcodec should access this field using AVOptions 2797 * - encoding: Set by user. 2798 * - decoding: Set by user. 2799 */ 2800 int debug_mv; 2801 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames 2802 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames 2803 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames 2804 #endif 2805 2806 /** 2807 * Error recognition; may misdetect some more or less valid parts as errors. 2808 * - encoding: unused 2809 * - decoding: Set by user. 2810 */ 2811 int err_recognition; 2812 2813 /** 2814 * Verify checksums embedded in the bitstream (could be of either encoded or 2815 * decoded data, depending on the codec) and print an error message on mismatch. 2816 * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the 2817 * decoder returning an error. 2818 */ 2819 #define AV_EF_CRCCHECK (1<<0) 2820 #define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations 2821 #define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length 2822 #define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection 2823 2824 #define AV_EF_IGNORE_ERR (1<<15) ///< ignore errors and continue 2825 #define AV_EF_CAREFUL (1<<16) ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors 2826 #define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliances as errors 2827 #define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder should not do as an error 2828 2829 2830 /** 2831 * opaque 64bit number (generally a PTS) that will be reordered and 2832 * output in AVFrame.reordered_opaque 2833 * - encoding: unused 2834 * - decoding: Set by user. 2835 */ 2836 int64_t reordered_opaque; 2837 2838 /** 2839 * Hardware accelerator in use 2840 * - encoding: unused. 2841 * - decoding: Set by libavcodec 2842 */ 2843 struct AVHWAccel *hwaccel; 2844 2845 /** 2846 * Hardware accelerator context. 2847 * For some hardware accelerators, a global context needs to be 2848 * provided by the user. In that case, this holds display-dependent 2849 * data FFmpeg cannot instantiate itself. Please refer to the 2850 * FFmpeg HW accelerator documentation to know how to fill this 2851 * is. e.g. for VA API, this is a struct vaapi_context. 2852 * - encoding: unused 2853 * - decoding: Set by user 2854 */ 2855 void *hwaccel_context; 2856 2857 /** 2858 * error 2859 * - encoding: Set by libavcodec if flags & AV_CODEC_FLAG_PSNR. 2860 * - decoding: unused 2861 */ 2862 uint64_t error[AV_NUM_DATA_POINTERS]; 2863 2864 /** 2865 * DCT algorithm, see FF_DCT_* below 2866 * - encoding: Set by user. 2867 * - decoding: unused 2868 */ 2869 int dct_algo; 2870 #define FF_DCT_AUTO 0 2871 #define FF_DCT_FASTINT 1 2872 #define FF_DCT_INT 2 2873 #define FF_DCT_MMX 3 2874 #define FF_DCT_ALTIVEC 5 2875 #define FF_DCT_FAAN 6 2876 2877 /** 2878 * IDCT algorithm, see FF_IDCT_* below. 2879 * - encoding: Set by user. 2880 * - decoding: Set by user. 2881 */ 2882 int idct_algo; 2883 #define FF_IDCT_AUTO 0 2884 #define FF_IDCT_INT 1 2885 #define FF_IDCT_SIMPLE 2 2886 #define FF_IDCT_SIMPLEMMX 3 2887 #define FF_IDCT_ARM 7 2888 #define FF_IDCT_ALTIVEC 8 2889 #if FF_API_ARCH_SH4 2890 #define FF_IDCT_SH4 9 2891 #endif 2892 #define FF_IDCT_SIMPLEARM 10 2893 #if FF_API_UNUSED_MEMBERS 2894 #define FF_IDCT_IPP 13 2895 #endif /* FF_API_UNUSED_MEMBERS */ 2896 #define FF_IDCT_XVID 14 2897 #if FF_API_IDCT_XVIDMMX 2898 #define FF_IDCT_XVIDMMX 14 2899 #endif /* FF_API_IDCT_XVIDMMX */ 2900 #define FF_IDCT_SIMPLEARMV5TE 16 2901 #define FF_IDCT_SIMPLEARMV6 17 2902 #if FF_API_ARCH_SPARC 2903 #define FF_IDCT_SIMPLEVIS 18 2904 #endif 2905 #define FF_IDCT_FAAN 20 2906 #define FF_IDCT_SIMPLENEON 22 2907 #if FF_API_ARCH_ALPHA 2908 #define FF_IDCT_SIMPLEALPHA 23 2909 #endif 2910 #define FF_IDCT_SIMPLEAUTO 128 2911 2912 /** 2913 * bits per sample/pixel from the demuxer (needed for huffyuv). 2914 * - encoding: Set by libavcodec. 2915 * - decoding: Set by user. 2916 */ 2917 int bits_per_coded_sample; 2918 2919 /** 2920 * Bits per sample/pixel of internal libavcodec pixel/sample format. 2921 * - encoding: set by user. 2922 * - decoding: set by libavcodec. 2923 */ 2924 int bits_per_raw_sample; 2925 2926 #if FF_API_LOWRES 2927 /** 2928 * low resolution decoding, 1-> 1/2 size, 2->1/4 size 2929 * - encoding: unused 2930 * - decoding: Set by user. 2931 * Code outside libavcodec should access this field using: 2932 * av_codec_{get,set}_lowres(avctx) 2933 */ 2934 int lowres; 2935 #endif 2936 2937 #if FF_API_CODED_FRAME 2938 /** 2939 * the picture in the bitstream 2940 * - encoding: Set by libavcodec. 2941 * - decoding: unused 2942 * 2943 * @deprecated use the quality factor packet side data instead 2944 */ 2945 attribute_deprecated AVFrame *coded_frame; 2946 #endif 2947 2948 /** 2949 * thread count 2950 * is used to decide how many independent tasks should be passed to execute() 2951 * - encoding: Set by user. 2952 * - decoding: Set by user. 2953 */ 2954 int thread_count; 2955 2956 /** 2957 * Which multithreading methods to use. 2958 * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread, 2959 * so clients which cannot provide future frames should not use it. 2960 * 2961 * - encoding: Set by user, otherwise the default is used. 2962 * - decoding: Set by user, otherwise the default is used. 2963 */ 2964 int thread_type; 2965 #define FF_THREAD_FRAME 1 ///< Decode more than one frame at once 2966 #define FF_THREAD_SLICE 2 ///< Decode more than one part of a single frame at once 2967 2968 /** 2969 * Which multithreading methods are in use by the codec. 2970 * - encoding: Set by libavcodec. 2971 * - decoding: Set by libavcodec. 2972 */ 2973 int active_thread_type; 2974 2975 /** 2976 * Set by the client if its custom get_buffer() callback can be called 2977 * synchronously from another thread, which allows faster multithreaded decoding. 2978 * draw_horiz_band() will be called from other threads regardless of this setting. 2979 * Ignored if the default get_buffer() is used. 2980 * - encoding: Set by user. 2981 * - decoding: Set by user. 2982 */ 2983 int thread_safe_callbacks; 2984 2985 /** 2986 * The codec may call this to execute several independent things. 2987 * It will return only after finishing all tasks. 2988 * The user may replace this with some multithreaded implementation, 2989 * the default implementation will execute the parts serially. 2990 * @param count the number of things to execute 2991 * - encoding: Set by libavcodec, user can override. 2992 * - decoding: Set by libavcodec, user can override. 2993 */ 2994 int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size); 2995 2996 /** 2997 * The codec may call this to execute several independent things. 2998 * It will return only after finishing all tasks. 2999 * The user may replace this with some multithreaded implementation, 3000 * the default implementation will execute the parts serially. 3001 * Also see avcodec_thread_init and e.g. the --enable-pthread configure option. 3002 * @param c context passed also to func 3003 * @param count the number of things to execute 3004 * @param arg2 argument passed unchanged to func 3005 * @param ret return values of executed functions, must have space for "count" values. May be NULL. 3006 * @param func function that will be called count times, with jobnr from 0 to count-1. 3007 * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no 3008 * two instances of func executing at the same time will have the same threadnr. 3009 * @return always 0 currently, but code should handle a future improvement where when any call to func 3010 * returns < 0 no further calls to func may be done and < 0 is returned. 3011 * - encoding: Set by libavcodec, user can override. 3012 * - decoding: Set by libavcodec, user can override. 3013 */ 3014 int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count); 3015 3016 /** 3017 * noise vs. sse weight for the nsse comparison function 3018 * - encoding: Set by user. 3019 * - decoding: unused 3020 */ 3021 int nsse_weight; 3022 3023 /** 3024 * profile 3025 * - encoding: Set by user. 3026 * - decoding: Set by libavcodec. 3027 */ 3028 int profile; 3029 #define FF_PROFILE_UNKNOWN -99 3030 #define FF_PROFILE_RESERVED -100 3031 3032 #define FF_PROFILE_AAC_MAIN 0 3033 #define FF_PROFILE_AAC_LOW 1 3034 #define FF_PROFILE_AAC_SSR 2 3035 #define FF_PROFILE_AAC_LTP 3 3036 #define FF_PROFILE_AAC_HE 4 3037 #define FF_PROFILE_AAC_HE_V2 28 3038 #define FF_PROFILE_AAC_LD 22 3039 #define FF_PROFILE_AAC_ELD 38 3040 #define FF_PROFILE_MPEG2_AAC_LOW 128 3041 #define FF_PROFILE_MPEG2_AAC_HE 131 3042 3043 #define FF_PROFILE_DTS 20 3044 #define FF_PROFILE_DTS_ES 30 3045 #define FF_PROFILE_DTS_96_24 40 3046 #define FF_PROFILE_DTS_HD_HRA 50 3047 #define FF_PROFILE_DTS_HD_MA 60 3048 #define FF_PROFILE_DTS_EXPRESS 70 3049 3050 #define FF_PROFILE_MPEG2_422 0 3051 #define FF_PROFILE_MPEG2_HIGH 1 3052 #define FF_PROFILE_MPEG2_SS 2 3053 #define FF_PROFILE_MPEG2_SNR_SCALABLE 3 3054 #define FF_PROFILE_MPEG2_MAIN 4 3055 #define FF_PROFILE_MPEG2_SIMPLE 5 3056 3057 #define FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag 3058 #define FF_PROFILE_H264_INTRA (1<<11) // 8+3; constraint_set3_flag 3059 3060 #define FF_PROFILE_H264_BASELINE 66 3061 #define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED) 3062 #define FF_PROFILE_H264_MAIN 77 3063 #define FF_PROFILE_H264_EXTENDED 88 3064 #define FF_PROFILE_H264_HIGH 100 3065 #define FF_PROFILE_H264_HIGH_10 110 3066 #define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA) 3067 #define FF_PROFILE_H264_HIGH_422 122 3068 #define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA) 3069 #define FF_PROFILE_H264_HIGH_444 144 3070 #define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244 3071 #define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA) 3072 #define FF_PROFILE_H264_CAVLC_444 44 3073 3074 #define FF_PROFILE_VC1_SIMPLE 0 3075 #define FF_PROFILE_VC1_MAIN 1 3076 #define FF_PROFILE_VC1_COMPLEX 2 3077 #define FF_PROFILE_VC1_ADVANCED 3 3078 3079 #define FF_PROFILE_MPEG4_SIMPLE 0 3080 #define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1 3081 #define FF_PROFILE_MPEG4_CORE 2 3082 #define FF_PROFILE_MPEG4_MAIN 3 3083 #define FF_PROFILE_MPEG4_N_BIT 4 3084 #define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5 3085 #define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6 3086 #define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7 3087 #define FF_PROFILE_MPEG4_HYBRID 8 3088 #define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9 3089 #define FF_PROFILE_MPEG4_CORE_SCALABLE 10 3090 #define FF_PROFILE_MPEG4_ADVANCED_CODING 11 3091 #define FF_PROFILE_MPEG4_ADVANCED_CORE 12 3092 #define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13 3093 #define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14 3094 #define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15 3095 3096 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 0 3097 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 1 3098 #define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 2 3099 #define FF_PROFILE_JPEG2000_DCINEMA_2K 3 3100 #define FF_PROFILE_JPEG2000_DCINEMA_4K 4 3101 3102 #define FF_PROFILE_VP9_0 0 3103 #define FF_PROFILE_VP9_1 1 3104 #define FF_PROFILE_VP9_2 2 3105 #define FF_PROFILE_VP9_3 3 3106 3107 #define FF_PROFILE_HEVC_MAIN 1 3108 #define FF_PROFILE_HEVC_MAIN_10 2 3109 #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3 3110 #define FF_PROFILE_HEVC_REXT 4 3111 3112 /** 3113 * level 3114 * - encoding: Set by user. 3115 * - decoding: Set by libavcodec. 3116 */ 3117 int level; 3118 #define FF_LEVEL_UNKNOWN -99 3119 3120 /** 3121 * Skip loop filtering for selected frames. 3122 * - encoding: unused 3123 * - decoding: Set by user. 3124 */ 3125 enum AVDiscard skip_loop_filter; 3126 3127 /** 3128 * Skip IDCT/dequantization for selected frames. 3129 * - encoding: unused 3130 * - decoding: Set by user. 3131 */ 3132 enum AVDiscard skip_idct; 3133 3134 /** 3135 * Skip decoding for selected frames. 3136 * - encoding: unused 3137 * - decoding: Set by user. 3138 */ 3139 enum AVDiscard skip_frame; 3140 3141 /** 3142 * Header containing style information for text subtitles. 3143 * For SUBTITLE_ASS subtitle type, it should contain the whole ASS 3144 * [Script Info] and [V4+ Styles] section, plus the [Events] line and 3145 * the Format line following. It shouldn't include any Dialogue line. 3146 * - encoding: Set/allocated/freed by user (before avcodec_open2()) 3147 * - decoding: Set/allocated/freed by libavcodec (by avcodec_open2()) 3148 */ 3149 uint8_t *subtitle_header; 3150 int subtitle_header_size; 3151 3152 #if FF_API_ERROR_RATE 3153 /** 3154 * @deprecated use the 'error_rate' private AVOption of the mpegvideo 3155 * encoders 3156 */ 3157 attribute_deprecated 3158 int error_rate; 3159 #endif 3160 3161 #if FF_API_VBV_DELAY 3162 /** 3163 * VBV delay coded in the last frame (in periods of a 27 MHz clock). 3164 * Used for compliant TS muxing. 3165 * - encoding: Set by libavcodec. 3166 * - decoding: unused. 3167 * @deprecated this value is now exported as a part of 3168 * AV_PKT_DATA_CPB_PROPERTIES packet side data 3169 */ 3170 attribute_deprecated 3171 uint64_t vbv_delay; 3172 #endif 3173 3174 #if FF_API_SIDEDATA_ONLY_PKT 3175 /** 3176 * Encoding only and set by default. Allow encoders to output packets 3177 * that do not contain any encoded data, only side data. 3178 * 3179 * Some encoders need to output such packets, e.g. to update some stream 3180 * parameters at the end of encoding. 3181 * 3182 * @deprecated this field disables the default behaviour and 3183 * it is kept only for compatibility. 3184 */ 3185 attribute_deprecated 3186 int side_data_only_packets; 3187 #endif 3188 3189 /** 3190 * Audio only. The number of "priming" samples (padding) inserted by the 3191 * encoder at the beginning of the audio. I.e. this number of leading 3192 * decoded samples must be discarded by the caller to get the original audio 3193 * without leading padding. 3194 * 3195 * - decoding: unused 3196 * - encoding: Set by libavcodec. The timestamps on the output packets are 3197 * adjusted by the encoder so that they always refer to the 3198 * first sample of the data actually contained in the packet, 3199 * including any added padding. E.g. if the timebase is 3200 * 1/samplerate and the timestamp of the first input sample is 3201 * 0, the timestamp of the first output packet will be 3202 * -initial_padding. 3203 */ 3204 int initial_padding; 3205 3206 /** 3207 * - decoding: For codecs that store a framerate value in the compressed 3208 * bitstream, the decoder may export it here. { 0, 1} when 3209 * unknown. 3210 * - encoding: unused 3211 */ 3212 AVRational framerate; 3213 3214 /** 3215 * Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx. 3216 * - encoding: unused. 3217 * - decoding: Set by libavcodec before calling get_format() 3218 */ 3219 enum AVPixelFormat sw_pix_fmt; 3220 3221 /** 3222 * Timebase in which pkt_dts/pts and AVPacket.dts/pts are. 3223 * Code outside libavcodec should access this field using: 3224 * av_codec_{get,set}_pkt_timebase(avctx) 3225 * - encoding unused. 3226 * - decoding set by user. 3227 */ 3228 AVRational pkt_timebase; 3229 3230 /** 3231 * AVCodecDescriptor 3232 * Code outside libavcodec should access this field using: 3233 * av_codec_{get,set}_codec_descriptor(avctx) 3234 * - encoding: unused. 3235 * - decoding: set by libavcodec. 3236 */ 3237 const AVCodecDescriptor *codec_descriptor; 3238 3239 #if !FF_API_LOWRES 3240 /** 3241 * low resolution decoding, 1-> 1/2 size, 2->1/4 size 3242 * - encoding: unused 3243 * - decoding: Set by user. 3244 * Code outside libavcodec should access this field using: 3245 * av_codec_{get,set}_lowres(avctx) 3246 */ 3247 int lowres; 3248 #endif 3249 3250 /** 3251 * Current statistics for PTS correction. 3252 * - decoding: maintained and used by libavcodec, not intended to be used by user apps 3253 * - encoding: unused 3254 */ 3255 int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far 3256 int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far 3257 int64_t pts_correction_last_pts; /// PTS of the last frame 3258 int64_t pts_correction_last_dts; /// DTS of the last frame 3259 3260 /** 3261 * Character encoding of the input subtitles file. 3262 * - decoding: set by user 3263 * - encoding: unused 3264 */ 3265 char *sub_charenc; 3266 3267 /** 3268 * Subtitles character encoding mode. Formats or codecs might be adjusting 3269 * this setting (if they are doing the conversion themselves for instance). 3270 * - decoding: set by libavcodec 3271 * - encoding: unused 3272 */ 3273 int sub_charenc_mode; 3274 #define FF_SUB_CHARENC_MODE_DO_NOTHING -1 ///< do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance) 3275 #define FF_SUB_CHARENC_MODE_AUTOMATIC 0 ///< libavcodec will select the mode itself 3276 #define FF_SUB_CHARENC_MODE_PRE_DECODER 1 ///< the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv 3277 3278 /** 3279 * Skip processing alpha if supported by codec. 3280 * Note that if the format uses pre-multiplied alpha (common with VP6, 3281 * and recommended due to better video quality/compression) 3282 * the image will look as if alpha-blended onto a black background. 3283 * However for formats that do not use pre-multiplied alpha 3284 * there might be serious artefacts (though e.g. libswscale currently 3285 * assumes pre-multiplied alpha anyway). 3286 * Code outside libavcodec should access this field using AVOptions 3287 * 3288 * - decoding: set by user 3289 * - encoding: unused 3290 */ 3291 int skip_alpha; 3292 3293 /** 3294 * Number of samples to skip after a discontinuity 3295 * - decoding: unused 3296 * - encoding: set by libavcodec 3297 */ 3298 int seek_preroll; 3299 3300 #if !FF_API_DEBUG_MV 3301 /** 3302 * debug motion vectors 3303 * Code outside libavcodec should access this field using AVOptions 3304 * - encoding: Set by user. 3305 * - decoding: Set by user. 3306 */ 3307 int debug_mv; 3308 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames 3309 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames 3310 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames 3311 #endif 3312 3313 /** 3314 * custom intra quantization matrix 3315 * Code outside libavcodec should access this field using av_codec_g/set_chroma_intra_matrix() 3316 * - encoding: Set by user, can be NULL. 3317 * - decoding: unused. 3318 */ 3319 uint16_t *chroma_intra_matrix; 3320 3321 /** 3322 * dump format separator. 3323 * can be ", " or "\n " or anything else 3324 * Code outside libavcodec should access this field using AVOptions 3325 * (NO direct access). 3326 * - encoding: Set by user. 3327 * - decoding: Set by user. 3328 */ 3329 uint8_t *dump_separator; 3330 3331 /** 3332 * ',' separated list of allowed decoders. 3333 * If NULL then all are allowed 3334 * - encoding: unused 3335 * - decoding: set by user through AVOPtions (NO direct access) 3336 */ 3337 char *codec_whitelist; 3338 3339 /* 3340 * Properties of the stream that gets decoded 3341 * To be accessed through av_codec_get_properties() (NO direct access) 3342 * - encoding: unused 3343 * - decoding: set by libavcodec 3344 */ 3345 unsigned properties; 3346 #define FF_CODEC_PROPERTY_LOSSLESS 0x00000001 3347 #define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002 3348 3349 /** 3350 * Additional data associated with the entire coded stream. 3351 * 3352 * - decoding: unused 3353 * - encoding: may be set by libavcodec after avcodec_open2(). 3354 */ 3355 AVPacketSideData *coded_side_data; 3356 int nb_coded_side_data; 3357 3358 } AVCodecContext; 3359 3360 AVRational av_codec_get_pkt_timebase (const AVCodecContext *avctx); 3361 void av_codec_set_pkt_timebase (AVCodecContext *avctx, AVRational val); 3362 3363 const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx); 3364 void av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc); 3365 3366 unsigned av_codec_get_codec_properties(const AVCodecContext *avctx); 3367 3368 int av_codec_get_lowres(const AVCodecContext *avctx); 3369 void av_codec_set_lowres(AVCodecContext *avctx, int val); 3370 3371 int av_codec_get_seek_preroll(const AVCodecContext *avctx); 3372 void av_codec_set_seek_preroll(AVCodecContext *avctx, int val); 3373 3374 uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx); 3375 void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val); 3376 3377 /** 3378 * AVProfile. 3379 */ 3380 typedef struct AVProfile { 3381 int profile; 3382 const char *name; ///< short name for the profile 3383 } AVProfile; 3384 3385 typedef struct AVCodecDefault AVCodecDefault; 3386 3387 struct AVSubtitle; 3388 3389 /** 3390 * AVCodec. 3391 */ 3392 typedef struct AVCodec { 3393 /** 3394 * Name of the codec implementation. 3395 * The name is globally unique among encoders and among decoders (but an 3396 * encoder and a decoder can share the same name). 3397 * This is the primary way to find a codec from the user perspective. 3398 */ 3399 const char *name; 3400 /** 3401 * Descriptive name for the codec, meant to be more human readable than name. 3402 * You should use the NULL_IF_CONFIG_SMALL() macro to define it. 3403 */ 3404 const char *long_name; 3405 enum AVMediaType type; 3406 enum AVCodecID id; 3407 /** 3408 * Codec capabilities. 3409 * see AV_CODEC_CAP_* 3410 */ 3411 int capabilities; 3412 const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0} 3413 const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1 3414 const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0 3415 const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1 3416 const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0 3417 uint8_t max_lowres; ///< maximum value for lowres supported by the decoder, no direct access, use av_codec_get_max_lowres() 3418 const AVClass *priv_class; ///< AVClass for the private context 3419 const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN} 3420 3421 /***************************************************************** 3422 * No fields below this line are part of the public API. They 3423 * may not be used outside of libavcodec and can be changed and 3424 * removed at will. 3425 * New public fields should be added right above. 3426 ***************************************************************** 3427 */ 3428 int priv_data_size; 3429 struct AVCodec *next; 3430 /** 3431 * @name Frame-level threading support functions 3432 * @{ 3433 */ 3434 /** 3435 * If defined, called on thread contexts when they are created. 3436 * If the codec allocates writable tables in init(), re-allocate them here. 3437 * priv_data will be set to a copy of the original. 3438 */ 3439 int (*init_thread_copy)(AVCodecContext *); 3440 /** 3441 * Copy necessary context variables from a previous thread context to the current one. 3442 * If not defined, the next thread will start automatically; otherwise, the codec 3443 * must call ff_thread_finish_setup(). 3444 * 3445 * dst and src will (rarely) point to the same context, in which case memcpy should be skipped. 3446 */ 3447 int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src); 3448 /** @} */ 3449 3450 /** 3451 * Private codec-specific defaults. 3452 */ 3453 const AVCodecDefault *defaults; 3454 3455 /** 3456 * Initialize codec static data, called from avcodec_register(). 3457 */ 3458 void (*init_static_data)(struct AVCodec *codec); 3459 3460 int (*init)(AVCodecContext *); 3461 int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size, 3462 const struct AVSubtitle *sub); 3463 /** 3464 * Encode data to an AVPacket. 3465 * 3466 * @param avctx codec context 3467 * @param avpkt output AVPacket (may contain a user-provided buffer) 3468 * @param[in] frame AVFrame containing the raw data to be encoded 3469 * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a 3470 * non-empty packet was returned in avpkt. 3471 * @return 0 on success, negative error code on failure 3472 */ 3473 int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, 3474 int *got_packet_ptr); 3475 int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt); 3476 int (*close)(AVCodecContext *); 3477 /** 3478 * Flush buffers. 3479 * Will be called when seeking 3480 */ 3481 void (*flush)(AVCodecContext *); 3482 /** 3483 * Internal codec capabilities. 3484 * See FF_CODEC_CAP_* in internal.h 3485 */ 3486 int caps_internal; 3487 } AVCodec; 3488 3489 int av_codec_get_max_lowres(const AVCodec *codec); 3490 3491 struct MpegEncContext; 3492 3493 /** 3494 * @defgroup lavc_hwaccel AVHWAccel 3495 * @{ 3496 */ 3497 typedef struct AVHWAccel { 3498 /** 3499 * Name of the hardware accelerated codec. 3500 * The name is globally unique among encoders and among decoders (but an 3501 * encoder and a decoder can share the same name). 3502 */ 3503 const char *name; 3504 3505 /** 3506 * Type of codec implemented by the hardware accelerator. 3507 * 3508 * See AVMEDIA_TYPE_xxx 3509 */ 3510 enum AVMediaType type; 3511 3512 /** 3513 * Codec implemented by the hardware accelerator. 3514 * 3515 * See AV_CODEC_ID_xxx 3516 */ 3517 enum AVCodecID id; 3518 3519 /** 3520 * Supported pixel format. 3521 * 3522 * Only hardware accelerated formats are supported here. 3523 */ 3524 enum AVPixelFormat pix_fmt; 3525 3526 /** 3527 * Hardware accelerated codec capabilities. 3528 * see HWACCEL_CODEC_CAP_* 3529 */ 3530 int capabilities; 3531 3532 /***************************************************************** 3533 * No fields below this line are part of the public API. They 3534 * may not be used outside of libavcodec and can be changed and 3535 * removed at will. 3536 * New public fields should be added right above. 3537 ***************************************************************** 3538 */ 3539 struct AVHWAccel *next; 3540 3541 /** 3542 * Allocate a custom buffer 3543 */ 3544 int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame); 3545 3546 /** 3547 * Called at the beginning of each frame or field picture. 3548 * 3549 * Meaningful frame information (codec specific) is guaranteed to 3550 * be parsed at this point. This function is mandatory. 3551 * 3552 * Note that buf can be NULL along with buf_size set to 0. 3553 * Otherwise, this means the whole frame is available at this point. 3554 * 3555 * @param avctx the codec context 3556 * @param buf the frame data buffer base 3557 * @param buf_size the size of the frame in bytes 3558 * @return zero if successful, a negative value otherwise 3559 */ 3560 int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); 3561 3562 /** 3563 * Callback for each slice. 3564 * 3565 * Meaningful slice information (codec specific) is guaranteed to 3566 * be parsed at this point. This function is mandatory. 3567 * The only exception is XvMC, that works on MB level. 3568 * 3569 * @param avctx the codec context 3570 * @param buf the slice data buffer base 3571 * @param buf_size the size of the slice in bytes 3572 * @return zero if successful, a negative value otherwise 3573 */ 3574 int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); 3575 3576 /** 3577 * Called at the end of each frame or field picture. 3578 * 3579 * The whole picture is parsed at this point and can now be sent 3580 * to the hardware accelerator. This function is mandatory. 3581 * 3582 * @param avctx the codec context 3583 * @return zero if successful, a negative value otherwise 3584 */ 3585 int (*end_frame)(AVCodecContext *avctx); 3586 3587 /** 3588 * Size of per-frame hardware accelerator private data. 3589 * 3590 * Private data is allocated with av_mallocz() before 3591 * AVCodecContext.get_buffer() and deallocated after 3592 * AVCodecContext.release_buffer(). 3593 */ 3594 int frame_priv_data_size; 3595 3596 /** 3597 * Called for every Macroblock in a slice. 3598 * 3599 * XvMC uses it to replace the ff_mpv_decode_mb(). 3600 * Instead of decoding to raw picture, MB parameters are 3601 * stored in an array provided by the video driver. 3602 * 3603 * @param s the mpeg context 3604 */ 3605 void (*decode_mb)(struct MpegEncContext *s); 3606 3607 /** 3608 * Initialize the hwaccel private data. 3609 * 3610 * This will be called from ff_get_format(), after hwaccel and 3611 * hwaccel_context are set and the hwaccel private data in AVCodecInternal 3612 * is allocated. 3613 */ 3614 int (*init)(AVCodecContext *avctx); 3615 3616 /** 3617 * Uninitialize the hwaccel private data. 3618 * 3619 * This will be called from get_format() or avcodec_close(), after hwaccel 3620 * and hwaccel_context are already uninitialized. 3621 */ 3622 int (*uninit)(AVCodecContext *avctx); 3623 3624 /** 3625 * Size of the private data to allocate in 3626 * AVCodecInternal.hwaccel_priv_data. 3627 */ 3628 int priv_data_size; 3629 } AVHWAccel; 3630 3631 /** 3632 * Hardware acceleration should be used for decoding even if the codec level 3633 * used is unknown or higher than the maximum supported level reported by the 3634 * hardware driver. 3635 * 3636 * It's generally a good idea to pass this flag unless you have a specific 3637 * reason not to, as hardware tends to under-report supported levels. 3638 */ 3639 #define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0) 3640 3641 /** 3642 * Hardware acceleration can output YUV pixel formats with a different chroma 3643 * sampling than 4:2:0 and/or other than 8 bits per component. 3644 */ 3645 #define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1) 3646 3647 /** 3648 * @} 3649 */ 3650 3651 #if FF_API_AVPICTURE 3652 /** 3653 * @defgroup lavc_picture AVPicture 3654 * 3655 * Functions for working with AVPicture 3656 * @{ 3657 */ 3658 3659 /** 3660 * Picture data structure. 3661 * 3662 * Up to four components can be stored into it, the last component is 3663 * alpha. 3664 * @deprecated use AVFrame or imgutils functions instead 3665 */ 3666 typedef struct AVPicture { 3667 attribute_deprecated 3668 uint8_t *data[AV_NUM_DATA_POINTERS]; ///< pointers to the image data planes 3669 attribute_deprecated 3670 int linesize[AV_NUM_DATA_POINTERS]; ///< number of bytes per line 3671 } AVPicture; 3672 3673 /** 3674 * @} 3675 */ 3676 #endif 3677 3678 enum AVSubtitleType { 3679 SUBTITLE_NONE, 3680 3681 SUBTITLE_BITMAP, ///< A bitmap, pict will be set 3682 3683 /** 3684 * Plain text, the text field must be set by the decoder and is 3685 * authoritative. ass and pict fields may contain approximations. 3686 */ 3687 SUBTITLE_TEXT, 3688 3689 /** 3690 * Formatted text, the ass field must be set by the decoder and is 3691 * authoritative. pict and text fields may contain approximations. 3692 */ 3693 SUBTITLE_ASS, 3694 }; 3695 3696 #define AV_SUBTITLE_FLAG_FORCED 0x00000001 3697 3698 typedef struct AVSubtitleRect { 3699 int x; ///< top left corner of pict, undefined when pict is not set 3700 int y; ///< top left corner of pict, undefined when pict is not set 3701 int w; ///< width of pict, undefined when pict is not set 3702 int h; ///< height of pict, undefined when pict is not set 3703 int nb_colors; ///< number of colors in pict, undefined when pict is not set 3704 3705 #if FF_API_AVPICTURE 3706 /** 3707 * @deprecated unused 3708 */ 3709 attribute_deprecated 3710 AVPicture pict; 3711 #endif 3712 /** 3713 * data+linesize for the bitmap of this subtitle. 3714 * Can be set for text/ass as well once they are rendered. 3715 */ 3716 uint8_t *data[4]; 3717 int linesize[4]; 3718 3719 enum AVSubtitleType type; 3720 3721 char *text; ///< 0 terminated plain UTF-8 text 3722 3723 /** 3724 * 0 terminated ASS/SSA compatible event line. 3725 * The presentation of this is unaffected by the other values in this 3726 * struct. 3727 */ 3728 char *ass; 3729 3730 int flags; 3731 } AVSubtitleRect; 3732 3733 typedef struct AVSubtitle { 3734 uint16_t format; /* 0 = graphics */ 3735 uint32_t start_display_time; /* relative to packet pts, in ms */ 3736 uint32_t end_display_time; /* relative to packet pts, in ms */ 3737 unsigned num_rects; 3738 AVSubtitleRect **rects; 3739 int64_t pts; ///< Same as packet pts, in AV_TIME_BASE 3740 } AVSubtitle; 3741 3742 /** 3743 * If c is NULL, returns the first registered codec, 3744 * if c is non-NULL, returns the next registered codec after c, 3745 * or NULL if c is the last one. 3746 */ 3747 AVCodec *av_codec_next(const AVCodec *c); 3748 3749 /** 3750 * Return the LIBAVCODEC_VERSION_INT constant. 3751 */ 3752 unsigned avcodec_version(void); 3753 3754 /** 3755 * Return the libavcodec build-time configuration. 3756 */ 3757 const char *avcodec_configuration(void); 3758 3759 /** 3760 * Return the libavcodec license. 3761 */ 3762 const char *avcodec_license(void); 3763 3764 /** 3765 * Register the codec codec and initialize libavcodec. 3766 * 3767 * @warning either this function or avcodec_register_all() must be called 3768 * before any other libavcodec functions. 3769 * 3770 * @see avcodec_register_all() 3771 */ 3772 void avcodec_register(AVCodec *codec); 3773 3774 /** 3775 * Register all the codecs, parsers and bitstream filters which were enabled at 3776 * configuration time. If you do not call this function you can select exactly 3777 * which formats you want to support, by using the individual registration 3778 * functions. 3779 * 3780 * @see avcodec_register 3781 * @see av_register_codec_parser 3782 * @see av_register_bitstream_filter 3783 */ 3784 void avcodec_register_all(void); 3785 3786 /** 3787 * Allocate an AVCodecContext and set its fields to default values. The 3788 * resulting struct should be freed with avcodec_free_context(). 3789 * 3790 * @param codec if non-NULL, allocate private data and initialize defaults 3791 * for the given codec. It is illegal to then call avcodec_open2() 3792 * with a different codec. 3793 * If NULL, then the codec-specific defaults won't be initialized, 3794 * which may result in suboptimal default settings (this is 3795 * important mainly for encoders, e.g. libx264). 3796 * 3797 * @return An AVCodecContext filled with default values or NULL on failure. 3798 * @see avcodec_get_context_defaults 3799 */ 3800 AVCodecContext *avcodec_alloc_context3(const AVCodec *codec); 3801 3802 /** 3803 * Free the codec context and everything associated with it and write NULL to 3804 * the provided pointer. 3805 */ 3806 void avcodec_free_context(AVCodecContext **avctx); 3807 3808 /** 3809 * Set the fields of the given AVCodecContext to default values corresponding 3810 * to the given codec (defaults may be codec-dependent). 3811 * 3812 * Do not call this function if a non-NULL codec has been passed 3813 * to avcodec_alloc_context3() that allocated this AVCodecContext. 3814 * If codec is non-NULL, it is illegal to call avcodec_open2() with a 3815 * different codec on this AVCodecContext. 3816 */ 3817 int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec); 3818 3819 /** 3820 * Get the AVClass for AVCodecContext. It can be used in combination with 3821 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 3822 * 3823 * @see av_opt_find(). 3824 */ 3825 const AVClass *avcodec_get_class(void); 3826 3827 /** 3828 * Get the AVClass for AVFrame. It can be used in combination with 3829 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 3830 * 3831 * @see av_opt_find(). 3832 */ 3833 const AVClass *avcodec_get_frame_class(void); 3834 3835 /** 3836 * Get the AVClass for AVSubtitleRect. It can be used in combination with 3837 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 3838 * 3839 * @see av_opt_find(). 3840 */ 3841 const AVClass *avcodec_get_subtitle_rect_class(void); 3842 3843 /** 3844 * Copy the settings of the source AVCodecContext into the destination 3845 * AVCodecContext. The resulting destination codec context will be 3846 * unopened, i.e. you are required to call avcodec_open2() before you 3847 * can use this AVCodecContext to decode/encode video/audio data. 3848 * 3849 * @param dest target codec context, should be initialized with 3850 * avcodec_alloc_context3(NULL), but otherwise uninitialized 3851 * @param src source codec context 3852 * @return AVERROR() on error (e.g. memory allocation error), 0 on success 3853 */ 3854 int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src); 3855 3856 /** 3857 * Initialize the AVCodecContext to use the given AVCodec. Prior to using this 3858 * function the context has to be allocated with avcodec_alloc_context3(). 3859 * 3860 * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(), 3861 * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for 3862 * retrieving a codec. 3863 * 3864 * @warning This function is not thread safe! 3865 * 3866 * @note Always call this function before using decoding routines (such as 3867 * @ref avcodec_decode_video2()). 3868 * 3869 * @code 3870 * avcodec_register_all(); 3871 * av_dict_set(&opts, "b", "2.5M", 0); 3872 * codec = avcodec_find_decoder(AV_CODEC_ID_H264); 3873 * if (!codec) 3874 * exit(1); 3875 * 3876 * context = avcodec_alloc_context3(codec); 3877 * 3878 * if (avcodec_open2(context, codec, opts) < 0) 3879 * exit(1); 3880 * @endcode 3881 * 3882 * @param avctx The context to initialize. 3883 * @param codec The codec to open this context for. If a non-NULL codec has been 3884 * previously passed to avcodec_alloc_context3() or 3885 * avcodec_get_context_defaults3() for this context, then this 3886 * parameter MUST be either NULL or equal to the previously passed 3887 * codec. 3888 * @param options A dictionary filled with AVCodecContext and codec-private options. 3889 * On return this object will be filled with options that were not found. 3890 * 3891 * @return zero on success, a negative value on error 3892 * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(), 3893 * av_dict_set(), av_opt_find(). 3894 */ 3895 int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options); 3896 3897 /** 3898 * Close a given AVCodecContext and free all the data associated with it 3899 * (but not the AVCodecContext itself). 3900 * 3901 * Calling this function on an AVCodecContext that hasn't been opened will free 3902 * the codec-specific data allocated in avcodec_alloc_context3() / 3903 * avcodec_get_context_defaults3() with a non-NULL codec. Subsequent calls will 3904 * do nothing. 3905 */ 3906 int avcodec_close(AVCodecContext *avctx); 3907 3908 /** 3909 * Free all allocated data in the given subtitle struct. 3910 * 3911 * @param sub AVSubtitle to free. 3912 */ 3913 void avsubtitle_free(AVSubtitle *sub); 3914 3915 /** 3916 * @} 3917 */ 3918 3919 /** 3920 * @addtogroup lavc_packet 3921 * @{ 3922 */ 3923 3924 /** 3925 * Allocate an AVPacket and set its fields to default values. The resulting 3926 * struct must be freed using av_packet_free(). 3927 * 3928 * @return An AVPacket filled with default values or NULL on failure. 3929 * 3930 * @note this only allocates the AVPacket itself, not the data buffers. Those 3931 * must be allocated through other means such as av_new_packet. 3932 * 3933 * @see av_new_packet 3934 */ 3935 AVPacket *av_packet_alloc(void); 3936 3937 /** 3938 * Create a new packet that references the same data as src. 3939 * 3940 * This is a shortcut for av_packet_alloc()+av_packet_ref(). 3941 * 3942 * @return newly created AVPacket on success, NULL on error. 3943 * 3944 * @see av_packet_alloc 3945 * @see av_packet_ref 3946 */ 3947 AVPacket *av_packet_clone(AVPacket *src); 3948 3949 /** 3950 * Free the packet, if the packet is reference counted, it will be 3951 * unreferenced first. 3952 * 3953 * @param packet packet to be freed. The pointer will be set to NULL. 3954 * @note passing NULL is a no-op. 3955 */ 3956 void av_packet_free(AVPacket **pkt); 3957 3958 /** 3959 * Initialize optional fields of a packet with default values. 3960 * 3961 * Note, this does not touch the data and size members, which have to be 3962 * initialized separately. 3963 * 3964 * @param pkt packet 3965 */ 3966 void av_init_packet(AVPacket *pkt); 3967 3968 /** 3969 * Allocate the payload of a packet and initialize its fields with 3970 * default values. 3971 * 3972 * @param pkt packet 3973 * @param size wanted payload size 3974 * @return 0 if OK, AVERROR_xxx otherwise 3975 */ 3976 int av_new_packet(AVPacket *pkt, int size); 3977 3978 /** 3979 * Reduce packet size, correctly zeroing padding 3980 * 3981 * @param pkt packet 3982 * @param size new size 3983 */ 3984 void av_shrink_packet(AVPacket *pkt, int size); 3985 3986 /** 3987 * Increase packet size, correctly zeroing padding 3988 * 3989 * @param pkt packet 3990 * @param grow_by number of bytes by which to increase the size of the packet 3991 */ 3992 int av_grow_packet(AVPacket *pkt, int grow_by); 3993 3994 /** 3995 * Initialize a reference-counted packet from av_malloc()ed data. 3996 * 3997 * @param pkt packet to be initialized. This function will set the data, size, 3998 * buf and destruct fields, all others are left untouched. 3999 * @param data Data allocated by av_malloc() to be used as packet data. If this 4000 * function returns successfully, the data is owned by the underlying AVBuffer. 4001 * The caller may not access the data through other means. 4002 * @param size size of data in bytes, without the padding. I.e. the full buffer 4003 * size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE. 4004 * 4005 * @return 0 on success, a negative AVERROR on error 4006 */ 4007 int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size); 4008 4009 #if FF_API_AVPACKET_OLD_API 4010 /** 4011 * @warning This is a hack - the packet memory allocation stuff is broken. The 4012 * packet is allocated if it was not really allocated. 4013 * 4014 * @deprecated Use av_packet_ref 4015 */ 4016 attribute_deprecated 4017 int av_dup_packet(AVPacket *pkt); 4018 /** 4019 * Copy packet, including contents 4020 * 4021 * @return 0 on success, negative AVERROR on fail 4022 */ 4023 int av_copy_packet(AVPacket *dst, const AVPacket *src); 4024 4025 /** 4026 * Copy packet side data 4027 * 4028 * @return 0 on success, negative AVERROR on fail 4029 */ 4030 int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src); 4031 4032 /** 4033 * Free a packet. 4034 * 4035 * @deprecated Use av_packet_unref 4036 * 4037 * @param pkt packet to free 4038 */ 4039 attribute_deprecated 4040 void av_free_packet(AVPacket *pkt); 4041 #endif 4042 /** 4043 * Allocate new information of a packet. 4044 * 4045 * @param pkt packet 4046 * @param type side information type 4047 * @param size side information size 4048 * @return pointer to fresh allocated data or NULL otherwise 4049 */ 4050 uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 4051 int size); 4052 4053 /** 4054 * Wrap an existing array as a packet side data. 4055 * 4056 * @param pkt packet 4057 * @param type side information type 4058 * @param data the side data array. It must be allocated with the av_malloc() 4059 * family of functions. The ownership of the data is transferred to 4060 * pkt. 4061 * @param size side information size 4062 * @return a non-negative number on success, a negative AVERROR code on 4063 * failure. On failure, the packet is unchanged and the data remains 4064 * owned by the caller. 4065 */ 4066 int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 4067 uint8_t *data, size_t size); 4068 4069 /** 4070 * Shrink the already allocated side data buffer 4071 * 4072 * @param pkt packet 4073 * @param type side information type 4074 * @param size new side information size 4075 * @return 0 on success, < 0 on failure 4076 */ 4077 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 4078 int size); 4079 4080 /** 4081 * Get side information from packet. 4082 * 4083 * @param pkt packet 4084 * @param type desired side information type 4085 * @param size pointer for side information size to store (optional) 4086 * @return pointer to data if present or NULL otherwise 4087 */ 4088 uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 4089 int *size); 4090 4091 int av_packet_merge_side_data(AVPacket *pkt); 4092 4093 int av_packet_split_side_data(AVPacket *pkt); 4094 4095 const char *av_packet_side_data_name(enum AVPacketSideDataType type); 4096 4097 /** 4098 * Pack a dictionary for use in side_data. 4099 * 4100 * @param dict The dictionary to pack. 4101 * @param size pointer to store the size of the returned data 4102 * @return pointer to data if successful, NULL otherwise 4103 */ 4104 uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size); 4105 /** 4106 * Unpack a dictionary from side_data. 4107 * 4108 * @param data data from side_data 4109 * @param size size of the data 4110 * @param dict the metadata storage dictionary 4111 * @return 0 on success, < 0 on failure 4112 */ 4113 int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict); 4114 4115 4116 /** 4117 * Convenience function to free all the side data stored. 4118 * All the other fields stay untouched. 4119 * 4120 * @param pkt packet 4121 */ 4122 void av_packet_free_side_data(AVPacket *pkt); 4123 4124 /** 4125 * Setup a new reference to the data described by a given packet 4126 * 4127 * If src is reference-counted, setup dst as a new reference to the 4128 * buffer in src. Otherwise allocate a new buffer in dst and copy the 4129 * data from src into it. 4130 * 4131 * All the other fields are copied from src. 4132 * 4133 * @see av_packet_unref 4134 * 4135 * @param dst Destination packet 4136 * @param src Source packet 4137 * 4138 * @return 0 on success, a negative AVERROR on error. 4139 */ 4140 int av_packet_ref(AVPacket *dst, const AVPacket *src); 4141 4142 /** 4143 * Wipe the packet. 4144 * 4145 * Unreference the buffer referenced by the packet and reset the 4146 * remaining packet fields to their default values. 4147 * 4148 * @param pkt The packet to be unreferenced. 4149 */ 4150 void av_packet_unref(AVPacket *pkt); 4151 4152 /** 4153 * Move every field in src to dst and reset src. 4154 * 4155 * @see av_packet_unref 4156 * 4157 * @param src Source packet, will be reset 4158 * @param dst Destination packet 4159 */ 4160 void av_packet_move_ref(AVPacket *dst, AVPacket *src); 4161 4162 /** 4163 * Copy only "properties" fields from src to dst. 4164 * 4165 * Properties for the purpose of this function are all the fields 4166 * beside those related to the packet data (buf, data, size) 4167 * 4168 * @param dst Destination packet 4169 * @param src Source packet 4170 * 4171 * @return 0 on success AVERROR on failure. 4172 * 4173 */ 4174 int av_packet_copy_props(AVPacket *dst, const AVPacket *src); 4175 4176 /** 4177 * Convert valid timing fields (timestamps / durations) in a packet from one 4178 * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be 4179 * ignored. 4180 * 4181 * @param pkt packet on which the conversion will be performed 4182 * @param tb_src source timebase, in which the timing fields in pkt are 4183 * expressed 4184 * @param tb_dst destination timebase, to which the timing fields will be 4185 * converted 4186 */ 4187 void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst); 4188 4189 /** 4190 * @} 4191 */ 4192 4193 /** 4194 * @addtogroup lavc_decoding 4195 * @{ 4196 */ 4197 4198 /** 4199 * Find a registered decoder with a matching codec ID. 4200 * 4201 * @param id AVCodecID of the requested decoder 4202 * @return A decoder if one was found, NULL otherwise. 4203 */ 4204 AVCodec *avcodec_find_decoder(enum AVCodecID id); 4205 4206 /** 4207 * Find a registered decoder with the specified name. 4208 * 4209 * @param name name of the requested decoder 4210 * @return A decoder if one was found, NULL otherwise. 4211 */ 4212 AVCodec *avcodec_find_decoder_by_name(const char *name); 4213 4214 /** 4215 * The default callback for AVCodecContext.get_buffer2(). It is made public so 4216 * it can be called by custom get_buffer2() implementations for decoders without 4217 * AV_CODEC_CAP_DR1 set. 4218 */ 4219 int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags); 4220 4221 #if FF_API_EMU_EDGE 4222 /** 4223 * Return the amount of padding in pixels which the get_buffer callback must 4224 * provide around the edge of the image for codecs which do not have the 4225 * CODEC_FLAG_EMU_EDGE flag. 4226 * 4227 * @return Required padding in pixels. 4228 * 4229 * @deprecated CODEC_FLAG_EMU_EDGE is deprecated, so this function is no longer 4230 * needed 4231 */ 4232 attribute_deprecated 4233 unsigned avcodec_get_edge_width(void); 4234 #endif 4235 4236 /** 4237 * Modify width and height values so that they will result in a memory 4238 * buffer that is acceptable for the codec if you do not use any horizontal 4239 * padding. 4240 * 4241 * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened. 4242 */ 4243 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height); 4244 4245 /** 4246 * Modify width and height values so that they will result in a memory 4247 * buffer that is acceptable for the codec if you also ensure that all 4248 * line sizes are a multiple of the respective linesize_align[i]. 4249 * 4250 * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened. 4251 */ 4252 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, 4253 int linesize_align[AV_NUM_DATA_POINTERS]); 4254 4255 /** 4256 * Converts AVChromaLocation to swscale x/y chroma position. 4257 * 4258 * The positions represent the chroma (0,0) position in a coordinates system 4259 * with luma (0,0) representing the origin and luma(1,1) representing 256,256 4260 * 4261 * @param xpos horizontal chroma sample position 4262 * @param ypos vertical chroma sample position 4263 */ 4264 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos); 4265 4266 /** 4267 * Converts swscale x/y chroma position to AVChromaLocation. 4268 * 4269 * The positions represent the chroma (0,0) position in a coordinates system 4270 * with luma (0,0) representing the origin and luma(1,1) representing 256,256 4271 * 4272 * @param xpos horizontal chroma sample position 4273 * @param ypos vertical chroma sample position 4274 */ 4275 enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos); 4276 4277 /** 4278 * Decode the audio frame of size avpkt->size from avpkt->data into frame. 4279 * 4280 * Some decoders may support multiple frames in a single AVPacket. Such 4281 * decoders would then just decode the first frame and the return value would be 4282 * less than the packet size. In this case, avcodec_decode_audio4 has to be 4283 * called again with an AVPacket containing the remaining data in order to 4284 * decode the second frame, etc... Even if no frames are returned, the packet 4285 * needs to be fed to the decoder with remaining data until it is completely 4286 * consumed or an error occurs. 4287 * 4288 * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input 4289 * and output. This means that for some packets they will not immediately 4290 * produce decoded output and need to be flushed at the end of decoding to get 4291 * all the decoded data. Flushing is done by calling this function with packets 4292 * with avpkt->data set to NULL and avpkt->size set to 0 until it stops 4293 * returning samples. It is safe to flush even those decoders that are not 4294 * marked with AV_CODEC_CAP_DELAY, then no samples will be returned. 4295 * 4296 * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE 4297 * larger than the actual read bytes because some optimized bitstream 4298 * readers read 32 or 64 bits at once and could read over the end. 4299 * 4300 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 4301 * before packets may be fed to the decoder. 4302 * 4303 * @param avctx the codec context 4304 * @param[out] frame The AVFrame in which to store decoded audio samples. 4305 * The decoder will allocate a buffer for the decoded frame by 4306 * calling the AVCodecContext.get_buffer2() callback. 4307 * When AVCodecContext.refcounted_frames is set to 1, the frame is 4308 * reference counted and the returned reference belongs to the 4309 * caller. The caller must release the frame using av_frame_unref() 4310 * when the frame is no longer needed. The caller may safely write 4311 * to the frame if av_frame_is_writable() returns 1. 4312 * When AVCodecContext.refcounted_frames is set to 0, the returned 4313 * reference belongs to the decoder and is valid only until the 4314 * next call to this function or until closing or flushing the 4315 * decoder. The caller may not write to it. 4316 * @param[out] got_frame_ptr Zero if no frame could be decoded, otherwise it is 4317 * non-zero. Note that this field being set to zero 4318 * does not mean that an error has occurred. For 4319 * decoders with AV_CODEC_CAP_DELAY set, no given decode 4320 * call is guaranteed to produce a frame. 4321 * @param[in] avpkt The input AVPacket containing the input buffer. 4322 * At least avpkt->data and avpkt->size should be set. Some 4323 * decoders might also require additional fields to be set. 4324 * @return A negative error code is returned if an error occurred during 4325 * decoding, otherwise the number of bytes consumed from the input 4326 * AVPacket is returned. 4327 */ 4328 int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, 4329 int *got_frame_ptr, const AVPacket *avpkt); 4330 4331 /** 4332 * Decode the video frame of size avpkt->size from avpkt->data into picture. 4333 * Some decoders may support multiple frames in a single AVPacket, such 4334 * decoders would then just decode the first frame. 4335 * 4336 * @warning The input buffer must be AV_INPUT_BUFFER_PADDING_SIZE larger than 4337 * the actual read bytes because some optimized bitstream readers read 32 or 64 4338 * bits at once and could read over the end. 4339 * 4340 * @warning The end of the input buffer buf should be set to 0 to ensure that 4341 * no overreading happens for damaged MPEG streams. 4342 * 4343 * @note Codecs which have the AV_CODEC_CAP_DELAY capability set have a delay 4344 * between input and output, these need to be fed with avpkt->data=NULL, 4345 * avpkt->size=0 at the end to return the remaining frames. 4346 * 4347 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 4348 * before packets may be fed to the decoder. 4349 * 4350 * @param avctx the codec context 4351 * @param[out] picture The AVFrame in which the decoded video frame will be stored. 4352 * Use av_frame_alloc() to get an AVFrame. The codec will 4353 * allocate memory for the actual bitmap by calling the 4354 * AVCodecContext.get_buffer2() callback. 4355 * When AVCodecContext.refcounted_frames is set to 1, the frame is 4356 * reference counted and the returned reference belongs to the 4357 * caller. The caller must release the frame using av_frame_unref() 4358 * when the frame is no longer needed. The caller may safely write 4359 * to the frame if av_frame_is_writable() returns 1. 4360 * When AVCodecContext.refcounted_frames is set to 0, the returned 4361 * reference belongs to the decoder and is valid only until the 4362 * next call to this function or until closing or flushing the 4363 * decoder. The caller may not write to it. 4364 * 4365 * @param[in] avpkt The input AVPacket containing the input buffer. 4366 * You can create such packet with av_init_packet() and by then setting 4367 * data and size, some decoders might in addition need other fields like 4368 * flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least 4369 * fields possible. 4370 * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero. 4371 * @return On error a negative value is returned, otherwise the number of bytes 4372 * used or zero if no frame could be decompressed. 4373 */ 4374 int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, 4375 int *got_picture_ptr, 4376 const AVPacket *avpkt); 4377 4378 /** 4379 * Decode a subtitle message. 4380 * Return a negative value on error, otherwise return the number of bytes used. 4381 * If no subtitle could be decompressed, got_sub_ptr is zero. 4382 * Otherwise, the subtitle is stored in *sub. 4383 * Note that AV_CODEC_CAP_DR1 is not available for subtitle codecs. This is for 4384 * simplicity, because the performance difference is expect to be negligible 4385 * and reusing a get_buffer written for video codecs would probably perform badly 4386 * due to a potentially very different allocation pattern. 4387 * 4388 * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input 4389 * and output. This means that for some packets they will not immediately 4390 * produce decoded output and need to be flushed at the end of decoding to get 4391 * all the decoded data. Flushing is done by calling this function with packets 4392 * with avpkt->data set to NULL and avpkt->size set to 0 until it stops 4393 * returning subtitles. It is safe to flush even those decoders that are not 4394 * marked with CODEC_CAP_DELAY, then no subtitles will be returned. 4395 * 4396 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 4397 * before packets may be fed to the decoder. 4398 * 4399 * @param avctx the codec context 4400 * @param[out] sub The Preallocated AVSubtitle in which the decoded subtitle will be stored, 4401 * must be freed with avsubtitle_free if *got_sub_ptr is set. 4402 * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero. 4403 * @param[in] avpkt The input AVPacket containing the input buffer. 4404 */ 4405 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, 4406 int *got_sub_ptr, 4407 AVPacket *avpkt); 4408 4409 /** 4410 * @defgroup lavc_parsing Frame parsing 4411 * @{ 4412 */ 4413 4414 enum AVPictureStructure { 4415 AV_PICTURE_STRUCTURE_UNKNOWN, //< unknown 4416 AV_PICTURE_STRUCTURE_TOP_FIELD, //< coded as top field 4417 AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field 4418 AV_PICTURE_STRUCTURE_FRAME, //< coded as frame 4419 }; 4420 4421 typedef struct AVCodecParserContext { 4422 void *priv_data; 4423 struct AVCodecParser *parser; 4424 int64_t frame_offset; /* offset of the current frame */ 4425 int64_t cur_offset; /* current offset 4426 (incremented by each av_parser_parse()) */ 4427 int64_t next_frame_offset; /* offset of the next frame */ 4428 /* video info */ 4429 int pict_type; /* XXX: Put it back in AVCodecContext. */ 4430 /** 4431 * This field is used for proper frame duration computation in lavf. 4432 * It signals, how much longer the frame duration of the current frame 4433 * is compared to normal frame duration. 4434 * 4435 * frame_duration = (1 + repeat_pict) * time_base 4436 * 4437 * It is used by codecs like H.264 to display telecined material. 4438 */ 4439 int repeat_pict; /* XXX: Put it back in AVCodecContext. */ 4440 int64_t pts; /* pts of the current frame */ 4441 int64_t dts; /* dts of the current frame */ 4442 4443 /* private data */ 4444 int64_t last_pts; 4445 int64_t last_dts; 4446 int fetch_timestamp; 4447 4448 #define AV_PARSER_PTS_NB 4 4449 int cur_frame_start_index; 4450 int64_t cur_frame_offset[AV_PARSER_PTS_NB]; 4451 int64_t cur_frame_pts[AV_PARSER_PTS_NB]; 4452 int64_t cur_frame_dts[AV_PARSER_PTS_NB]; 4453 4454 int flags; 4455 #define PARSER_FLAG_COMPLETE_FRAMES 0x0001 4456 #define PARSER_FLAG_ONCE 0x0002 4457 /// Set if the parser has a valid file offset 4458 #define PARSER_FLAG_FETCHED_OFFSET 0x0004 4459 #define PARSER_FLAG_USE_CODEC_TS 0x1000 4460 4461 int64_t offset; ///< byte offset from starting packet start 4462 int64_t cur_frame_end[AV_PARSER_PTS_NB]; 4463 4464 /** 4465 * Set by parser to 1 for key frames and 0 for non-key frames. 4466 * It is initialized to -1, so if the parser doesn't set this flag, 4467 * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames 4468 * will be used. 4469 */ 4470 int key_frame; 4471 4472 #if FF_API_CONVERGENCE_DURATION 4473 /** 4474 * @deprecated unused 4475 */ 4476 attribute_deprecated 4477 int64_t convergence_duration; 4478 #endif 4479 4480 // Timestamp generation support: 4481 /** 4482 * Synchronization point for start of timestamp generation. 4483 * 4484 * Set to >0 for sync point, 0 for no sync point and <0 for undefined 4485 * (default). 4486 * 4487 * For example, this corresponds to presence of H.264 buffering period 4488 * SEI message. 4489 */ 4490 int dts_sync_point; 4491 4492 /** 4493 * Offset of the current timestamp against last timestamp sync point in 4494 * units of AVCodecContext.time_base. 4495 * 4496 * Set to INT_MIN when dts_sync_point unused. Otherwise, it must 4497 * contain a valid timestamp offset. 4498 * 4499 * Note that the timestamp of sync point has usually a nonzero 4500 * dts_ref_dts_delta, which refers to the previous sync point. Offset of 4501 * the next frame after timestamp sync point will be usually 1. 4502 * 4503 * For example, this corresponds to H.264 cpb_removal_delay. 4504 */ 4505 int dts_ref_dts_delta; 4506 4507 /** 4508 * Presentation delay of current frame in units of AVCodecContext.time_base. 4509 * 4510 * Set to INT_MIN when dts_sync_point unused. Otherwise, it must 4511 * contain valid non-negative timestamp delta (presentation time of a frame 4512 * must not lie in the past). 4513 * 4514 * This delay represents the difference between decoding and presentation 4515 * time of the frame. 4516 * 4517 * For example, this corresponds to H.264 dpb_output_delay. 4518 */ 4519 int pts_dts_delta; 4520 4521 /** 4522 * Position of the packet in file. 4523 * 4524 * Analogous to cur_frame_pts/dts 4525 */ 4526 int64_t cur_frame_pos[AV_PARSER_PTS_NB]; 4527 4528 /** 4529 * Byte position of currently parsed frame in stream. 4530 */ 4531 int64_t pos; 4532 4533 /** 4534 * Previous frame byte position. 4535 */ 4536 int64_t last_pos; 4537 4538 /** 4539 * Duration of the current frame. 4540 * For audio, this is in units of 1 / AVCodecContext.sample_rate. 4541 * For all other types, this is in units of AVCodecContext.time_base. 4542 */ 4543 int duration; 4544 4545 enum AVFieldOrder field_order; 4546 4547 /** 4548 * Indicate whether a picture is coded as a frame, top field or bottom field. 4549 * 4550 * For example, H.264 field_pic_flag equal to 0 corresponds to 4551 * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag 4552 * equal to 1 and bottom_field_flag equal to 0 corresponds to 4553 * AV_PICTURE_STRUCTURE_TOP_FIELD. 4554 */ 4555 enum AVPictureStructure picture_structure; 4556 4557 /** 4558 * Picture number incremented in presentation or output order. 4559 * This field may be reinitialized at the first picture of a new sequence. 4560 * 4561 * For example, this corresponds to H.264 PicOrderCnt. 4562 */ 4563 int output_picture_number; 4564 4565 /** 4566 * Dimensions of the decoded video intended for presentation. 4567 */ 4568 int width; 4569 int height; 4570 4571 /** 4572 * Dimensions of the coded video. 4573 */ 4574 int coded_width; 4575 int coded_height; 4576 4577 /** 4578 * The format of the coded data, corresponds to enum AVPixelFormat for video 4579 * and for enum AVSampleFormat for audio. 4580 * 4581 * Note that a decoder can have considerable freedom in how exactly it 4582 * decodes the data, so the format reported here might be different from the 4583 * one returned by a decoder. 4584 */ 4585 int format; 4586 } AVCodecParserContext; 4587 4588 typedef struct AVCodecParser { 4589 int codec_ids[5]; /* several codec IDs are permitted */ 4590 int priv_data_size; 4591 int (*parser_init)(AVCodecParserContext *s); 4592 /* This callback never returns an error, a negative value means that 4593 * the frame start was in a previous packet. */ 4594 int (*parser_parse)(AVCodecParserContext *s, 4595 AVCodecContext *avctx, 4596 const uint8_t **poutbuf, int *poutbuf_size, 4597 const uint8_t *buf, int buf_size); 4598 void (*parser_close)(AVCodecParserContext *s); 4599 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size); 4600 struct AVCodecParser *next; 4601 } AVCodecParser; 4602 4603 AVCodecParser *av_parser_next(const AVCodecParser *c); 4604 4605 void av_register_codec_parser(AVCodecParser *parser); 4606 AVCodecParserContext *av_parser_init(int codec_id); 4607 4608 /** 4609 * Parse a packet. 4610 * 4611 * @param s parser context. 4612 * @param avctx codec context. 4613 * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished. 4614 * @param poutbuf_size set to size of parsed buffer or zero if not yet finished. 4615 * @param buf input buffer. 4616 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output). 4617 * @param pts input presentation timestamp. 4618 * @param dts input decoding timestamp. 4619 * @param pos input byte position in stream. 4620 * @return the number of bytes of the input bitstream used. 4621 * 4622 * Example: 4623 * @code 4624 * while(in_len){ 4625 * len = av_parser_parse2(myparser, AVCodecContext, &data, &size, 4626 * in_data, in_len, 4627 * pts, dts, pos); 4628 * in_data += len; 4629 * in_len -= len; 4630 * 4631 * if(size) 4632 * decode_frame(data, size); 4633 * } 4634 * @endcode 4635 */ 4636 int av_parser_parse2(AVCodecParserContext *s, 4637 AVCodecContext *avctx, 4638 uint8_t **poutbuf, int *poutbuf_size, 4639 const uint8_t *buf, int buf_size, 4640 int64_t pts, int64_t dts, 4641 int64_t pos); 4642 4643 /** 4644 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed 4645 * @deprecated use AVBitStreamFilter 4646 */ 4647 int av_parser_change(AVCodecParserContext *s, 4648 AVCodecContext *avctx, 4649 uint8_t **poutbuf, int *poutbuf_size, 4650 const uint8_t *buf, int buf_size, int keyframe); 4651 void av_parser_close(AVCodecParserContext *s); 4652 4653 /** 4654 * @} 4655 * @} 4656 */ 4657 4658 /** 4659 * @addtogroup lavc_encoding 4660 * @{ 4661 */ 4662 4663 /** 4664 * Find a registered encoder with a matching codec ID. 4665 * 4666 * @param id AVCodecID of the requested encoder 4667 * @return An encoder if one was found, NULL otherwise. 4668 */ 4669 AVCodec *avcodec_find_encoder(enum AVCodecID id); 4670 4671 /** 4672 * Find a registered encoder with the specified name. 4673 * 4674 * @param name name of the requested encoder 4675 * @return An encoder if one was found, NULL otherwise. 4676 */ 4677 AVCodec *avcodec_find_encoder_by_name(const char *name); 4678 4679 /** 4680 * Encode a frame of audio. 4681 * 4682 * Takes input samples from frame and writes the next output packet, if 4683 * available, to avpkt. The output packet does not necessarily contain data for 4684 * the most recent frame, as encoders can delay, split, and combine input frames 4685 * internally as needed. 4686 * 4687 * @param avctx codec context 4688 * @param avpkt output AVPacket. 4689 * The user can supply an output buffer by setting 4690 * avpkt->data and avpkt->size prior to calling the 4691 * function, but if the size of the user-provided data is not 4692 * large enough, encoding will fail. If avpkt->data and 4693 * avpkt->size are set, avpkt->destruct must also be set. All 4694 * other AVPacket fields will be reset by the encoder using 4695 * av_init_packet(). If avpkt->data is NULL, the encoder will 4696 * allocate it. The encoder will set avpkt->size to the size 4697 * of the output packet. 4698 * 4699 * If this function fails or produces no output, avpkt will be 4700 * freed using av_packet_unref(). 4701 * @param[in] frame AVFrame containing the raw audio data to be encoded. 4702 * May be NULL when flushing an encoder that has the 4703 * AV_CODEC_CAP_DELAY capability set. 4704 * If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame 4705 * can have any number of samples. 4706 * If it is not set, frame->nb_samples must be equal to 4707 * avctx->frame_size for all frames except the last. 4708 * The final frame may be smaller than avctx->frame_size. 4709 * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the 4710 * output packet is non-empty, and to 0 if it is 4711 * empty. If the function returns an error, the 4712 * packet can be assumed to be invalid, and the 4713 * value of got_packet_ptr is undefined and should 4714 * not be used. 4715 * @return 0 on success, negative error code on failure 4716 */ 4717 int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, 4718 const AVFrame *frame, int *got_packet_ptr); 4719 4720 /** 4721 * Encode a frame of video. 4722 * 4723 * Takes input raw video data from frame and writes the next output packet, if 4724 * available, to avpkt. The output packet does not necessarily contain data for 4725 * the most recent frame, as encoders can delay and reorder input frames 4726 * internally as needed. 4727 * 4728 * @param avctx codec context 4729 * @param avpkt output AVPacket. 4730 * The user can supply an output buffer by setting 4731 * avpkt->data and avpkt->size prior to calling the 4732 * function, but if the size of the user-provided data is not 4733 * large enough, encoding will fail. All other AVPacket fields 4734 * will be reset by the encoder using av_init_packet(). If 4735 * avpkt->data is NULL, the encoder will allocate it. 4736 * The encoder will set avpkt->size to the size of the 4737 * output packet. The returned data (if any) belongs to the 4738 * caller, he is responsible for freeing it. 4739 * 4740 * If this function fails or produces no output, avpkt will be 4741 * freed using av_packet_unref(). 4742 * @param[in] frame AVFrame containing the raw video data to be encoded. 4743 * May be NULL when flushing an encoder that has the 4744 * AV_CODEC_CAP_DELAY capability set. 4745 * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the 4746 * output packet is non-empty, and to 0 if it is 4747 * empty. If the function returns an error, the 4748 * packet can be assumed to be invalid, and the 4749 * value of got_packet_ptr is undefined and should 4750 * not be used. 4751 * @return 0 on success, negative error code on failure 4752 */ 4753 int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, 4754 const AVFrame *frame, int *got_packet_ptr); 4755 4756 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, 4757 const AVSubtitle *sub); 4758 4759 4760 /** 4761 * @} 4762 */ 4763 4764 #if FF_API_AVCODEC_RESAMPLE 4765 /** 4766 * @defgroup lavc_resample Audio resampling 4767 * @ingroup libavc 4768 * @deprecated use libswresample instead 4769 * 4770 * @{ 4771 */ 4772 struct ReSampleContext; 4773 struct AVResampleContext; 4774 4775 typedef struct ReSampleContext ReSampleContext; 4776 4777 /** 4778 * Initialize audio resampling context. 4779 * 4780 * @param output_channels number of output channels 4781 * @param input_channels number of input channels 4782 * @param output_rate output sample rate 4783 * @param input_rate input sample rate 4784 * @param sample_fmt_out requested output sample format 4785 * @param sample_fmt_in input sample format 4786 * @param filter_length length of each FIR filter in the filterbank relative to the cutoff frequency 4787 * @param log2_phase_count log2 of the number of entries in the polyphase filterbank 4788 * @param linear if 1 then the used FIR filter will be linearly interpolated 4789 between the 2 closest, if 0 the closest will be used 4790 * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate 4791 * @return allocated ReSampleContext, NULL if error occurred 4792 */ 4793 attribute_deprecated 4794 ReSampleContext *av_audio_resample_init(int output_channels, int input_channels, 4795 int output_rate, int input_rate, 4796 enum AVSampleFormat sample_fmt_out, 4797 enum AVSampleFormat sample_fmt_in, 4798 int filter_length, int log2_phase_count, 4799 int linear, double cutoff); 4800 4801 attribute_deprecated 4802 int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples); 4803 4804 /** 4805 * Free resample context. 4806 * 4807 * @param s a non-NULL pointer to a resample context previously 4808 * created with av_audio_resample_init() 4809 */ 4810 attribute_deprecated 4811 void audio_resample_close(ReSampleContext *s); 4812 4813 4814 /** 4815 * Initialize an audio resampler. 4816 * Note, if either rate is not an integer then simply scale both rates up so they are. 4817 * @param filter_length length of each FIR filter in the filterbank relative to the cutoff freq 4818 * @param log2_phase_count log2 of the number of entries in the polyphase filterbank 4819 * @param linear If 1 then the used FIR filter will be linearly interpolated 4820 between the 2 closest, if 0 the closest will be used 4821 * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate 4822 */ 4823 attribute_deprecated 4824 struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff); 4825 4826 /** 4827 * Resample an array of samples using a previously configured context. 4828 * @param src an array of unconsumed samples 4829 * @param consumed the number of samples of src which have been consumed are returned here 4830 * @param src_size the number of unconsumed samples available 4831 * @param dst_size the amount of space in samples available in dst 4832 * @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. 4833 * @return the number of samples written in dst or -1 if an error occurred 4834 */ 4835 attribute_deprecated 4836 int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx); 4837 4838 4839 /** 4840 * Compensate samplerate/timestamp drift. The compensation is done by changing 4841 * the resampler parameters, so no audible clicks or similar distortions occur 4842 * @param compensation_distance distance in output samples over which the compensation should be performed 4843 * @param sample_delta number of output samples which should be output less 4844 * 4845 * example: av_resample_compensate(c, 10, 500) 4846 * here instead of 510 samples only 500 samples would be output 4847 * 4848 * note, due to rounding the actual compensation might be slightly different, 4849 * especially if the compensation_distance is large and the in_rate used during init is small 4850 */ 4851 attribute_deprecated 4852 void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance); 4853 attribute_deprecated 4854 void av_resample_close(struct AVResampleContext *c); 4855 4856 /** 4857 * @} 4858 */ 4859 #endif 4860 4861 #if FF_API_AVPICTURE 4862 /** 4863 * @addtogroup lavc_picture 4864 * @{ 4865 */ 4866 4867 /** 4868 * @deprecated unused 4869 */ 4870 attribute_deprecated 4871 int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height); 4872 4873 /** 4874 * @deprecated unused 4875 */ 4876 attribute_deprecated 4877 void avpicture_free(AVPicture *picture); 4878 4879 /** 4880 * @deprecated use av_image_fill_arrays() instead. 4881 */ 4882 attribute_deprecated 4883 int avpicture_fill(AVPicture *picture, const uint8_t *ptr, 4884 enum AVPixelFormat pix_fmt, int width, int height); 4885 4886 /** 4887 * @deprecated use av_image_copy_to_buffer() instead. 4888 */ 4889 attribute_deprecated 4890 int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt, 4891 int width, int height, 4892 unsigned char *dest, int dest_size); 4893 4894 /** 4895 * @deprecated use av_image_get_buffer_size() instead. 4896 */ 4897 attribute_deprecated 4898 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height); 4899 4900 /** 4901 * @deprecated av_image_copy() instead. 4902 */ 4903 attribute_deprecated 4904 void av_picture_copy(AVPicture *dst, const AVPicture *src, 4905 enum AVPixelFormat pix_fmt, int width, int height); 4906 4907 /** 4908 * @deprecated unused 4909 */ 4910 attribute_deprecated 4911 int av_picture_crop(AVPicture *dst, const AVPicture *src, 4912 enum AVPixelFormat pix_fmt, int top_band, int left_band); 4913 4914 /** 4915 * @deprecated unused 4916 */ 4917 attribute_deprecated 4918 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt, 4919 int padtop, int padbottom, int padleft, int padright, int *color); 4920 4921 /** 4922 * @} 4923 */ 4924 #endif 4925 4926 /** 4927 * @defgroup lavc_misc Utility functions 4928 * @ingroup libavc 4929 * 4930 * Miscellaneous utility functions related to both encoding and decoding 4931 * (or neither). 4932 * @{ 4933 */ 4934 4935 /** 4936 * @defgroup lavc_misc_pixfmt Pixel formats 4937 * 4938 * Functions for working with pixel formats. 4939 * @{ 4940 */ 4941 4942 /** 4943 * Utility function to access log2_chroma_w log2_chroma_h from 4944 * the pixel format AVPixFmtDescriptor. 4945 * 4946 * This function asserts that pix_fmt is valid. See av_pix_fmt_get_chroma_sub_sample 4947 * for one that returns a failure code and continues in case of invalid 4948 * pix_fmts. 4949 * 4950 * @param[in] pix_fmt the pixel format 4951 * @param[out] h_shift store log2_chroma_w 4952 * @param[out] v_shift store log2_chroma_h 4953 * 4954 * @see av_pix_fmt_get_chroma_sub_sample 4955 */ 4956 4957 void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift); 4958 4959 /** 4960 * Return a value representing the fourCC code associated to the 4961 * pixel format pix_fmt, or 0 if no associated fourCC code can be 4962 * found. 4963 */ 4964 unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt); 4965 4966 /** 4967 * @deprecated see av_get_pix_fmt_loss() 4968 */ 4969 int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt, 4970 int has_alpha); 4971 4972 /** 4973 * Find the best pixel format to convert to given a certain source pixel 4974 * format. When converting from one pixel format to another, information loss 4975 * may occur. For example, when converting from RGB24 to GRAY, the color 4976 * information will be lost. Similarly, other losses occur when converting from 4977 * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of 4978 * the given pixel formats should be used to suffer the least amount of loss. 4979 * The pixel formats from which it chooses one, are determined by the 4980 * pix_fmt_list parameter. 4981 * 4982 * 4983 * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from 4984 * @param[in] src_pix_fmt source pixel format 4985 * @param[in] has_alpha Whether the source pixel format alpha channel is used. 4986 * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur. 4987 * @return The best pixel format to convert to or -1 if none was found. 4988 */ 4989 enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list, 4990 enum AVPixelFormat src_pix_fmt, 4991 int has_alpha, int *loss_ptr); 4992 4993 /** 4994 * @deprecated see av_find_best_pix_fmt_of_2() 4995 */ 4996 enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2, 4997 enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr); 4998 4999 attribute_deprecated 5000 #if AV_HAVE_INCOMPATIBLE_LIBAV_ABI 5001 enum AVPixelFormat avcodec_find_best_pix_fmt2(const enum AVPixelFormat *pix_fmt_list, 5002 enum AVPixelFormat src_pix_fmt, 5003 int has_alpha, int *loss_ptr); 5004 #else 5005 enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2, 5006 enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr); 5007 #endif 5008 5009 5010 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt); 5011 5012 /** 5013 * @} 5014 */ 5015 5016 #if FF_API_SET_DIMENSIONS 5017 /** 5018 * @deprecated this function is not supposed to be used from outside of lavc 5019 */ 5020 attribute_deprecated 5021 void avcodec_set_dimensions(AVCodecContext *s, int width, int height); 5022 #endif 5023 5024 /** 5025 * Put a string representing the codec tag codec_tag in buf. 5026 * 5027 * @param buf buffer to place codec tag in 5028 * @param buf_size size in bytes of buf 5029 * @param codec_tag codec tag to assign 5030 * @return the length of the string that would have been generated if 5031 * enough space had been available, excluding the trailing null 5032 */ 5033 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag); 5034 5035 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode); 5036 5037 /** 5038 * Return a name for the specified profile, if available. 5039 * 5040 * @param codec the codec that is searched for the given profile 5041 * @param profile the profile value for which a name is requested 5042 * @return A name for the profile if found, NULL otherwise. 5043 */ 5044 const char *av_get_profile_name(const AVCodec *codec, int profile); 5045 5046 /** 5047 * Return a name for the specified profile, if available. 5048 * 5049 * @param codec_id the ID of the codec to which the requested profile belongs 5050 * @param profile the profile value for which a name is requested 5051 * @return A name for the profile if found, NULL otherwise. 5052 * 5053 * @note unlike av_get_profile_name(), which searches a list of profiles 5054 * supported by a specific decoder or encoder implementation, this 5055 * function searches the list of profiles from the AVCodecDescriptor 5056 */ 5057 const char *avcodec_profile_name(enum AVCodecID codec_id, int profile); 5058 5059 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size); 5060 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count); 5061 //FIXME func typedef 5062 5063 /** 5064 * Fill AVFrame audio data and linesize pointers. 5065 * 5066 * The buffer buf must be a preallocated buffer with a size big enough 5067 * to contain the specified samples amount. The filled AVFrame data 5068 * pointers will point to this buffer. 5069 * 5070 * AVFrame extended_data channel pointers are allocated if necessary for 5071 * planar audio. 5072 * 5073 * @param frame the AVFrame 5074 * frame->nb_samples must be set prior to calling the 5075 * function. This function fills in frame->data, 5076 * frame->extended_data, frame->linesize[0]. 5077 * @param nb_channels channel count 5078 * @param sample_fmt sample format 5079 * @param buf buffer to use for frame data 5080 * @param buf_size size of buffer 5081 * @param align plane size sample alignment (0 = default) 5082 * @return >=0 on success, negative error code on failure 5083 * @todo return the size in bytes required to store the samples in 5084 * case of success, at the next libavutil bump 5085 */ 5086 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, 5087 enum AVSampleFormat sample_fmt, const uint8_t *buf, 5088 int buf_size, int align); 5089 5090 /** 5091 * Reset the internal decoder state / flush internal buffers. Should be called 5092 * e.g. when seeking or when switching to a different stream. 5093 * 5094 * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0), 5095 * this invalidates the frames previously returned from the decoder. When 5096 * refcounted frames are used, the decoder just releases any references it might 5097 * keep internally, but the caller's reference remains valid. 5098 */ 5099 void avcodec_flush_buffers(AVCodecContext *avctx); 5100 5101 /** 5102 * Return codec bits per sample. 5103 * 5104 * @param[in] codec_id the codec 5105 * @return Number of bits per sample or zero if unknown for the given codec. 5106 */ 5107 int av_get_bits_per_sample(enum AVCodecID codec_id); 5108 5109 /** 5110 * Return the PCM codec associated with a sample format. 5111 * @param be endianness, 0 for little, 1 for big, 5112 * -1 (or anything else) for native 5113 * @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE 5114 */ 5115 enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be); 5116 5117 /** 5118 * Return codec bits per sample. 5119 * Only return non-zero if the bits per sample is exactly correct, not an 5120 * approximation. 5121 * 5122 * @param[in] codec_id the codec 5123 * @return Number of bits per sample or zero if unknown for the given codec. 5124 */ 5125 int av_get_exact_bits_per_sample(enum AVCodecID codec_id); 5126 5127 /** 5128 * Return audio frame duration. 5129 * 5130 * @param avctx codec context 5131 * @param frame_bytes size of the frame, or 0 if unknown 5132 * @return frame duration, in samples, if known. 0 if not able to 5133 * determine. 5134 */ 5135 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes); 5136 5137 5138 typedef struct AVBitStreamFilterContext { 5139 void *priv_data; 5140 struct AVBitStreamFilter *filter; 5141 AVCodecParserContext *parser; 5142 struct AVBitStreamFilterContext *next; 5143 /** 5144 * Internal default arguments, used if NULL is passed to av_bitstream_filter_filter(). 5145 * Not for access by library users. 5146 */ 5147 char *args; 5148 } AVBitStreamFilterContext; 5149 5150 5151 typedef struct AVBitStreamFilter { 5152 const char *name; 5153 int priv_data_size; 5154 int (*filter)(AVBitStreamFilterContext *bsfc, 5155 AVCodecContext *avctx, const char *args, 5156 uint8_t **poutbuf, int *poutbuf_size, 5157 const uint8_t *buf, int buf_size, int keyframe); 5158 void (*close)(AVBitStreamFilterContext *bsfc); 5159 struct AVBitStreamFilter *next; 5160 } AVBitStreamFilter; 5161 5162 /** 5163 * Register a bitstream filter. 5164 * 5165 * The filter will be accessible to the application code through 5166 * av_bitstream_filter_next() or can be directly initialized with 5167 * av_bitstream_filter_init(). 5168 * 5169 * @see avcodec_register_all() 5170 */ 5171 void av_register_bitstream_filter(AVBitStreamFilter *bsf); 5172 5173 /** 5174 * Create and initialize a bitstream filter context given a bitstream 5175 * filter name. 5176 * 5177 * The returned context must be freed with av_bitstream_filter_close(). 5178 * 5179 * @param name the name of the bitstream filter 5180 * @return a bitstream filter context if a matching filter was found 5181 * and successfully initialized, NULL otherwise 5182 */ 5183 AVBitStreamFilterContext *av_bitstream_filter_init(const char *name); 5184 5185 /** 5186 * Filter bitstream. 5187 * 5188 * This function filters the buffer buf with size buf_size, and places the 5189 * filtered buffer in the buffer pointed to by poutbuf. 5190 * 5191 * The output buffer must be freed by the caller. 5192 * 5193 * @param bsfc bitstream filter context created by av_bitstream_filter_init() 5194 * @param avctx AVCodecContext accessed by the filter, may be NULL. 5195 * If specified, this must point to the encoder context of the 5196 * output stream the packet is sent to. 5197 * @param args arguments which specify the filter configuration, may be NULL 5198 * @param poutbuf pointer which is updated to point to the filtered buffer 5199 * @param poutbuf_size pointer which is updated to the filtered buffer size in bytes 5200 * @param buf buffer containing the data to filter 5201 * @param buf_size size in bytes of buf 5202 * @param keyframe set to non-zero if the buffer to filter corresponds to a key-frame packet data 5203 * @return >= 0 in case of success, or a negative error code in case of failure 5204 * 5205 * If the return value is positive, an output buffer is allocated and 5206 * is available in *poutbuf, and is distinct from the input buffer. 5207 * 5208 * If the return value is 0, the output buffer is not allocated and 5209 * should be considered identical to the input buffer, or in case 5210 * *poutbuf was set it points to the input buffer (not necessarily to 5211 * its starting address). 5212 */ 5213 int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, 5214 AVCodecContext *avctx, const char *args, 5215 uint8_t **poutbuf, int *poutbuf_size, 5216 const uint8_t *buf, int buf_size, int keyframe); 5217 5218 /** 5219 * Release bitstream filter context. 5220 * 5221 * @param bsf the bitstream filter context created with 5222 * av_bitstream_filter_init(), can be NULL 5223 */ 5224 void av_bitstream_filter_close(AVBitStreamFilterContext *bsf); 5225 5226 /** 5227 * If f is NULL, return the first registered bitstream filter, 5228 * if f is non-NULL, return the next registered bitstream filter 5229 * after f, or NULL if f is the last one. 5230 * 5231 * This function can be used to iterate over all registered bitstream 5232 * filters. 5233 */ 5234 AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f); 5235 5236 /* memory */ 5237 5238 /** 5239 * Same behaviour av_fast_malloc but the buffer has additional 5240 * AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0. 5241 * 5242 * In addition the whole buffer will initially and after resizes 5243 * be 0-initialized so that no uninitialized data will ever appear. 5244 */ 5245 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size); 5246 5247 /** 5248 * Same behaviour av_fast_padded_malloc except that buffer will always 5249 * be 0-initialized after call. 5250 */ 5251 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size); 5252 5253 /** 5254 * Encode extradata length to a buffer. Used by xiph codecs. 5255 * 5256 * @param s buffer to write to; must be at least (v/255+1) bytes long 5257 * @param v size of extradata in bytes 5258 * @return number of bytes written to the buffer. 5259 */ 5260 unsigned int av_xiphlacing(unsigned char *s, unsigned int v); 5261 5262 #if FF_API_MISSING_SAMPLE 5263 /** 5264 * Log a generic warning message about a missing feature. This function is 5265 * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.) 5266 * only, and would normally not be used by applications. 5267 * @param[in] avc a pointer to an arbitrary struct of which the first field is 5268 * a pointer to an AVClass struct 5269 * @param[in] feature string containing the name of the missing feature 5270 * @param[in] want_sample indicates if samples are wanted which exhibit this feature. 5271 * If want_sample is non-zero, additional verbage will be added to the log 5272 * message which tells the user how to report samples to the development 5273 * mailing list. 5274 * @deprecated Use avpriv_report_missing_feature() instead. 5275 */ 5276 attribute_deprecated 5277 void av_log_missing_feature(void *avc, const char *feature, int want_sample); 5278 5279 /** 5280 * Log a generic warning message asking for a sample. This function is 5281 * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.) 5282 * only, and would normally not be used by applications. 5283 * @param[in] avc a pointer to an arbitrary struct of which the first field is 5284 * a pointer to an AVClass struct 5285 * @param[in] msg string containing an optional message, or NULL if no message 5286 * @deprecated Use avpriv_request_sample() instead. 5287 */ 5288 attribute_deprecated 5289 void av_log_ask_for_sample(void *avc, const char *msg, ...) av_printf_format(2, 3); 5290 #endif /* FF_API_MISSING_SAMPLE */ 5291 5292 /** 5293 * Register the hardware accelerator hwaccel. 5294 */ 5295 void av_register_hwaccel(AVHWAccel *hwaccel); 5296 5297 /** 5298 * If hwaccel is NULL, returns the first registered hardware accelerator, 5299 * if hwaccel is non-NULL, returns the next registered hardware accelerator 5300 * after hwaccel, or NULL if hwaccel is the last one. 5301 */ 5302 AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel); 5303 5304 5305 /** 5306 * Lock operation used by lockmgr 5307 */ 5308 enum AVLockOp { 5309 AV_LOCK_CREATE, ///< Create a mutex 5310 AV_LOCK_OBTAIN, ///< Lock the mutex 5311 AV_LOCK_RELEASE, ///< Unlock the mutex 5312 AV_LOCK_DESTROY, ///< Free mutex resources 5313 }; 5314 5315 /** 5316 * Register a user provided lock manager supporting the operations 5317 * specified by AVLockOp. The "mutex" argument to the function points 5318 * to a (void *) where the lockmgr should store/get a pointer to a user 5319 * allocated mutex. It is NULL upon AV_LOCK_CREATE and equal to the 5320 * value left by the last call for all other ops. If the lock manager is 5321 * unable to perform the op then it should leave the mutex in the same 5322 * state as when it was called and return a non-zero value. However, 5323 * when called with AV_LOCK_DESTROY the mutex will always be assumed to 5324 * have been successfully destroyed. If av_lockmgr_register succeeds 5325 * it will return a non-negative value, if it fails it will return a 5326 * negative value and destroy all mutex and unregister all callbacks. 5327 * av_lockmgr_register is not thread-safe, it must be called from a 5328 * single thread before any calls which make use of locking are used. 5329 * 5330 * @param cb User defined callback. av_lockmgr_register invokes calls 5331 * to this callback and the previously registered callback. 5332 * The callback will be used to create more than one mutex 5333 * each of which must be backed by its own underlying locking 5334 * mechanism (i.e. do not use a single static object to 5335 * implement your lock manager). If cb is set to NULL the 5336 * lockmgr will be unregistered. 5337 */ 5338 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op)); 5339 5340 /** 5341 * Get the type of the given codec. 5342 */ 5343 enum AVMediaType avcodec_get_type(enum AVCodecID codec_id); 5344 5345 /** 5346 * Get the name of a codec. 5347 * @return a static string identifying the codec; never NULL 5348 */ 5349 const char *avcodec_get_name(enum AVCodecID id); 5350 5351 /** 5352 * @return a positive value if s is open (i.e. avcodec_open2() was called on it 5353 * with no corresponding avcodec_close()), 0 otherwise. 5354 */ 5355 int avcodec_is_open(AVCodecContext *s); 5356 5357 /** 5358 * @return a non-zero number if codec is an encoder, zero otherwise 5359 */ 5360 int av_codec_is_encoder(const AVCodec *codec); 5361 5362 /** 5363 * @return a non-zero number if codec is a decoder, zero otherwise 5364 */ 5365 int av_codec_is_decoder(const AVCodec *codec); 5366 5367 /** 5368 * @return descriptor for given codec ID or NULL if no descriptor exists. 5369 */ 5370 const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id); 5371 5372 /** 5373 * Iterate over all codec descriptors known to libavcodec. 5374 * 5375 * @param prev previous descriptor. NULL to get the first descriptor. 5376 * 5377 * @return next descriptor or NULL after the last descriptor 5378 */ 5379 const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev); 5380 5381 /** 5382 * @return codec descriptor with the given name or NULL if no such descriptor 5383 * exists. 5384 */ 5385 const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name); 5386 5387 /** 5388 * Allocate a CPB properties structure and initialize its fields to default 5389 * values. 5390 * 5391 * @param size if non-NULL, the size of the allocated struct will be written 5392 * here. This is useful for embedding it in side data. 5393 * 5394 * @return the newly allocated struct or NULL on failure 5395 */ 5396 AVCPBProperties *av_cpb_properties_alloc(size_t *size); 5397 5398 /** 5399 * @} 5400 */ 5401 5402 #endif /* AVCODEC_AVCODEC_H */ 5403