PeerStreamer

/*

 * copyright (c) 2001 Fabrice Bellard

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#ifndef AVCODEC_AVCODEC_H

#define AVCODEC_AVCODEC_H

/**

 * @file

 * external API header

 */

#include <errno.h>

#include "libavutil/samplefmt.h"

#include "libavutil/avutil.h"

#include "libavutil/cpu.h"

#define LIBAVCODEC_VERSION_MAJOR 52

#define LIBAVCODEC_VERSION_MINOR 113

#define LIBAVCODEC_VERSION_MICRO  2

#define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \

                                               LIBAVCODEC_VERSION_MINOR, \

                                               LIBAVCODEC_VERSION_MICRO)

#define LIBAVCODEC_VERSION      AV_VERSION(LIBAVCODEC_VERSION_MAJOR,    \

                                           LIBAVCODEC_VERSION_MINOR,    \

                                           LIBAVCODEC_VERSION_MICRO)

#define LIBAVCODEC_BUILD        LIBAVCODEC_VERSION_INT

#define LIBAVCODEC_IDENT        "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)

/**

 * Those FF_API_* defines are not part of public API.

 * They may change, break or disappear at any time.

 */

#ifndef FF_API_PALETTE_CONTROL

#define FF_API_PALETTE_CONTROL  (LIBAVCODEC_VERSION_MAJOR < 54)

#endif

#ifndef FF_API_MM_FLAGS

#define FF_API_MM_FLAGS         (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_OPT_SHOW

#define FF_API_OPT_SHOW         (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_AUDIO_OLD

#define FF_API_AUDIO_OLD        (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_VIDEO_OLD

#define FF_API_VIDEO_OLD        (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_SUBTITLE_OLD

#define FF_API_SUBTITLE_OLD     (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_USE_LPC

#define FF_API_USE_LPC          (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_SET_STRING_OLD

#define FF_API_SET_STRING_OLD   (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_INOFFICIAL

#define FF_API_INOFFICIAL       (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_OLD_SAMPLE_FMT

#define FF_API_OLD_SAMPLE_FMT   (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#ifndef FF_API_OLD_AUDIOCONVERT

#define FF_API_OLD_AUDIOCONVERT (LIBAVCODEC_VERSION_MAJOR < 53)

#endif

#if LIBAVCODEC_VERSION_MAJOR < 53

#   define FF_INTERNALC_MEM_TYPE unsigned int

#else

#   define FF_INTERNALC_MEM_TYPE size_t

#endif

/**

 * Identify the syntax and semantics of the bitstream.

 * The principle is roughly:

 * Two decoders with the same ID can decode the same streams.

 * Two encoders with the same ID can encode compatible streams.

 * There may be slight deviations from the principle due to implementation

 * details.

 *

 * If you add a codec ID to this list, add it so that

 * 1. no value of a existing codec ID changes (that would break ABI),

 * 2. it is as close as possible to similar codecs.

 */

enum CodecID {

    CODEC_ID_NONE,

    /* video codecs */

    CODEC_ID_MPEG1VIDEO,

    CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding

    CODEC_ID_MPEG2VIDEO_XVMC,

    CODEC_ID_H261,

    CODEC_ID_H263,

    CODEC_ID_RV10,

    CODEC_ID_RV20,

    CODEC_ID_MJPEG,

    CODEC_ID_MJPEGB,

    CODEC_ID_LJPEG,

    CODEC_ID_SP5X,

    CODEC_ID_JPEGLS,

    CODEC_ID_MPEG4,

    CODEC_ID_RAWVIDEO,

    CODEC_ID_MSMPEG4V1,

    CODEC_ID_MSMPEG4V2,

    CODEC_ID_MSMPEG4V3,

    CODEC_ID_WMV1,

    CODEC_ID_WMV2,

    CODEC_ID_H263P,

    CODEC_ID_H263I,

    CODEC_ID_FLV1,

    CODEC_ID_SVQ1,

    CODEC_ID_SVQ3,

    CODEC_ID_DVVIDEO,

    CODEC_ID_HUFFYUV,

    CODEC_ID_CYUV,

    CODEC_ID_H264,

    CODEC_ID_INDEO3,

    CODEC_ID_VP3,

    CODEC_ID_THEORA,

    CODEC_ID_ASV1,

    CODEC_ID_ASV2,

    CODEC_ID_FFV1,

    CODEC_ID_4XM,

    CODEC_ID_VCR1,

    CODEC_ID_CLJR,

    CODEC_ID_MDEC,

    CODEC_ID_ROQ,

    CODEC_ID_INTERPLAY_VIDEO,

    CODEC_ID_XAN_WC3,

    CODEC_ID_XAN_WC4,

    CODEC_ID_RPZA,

    CODEC_ID_CINEPAK,

    CODEC_ID_WS_VQA,

    CODEC_ID_MSRLE,

    CODEC_ID_MSVIDEO1,

    CODEC_ID_IDCIN,

    CODEC_ID_8BPS,

    CODEC_ID_SMC,

    CODEC_ID_FLIC,

    CODEC_ID_TRUEMOTION1,

    CODEC_ID_VMDVIDEO,

    CODEC_ID_MSZH,

    CODEC_ID_ZLIB,

    CODEC_ID_QTRLE,

    CODEC_ID_SNOW,

    CODEC_ID_TSCC,

    CODEC_ID_ULTI,

    CODEC_ID_QDRAW,

    CODEC_ID_VIXL,

    CODEC_ID_QPEG,

#if LIBAVCODEC_VERSION_MAJOR < 53

    CODEC_ID_XVID,

#endif

    CODEC_ID_PNG,

    CODEC_ID_PPM,

    CODEC_ID_PBM,

    CODEC_ID_PGM,

    CODEC_ID_PGMYUV,

    CODEC_ID_PAM,

    CODEC_ID_FFVHUFF,

    CODEC_ID_RV30,

    CODEC_ID_RV40,

    CODEC_ID_VC1,

    CODEC_ID_WMV3,

    CODEC_ID_LOCO,

    CODEC_ID_WNV1,

    CODEC_ID_AASC,

    CODEC_ID_INDEO2,

    CODEC_ID_FRAPS,

    CODEC_ID_TRUEMOTION2,

    CODEC_ID_BMP,

    CODEC_ID_CSCD,

    CODEC_ID_MMVIDEO,

    CODEC_ID_ZMBV,

    CODEC_ID_AVS,

    CODEC_ID_SMACKVIDEO,

    CODEC_ID_NUV,

    CODEC_ID_KMVC,

    CODEC_ID_FLASHSV,

    CODEC_ID_CAVS,

    CODEC_ID_JPEG2000,

    CODEC_ID_VMNC,

    CODEC_ID_VP5,

