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