git.sesse.net Git - ffmpeg/blob - libavcodec/avcodec.h

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