    CODEC_ID_VP6,

    CODEC_ID_VP6F,

    CODEC_ID_TARGA,

    CODEC_ID_DSICINVIDEO,

    CODEC_ID_TIERTEXSEQVIDEO,

    CODEC_ID_TIFF,

    CODEC_ID_GIF,

    CODEC_ID_FFH264,

    CODEC_ID_DXA,

    CODEC_ID_DNXHD,

    CODEC_ID_THP,

    CODEC_ID_SGI,

    CODEC_ID_C93,

    CODEC_ID_BETHSOFTVID,

    CODEC_ID_PTX,

    CODEC_ID_TXD,

    CODEC_ID_VP6A,

    CODEC_ID_AMV,

    CODEC_ID_VB,

    CODEC_ID_PCX,

    CODEC_ID_SUNRAST,

    CODEC_ID_INDEO4,

    CODEC_ID_INDEO5,

    CODEC_ID_MIMIC,

    CODEC_ID_RL2,

    CODEC_ID_8SVX_EXP,

    CODEC_ID_8SVX_FIB,

    CODEC_ID_ESCAPE124,

    CODEC_ID_DIRAC,

    CODEC_ID_BFI,

    CODEC_ID_CMV,

    CODEC_ID_MOTIONPIXELS,

    CODEC_ID_TGV,

    CODEC_ID_TGQ,

    CODEC_ID_TQI,

    CODEC_ID_AURA,

    CODEC_ID_AURA2,

    CODEC_ID_V210X,

    CODEC_ID_TMV,

    CODEC_ID_V210,

    CODEC_ID_DPX,

    CODEC_ID_MAD,

    CODEC_ID_FRWU,

    CODEC_ID_FLASHSV2,

    CODEC_ID_CDGRAPHICS,

    CODEC_ID_R210,

    CODEC_ID_ANM,

    CODEC_ID_BINKVIDEO,

    CODEC_ID_IFF_ILBM,

    CODEC_ID_IFF_BYTERUN1,

    CODEC_ID_KGV1,

    CODEC_ID_YOP,

    CODEC_ID_VP8,

    CODEC_ID_PICTOR,

    CODEC_ID_ANSI,

    CODEC_ID_A64_MULTI,

    CODEC_ID_A64_MULTI5,

    CODEC_ID_R10K,

    CODEC_ID_MXPEG,

    CODEC_ID_LAGARITH,

    CODEC_ID_PRORES,

    /* various PCM "codecs" */

    CODEC_ID_PCM_S16LE= 0x10000,

    CODEC_ID_PCM_S16BE,

    CODEC_ID_PCM_U16LE,

    CODEC_ID_PCM_U16BE,

    CODEC_ID_PCM_S8,

    CODEC_ID_PCM_U8,

    CODEC_ID_PCM_MULAW,

    CODEC_ID_PCM_ALAW,

    CODEC_ID_PCM_S32LE,

    CODEC_ID_PCM_S32BE,

    CODEC_ID_PCM_U32LE,

    CODEC_ID_PCM_U32BE,

    CODEC_ID_PCM_S24LE,

    CODEC_ID_PCM_S24BE,

    CODEC_ID_PCM_U24LE,

    CODEC_ID_PCM_U24BE,

    CODEC_ID_PCM_S24DAUD,

    CODEC_ID_PCM_ZORK,

    CODEC_ID_PCM_S16LE_PLANAR,

    CODEC_ID_PCM_DVD,

    CODEC_ID_PCM_F32BE,

    CODEC_ID_PCM_F32LE,

    CODEC_ID_PCM_F64BE,

    CODEC_ID_PCM_F64LE,

    CODEC_ID_PCM_BLURAY,

    CODEC_ID_PCM_LXF,

    /* various ADPCM codecs */

    CODEC_ID_ADPCM_IMA_QT= 0x11000,

    CODEC_ID_ADPCM_IMA_WAV,

    CODEC_ID_ADPCM_IMA_DK3,

    CODEC_ID_ADPCM_IMA_DK4,

    CODEC_ID_ADPCM_IMA_WS,

    CODEC_ID_ADPCM_IMA_SMJPEG,

    CODEC_ID_ADPCM_MS,

    CODEC_ID_ADPCM_4XM,

    CODEC_ID_ADPCM_XA,

    CODEC_ID_ADPCM_ADX,

    CODEC_ID_ADPCM_EA,

    CODEC_ID_ADPCM_G726,

    CODEC_ID_ADPCM_CT,

    CODEC_ID_ADPCM_SWF,

    CODEC_ID_ADPCM_YAMAHA,

    CODEC_ID_ADPCM_SBPRO_4,

    CODEC_ID_ADPCM_SBPRO_3,

    CODEC_ID_ADPCM_SBPRO_2,

    CODEC_ID_ADPCM_THP,

    CODEC_ID_ADPCM_IMA_AMV,

    CODEC_ID_ADPCM_EA_R1,

    CODEC_ID_ADPCM_EA_R3,

    CODEC_ID_ADPCM_EA_R2,

    CODEC_ID_ADPCM_IMA_EA_SEAD,

    CODEC_ID_ADPCM_IMA_EA_EACS,

    CODEC_ID_ADPCM_EA_XAS,

    CODEC_ID_ADPCM_EA_MAXIS_XA,

    CODEC_ID_ADPCM_IMA_ISS,

    CODEC_ID_ADPCM_G722,

    /* AMR */

    CODEC_ID_AMR_NB= 0x12000,

    CODEC_ID_AMR_WB,

    /* RealAudio codecs*/

    CODEC_ID_RA_144= 0x13000,

    CODEC_ID_RA_288,

    /* various DPCM codecs */

    CODEC_ID_ROQ_DPCM= 0x14000,

    CODEC_ID_INTERPLAY_DPCM,

    CODEC_ID_XAN_DPCM,

    CODEC_ID_SOL_DPCM,

    /* audio codecs */

    CODEC_ID_MP2= 0x15000,

    CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3

    CODEC_ID_AAC,

    CODEC_ID_AC3,

    CODEC_ID_DTS,

    CODEC_ID_VORBIS,

    CODEC_ID_DVAUDIO,

    CODEC_ID_WMAV1,

    CODEC_ID_WMAV2,

    CODEC_ID_MACE3,

    CODEC_ID_MACE6,

    CODEC_ID_VMDAUDIO,

    CODEC_ID_SONIC,

    CODEC_ID_SONIC_LS,

    CODEC_ID_FLAC,

    CODEC_ID_MP3ADU,

    CODEC_ID_MP3ON4,

    CODEC_ID_SHORTEN,

    CODEC_ID_ALAC,

    CODEC_ID_WESTWOOD_SND1,

    CODEC_ID_GSM, ///< as in Berlin toast format

