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