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