    CODEC_ID_QDM2,

    CODEC_ID_COOK,

    CODEC_ID_TRUESPEECH,

    CODEC_ID_TTA,

    CODEC_ID_SMACKAUDIO,

    CODEC_ID_QCELP,

    CODEC_ID_WAVPACK,

    CODEC_ID_DSICINAUDIO,

    CODEC_ID_IMC,

    CODEC_ID_MUSEPACK7,

    CODEC_ID_MLP,

    CODEC_ID_GSM_MS, /* as found in WAV */

    CODEC_ID_ATRAC3,

    CODEC_ID_VOXWARE,

    CODEC_ID_APE,

    CODEC_ID_NELLYMOSER,

    CODEC_ID_MUSEPACK8,

    CODEC_ID_SPEEX,

    CODEC_ID_WMAVOICE,

    CODEC_ID_WMAPRO,

    CODEC_ID_WMALOSSLESS,

    CODEC_ID_ATRAC3P,

    CODEC_ID_EAC3,

    CODEC_ID_SIPR,

    CODEC_ID_MP1,

    CODEC_ID_TWINVQ,

    CODEC_ID_TRUEHD,

    CODEC_ID_MP4ALS,

    CODEC_ID_ATRAC1,

    CODEC_ID_BINKAUDIO_RDFT,

    CODEC_ID_BINKAUDIO_DCT,

    CODEC_ID_AAC_LATM,

    CODEC_ID_QDMC,

    /* subtitle codecs */

    CODEC_ID_DVD_SUBTITLE= 0x17000,

    CODEC_ID_DVB_SUBTITLE,

    CODEC_ID_TEXT,  ///< raw UTF-8 text

    CODEC_ID_XSUB,

    CODEC_ID_SSA,

    CODEC_ID_MOV_TEXT,

    CODEC_ID_HDMV_PGS_SUBTITLE,

    CODEC_ID_DVB_TELETEXT,

    CODEC_ID_SRT,

    /* other specific kind of codecs (generally used for attachments) */

    CODEC_ID_TTF= 0x18000,

    CODEC_ID_PROBE= 0x19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it

    CODEC_ID_MPEG2TS= 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS

                                * stream (only used by libavformat) */

    CODEC_ID_FFMETADATA=0x21000,   ///< Dummy codec for streams containing only metadata information.

};

#if LIBAVCODEC_VERSION_MAJOR < 53

#define CodecType AVMediaType

#define CODEC_TYPE_UNKNOWN    AVMEDIA_TYPE_UNKNOWN

#define CODEC_TYPE_VIDEO      AVMEDIA_TYPE_VIDEO

#define CODEC_TYPE_AUDIO      AVMEDIA_TYPE_AUDIO

#define CODEC_TYPE_DATA       AVMEDIA_TYPE_DATA

#define CODEC_TYPE_SUBTITLE   AVMEDIA_TYPE_SUBTITLE

#define CODEC_TYPE_ATTACHMENT AVMEDIA_TYPE_ATTACHMENT

#define CODEC_TYPE_NB         AVMEDIA_TYPE_NB

#endif

#if FF_API_OLD_SAMPLE_FMT

#define SampleFormat AVSampleFormat

#define SAMPLE_FMT_NONE AV_SAMPLE_FMT_NONE

#define SAMPLE_FMT_U8   AV_SAMPLE_FMT_U8

#define SAMPLE_FMT_S16  AV_SAMPLE_FMT_S16

#define SAMPLE_FMT_S32  AV_SAMPLE_FMT_S32

#define SAMPLE_FMT_FLT  AV_SAMPLE_FMT_FLT

#define SAMPLE_FMT_DBL  AV_SAMPLE_FMT_DBL

#define SAMPLE_FMT_NB   AV_SAMPLE_FMT_NB

#endif

#if FF_API_OLD_AUDIOCONVERT

#include "libavutil/audioconvert.h"

/* Audio channel masks */

#define CH_FRONT_LEFT            AV_CH_FRONT_LEFT

#define CH_FRONT_RIGHT           AV_CH_FRONT_RIGHT

#define CH_FRONT_CENTER          AV_CH_FRONT_CENTER

#define CH_LOW_FREQUENCY         AV_CH_LOW_FREQUENCY

#define CH_BACK_LEFT             AV_CH_BACK_LEFT

#define CH_BACK_RIGHT            AV_CH_BACK_RIGHT

#define CH_FRONT_LEFT_OF_CENTER  AV_CH_FRONT_LEFT_OF_CENTER

#define CH_FRONT_RIGHT_OF_CENTER AV_CH_FRONT_RIGHT_OF_CENTER

#define CH_BACK_CENTER           AV_CH_BACK_CENTER

#define CH_SIDE_LEFT             AV_CH_SIDE_LEFT

#define CH_SIDE_RIGHT            AV_CH_SIDE_RIGHT

#define CH_TOP_CENTER            AV_CH_TOP_CENTER

#define CH_TOP_FRONT_LEFT        AV_CH_TOP_FRONT_LEFT

#define CH_TOP_FRONT_CENTER      AV_CH_TOP_FRONT_CENTER

#define CH_TOP_FRONT_RIGHT       AV_CH_TOP_FRONT_RIGHT

#define CH_TOP_BACK_LEFT         AV_CH_TOP_BACK_LEFT

#define CH_TOP_BACK_CENTER       AV_CH_TOP_BACK_CENTER

#define CH_TOP_BACK_RIGHT        AV_CH_TOP_BACK_RIGHT

#define CH_STEREO_LEFT           AV_CH_STEREO_LEFT

#define CH_STEREO_RIGHT          AV_CH_STEREO_RIGHT

/** Channel mask value used for AVCodecContext.request_channel_layout

    to indicate that the user requests the channel order of the decoder output

    to be the native codec channel order. */

#define CH_LAYOUT_NATIVE         AV_CH_LAYOUT_NATIVE

/* Audio channel convenience macros */

#define CH_LAYOUT_MONO           AV_CH_LAYOUT_MONO

#define CH_LAYOUT_STEREO         AV_CH_LAYOUT_STEREO

#define CH_LAYOUT_2_1            AV_CH_LAYOUT_2_1

#define CH_LAYOUT_SURROUND       AV_CH_LAYOUT_SURROUND

#define CH_LAYOUT_4POINT0        AV_CH_LAYOUT_4POINT0

#define CH_LAYOUT_2_2            AV_CH_LAYOUT_2_2

#define CH_LAYOUT_QUAD           AV_CH_LAYOUT_QUAD

#define CH_LAYOUT_5POINT0        AV_CH_LAYOUT_5POINT0

#define CH_LAYOUT_5POINT1        AV_CH_LAYOUT_5POINT1

#define CH_LAYOUT_5POINT0_BACK   AV_CH_LAYOUT_5POINT0_BACK

#define CH_LAYOUT_5POINT1_BACK   AV_CH_LAYOUT_5POINT1_BACK

#define CH_LAYOUT_7POINT0        AV_CH_LAYOUT_7POINT0

#define CH_LAYOUT_7POINT1        AV_CH_LAYOUT_7POINT1

#define CH_LAYOUT_7POINT1_WIDE   AV_CH_LAYOUT_7POINT1_WIDE

#define CH_LAYOUT_STEREO_DOWNMIX AV_CH_LAYOUT_STEREO_DOWNMIX

#endif

/* in bytes */

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio

/**

 * Required number of additionally allocated bytes at the end of the input bitstream for decoding.

 * This is mainly needed because some optimized bitstream readers read

 * 32 or 64 bit at once and could read over the end.<br>

 * Note: If the first 23 bits of the additional bytes are not 0, then damaged

 * MPEG bitstreams could cause overread and segfault.

 */

#define FF_INPUT_BUFFER_PADDING_SIZE 8

/**

 * minimum encoding buffer size

 * Used to avoid some checks during header writing.

 */

#define FF_MIN_BUFFER_SIZE 16384

/**

 * motion estimation type.

 */

enum Motion_Est_ID {

    ME_ZERO = 1,    ///< no search, that is use 0,0 vector whenever one is needed

    ME_FULL,

    ME_LOG,

    ME_PHODS,

    ME_EPZS,        ///< enhanced predictive zonal search

    ME_X1,          ///< reserved for experiments

    ME_HEX,         ///< hexagon based search

    ME_UMH,         ///< uneven multi-hexagon search

    ME_ITER,        ///< iterative search

    ME_TESA,        ///< transformed exhaustive search algorithm

};

enum AVDiscard{

    /* We leave some space between them for extensions (drop some

     * keyframes for intra-only or drop just some bidir frames). */

    AVDISCARD_NONE   =-16, ///< discard nothing

    AVDISCARD_DEFAULT=  0, ///< discard useless packets like 0 size packets in avi

    AVDISCARD_NONREF =  8, ///< discard all non reference

    AVDISCARD_BIDIR  = 16, ///< discard all bidirectional frames

    AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes

    AVDISCARD_ALL    = 48, ///< discard all

};

enum AVColorPrimaries{

    AVCOL_PRI_BT709      =1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B

    AVCOL_PRI_UNSPECIFIED=2,

    AVCOL_PRI_BT470M     =4,

    AVCOL_PRI_BT470BG    =5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM

    AVCOL_PRI_SMPTE170M  =6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC

    AVCOL_PRI_SMPTE240M  =7, ///< functionally identical to above

    AVCOL_PRI_FILM       =8,

    AVCOL_PRI_NB           , ///< Not part of ABI

};

enum AVColorTransferCharacteristic{

    AVCOL_TRC_BT709      =1, ///< also ITU-R BT1361

    AVCOL_TRC_UNSPECIFIED=2,

    AVCOL_TRC_GAMMA22    =4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM

    AVCOL_TRC_GAMMA28    =5, ///< also ITU-R BT470BG

    AVCOL_TRC_NB           , ///< Not part of ABI

};

enum AVColorSpace{

    AVCOL_SPC_RGB        =0,

    AVCOL_SPC_BT709      =1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B

    AVCOL_SPC_UNSPECIFIED=2,

    AVCOL_SPC_FCC        =4,

    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

    AVCOL_SPC_SMPTE170M  =6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above

    AVCOL_SPC_SMPTE240M  =7,

    AVCOL_SPC_NB           , ///< Not part of ABI

};

enum AVColorRange{

    AVCOL_RANGE_UNSPECIFIED=0,

    AVCOL_RANGE_MPEG       =1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges

    AVCOL_RANGE_JPEG       =2, ///< the normal     2^n-1   "JPEG" YUV ranges

    AVCOL_RANGE_NB           , ///< Not part of ABI

};

/**

 *  X   X      3 4 X      X are luma samples,

 *             1 2        1-6 are possible chroma positions

 *  X   X      5 6 X      0 is undefined/unknown position

 */

enum AVChromaLocation{

    AVCHROMA_LOC_UNSPECIFIED=0,

    AVCHROMA_LOC_LEFT       =1, ///< mpeg2/4, h264 default

    AVCHROMA_LOC_CENTER     =2, ///< mpeg1, jpeg, h263

    AVCHROMA_LOC_TOPLEFT    =3, ///< DV

    AVCHROMA_LOC_TOP        =4,

    AVCHROMA_LOC_BOTTOMLEFT =5,

    AVCHROMA_LOC_BOTTOM     =6,

    AVCHROMA_LOC_NB           , ///< Not part of ABI

};

/**

 * LPC analysis type

 */

enum AVLPCType {

    AV_LPC_TYPE_DEFAULT     = -1, ///< use the codec default LPC type

    AV_LPC_TYPE_NONE        =  0, ///< do not use LPC prediction or use all zero coefficients

    AV_LPC_TYPE_FIXED       =  1, ///< fixed LPC coefficients

    AV_LPC_TYPE_LEVINSON    =  2, ///< Levinson-Durbin recursion

    AV_LPC_TYPE_CHOLESKY    =  3, ///< Cholesky factorization

    AV_LPC_TYPE_NB              , ///< Not part of ABI

};

typedef struct RcOverride{

    int start_frame;

    int end_frame;

    int qscale; // If this is 0 then quality_factor will be used instead.

    float quality_factor;

} RcOverride;

#define FF_MAX_B_FRAMES 16

/* encoding support

   These flags can be passed in AVCodecContext.flags before initialization.

   Note: Not everything is supported yet.

*/

#define CODEC_FLAG_QSCALE 0x0002  ///< Use fixed qscale.

#define CODEC_FLAG_4MV    0x0004  ///< 4 MV per MB allowed / advanced prediction for H.263.

#define CODEC_FLAG_QPEL   0x0010  ///< Use qpel MC.

#define CODEC_FLAG_GMC    0x0020  ///< Use GMC.

#define CODEC_FLAG_MV0    0x0040  ///< Always try a MB with MV=<0,0>.

#define CODEC_FLAG_PART   0x0080  ///< Use data partitioning.

/**

 * The parent program guarantees that the input for B-frames containing

 * streams is not written to for at least s->max_b_frames+1 frames, if

 * this is not set the input will be copied.

 */

#define CODEC_FLAG_INPUT_PRESERVED 0x0100

#define CODEC_FLAG_PASS1           0x0200   ///< Use internal 2pass ratecontrol in first pass mode.

#define CODEC_FLAG_PASS2           0x0400   ///< Use internal 2pass ratecontrol in second pass mode.

#define CODEC_FLAG_EXTERN_HUFF     0x1000   ///< Use external Huffman table (for MJPEG).

#define CODEC_FLAG_GRAY            0x2000   ///< Only decode/encode grayscale.

#define CODEC_FLAG_EMU_EDGE        0x4000   ///< Don't draw edges.

#define CODEC_FLAG_PSNR            0x8000   ///< error[?] variables will be set during encoding.

#define CODEC_FLAG_TRUNCATED       0x00010000 /** Input bitstream might be truncated at a random

                                                  location instead of only at frame boundaries. */

#define CODEC_FLAG_NORMALIZE_AQP  0x00020000 ///< Normalize adaptive quantization.

#define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< Use interlaced DCT.

#define CODEC_FLAG_LOW_DELAY      0x00080000 ///< Force low delay.

#define CODEC_FLAG_ALT_SCAN       0x00100000 ///< Use alternate scan.

#define CODEC_FLAG_GLOBAL_HEADER  0x00400000 ///< Place global headers in extradata instead of every keyframe.

#define CODEC_FLAG_BITEXACT       0x00800000 ///< Use only bitexact stuff (except (I)DCT).

/* Fx : Flag for h263+ extra options */

#define CODEC_FLAG_AC_PRED        0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction

#define CODEC_FLAG_H263P_UMV      0x02000000 ///< unlimited motion vector

#define CODEC_FLAG_CBP_RD         0x04000000 ///< Use rate distortion optimization for cbp.

#define CODEC_FLAG_QP_RD          0x08000000 ///< Use rate distortion optimization for qp selectioon.

#define CODEC_FLAG_H263P_AIV      0x00000008 ///< H.263 alternative inter VLC

#define CODEC_FLAG_OBMC           0x00000001 ///< OBMC

#define CODEC_FLAG_LOOP_FILTER    0x00000800 ///< loop filter

#define CODEC_FLAG_H263P_SLICE_STRUCT 0x10000000

#define CODEC_FLAG_INTERLACED_ME  0x20000000 ///< interlaced motion estimation

#define CODEC_FLAG_SVCD_SCAN_OFFSET 0x40000000 ///< Will reserve space for SVCD scan offset user data.

#define CODEC_FLAG_CLOSED_GOP     0x80000000

#define CODEC_FLAG2_FAST          0x00000001 ///< Allow non spec compliant speedup tricks.

#define CODEC_FLAG2_STRICT_GOP    0x00000002 ///< Strictly enforce GOP size.

#define CODEC_FLAG2_NO_OUTPUT     0x00000004 ///< Skip bitstream encoding.

#define CODEC_FLAG2_LOCAL_HEADER  0x00000008 ///< Place global headers at every keyframe instead of in extradata.

#define CODEC_FLAG2_BPYRAMID      0x00000010 ///< H.264 allow B-frames to be used as references.

#define CODEC_FLAG2_WPRED         0x00000020 ///< H.264 weighted biprediction for B-frames

#define CODEC_FLAG2_MIXED_REFS    0x00000040 ///< H.264 one reference per partition, as opposed to one reference per macroblock

#define CODEC_FLAG2_8X8DCT        0x00000080 ///< H.264 high profile 8x8 transform

#define CODEC_FLAG2_FASTPSKIP     0x00000100 ///< H.264 fast pskip

#define CODEC_FLAG2_AUD           0x00000200 ///< H.264 access unit delimiters

#define CODEC_FLAG2_BRDO          0x00000400 ///< B-frame rate-distortion optimization

#define CODEC_FLAG2_INTRA_VLC     0x00000800 ///< Use MPEG-2 intra VLC table.

#define CODEC_FLAG2_MEMC_ONLY     0x00001000 ///< Only do ME/MC (I frames -> ref, P frame -> ME+MC).

#define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format.

#define CODEC_FLAG2_SKIP_RD       0x00004000 ///< RD optimal MB level residual skipping

#define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.

#define CODEC_FLAG2_NON_LINEAR_QUANT 0x00010000 ///< Use MPEG-2 nonlinear quantizer.

#define CODEC_FLAG2_BIT_RESERVOIR 0x00020000 ///< Use a bit reservoir when encoding if possible

#define CODEC_FLAG2_MBTREE        0x00040000 ///< Use macroblock tree ratecontrol (x264 only)

#define CODEC_FLAG2_PSY           0x00080000 ///< Use psycho visual optimizations.

#define CODEC_FLAG2_SSIM          0x00100000 ///< Compute SSIM during encoding, error[] values are undefined.

#define CODEC_FLAG2_INTRA_REFRESH 0x00200000 ///< Use periodic insertion of intra blocks instead of keyframes.

/* Unsupported options :

 *              Syntax Arithmetic coding (SAC)

 *              Reference Picture Selection

 *              Independent Segment Decoding */

/* /Fx */

/* codec capabilities */

#define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< Decoder can use draw_horiz_band callback.

/**

 * Codec uses get_buffer() for allocating buffers and supports custom allocators.

 * If not set, it might not use get_buffer() at all or use operations that

 * assume the buffer was allocated by avcodec_default_get_buffer.

 */

#define CODEC_CAP_DR1             0x0002

/* If 'parse_only' field is true, then avcodec_parse_frame() can be used. */

#define CODEC_CAP_PARSE_ONLY      0x0004

#define CODEC_CAP_TRUNCATED       0x0008

/* Codec can export data for HW decoding (XvMC). */

#define CODEC_CAP_HWACCEL         0x0010

/**

 * Codec has a nonzero delay and needs to be fed with NULL at the end to get the delayed data.

 * If this is not set, the codec is guaranteed to never be fed with NULL data.

 */

#define CODEC_CAP_DELAY           0x0020

/**

 * Codec can be fed a final frame with a smaller size.

 * This can be used to prevent truncation of the last audio samples.

 */

#define CODEC_CAP_SMALL_LAST_FRAME 0x0040

/**

 * Codec can export data for HW decoding (VDPAU).

 */

#define CODEC_CAP_HWACCEL_VDPAU    0x0080

/**

 * Codec can output multiple frames per AVPacket

 * Normally demuxers return one frame at a time, demuxers which do not do

 * are connected to a parser to split what they return into proper frames.

 * This flag is reserved to the very rare category of codecs which have a

 * bitstream that cannot be split into frames without timeconsuming

 * operations like full decoding. Demuxers carring such bitstreams thus

 * may return multiple frames in a packet. This has many disadvantages like

 * prohibiting stream copy in many cases thus it should only be considered

 * as a last resort.

 */

#define CODEC_CAP_SUBFRAMES        0x0100

/**

 * Codec is experimental and is thus avoided in favor of non experimental

 * encoders

 */

#define CODEC_CAP_EXPERIMENTAL     0x0200

/**

 * Codec should fill in channel configuration and samplerate instead of container

 */

#define CODEC_CAP_CHANNEL_CONF     0x0400

/**

 * Codec is able to deal with negative linesizes

 */

#define CODEC_CAP_NEG_LINESIZES    0x0800

/**

 * Codec supports frame-level multithreading.

 */

#define CODEC_CAP_FRAME_THREADS    0x1000

//The following defines may change, don't expect compatibility if you use them.

#define MB_TYPE_INTRA4x4   0x0001

#define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific

#define MB_TYPE_INTRA_PCM  0x0004 //FIXME H.264-specific

#define MB_TYPE_16x16      0x0008

#define MB_TYPE_16x8       0x0010

#define MB_TYPE_8x16       0x0020

#define MB_TYPE_8x8        0x0040

#define MB_TYPE_INTERLACED 0x0080

#define MB_TYPE_DIRECT2    0x0100 //FIXME

#define MB_TYPE_ACPRED     0x0200

#define MB_TYPE_GMC        0x0400

#define MB_TYPE_SKIP       0x0800

#define MB_TYPE_P0L0       0x1000

#define MB_TYPE_P1L0       0x2000

#define MB_TYPE_P0L1       0x4000

#define MB_TYPE_P1L1       0x8000

#define MB_TYPE_L0         (MB_TYPE_P0L0 | MB_TYPE_P1L0)

#define MB_TYPE_L1         (MB_TYPE_P0L1 | MB_TYPE_P1L1)

#define MB_TYPE_L0L1       (MB_TYPE_L0   | MB_TYPE_L1)

#define MB_TYPE_QUANT      0x00010000

#define MB_TYPE_CBP        0x00020000

//Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...)

/**

 * Pan Scan area.

 * This specifies the area which should be displayed.

 * Note there may be multiple such areas for one frame.

 */

typedef struct AVPanScan{

    /**

     * id

     * - encoding: Set by user.

     * - decoding: Set by libavcodec.

     */

    int id;

    /**

     * width and height in 1/16 pel

     * - encoding: Set by user.

     * - decoding: Set by libavcodec.

     */

    int width;

    int height;

    /**

     * position of the top left corner in 1/16 pel for up to 3 fields/frames

     * - encoding: Set by user.

     * - decoding: Set by libavcodec.

     */

    int16_t position[3][2];

}AVPanScan;

#define FF_COMMON_FRAME \

    /**\

     * pointer to the picture planes.\

     * This might be different from the first allocated byte\

     * - encoding: \

     * - decoding: \

     */\

    uint8_t *data[4];\

    int linesize[4];\

    /**\

     * pointer to the first allocated byte of the picture. Can be used in get_buffer/release_buffer.\

     * This isn't used by libavcodec unless the default get/release_buffer() is used.\

     * - encoding: \

     * - decoding: \

     */\

    uint8_t *base[4];\

    /**\

     * 1 -> keyframe, 0-> not\

     * - encoding: Set by libavcodec.\

     * - decoding: Set by libavcodec.\

     */\

    int key_frame;\

\

    /**\

     * Picture type of the frame, see ?_TYPE below.\

     * - encoding: Set by libavcodec. for coded_picture (and set by user for input).\

     * - decoding: Set by libavcodec.\

     */\

    int pict_type;\

\

    /**\

     * presentation timestamp in time_base units (time when frame should be shown to user)\

     * If AV_NOPTS_VALUE then frame_rate = 1/time_base will be assumed.\

     * - encoding: MUST be set by user.\

     * - decoding: Set by libavcodec.\

     */\

    int64_t pts;\

\

    /**\

     * picture number in bitstream order\

     * - encoding: set by\

     * - decoding: Set by libavcodec.\

     */\

    int coded_picture_number;\

    /**\

     * picture number in display order\

     * - encoding: set by\

     * - decoding: Set by libavcodec.\

     */\

    int display_picture_number;\

\

    /**\

     * quality (between 1 (good) and FF_LAMBDA_MAX (bad)) \

     * - encoding: Set by libavcodec. for coded_picture (and set by user for input).\

     * - decoding: Set by libavcodec.\

     */\

    int quality; \

\

    /**\

     * buffer age (1->was last buffer and dint change, 2->..., ...).\

     * Set to INT_MAX if the buffer has not been used yet.\

     * - encoding: unused\

     * - decoding: MUST be set by get_buffer().\

     */\

    int age;\

\

    /**\

     * is this picture used as reference\

     * The values for this are the same as the MpegEncContext.picture_structure\

     * variable, that is 1->top field, 2->bottom field, 3->frame/both fields.\

     * Set to 4 for delayed, non-reference frames.\

     * - encoding: unused\

     * - decoding: Set by libavcodec. (before get_buffer() call)).\

     */\

    int reference;\

\

    /**\

     * QP table\

     * - encoding: unused\

     * - decoding: Set by libavcodec.\

     */\

    int8_t *qscale_table;\

    /**\

     * QP store stride\

     * - encoding: unused\

     * - decoding: Set by libavcodec.\

     */\

    int qstride;\

\

    /**\

     * mbskip_table[mb]>=1 if MB didn't change\

     * stride= mb_width = (width+15)>>4\

     * - encoding: unused\

     * - decoding: Set by libavcodec.\

     */\

    uint8_t *mbskip_table;\

\

    /**\

     * motion vector table\

     * @code\

     * example:\

     * int mv_sample_log2= 4 - motion_subsample_log2;\

     * int mb_width= (width+15)>>4;\

     * int mv_stride= (mb_width << mv_sample_log2) + 1;\

     * motion_val[direction][x + y*mv_stride][0->mv_x, 1->mv_y];\

     * @endcode\

     * - encoding: Set by user.\

     * - decoding: Set by libavcodec.\

     */\

    int16_t (*motion_val[2])[2];\

\

    /**\

     * macroblock type table\

     * mb_type_base + mb_width + 2\

     * - encoding: Set by user.\

     * - decoding: Set by libavcodec.\

     */\

    uint32_t *mb_type;\

\

    /**\

     * log2 of the size of the block which a single vector in motion_val represents: \

     * (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2)\

     * - encoding: unused\

     * - decoding: Set by libavcodec.\

     */\

    uint8_t motion_subsample_log2;\

\

    /**\

     * for some private data of the user\

     * - encoding: unused\

     * - decoding: Set by user.\

     */\

    void *opaque;\

\

    /**\

     * error\

     * - encoding: Set by libavcodec. if flags&CODEC_FLAG_PSNR.\

     * - decoding: unused\

     */\

    uint64_t error[4];\

\

    /**\

     * type of the buffer (to keep track of who has to deallocate data[*])\

     * - encoding: Set by the one who allocates it.\

     * - decoding: Set by the one who allocates it.\

     * Note: User allocated (direct rendering) & internal buffers cannot coexist currently.\

     */\

    int type;\

    \

    /**\

     * When decoding, this signals how much the picture must be delayed.\

     * extra_delay = repeat_pict / (2*fps)\

     * - encoding: unused\

     * - decoding: Set by libavcodec.\

     */\

    int repeat_pict;\

    \

    /**\

     * \

     */\

    int qscale_type;\

    \

    /**\

     * The content of the picture is interlaced.\

     * - encoding: Set by user.\

     * - decoding: Set by libavcodec. (default 0)\

     */\

    int interlaced_frame;\

    \

    /**\

     * If the content is interlaced, is top field displayed first.\

     * - encoding: Set by user.\

     * - decoding: Set by libavcodec.\

     */\

    int top_field_first;\

    \

    /**\

     * Pan scan.\

     * - encoding: Set by user.\

     * - decoding: Set by libavcodec.\

     */\

    AVPanScan *pan_scan;\

    \

    /**\

     * Tell user application that palette has changed from previous frame.\

     * - encoding: ??? (no palette-enabled encoder yet)\

     * - decoding: Set by libavcodec. (default 0).\

     */\

    int palette_has_changed;\

    \

    /**\

     * codec suggestion on buffer type if != 0\

     * - encoding: unused\

     * - decoding: Set by libavcodec. (before get_buffer() call)).\

     */\

    int buffer_hints;\

\

    /**\

     * DCT coefficients\

     * - encoding: unused\

     * - decoding: Set by libavcodec.\

     */\

    short *dct_coeff;\

\

    /**\

     * motion reference frame index\

     * the order in which these are stored can depend on the codec.\

     * - encoding: Set by user.\

     * - decoding: Set by libavcodec.\

     */\

    int8_t *ref_index[2];\

\

    /**\

     * reordered opaque 64bit (generally an integer or a double precision float\

     * PTS but can be anything). \

     * The user sets AVCodecContext.reordered_opaque to represent the input at\

     * that time,\

     * the decoder reorders values as needed and sets AVFrame.reordered_opaque\

     * to exactly one of the values provided by the user through AVCodecContext.reordered_opaque \

     * @deprecated in favor of pkt_pts\

     * - encoding: unused\

     * - decoding: Read by user.\

     */\

    int64_t reordered_opaque;\

\

    /**\

     * hardware accelerator private data (FFmpeg allocated)\

     * - encoding: unused\

     * - decoding: Set by libavcodec\

     */\

    void *hwaccel_picture_private;\

\

    /**\

     * reordered pts from the last AVPacket that has been input into the decoder\

     * - encoding: unused\

     * - decoding: Read by user.\

     */\

    int64_t pkt_pts;\

\

    /**\

     * dts from the last AVPacket that has been input into the decoder\

     * - encoding: unused\

     * - decoding: Read by user.\

     */\

    int64_t pkt_dts;\

\

    /**\

     * the AVCodecContext which ff_thread_get_buffer() was last called on\

     * - encoding: Set by libavcodec.\

     * - decoding: Set by libavcodec.\

     */\

    struct AVCodecContext *owner;\

\

    /**\

     * used by multithreading to store frame-specific info\

     * - encoding: Set by libavcodec.\

     * - decoding: Set by libavcodec.\

     */\

    void *thread_opaque;\

#define FF_QSCALE_TYPE_MPEG1 0

#define FF_QSCALE_TYPE_MPEG2 1

#define FF_QSCALE_TYPE_H264  2

#define FF_QSCALE_TYPE_VP56  3

#define FF_BUFFER_TYPE_INTERNAL 1

#define FF_BUFFER_TYPE_USER     2 ///< direct rendering buffers (image is (de)allocated by user)

#define FF_BUFFER_TYPE_SHARED   4 ///< Buffer from somewhere else; don't deallocate image (data/base), all other tables are not shared.

#define FF_BUFFER_TYPE_COPY     8 ///< Just a (modified) copy of some other buffer, don't deallocate anything.

#define FF_I_TYPE  1 ///< Intra

#define FF_P_TYPE  2 ///< Predicted

#define FF_B_TYPE  3 ///< Bi-dir predicted

#define FF_S_TYPE  4 ///< S(GMC)-VOP MPEG4

#define FF_SI_TYPE 5 ///< Switching Intra

#define FF_SP_TYPE 6 ///< Switching Predicted

#define FF_BI_TYPE 7

#define FF_BUFFER_HINTS_VALID    0x01 // Buffer hints value is meaningful (if 0 ignore).

#define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer.

#define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content.

#define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update).

typedef struct AVPacket {

    /**

     * Presentation timestamp in AVStream->time_base units; the time at which

     * the decompressed packet will be presented to the user.

     * Can be AV_NOPTS_VALUE if it is not stored in the file.

     * pts MUST be larger or equal to dts as presentation cannot happen before

     * decompression, unless one wants to view hex dumps. Some formats misuse

     * the terms dts and pts/cts to mean something different. Such timestamps

     * must be converted to true pts/dts before they are stored in AVPacket.

     */

    int64_t pts;

    /**

     * Decompression timestamp in AVStream->time_base units; the time at which

     * the packet is decompressed.

     * Can be AV_NOPTS_VALUE if it is not stored in the file.

     */

    int64_t dts;

    uint8_t *data;

    int   size;

    int   stream_index;

    int   flags;

    /**

     * Duration of this packet in AVStream->time_base units, 0 if unknown.

     * Equals next_pts - this_pts in presentation order.

     */

    int   duration;

    void  (*destruct)(struct AVPacket *);

    void  *priv;

    int64_t pos;                            ///< byte position in stream, -1 if unknown

    /**

     * Time difference in AVStream->time_base units from the pts of this

     * packet to the point at which the output from the decoder has converged

     * independent from the availability of previous frames. That is, the

     * frames are virtually identical no matter if decoding started from

     * the very first frame or from this keyframe.

     * Is AV_NOPTS_VALUE if unknown.

     * This field is not the display duration of the current packet.

     * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY

     * set.

     *

     * The purpose of this field is to allow seeking in streams that have no

     * keyframes in the conventional sense. It corresponds to the

     * recovery point SEI in H.264 and match_time_delta in NUT. It is also

     * essential for some types of subtitle streams to ensure that all

     * subtitles are correctly displayed after seeking.

     */

    int64_t convergence_duration;

} AVPacket;

#define AV_PKT_FLAG_KEY   0x0001

#if LIBAVCODEC_VERSION_MAJOR < 53

#define PKT_FLAG_KEY AV_PKT_FLAG_KEY

#endif

/**

 * Audio Video Frame.

 * New fields can be added to the end of FF_COMMON_FRAME with minor version

 * bumps.

 * Removal, reordering and changes to existing fields require a major

 * version bump. No fields should be added into AVFrame before or after

 * FF_COMMON_FRAME!

 * sizeof(AVFrame) must not be used outside libav*.

 */

typedef struct AVFrame {

    FF_COMMON_FRAME

} AVFrame;

/**

 * main external API structure.

 * New fields can be added to the end with minor version bumps.

 * Removal, reordering and changes to existing fields require a major

 * version bump.

 * sizeof(AVCodecContext) must not be used outside libav*.

 */

typedef struct AVCodecContext {

    /**

     * information on struct for av_log

     * - set by avcodec_alloc_context

     */

    const AVClass *av_class;

    /**

     * the average bitrate

     * - encoding: Set by user; unused for constant quantizer encoding.

     * - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream.

     */

    int bit_rate;

    /**

     * number of bits the bitstream is allowed to diverge from the reference.

     *           the reference can be CBR (for CBR pass1) or VBR (for pass2)

     * - encoding: Set by user; unused for constant quantizer encoding.

     * - decoding: unused

     */

    int bit_rate_tolerance;

    /**

     * CODEC_FLAG_*.

     * - encoding: Set by user.

     * - decoding: Set by user.

     */

    int flags;

    /**

     * Some codecs need additional format info. It is stored here.

     * If any muxer uses this then ALL demuxers/parsers AND encoders for the

     * specific codec MUST set it correctly otherwise stream copy breaks.

     * In general use of this field by muxers is not recommanded.

     * - encoding: Set by libavcodec.

     * - decoding: Set by libavcodec. (FIXME: Is this OK?)

     */

    int sub_id;

    /**

     * Motion estimation algorithm used for video coding.

     * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex),

     * 8 (umh), 9 (iter), 10 (tesa) [7, 8, 10 are x264 specific, 9 is snow specific]

     * - encoding: MUST be set by user.

     * - decoding: unused

     */

    int me_method;

    /**

     * some codecs need / can use extradata like Huffman tables.

     * mjpeg: Huffman tables

     * rv10: additional flags

     * mpeg4: global headers (they can be in the bitstream or here)

     * The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger

     * than extradata_size to avoid prolems if it is read with the bitstream reader.

     * The bytewise contents of extradata must not depend on the architecture or CPU endianness.

     * - encoding: Set/allocated/freed by libavcodec.

     * - decoding: Set/allocated/freed by user.

     */

    uint8_t *extradata;

    int extradata_size;

    /**

     * This is the fundamental unit of time (in seconds) in terms

     * of which frame timestamps are represented. For fixed-fps content,

     * timebase should be 1/framerate and timestamp increments should be

     * identically 1.

     * - encoding: MUST be set by user.

     * - decoding: Set by libavcodec.

     */

    AVRational time_base;

    /* video only */

    /**

     * picture width / height.

     * - encoding: MUST be set by user.

     * - decoding: Set by libavcodec.

     * Note: For compatibility it is possible to set this instead of

     * coded_width/height before decoding.

     */

    int width, height;

#define FF_ASPECT_EXTENDED 15

    /**

     * the number of pictures in a group of pictures, or 0 for intra_only

     * - encoding: Set by user.

     * - decoding: unused

     */

    int gop_size;

    /**

     * Pixel format, see PIX_FMT_xxx.

     * May be set by the demuxer if known from headers.

     * May be overriden by the decoder if it knows better.

     * - encoding: Set by user.

     * - decoding: Set by user if known, overridden by libavcodec if known

     */

    enum PixelFormat pix_fmt;

    /**

     * Frame rate emulation. If not zero, the lower layer (i.e. format handler)

     * has to read frames at native frame rate.

     * - encoding: Set by user.

     * - decoding: unused

     */

    int rate_emu;

    /**

     * If non NULL, 'draw_horiz_band' is called by the libavcodec

     * decoder to draw a horizontal band. It improves cache usage. Not

     * all codecs can do that. You must check the codec capabilities

     * beforehand.

     * When multithreading is used, it may be called from multiple threads

     * at the same time; threads might draw different parts of the same AVFrame,

     * or multiple AVFrames, and there is no guarantee that slices will be drawn

     * in order.

     * The function is also used by hardware acceleration APIs.

     * It is called at least once during frame decoding to pass

     * the data needed for hardware render.

     * In that mode instead of pixel data, AVFrame points to

     * a structure specific to the acceleration API. The application

     * reads the structure and can change some fields to indicate progress

     * or mark state.

     * - encoding: unused

     * - decoding: Set by user.

     * @param height the height of the slice

     * @param y the y position of the slice

     * @param type 1->top field, 2->bottom field, 3->frame

     * @param offset offset into the AVFrame.data from which the slice should be read

     */

    void (*draw_horiz_band)(struct AVCodecContext *s,

                            const AVFrame *src, int offset[4],

                            int y, int type, int height);

    /* audio only */

    int sample_rate; ///< samples per second

    int channels;    ///< number of audio channels

    /**

     * audio sample format

     * - encoding: Set by user.

     * - decoding: Set by libavcodec.

     */

    enum AVSampleFormat sample_fmt;  ///< sample format

    /* The following data should not be initialized. */

    /**

     * Samples per packet, initialized when calling 'init'.

     */

    int frame_size;

    int frame_number;   ///< audio or video frame number

#if LIBAVCODEC_VERSION_MAJOR < 53

    int real_pict_num;  ///< Returns the real picture number of previous encoded frame.

#endif

    /**

     * Number of frames the decoded output will be delayed relative to

     * the encoded input.

     * - encoding: Set by libavcodec.

     * - decoding: unused

     */

    int delay;

    /* - encoding parameters */

    float qcompress;  ///< amount of qscale change between easy & hard scenes (0.0-1.0)

    float qblur;      ///< amount of qscale smoothing over time (0.0-1.0)

    /**

     * minimum quantizer

     * - encoding: Set by user.

     * - decoding: unused

     */

    int qmin;

    /**

     * maximum quantizer

     * - encoding: Set by user.

     * - decoding: unused

     */

    int qmax;

    /**

     * maximum quantizer difference between frames

     * - encoding: Set by user.

     * - decoding: unused

     */

    int max_qdiff;

    /**

     * maximum number of B-frames between non-B-frames

     * Note: The output will be delayed by max_b_frames+1 relative to the input.

     * - encoding: Set by user.

     * - decoding: unused

     */

    int max_b_frames;

    /**

     * qscale factor between IP and B-frames

     * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset).

     * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).

     * - encoding: Set by user.