avcodec.h 173 KB
Newer Older
1 2 3
/*
 * copyright (c) 2001 Fabrice Bellard
 *
4 5 6
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
7 8
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 20
 */

21 22
#ifndef AVCODEC_AVCODEC_H
#define AVCODEC_AVCODEC_H
Fabrice Bellard's avatar
Fabrice Bellard committed
23

24
/**
25
 * @file
26 27
 * @ingroup libavc
 * Libavcodec external API header
28 29
 */

30
#include <errno.h>
31
#include "libavutil/samplefmt.h"
32
#include "libavutil/attributes.h"
33
#include "libavutil/avutil.h"
34
#include "libavutil/buffer.h"
35
#include "libavutil/cpu.h"
36
#include "libavutil/channel_layout.h"
37
#include "libavutil/dict.h"
38
#include "libavutil/frame.h"
39
#include "libavutil/log.h"
40
#include "libavutil/pixfmt.h"
41
#include "libavutil/rational.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
42

43 44
#include "version.h"

45 46 47 48 49
#if FF_API_FAST_MALLOC
// to provide fast_*alloc
#include "libavutil/mem.h"
#endif

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
/**
 * @defgroup libavc Encoding/Decoding Library
 * @{
 *
 * @defgroup lavc_decoding Decoding
 * @{
 * @}
 *
 * @defgroup lavc_encoding Encoding
 * @{
 * @}
 *
 * @defgroup lavc_codec Codecs
 * @{
 * @defgroup lavc_codec_native Native Codecs
 * @{
 * @}
 * @defgroup lavc_codec_wrappers External library wrappers
 * @{
 * @}
 * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge
 * @{
 * @}
 * @}
 * @defgroup lavc_internal Internal
 * @{
 * @}
 * @}
 *
 */

81 82 83 84 85 86 87 88
/**
 * @defgroup lavc_core Core functions/structures.
 * @ingroup libavc
 *
 * Basic definitions, functions for querying libavcodec capabilities,
 * allocating core structures, etc.
 * @{
 */
89

90

91
/**
Måns Rullgård's avatar
Måns Rullgård committed
92
 * Identify the syntax and semantics of the bitstream.
93 94 95 96 97
 * The principle is roughly:
 * Two decoders with the same ID can decode the same streams.
 * Two encoders with the same ID can encode compatible streams.
 * There may be slight deviations from the principle due to implementation
 * details.
98
 *
Diego Biurrun's avatar
Diego Biurrun committed
99 100
 * If you add a codec ID to this list, add it so that
 * 1. no value of a existing codec ID changes (that would break ABI),
101
 * 2. Give it a value which when taken as ASCII is recognized uniquely by a human as this specific codec.
102
 *    This ensures that 2 forks can independently add AVCodecIDs without producing conflicts.
103 104 105
 *
 * After adding new codec IDs, do not forget to add an entry to the codec
 * descriptor list and bump libavcodec minor version.
106
 */
107 108
enum AVCodecID {
    AV_CODEC_ID_NONE,
109 110

    /* video codecs */
111 112
    AV_CODEC_ID_MPEG1VIDEO,
    AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
113
#if FF_API_XVMC
114
    AV_CODEC_ID_MPEG2VIDEO_XVMC,
115
#endif /* FF_API_XVMC */
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
    AV_CODEC_ID_H261,
    AV_CODEC_ID_H263,
    AV_CODEC_ID_RV10,
    AV_CODEC_ID_RV20,
    AV_CODEC_ID_MJPEG,
    AV_CODEC_ID_MJPEGB,
    AV_CODEC_ID_LJPEG,
    AV_CODEC_ID_SP5X,
    AV_CODEC_ID_JPEGLS,
    AV_CODEC_ID_MPEG4,
    AV_CODEC_ID_RAWVIDEO,
    AV_CODEC_ID_MSMPEG4V1,
    AV_CODEC_ID_MSMPEG4V2,
    AV_CODEC_ID_MSMPEG4V3,
    AV_CODEC_ID_WMV1,
    AV_CODEC_ID_WMV2,
    AV_CODEC_ID_H263P,
    AV_CODEC_ID_H263I,
    AV_CODEC_ID_FLV1,
    AV_CODEC_ID_SVQ1,
    AV_CODEC_ID_SVQ3,
    AV_CODEC_ID_DVVIDEO,
    AV_CODEC_ID_HUFFYUV,
    AV_CODEC_ID_CYUV,
    AV_CODEC_ID_H264,
    AV_CODEC_ID_INDEO3,
    AV_CODEC_ID_VP3,
    AV_CODEC_ID_THEORA,
    AV_CODEC_ID_ASV1,
    AV_CODEC_ID_ASV2,
    AV_CODEC_ID_FFV1,
    AV_CODEC_ID_4XM,
    AV_CODEC_ID_VCR1,
    AV_CODEC_ID_CLJR,
    AV_CODEC_ID_MDEC,
    AV_CODEC_ID_ROQ,
    AV_CODEC_ID_INTERPLAY_VIDEO,
    AV_CODEC_ID_XAN_WC3,
    AV_CODEC_ID_XAN_WC4,
    AV_CODEC_ID_RPZA,
    AV_CODEC_ID_CINEPAK,
    AV_CODEC_ID_WS_VQA,
    AV_CODEC_ID_MSRLE,
    AV_CODEC_ID_MSVIDEO1,
    AV_CODEC_ID_IDCIN,
    AV_CODEC_ID_8BPS,
    AV_CODEC_ID_SMC,
    AV_CODEC_ID_FLIC,
    AV_CODEC_ID_TRUEMOTION1,
    AV_CODEC_ID_VMDVIDEO,
    AV_CODEC_ID_MSZH,
    AV_CODEC_ID_ZLIB,
    AV_CODEC_ID_QTRLE,
    AV_CODEC_ID_TSCC,
    AV_CODEC_ID_ULTI,
    AV_CODEC_ID_QDRAW,
    AV_CODEC_ID_VIXL,
    AV_CODEC_ID_QPEG,
    AV_CODEC_ID_PNG,
    AV_CODEC_ID_PPM,
    AV_CODEC_ID_PBM,
    AV_CODEC_ID_PGM,
    AV_CODEC_ID_PGMYUV,
    AV_CODEC_ID_PAM,
    AV_CODEC_ID_FFVHUFF,
    AV_CODEC_ID_RV30,
    AV_CODEC_ID_RV40,
    AV_CODEC_ID_VC1,
    AV_CODEC_ID_WMV3,
    AV_CODEC_ID_LOCO,
    AV_CODEC_ID_WNV1,
    AV_CODEC_ID_AASC,
    AV_CODEC_ID_INDEO2,
    AV_CODEC_ID_FRAPS,
    AV_CODEC_ID_TRUEMOTION2,
    AV_CODEC_ID_BMP,
    AV_CODEC_ID_CSCD,
    AV_CODEC_ID_MMVIDEO,
    AV_CODEC_ID_ZMBV,
    AV_CODEC_ID_AVS,
    AV_CODEC_ID_SMACKVIDEO,
    AV_CODEC_ID_NUV,
    AV_CODEC_ID_KMVC,
    AV_CODEC_ID_FLASHSV,
    AV_CODEC_ID_CAVS,
    AV_CODEC_ID_JPEG2000,
    AV_CODEC_ID_VMNC,
    AV_CODEC_ID_VP5,
    AV_CODEC_ID_VP6,
    AV_CODEC_ID_VP6F,
    AV_CODEC_ID_TARGA,
    AV_CODEC_ID_DSICINVIDEO,
    AV_CODEC_ID_TIERTEXSEQVIDEO,
    AV_CODEC_ID_TIFF,
    AV_CODEC_ID_GIF,
    AV_CODEC_ID_DXA,
    AV_CODEC_ID_DNXHD,
    AV_CODEC_ID_THP,
    AV_CODEC_ID_SGI,
    AV_CODEC_ID_C93,
    AV_CODEC_ID_BETHSOFTVID,
    AV_CODEC_ID_PTX,
    AV_CODEC_ID_TXD,
    AV_CODEC_ID_VP6A,
    AV_CODEC_ID_AMV,
    AV_CODEC_ID_VB,
    AV_CODEC_ID_PCX,
    AV_CODEC_ID_SUNRAST,
    AV_CODEC_ID_INDEO4,
    AV_CODEC_ID_INDEO5,
    AV_CODEC_ID_MIMIC,
    AV_CODEC_ID_RL2,
    AV_CODEC_ID_ESCAPE124,
    AV_CODEC_ID_DIRAC,
    AV_CODEC_ID_BFI,
    AV_CODEC_ID_CMV,
    AV_CODEC_ID_MOTIONPIXELS,
    AV_CODEC_ID_TGV,
    AV_CODEC_ID_TGQ,
    AV_CODEC_ID_TQI,
    AV_CODEC_ID_AURA,
    AV_CODEC_ID_AURA2,
    AV_CODEC_ID_V210X,
    AV_CODEC_ID_TMV,
    AV_CODEC_ID_V210,
    AV_CODEC_ID_DPX,
    AV_CODEC_ID_MAD,
    AV_CODEC_ID_FRWU,
    AV_CODEC_ID_FLASHSV2,
    AV_CODEC_ID_CDGRAPHICS,
    AV_CODEC_ID_R210,
    AV_CODEC_ID_ANM,
    AV_CODEC_ID_BINKVIDEO,
    AV_CODEC_ID_IFF_ILBM,
    AV_CODEC_ID_IFF_BYTERUN1,
    AV_CODEC_ID_KGV1,
    AV_CODEC_ID_YOP,
    AV_CODEC_ID_VP8,
    AV_CODEC_ID_PICTOR,
    AV_CODEC_ID_ANSI,
    AV_CODEC_ID_A64_MULTI,
    AV_CODEC_ID_A64_MULTI5,
    AV_CODEC_ID_R10K,
    AV_CODEC_ID_MXPEG,
    AV_CODEC_ID_LAGARITH,
    AV_CODEC_ID_PRORES,
    AV_CODEC_ID_JV,
    AV_CODEC_ID_DFA,
    AV_CODEC_ID_WMV3IMAGE,
    AV_CODEC_ID_VC1IMAGE,
    AV_CODEC_ID_UTVIDEO,
    AV_CODEC_ID_BMV_VIDEO,
    AV_CODEC_ID_VBLE,
    AV_CODEC_ID_DXTORY,
    AV_CODEC_ID_V410,
    AV_CODEC_ID_XWD,
    AV_CODEC_ID_CDXL,
    AV_CODEC_ID_XBM,
    AV_CODEC_ID_ZEROCODEC,
    AV_CODEC_ID_MSS1,
    AV_CODEC_ID_MSA1,
    AV_CODEC_ID_TSCC2,
    AV_CODEC_ID_MTS2,
    AV_CODEC_ID_CLLC,
Alberto Delmás's avatar
Alberto Delmás committed
280
    AV_CODEC_ID_MSS2,
Tom Finegan's avatar
Tom Finegan committed
281
    AV_CODEC_ID_VP9,
282
    AV_CODEC_ID_AIC,
283
    AV_CODEC_ID_ESCAPE130_DEPRECATED,
284
    AV_CODEC_ID_G2M_DEPRECATED,
285
    AV_CODEC_ID_WEBP_DEPRECATED,
286
    AV_CODEC_ID_HNM4_VIDEO,
287
    AV_CODEC_ID_HEVC_DEPRECATED,
288
    AV_CODEC_ID_FIC,
289
    AV_CODEC_ID_ALIAS_PIX,
290
    AV_CODEC_ID_BRENDER_PIX_DEPRECATED,
291
    AV_CODEC_ID_PAF_VIDEO_DEPRECATED,
292
    AV_CODEC_ID_EXR_DEPRECATED,
293
    AV_CODEC_ID_VP7_DEPRECATED,
294
    AV_CODEC_ID_SANM_DEPRECATED,
295
    AV_CODEC_ID_SGIRLE_DEPRECATED,
296 297
    AV_CODEC_ID_MVC1_DEPRECATED,
    AV_CODEC_ID_MVC2_DEPRECATED,
298

299
    AV_CODEC_ID_BRENDER_PIX= MKBETAG('B','P','I','X'),
300 301 302 303 304
    AV_CODEC_ID_Y41P       = MKBETAG('Y','4','1','P'),
    AV_CODEC_ID_ESCAPE130  = MKBETAG('E','1','3','0'),
    AV_CODEC_ID_EXR        = MKBETAG('0','E','X','R'),
    AV_CODEC_ID_AVRP       = MKBETAG('A','V','R','P'),

Carl Eugen Hoyos's avatar
Carl Eugen Hoyos committed
305
    AV_CODEC_ID_012V       = MKBETAG('0','1','2','V'),
306 307 308
    AV_CODEC_ID_G2M        = MKBETAG( 0 ,'G','2','M'),
    AV_CODEC_ID_AVUI       = MKBETAG('A','V','U','I'),
    AV_CODEC_ID_AYUV       = MKBETAG('A','Y','U','V'),
309
    AV_CODEC_ID_TARGA_Y216 = MKBETAG('T','2','1','6'),
310 311 312 313 314
    AV_CODEC_ID_V308       = MKBETAG('V','3','0','8'),
    AV_CODEC_ID_V408       = MKBETAG('V','4','0','8'),
    AV_CODEC_ID_YUV4       = MKBETAG('Y','U','V','4'),
    AV_CODEC_ID_SANM       = MKBETAG('S','A','N','M'),
    AV_CODEC_ID_PAF_VIDEO  = MKBETAG('P','A','F','V'),
315
    AV_CODEC_ID_AVRN       = MKBETAG('A','V','R','n'),
Stephan Hilb's avatar
Stephan Hilb committed
316
    AV_CODEC_ID_CPIA       = MKBETAG('C','P','I','A'),
317
    AV_CODEC_ID_XFACE      = MKBETAG('X','F','A','C'),
Peter Ross's avatar
Peter Ross committed
318
    AV_CODEC_ID_SGIRLE     = MKBETAG('S','G','I','R'),
319 320
    AV_CODEC_ID_MVC1       = MKBETAG('M','V','C','1'),
    AV_CODEC_ID_MVC2       = MKBETAG('M','V','C','2'),
321
    AV_CODEC_ID_SNOW       = MKBETAG('S','N','O','W'),
322
    AV_CODEC_ID_WEBP       = MKBETAG('W','E','B','P'),
Ash Hughes's avatar
Ash Hughes committed
323
    AV_CODEC_ID_SMVJPEG    = MKBETAG('S','M','V','J'),
324 325
    AV_CODEC_ID_HEVC       = MKBETAG('H','2','6','5'),
#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
Peter Ross's avatar
Peter Ross committed
326
    AV_CODEC_ID_VP7        = MKBETAG('V','P','7','0'),
327

Diego Biurrun's avatar
Diego Biurrun committed
328
    /* various PCM "codecs" */
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
    AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
    AV_CODEC_ID_PCM_S16LE = 0x10000,
    AV_CODEC_ID_PCM_S16BE,
    AV_CODEC_ID_PCM_U16LE,
    AV_CODEC_ID_PCM_U16BE,
    AV_CODEC_ID_PCM_S8,
    AV_CODEC_ID_PCM_U8,
    AV_CODEC_ID_PCM_MULAW,
    AV_CODEC_ID_PCM_ALAW,
    AV_CODEC_ID_PCM_S32LE,
    AV_CODEC_ID_PCM_S32BE,
    AV_CODEC_ID_PCM_U32LE,
    AV_CODEC_ID_PCM_U32BE,
    AV_CODEC_ID_PCM_S24LE,
    AV_CODEC_ID_PCM_S24BE,
    AV_CODEC_ID_PCM_U24LE,
    AV_CODEC_ID_PCM_U24BE,
    AV_CODEC_ID_PCM_S24DAUD,
    AV_CODEC_ID_PCM_ZORK,
    AV_CODEC_ID_PCM_S16LE_PLANAR,
    AV_CODEC_ID_PCM_DVD,
    AV_CODEC_ID_PCM_F32BE,
    AV_CODEC_ID_PCM_F32LE,
    AV_CODEC_ID_PCM_F64BE,
    AV_CODEC_ID_PCM_F64LE,
    AV_CODEC_ID_PCM_BLURAY,
    AV_CODEC_ID_PCM_LXF,
    AV_CODEC_ID_S302M,
    AV_CODEC_ID_PCM_S8_PLANAR,
358 359
    AV_CODEC_ID_PCM_S24LE_PLANAR_DEPRECATED,
    AV_CODEC_ID_PCM_S32LE_PLANAR_DEPRECATED,
360 361
    AV_CODEC_ID_PCM_S24LE_PLANAR = MKBETAG(24,'P','S','P'),
    AV_CODEC_ID_PCM_S32LE_PLANAR = MKBETAG(32,'P','S','P'),
362
    AV_CODEC_ID_PCM_S16BE_PLANAR = MKBETAG('P','S','P',16),
363

Diego Biurrun's avatar
Diego Biurrun committed
364
    /* various ADPCM codecs */
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
    AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
    AV_CODEC_ID_ADPCM_IMA_WAV,
    AV_CODEC_ID_ADPCM_IMA_DK3,
    AV_CODEC_ID_ADPCM_IMA_DK4,
    AV_CODEC_ID_ADPCM_IMA_WS,
    AV_CODEC_ID_ADPCM_IMA_SMJPEG,
    AV_CODEC_ID_ADPCM_MS,
    AV_CODEC_ID_ADPCM_4XM,
    AV_CODEC_ID_ADPCM_XA,
    AV_CODEC_ID_ADPCM_ADX,
    AV_CODEC_ID_ADPCM_EA,
    AV_CODEC_ID_ADPCM_G726,
    AV_CODEC_ID_ADPCM_CT,
    AV_CODEC_ID_ADPCM_SWF,
    AV_CODEC_ID_ADPCM_YAMAHA,
    AV_CODEC_ID_ADPCM_SBPRO_4,
    AV_CODEC_ID_ADPCM_SBPRO_3,
    AV_CODEC_ID_ADPCM_SBPRO_2,
    AV_CODEC_ID_ADPCM_THP,
    AV_CODEC_ID_ADPCM_IMA_AMV,
    AV_CODEC_ID_ADPCM_EA_R1,
    AV_CODEC_ID_ADPCM_EA_R3,
    AV_CODEC_ID_ADPCM_EA_R2,
    AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
    AV_CODEC_ID_ADPCM_IMA_EA_EACS,
    AV_CODEC_ID_ADPCM_EA_XAS,
    AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
    AV_CODEC_ID_ADPCM_IMA_ISS,
    AV_CODEC_ID_ADPCM_G722,
    AV_CODEC_ID_ADPCM_IMA_APC,
395 396
    AV_CODEC_ID_ADPCM_VIMA_DEPRECATED,
    AV_CODEC_ID_ADPCM_VIMA = MKBETAG('V','I','M','A'),
397
    AV_CODEC_ID_VIMA       = MKBETAG('V','I','M','A'),
Paul B Mahol's avatar
Paul B Mahol committed
398
    AV_CODEC_ID_ADPCM_AFC  = MKBETAG('A','F','C',' '),
399
    AV_CODEC_ID_ADPCM_IMA_OKI = MKBETAG('O','K','I',' '),
James Almer's avatar
James Almer committed
400
    AV_CODEC_ID_ADPCM_DTK  = MKBETAG('D','T','K',' '),
James Almer's avatar
James Almer committed
401
    AV_CODEC_ID_ADPCM_IMA_RAD = MKBETAG('R','A','D',' '),
402
    AV_CODEC_ID_ADPCM_G726LE = MKBETAG('6','2','7','G'),
403

404
    /* AMR */
405 406
    AV_CODEC_ID_AMR_NB = 0x12000,
    AV_CODEC_ID_AMR_WB,
407

408
    /* RealAudio codecs*/
409 410
    AV_CODEC_ID_RA_144 = 0x13000,
    AV_CODEC_ID_RA_288,
411 412

    /* various DPCM codecs */
413 414 415 416
    AV_CODEC_ID_ROQ_DPCM = 0x14000,
    AV_CODEC_ID_INTERPLAY_DPCM,
    AV_CODEC_ID_XAN_DPCM,
    AV_CODEC_ID_SOL_DPCM,
417

418
    /* audio codecs */
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
    AV_CODEC_ID_MP2 = 0x15000,
    AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
    AV_CODEC_ID_AAC,
    AV_CODEC_ID_AC3,
    AV_CODEC_ID_DTS,
    AV_CODEC_ID_VORBIS,
    AV_CODEC_ID_DVAUDIO,
    AV_CODEC_ID_WMAV1,
    AV_CODEC_ID_WMAV2,
    AV_CODEC_ID_MACE3,
    AV_CODEC_ID_MACE6,
    AV_CODEC_ID_VMDAUDIO,
    AV_CODEC_ID_FLAC,
    AV_CODEC_ID_MP3ADU,
    AV_CODEC_ID_MP3ON4,
    AV_CODEC_ID_SHORTEN,
    AV_CODEC_ID_ALAC,
    AV_CODEC_ID_WESTWOOD_SND1,
    AV_CODEC_ID_GSM, ///< as in Berlin toast format
    AV_CODEC_ID_QDM2,
    AV_CODEC_ID_COOK,
    AV_CODEC_ID_TRUESPEECH,
    AV_CODEC_ID_TTA,
    AV_CODEC_ID_SMACKAUDIO,
    AV_CODEC_ID_QCELP,
    AV_CODEC_ID_WAVPACK,
    AV_CODEC_ID_DSICINAUDIO,
    AV_CODEC_ID_IMC,
    AV_CODEC_ID_MUSEPACK7,
    AV_CODEC_ID_MLP,
    AV_CODEC_ID_GSM_MS, /* as found in WAV */
    AV_CODEC_ID_ATRAC3,
451
#if FF_API_VOXWARE
452
    AV_CODEC_ID_VOXWARE,
453
#endif
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
    AV_CODEC_ID_APE,
    AV_CODEC_ID_NELLYMOSER,
    AV_CODEC_ID_MUSEPACK8,
    AV_CODEC_ID_SPEEX,
    AV_CODEC_ID_WMAVOICE,
    AV_CODEC_ID_WMAPRO,
    AV_CODEC_ID_WMALOSSLESS,
    AV_CODEC_ID_ATRAC3P,
    AV_CODEC_ID_EAC3,
    AV_CODEC_ID_SIPR,
    AV_CODEC_ID_MP1,
    AV_CODEC_ID_TWINVQ,
    AV_CODEC_ID_TRUEHD,
    AV_CODEC_ID_MP4ALS,
    AV_CODEC_ID_ATRAC1,
    AV_CODEC_ID_BINKAUDIO_RDFT,
    AV_CODEC_ID_BINKAUDIO_DCT,
    AV_CODEC_ID_AAC_LATM,
    AV_CODEC_ID_QDMC,
    AV_CODEC_ID_CELT,
    AV_CODEC_ID_G723_1,
    AV_CODEC_ID_G729,
    AV_CODEC_ID_8SVX_EXP,
    AV_CODEC_ID_8SVX_FIB,
    AV_CODEC_ID_BMV_AUDIO,
    AV_CODEC_ID_RALF,
    AV_CODEC_ID_IAC,
    AV_CODEC_ID_ILBC,
482
    AV_CODEC_ID_OPUS_DEPRECATED,
483
    AV_CODEC_ID_COMFORT_NOISE,
484
    AV_CODEC_ID_TAK_DEPRECATED,
485
    AV_CODEC_ID_METASOUND,
486
    AV_CODEC_ID_PAF_AUDIO_DEPRECATED,
Kostya Shishkov's avatar
Kostya Shishkov committed
487
    AV_CODEC_ID_ON2AVC,
488 489 490 491 492
    AV_CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
    AV_CODEC_ID_SONIC       = MKBETAG('S','O','N','C'),
    AV_CODEC_ID_SONIC_LS    = MKBETAG('S','O','N','L'),
    AV_CODEC_ID_PAF_AUDIO   = MKBETAG('P','A','F','A'),
    AV_CODEC_ID_OPUS        = MKBETAG('O','P','U','S'),
493
    AV_CODEC_ID_TAK         = MKBETAG('t','B','a','K'),
494 495
    AV_CODEC_ID_EVRC        = MKBETAG('s','e','v','c'),
    AV_CODEC_ID_SMV         = MKBETAG('s','s','m','v'),
496 497 498 499
    AV_CODEC_ID_DSD_LSBF    = MKBETAG('D','S','D','L'),
    AV_CODEC_ID_DSD_MSBF    = MKBETAG('D','S','D','M'),
    AV_CODEC_ID_DSD_LSBF_PLANAR = MKBETAG('D','S','D','1'),
    AV_CODEC_ID_DSD_MSBF_PLANAR = MKBETAG('D','S','D','8'),
500

501
    /* subtitle codecs */
502 503 504 505 506 507 508 509 510 511
    AV_CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
    AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
    AV_CODEC_ID_DVB_SUBTITLE,
    AV_CODEC_ID_TEXT,  ///< raw UTF-8 text
    AV_CODEC_ID_XSUB,
    AV_CODEC_ID_SSA,
    AV_CODEC_ID_MOV_TEXT,
    AV_CODEC_ID_HDMV_PGS_SUBTITLE,
    AV_CODEC_ID_DVB_TELETEXT,
    AV_CODEC_ID_SRT,
512 513 514 515 516
    AV_CODEC_ID_MICRODVD   = MKBETAG('m','D','V','D'),
    AV_CODEC_ID_EIA_608    = MKBETAG('c','6','0','8'),
    AV_CODEC_ID_JACOSUB    = MKBETAG('J','S','U','B'),
    AV_CODEC_ID_SAMI       = MKBETAG('S','A','M','I'),
    AV_CODEC_ID_REALTEXT   = MKBETAG('R','T','X','T'),
517
    AV_CODEC_ID_SUBVIEWER1 = MKBETAG('S','b','V','1'),
518
    AV_CODEC_ID_SUBVIEWER  = MKBETAG('S','u','b','V'),
519
    AV_CODEC_ID_SUBRIP     = MKBETAG('S','R','i','p'),
520
    AV_CODEC_ID_WEBVTT     = MKBETAG('W','V','T','T'),
521
    AV_CODEC_ID_MPL2       = MKBETAG('M','P','L','2'),
522
    AV_CODEC_ID_VPLAYER    = MKBETAG('V','P','l','r'),
523
    AV_CODEC_ID_PJS        = MKBETAG('P','h','J','S'),
524
    AV_CODEC_ID_ASS        = MKBETAG('A','S','S',' '),  ///< ASS as defined in Matroska
525

Diego Biurrun's avatar
Diego Biurrun committed
526
    /* other specific kind of codecs (generally used for attachments) */
527 528
    AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
    AV_CODEC_ID_TTF = 0x18000,
529 530 531
    AV_CODEC_ID_BINTEXT    = MKBETAG('B','T','X','T'),
    AV_CODEC_ID_XBIN       = MKBETAG('X','B','I','N'),
    AV_CODEC_ID_IDF        = MKBETAG( 0 ,'I','D','F'),
532
    AV_CODEC_ID_OTF        = MKBETAG( 0 ,'O','T','F'),
533
    AV_CODEC_ID_SMPTE_KLV  = MKBETAG('K','L','V','A'),
534
    AV_CODEC_ID_DVD_NAV    = MKBETAG('D','N','A','V'),
535
    AV_CODEC_ID_TIMED_ID3  = MKBETAG('T','I','D','3'),
536
    AV_CODEC_ID_BIN_DATA   = MKBETAG('D','A','T','A'),
537

538

539
    AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
540

541
    AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
Diego Biurrun's avatar
Diego Biurrun committed
542
                                * stream (only used by libavformat) */
543
    AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
544
                                * stream (only used by libavformat) */
545
    AV_CODEC_ID_FFMETADATA = 0x21000,   ///< Dummy codec for streams containing only metadata information.
546 547 548 549

#if FF_API_CODEC_ID
#include "old_codec_ids.h"
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
550
};
551

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
/**
 * This struct describes the properties of a single codec described by an
 * AVCodecID.
 * @see avcodec_get_descriptor()
 */
typedef struct AVCodecDescriptor {
    enum AVCodecID     id;
    enum AVMediaType type;
    /**
     * Name of the codec described by this descriptor. It is non-empty and
     * unique for each codec descriptor. It should contain alphanumeric
     * characters and '_' only.
     */
    const char      *name;
    /**
     * A more descriptive name for this codec. May be NULL.
     */
    const char *long_name;
570 571 572 573
    /**
     * Codec properties, a combination of AV_CODEC_PROP_* flags.
     */
    int             props;
574 575 576 577 578 579 580

    /**
     * MIME type(s) associated with the codec.
     * May be NULL; if not, a NULL-terminated array of MIME types.
     * The first item is always non-NULL and is the prefered MIME type.
     */
    const char *const *mime_types;
581 582
} AVCodecDescriptor;

583 584 585 586 587
/**
 * Codec uses only intra compression.
 * Video codecs only.
 */
#define AV_CODEC_PROP_INTRA_ONLY    (1 << 0)
588 589 590 591 592 593 594 595 596 597
/**
 * Codec supports lossy compression. Audio and video codecs only.
 * @note a codec may support both lossy and lossless
 * compression modes
 */
#define AV_CODEC_PROP_LOSSY         (1 << 1)
/**
 * Codec supports lossless compression. Audio and video codecs only.
 */
#define AV_CODEC_PROP_LOSSLESS      (1 << 2)
598 599
/**
 * Subtitle codec is bitmap based
600
 * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
601 602
 */
#define AV_CODEC_PROP_BITMAP_SUB    (1 << 16)
603 604 605 606 607
/**
 * Subtitle codec is text based.
 * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
 */
#define AV_CODEC_PROP_TEXT_SUB      (1 << 17)
608

609
/**
610
 * @ingroup lavc_decoding
611
 * Required number of additionally allocated bytes at the end of the input bitstream for decoding.
612 613
 * This is mainly needed because some optimized bitstream readers read
 * 32 or 64 bit at once and could read over the end.<br>
Diego Biurrun's avatar
Diego Biurrun committed
614 615
 * Note: If the first 23 bits of the additional bytes are not 0, then damaged
 * MPEG bitstreams could cause overread and segfault.
616
 */
617
#define FF_INPUT_BUFFER_PADDING_SIZE 16
618

619
/**
620
 * @ingroup lavc_encoding
Diego Biurrun's avatar
Diego Biurrun committed
621 622
 * minimum encoding buffer size
 * Used to avoid some checks during header writing.
623 624 625
 */
#define FF_MIN_BUFFER_SIZE 16384

626

627
/**
628
 * @ingroup lavc_encoding
629
 * motion estimation type.
630
 */
631
enum Motion_Est_ID {
632
    ME_ZERO = 1,    ///< no search, that is use 0,0 vector whenever one is needed
633 634 635
    ME_FULL,
    ME_LOG,
    ME_PHODS,
636 637 638 639
    ME_EPZS,        ///< enhanced predictive zonal search
    ME_X1,          ///< reserved for experiments
    ME_HEX,         ///< hexagon based search
    ME_UMH,         ///< uneven multi-hexagon search
Loren Merritt's avatar
Loren Merritt committed
640
    ME_TESA,        ///< transformed exhaustive search algorithm
641
    ME_ITER=50,     ///< iterative search
642 643
};

644 645 646
/**
 * @ingroup lavc_decoding
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
647
enum AVDiscard{
Diego Biurrun's avatar
Diego Biurrun committed
648 649
    /* We leave some space between them for extensions (drop some
     * keyframes for intra-only or drop just some bidir frames). */
650 651 652 653 654 655
    AVDISCARD_NONE    =-16, ///< discard nothing
    AVDISCARD_DEFAULT =  0, ///< discard useless packets like 0 size packets in avi
    AVDISCARD_NONREF  =  8, ///< discard all non reference
    AVDISCARD_BIDIR   = 16, ///< discard all bidirectional frames
    AVDISCARD_NONKEY  = 32, ///< discard all frames except keyframes
    AVDISCARD_ALL     = 48, ///< discard all
Michael Niedermayer's avatar
Michael Niedermayer committed
656 657
};

658
enum AVColorPrimaries{
659 660 661 662 663 664 665
    AVCOL_PRI_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
    AVCOL_PRI_UNSPECIFIED = 2,
    AVCOL_PRI_BT470M      = 4,
    AVCOL_PRI_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
    AVCOL_PRI_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
    AVCOL_PRI_SMPTE240M   = 7, ///< functionally identical to above
    AVCOL_PRI_FILM        = 8,
666
    AVCOL_PRI_BT2020      = 9, ///< ITU-R BT2020
667
    AVCOL_PRI_NB             , ///< Not part of ABI
668 669 670
};

enum AVColorTransferCharacteristic{
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
    AVCOL_TRC_BT709        =  1, ///< also ITU-R BT1361
    AVCOL_TRC_UNSPECIFIED  =  2,
    AVCOL_TRC_GAMMA22      =  4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
    AVCOL_TRC_GAMMA28      =  5, ///< also ITU-R BT470BG
    AVCOL_TRC_SMPTE170M    =  6, ///< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
    AVCOL_TRC_SMPTE240M    =  7,
    AVCOL_TRC_LINEAR       =  8, ///< "Linear transfer characteristics"
    AVCOL_TRC_LOG          =  9, ///< "Logarithmic transfer characteristic (100:1 range)"
    AVCOL_TRC_LOG_SQRT     = 10, ///< "Logarithmic transfer characteristic (100 * Sqrt( 10 ) : 1 range)"
    AVCOL_TRC_IEC61966_2_4 = 11, ///< IEC 61966-2-4
    AVCOL_TRC_BT1361_ECG   = 12, ///< ITU-R BT1361 Extended Colour Gamut
    AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC)
    AVCOL_TRC_BT2020_10    = 14, ///< ITU-R BT2020 for 10 bit system
    AVCOL_TRC_BT2020_12    = 15, ///< ITU-R BT2020 for 12 bit system
    AVCOL_TRC_NB               , ///< Not part of ABI
686 687
};

688 689 690 691 692 693
/**
 *  X   X      3 4 X      X are luma samples,
 *             1 2        1-6 are possible chroma positions
 *  X   X      5 6 X      0 is undefined/unknown position
 */
enum AVChromaLocation{
694 695 696 697 698 699 700 701
    AVCHROMA_LOC_UNSPECIFIED = 0,
    AVCHROMA_LOC_LEFT        = 1, ///< mpeg2/4, h264 default
    AVCHROMA_LOC_CENTER      = 2, ///< mpeg1, jpeg, h263
    AVCHROMA_LOC_TOPLEFT     = 3, ///< DV
    AVCHROMA_LOC_TOP         = 4,
    AVCHROMA_LOC_BOTTOMLEFT  = 5,
    AVCHROMA_LOC_BOTTOM      = 6,
    AVCHROMA_LOC_NB             , ///< Not part of ABI
702 703
};

704 705 706 707 708 709 710 711 712 713 714 715 716
enum AVAudioServiceType {
    AV_AUDIO_SERVICE_TYPE_MAIN              = 0,
    AV_AUDIO_SERVICE_TYPE_EFFECTS           = 1,
    AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
    AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED  = 3,
    AV_AUDIO_SERVICE_TYPE_DIALOGUE          = 4,
    AV_AUDIO_SERVICE_TYPE_COMMENTARY        = 5,
    AV_AUDIO_SERVICE_TYPE_EMERGENCY         = 6,
    AV_AUDIO_SERVICE_TYPE_VOICE_OVER        = 7,
    AV_AUDIO_SERVICE_TYPE_KARAOKE           = 8,
    AV_AUDIO_SERVICE_TYPE_NB                   , ///< Not part of ABI
};

717 718 719
/**
 * @ingroup lavc_encoding
 */
720 721 722
typedef struct RcOverride{
    int start_frame;
    int end_frame;
Diego Biurrun's avatar
Diego Biurrun committed
723
    int qscale; // If this is 0 then quality_factor will be used instead.
724 725 726
    float quality_factor;
} RcOverride;

727 728 729 730
#if FF_API_MAX_BFRAMES
/**
 * @deprecated there is no libavcodec-wide limit on the number of B-frames
 */
731
#define FF_MAX_B_FRAMES 16
732
#endif
733

734
/* encoding support
Diego Biurrun's avatar
Diego Biurrun committed
735 736
   These flags can be passed in AVCodecContext.flags before initialization.
   Note: Not everything is supported yet.
737
*/
Fabrice Bellard's avatar
Fabrice Bellard committed
738

739 740 741 742 743
/**
 * Allow decoders to produce frames with data planes that are not aligned
 * to CPU requirements (e.g. due to cropping).
 */
#define CODEC_FLAG_UNALIGNED 0x0001
Diego Biurrun's avatar
Diego Biurrun committed
744 745
#define CODEC_FLAG_QSCALE 0x0002  ///< Use fixed qscale.
#define CODEC_FLAG_4MV    0x0004  ///< 4 MV per MB allowed / advanced prediction for H.263.
746
#define CODEC_FLAG_OUTPUT_CORRUPT 0x0008 ///< Output even those frames that might be corrupted
Diego Biurrun's avatar
Diego Biurrun committed
747
#define CODEC_FLAG_QPEL   0x0010  ///< Use qpel MC.
748 749 750 751
#if FF_API_GMC
/**
 * @deprecated use the "gmc" private option of the libxvid encoder
 */
Diego Biurrun's avatar
Diego Biurrun committed
752
#define CODEC_FLAG_GMC    0x0020  ///< Use GMC.
753
#endif
754 755 756 757 758 759 760
#if FF_API_MV0
/**
 * @deprecated use the flag "mv0" in the "mpv_flags" private option of the
 * mpegvideo encoders
 */
#define CODEC_FLAG_MV0    0x0040
#endif
761
#if FF_API_INPUT_PRESERVED
762
/**
763 764
 * @deprecated passing reference-counted frames to the encoders replaces this
 * flag
765
 */
766
#define CODEC_FLAG_INPUT_PRESERVED 0x0100
767
#endif
Diego Biurrun's avatar
Diego Biurrun committed
768 769 770
#define CODEC_FLAG_PASS1           0x0200   ///< Use internal 2pass ratecontrol in first pass mode.
#define CODEC_FLAG_PASS2           0x0400   ///< Use internal 2pass ratecontrol in second pass mode.
#define CODEC_FLAG_GRAY            0x2000   ///< Only decode/encode grayscale.
771 772 773 774 775 776 777
#if FF_API_EMU_EDGE
/**
 * @deprecated edges are not used/required anymore. I.e. this flag is now always
 * set.
 */
#define CODEC_FLAG_EMU_EDGE        0x4000
#endif
Diego Biurrun's avatar
Diego Biurrun committed
778 779 780
#define CODEC_FLAG_PSNR            0x8000   ///< error[?] variables will be set during encoding.
#define CODEC_FLAG_TRUNCATED       0x00010000 /** Input bitstream might be truncated at a random
                                                  location instead of only at frame boundaries. */
781 782 783 784 785 786 787
#if FF_API_NORMALIZE_AQP
/**
 * @deprecated use the flag "naq" in the "mpv_flags" private option of the
 * mpegvideo encoders
 */
#define CODEC_FLAG_NORMALIZE_AQP  0x00020000
#endif
Diego Biurrun's avatar
Diego Biurrun committed
788 789 790 791
#define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< Use interlaced DCT.
#define CODEC_FLAG_LOW_DELAY      0x00080000 ///< Force low delay.
#define CODEC_FLAG_GLOBAL_HEADER  0x00400000 ///< Place global headers in extradata instead of every keyframe.
#define CODEC_FLAG_BITEXACT       0x00800000 ///< Use only bitexact stuff (except (I)DCT).
792
/* Fx : Flag for h263+ extra options */
Diego Biurrun's avatar
Diego Biurrun committed
793
#define CODEC_FLAG_AC_PRED        0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction
Michael Niedermayer's avatar
Michael Niedermayer committed
794
#define CODEC_FLAG_LOOP_FILTER    0x00000800 ///< loop filter
795
#define CODEC_FLAG_INTERLACED_ME  0x20000000 ///< interlaced motion estimation
796
#define CODEC_FLAG_CLOSED_GOP     0x80000000
Diego Biurrun's avatar
Diego Biurrun committed
797 798 799
#define CODEC_FLAG2_FAST          0x00000001 ///< Allow non spec compliant speedup tricks.
#define CODEC_FLAG2_NO_OUTPUT     0x00000004 ///< Skip bitstream encoding.
#define CODEC_FLAG2_LOCAL_HEADER  0x00000008 ///< Place global headers at every keyframe instead of in extradata.
800
#define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!
801 802
#define CODEC_FLAG2_IGNORE_CROP   0x00010000 ///< Discard cropping information from SPS.

803
#define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
804
#define CODEC_FLAG2_SHOW_ALL      0x00400000 ///< Show all frames before the first keyframe
805

806
/* Unsupported options :
807 808
 *              Syntax Arithmetic coding (SAC)
 *              Reference Picture Selection
809
 *              Independent Segment Decoding */
810
/* /Fx */
811 812
/* codec capabilities */

Diego Biurrun's avatar
Diego Biurrun committed
813
#define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< Decoder can use draw_horiz_band callback.
814
/**
815 816 817
 * Codec uses get_buffer() for allocating buffers and supports custom allocators.
 * If not set, it might not use get_buffer() at all or use operations that
 * assume the buffer was allocated by avcodec_default_get_buffer.
818 819
 */
#define CODEC_CAP_DR1             0x0002
820
#define CODEC_CAP_TRUNCATED       0x0008
821
#if FF_API_XVMC
822 823 824 825 826 827 828
/* Codec can export data for HW decoding. This flag indicates that
 * the codec would call get_format() with list that might contain HW accelerated
 * pixel formats (XvMC, VDPAU, VAAPI, etc). The application can pick any of them
 * including raw image format.
 * The application can use the passed context to determine bitstream version,
 * chroma format, resolution etc.
 */
829
#define CODEC_CAP_HWACCEL         0x0010
830
#endif /* FF_API_XVMC */
831
/**
832 833 834 835 836 837 838 839 840 841
 * Encoder or decoder requires flushing with NULL input at the end in order to
 * give the complete and correct output.
 *
 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
 *       with NULL data. The user can still send NULL data to the public encode
 *       or decode function, but libavcodec will not pass it along to the codec
 *       unless this flag is set.
 *
 * Decoders:
 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
842
 * avpkt->size=0 at the end to get the delayed data until the decoder no longer
843 844 845 846 847
 * returns frames.
 *
 * Encoders:
 * The encoder needs to be fed with NULL data at the end of encoding until the
 * encoder no longer returns data.
848 849 850 851 852
 *
 * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
 *       flag also means that the encoder must set the pts and duration for
 *       each output packet. If this flag is not set, the pts and duration will
 *       be determined by libavcodec from the input frame.
853
 */
854
#define CODEC_CAP_DELAY           0x0020
855 856 857 858 859
/**
 * Codec can be fed a final frame with a smaller size.
 * This can be used to prevent truncation of the last audio samples.
 */
#define CODEC_CAP_SMALL_LAST_FRAME 0x0040
860
#if FF_API_CAP_VDPAU
861 862 863 864
/**
 * Codec can export data for HW decoding (VDPAU).
 */
#define CODEC_CAP_HWACCEL_VDPAU    0x0080
865
#endif
866 867
/**
 * Codec can output multiple frames per AVPacket
868 869 870 871 872 873 874 875
 * Normally demuxers return one frame at a time, demuxers which do not do
 * are connected to a parser to split what they return into proper frames.
 * This flag is reserved to the very rare category of codecs which have a
 * bitstream that cannot be split into frames without timeconsuming
 * operations like full decoding. Demuxers carring such bitstreams thus
 * may return multiple frames in a packet. This has many disadvantages like
 * prohibiting stream copy in many cases thus it should only be considered
 * as a last resort.
876 877
 */
#define CODEC_CAP_SUBFRAMES        0x0100
878 879 880 881 882
/**
 * Codec is experimental and is thus avoided in favor of non experimental
 * encoders
 */
#define CODEC_CAP_EXPERIMENTAL     0x0200
883 884 885 886
/**
 * Codec should fill in channel configuration and samplerate instead of container
 */
#define CODEC_CAP_CHANNEL_CONF     0x0400
887
#if FF_API_NEG_LINESIZES
888
/**
889
 * @deprecated no codecs use this capability
890 891
 */
#define CODEC_CAP_NEG_LINESIZES    0x0800
892
#endif
893 894 895 896
/**
 * Codec supports frame-level multithreading.
 */
#define CODEC_CAP_FRAME_THREADS    0x1000
897 898 899 900
/**
 * Codec supports slice-based (or partition-based) multithreading.
 */
#define CODEC_CAP_SLICE_THREADS    0x2000
901 902 903 904
/**
 * Codec supports changed parameters at any point.
 */
#define CODEC_CAP_PARAM_CHANGE     0x4000
905 906 907 908
/**
 * Codec supports avctx->thread_count == 0 (auto).
 */
#define CODEC_CAP_AUTO_THREADS     0x8000
909 910 911 912
/**
 * Audio encoder supports receiving a different number of samples in each call.
 */
#define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
913 914 915 916
/**
 * Codec is intra only.
 */
#define CODEC_CAP_INTRA_ONLY       0x40000000
917 918 919 920
/**
 * Codec is lossless.
 */
#define CODEC_CAP_LOSSLESS         0x80000000
921

922
#if FF_API_MB_TYPE
Diego Biurrun's avatar
Diego Biurrun committed
923
//The following defines may change, don't expect compatibility if you use them.
924
#define MB_TYPE_INTRA4x4   0x0001
Diego Biurrun's avatar
Diego Biurrun committed
925 926
#define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific
#define MB_TYPE_INTRA_PCM  0x0004 //FIXME H.264-specific
927 928 929 930 931
#define MB_TYPE_16x16      0x0008
#define MB_TYPE_16x8       0x0010
#define MB_TYPE_8x16       0x0020
#define MB_TYPE_8x8        0x0040
#define MB_TYPE_INTERLACED 0x0080
Diego Biurrun's avatar
Diego Biurrun committed
932
#define MB_TYPE_DIRECT2    0x0100 //FIXME
933 934 935 936 937 938 939 940 941 942 943 944 945
#define MB_TYPE_ACPRED     0x0200
#define MB_TYPE_GMC        0x0400
#define MB_TYPE_SKIP       0x0800
#define MB_TYPE_P0L0       0x1000
#define MB_TYPE_P1L0       0x2000
#define MB_TYPE_P0L1       0x4000
#define MB_TYPE_P1L1       0x8000
#define MB_TYPE_L0         (MB_TYPE_P0L0 | MB_TYPE_P1L0)
#define MB_TYPE_L1         (MB_TYPE_P0L1 | MB_TYPE_P1L1)
#define MB_TYPE_L0L1       (MB_TYPE_L0   | MB_TYPE_L1)
#define MB_TYPE_QUANT      0x00010000
#define MB_TYPE_CBP        0x00020000
//Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...)
946
#endif
947

948 949
/**
 * Pan Scan area.
Diego Biurrun's avatar
Diego Biurrun committed
950 951
 * This specifies the area which should be displayed.
 * Note there may be multiple such areas for one frame.
952 953 954
 */
typedef struct AVPanScan{
    /**
Diego Biurrun's avatar
Diego Biurrun committed
955 956 957
     * id
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
958 959 960 961 962
     */
    int id;

    /**
     * width and height in 1/16 pel
Diego Biurrun's avatar
Diego Biurrun committed
963 964
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
965 966 967 968 969
     */
    int width;
    int height;

    /**
Diego Biurrun's avatar
Diego Biurrun committed
970 971 972
     * position of the top left corner in 1/16 pel for up to 3 fields/frames
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
973 974 975 976
     */
    int16_t position[3][2];
}AVPanScan;

977
#if FF_API_QSCALE_TYPE
978 979 980
#define FF_QSCALE_TYPE_MPEG1 0
#define FF_QSCALE_TYPE_MPEG2 1
#define FF_QSCALE_TYPE_H264  2
981
#define FF_QSCALE_TYPE_VP56  3
982
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
983

984
#if FF_API_GET_BUFFER
Michael Niedermayer's avatar
Michael Niedermayer committed
985
#define FF_BUFFER_TYPE_INTERNAL 1
Diego Biurrun's avatar
Diego Biurrun committed
986 987 988
#define FF_BUFFER_TYPE_USER     2 ///< direct rendering buffers (image is (de)allocated by user)
#define FF_BUFFER_TYPE_SHARED   4 ///< Buffer from somewhere else; don't deallocate image (data/base), all other tables are not shared.
#define FF_BUFFER_TYPE_COPY     8 ///< Just a (modified) copy of some other buffer, don't deallocate anything.
Michael Niedermayer's avatar
Michael Niedermayer committed
989

Diego Biurrun's avatar
Diego Biurrun committed
990 991 992 993
#define FF_BUFFER_HINTS_VALID    0x01 // Buffer hints value is meaningful (if 0 ignore).
#define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer.
#define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content.
#define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update).
994 995 996 997 998 999
#endif

/**
 * The decoder will keep a reference to the frame and may reuse it later.
 */
#define AV_GET_BUFFER_FLAG_REF (1 << 0)
1000

1001 1002 1003 1004 1005 1006
/**
 * @defgroup lavc_packet AVPacket
 *
 * Types and functions for working with AVPacket.
 * @{
 */
1007 1008
enum AVPacketSideDataType {
    AV_PKT_DATA_PALETTE,
1009
    AV_PKT_DATA_NEW_EXTRADATA,
1010 1011 1012

    /**
     * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
1013
     * @code
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
     * u32le param_flags
     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
     *     s32le channel_count
     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
     *     u64le channel_layout
     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
     *     s32le sample_rate
     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
     *     s32le width
     *     s32le height
1024
     * @endcode
1025
     */
1026
    AV_PKT_DATA_PARAM_CHANGE,
1027 1028 1029 1030 1031 1032 1033 1034 1035

    /**
     * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
     * structures with info about macroblocks relevant to splitting the
     * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
     * That is, it does not necessarily contain info about all macroblocks,
     * as long as the distance between macroblocks in the info is smaller
     * than the target payload size.
     * Each MB info structure is 12 bytes, and is laid out as follows:
1036
     * @code
1037 1038 1039 1040 1041 1042 1043 1044
     * u32le bit offset from the start of the packet
     * u8    current quantizer at the start of the macroblock
     * u8    GOB number
     * u16le macroblock address within the GOB
     * u8    horizontal MV predictor
     * u8    vertical MV predictor
     * u8    horizontal MV predictor for block number 3
     * u8    vertical MV predictor for block number 3
1045
     * @endcode
1046
     */
1047
    AV_PKT_DATA_H263_MB_INFO,
1048

1049 1050 1051 1052 1053
    /**
     * This side data should be associated with an audio stream and contains
     * ReplayGain information in form of the AVReplayGain struct.
     */
    AV_PKT_DATA_REPLAYGAIN,
1054

1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
    /**
     * Recommmends skipping the specified number of samples
     * @code
     * u32le number of samples to skip from start of this packet
     * u32le number of samples to skip from end of this packet
     * u8    reason for start skip
     * u8    reason for end   skip (0=padding silence, 1=convergence)
     * @endcode
     */
    AV_PKT_DATA_SKIP_SAMPLES=70,
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074

    /**
     * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
     * the packet may contain "dual mono" audio specific to Japanese DTV
     * and if it is true, recommends only the selected channel to be used.
     * @code
     * u8    selected channels (0=mail/left, 1=sub/right, 2=both)
     * @endcode
     */
    AV_PKT_DATA_JP_DUALMONO,
1075 1076 1077 1078 1079 1080

    /**
     * A list of zero terminated key/value strings. There is no end marker for
     * the list, so it is required to rely on the side data size to stop.
     */
    AV_PKT_DATA_STRINGS_METADATA,
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091

    /**
     * Subtitle event position
     * @code
     * u32le x1
     * u32le y1
     * u32le x2
     * u32le y2
     * @endcode
     */
    AV_PKT_DATA_SUBTITLE_POSITION,
1092 1093 1094 1095 1096 1097 1098 1099

    /**
     * Data found in BlockAdditional element of matroska container. There is
     * no end marker for the data, so it is required to rely on the side data
     * size to recognize the end. 8 byte id (as found in BlockAddId) followed
     * by data.
     */
    AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110

    /**
     * The optional first identifier line of a WebVTT cue.
     */
    AV_PKT_DATA_WEBVTT_IDENTIFIER,

    /**
     * The optional settings (rendering instructions) that immediately
     * follow the timestamp specifier of a WebVTT cue.
     */
    AV_PKT_DATA_WEBVTT_SETTINGS,
1111 1112 1113 1114 1115 1116 1117

    /**
     * A list of zero terminated key/value strings. There is no end marker for
     * the list, so it is required to rely on the side data size to stop. This
     * side data includes updated metadata which appeared in the stream.
     */
    AV_PKT_DATA_METADATA_UPDATE,
1118 1119
};

1120 1121 1122 1123 1124 1125
typedef struct AVPacketSideData {
    uint8_t *data;
    int      size;
    enum AVPacketSideDataType type;
} AVPacketSideData;

1126 1127 1128 1129 1130 1131 1132 1133
/**
 * This structure stores compressed data. It is typically exported by demuxers
 * and then passed as input to decoders, or received as output from encoders and
 * then passed to muxers.
 *
 * For video, it should typically contain one compressed frame. For audio it may
 * contain several compressed frames.
 *
1134
 * AVPacket is one of the few structs in FFmpeg, whose size is a part of public
1135 1136 1137
 * ABI. Thus it may be allocated on stack and no new fields can be added to it
 * without libavcodec and libavformat major bump.
 *
1138 1139 1140 1141 1142 1143
 * The semantics of data ownership depends on the buf or destruct (deprecated)
 * fields. If either is set, the packet data is dynamically allocated and is
 * valid indefinitely until av_free_packet() is called (which in turn calls
 * av_buffer_unref()/the destruct callback to free the data). If neither is set,
 * the packet data is typically backed by some static buffer somewhere and is
 * only valid for a limited time (e.g. until the next read call when demuxing).
1144 1145 1146 1147
 *
 * The side data is always allocated with av_malloc() and is freed in
 * av_free_packet().
 */
1148
typedef struct AVPacket {
1149 1150 1151 1152 1153 1154
    /**
     * A reference to the reference-counted buffer where the packet data is
     * stored.
     * May be NULL, then the packet data is not reference-counted.
     */
    AVBufferRef *buf;
1155
    /**
1156 1157
     * Presentation timestamp in AVStream->time_base units; the time at which
     * the decompressed packet will be presented to the user.
1158 1159 1160 1161 1162 1163 1164 1165
     * Can be AV_NOPTS_VALUE if it is not stored in the file.
     * pts MUST be larger or equal to dts as presentation cannot happen before
     * decompression, unless one wants to view hex dumps. Some formats misuse
     * the terms dts and pts/cts to mean something different. Such timestamps
     * must be converted to true pts/dts before they are stored in AVPacket.
     */
    int64_t pts;
    /**
1166 1167
     * Decompression timestamp in AVStream->time_base units; the time at which
     * the packet is decompressed.
1168 1169 1170 1171 1172 1173
     * Can be AV_NOPTS_VALUE if it is not stored in the file.
     */
    int64_t dts;
    uint8_t *data;
    int   size;
    int   stream_index;
1174 1175 1176
    /**
     * A combination of AV_PKT_FLAG values
     */
1177
    int   flags;
1178 1179 1180 1181
    /**
     * Additional packet data that can be provided by the container.
     * Packet can contain several types of side information.
     */
1182
    AVPacketSideData *side_data;
1183 1184
    int side_data_elems;

1185
    /**
1186
     * Duration of this packet in AVStream->time_base units, 0 if unknown.
1187 1188 1189
     * Equals next_pts - this_pts in presentation order.
     */
    int   duration;
1190 1191
#if FF_API_DESTRUCT_PACKET
    attribute_deprecated
1192
    void  (*destruct)(struct AVPacket *);
1193
    attribute_deprecated
1194
    void  *priv;
1195
#endif
1196 1197 1198
    int64_t pos;                            ///< byte position in stream, -1 if unknown

    /**
1199
     * Time difference in AVStream->time_base units from the pts of this
1200 1201 1202 1203 1204 1205
     * packet to the point at which the output from the decoder has converged
     * independent from the availability of previous frames. That is, the
     * frames are virtually identical no matter if decoding started from
     * the very first frame or from this keyframe.
     * Is AV_NOPTS_VALUE if unknown.
     * This field is not the display duration of the current packet.
Aurelien Jacobs's avatar
Aurelien Jacobs committed
1206 1207
     * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY
     * set.
1208 1209 1210 1211 1212 1213 1214 1215 1216
     *
     * The purpose of this field is to allow seeking in streams that have no
     * keyframes in the conventional sense. It corresponds to the
     * recovery point SEI in H.264 and match_time_delta in NUT. It is also
     * essential for some types of subtitle streams to ensure that all
     * subtitles are correctly displayed after seeking.
     */
    int64_t convergence_duration;
} AVPacket;
1217 1218
#define AV_PKT_FLAG_KEY     0x0001 ///< The packet contains a keyframe
#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
1219

1220 1221 1222 1223 1224 1225
enum AVSideDataParamChangeFlags {
    AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT  = 0x0001,
    AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
    AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE    = 0x0004,
    AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS     = 0x0008,
};
1226 1227 1228
/**
 * @}
 */
1229

1230 1231
struct AVCodecInternal;

1232 1233 1234 1235 1236 1237 1238 1239 1240
enum AVFieldOrder {
    AV_FIELD_UNKNOWN,
    AV_FIELD_PROGRESSIVE,
    AV_FIELD_TT,          //< Top coded_first, top displayed first
    AV_FIELD_BB,          //< Bottom coded first, bottom displayed first
    AV_FIELD_TB,          //< Top coded first, bottom displayed first
    AV_FIELD_BT,          //< Bottom coded first, top displayed first
};

Michael Niedermayer's avatar
Michael Niedermayer committed
1241
/**
1242 1243
 * main external API structure.
 * New fields can be added to the end with minor version bumps.
Diego Biurrun's avatar
Diego Biurrun committed
1244
 * Removal, reordering and changes to existing fields require a major
1245
 * version bump.
1246
 * Please use AVOptions (av_opt* / av_set/get*()) to access these fields from user
1247
 * applications.
Diego Biurrun's avatar
Diego Biurrun committed
1248
 * sizeof(AVCodecContext) must not be used outside libav*.
Michael Niedermayer's avatar
Michael Niedermayer committed
1249
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
1250
typedef struct AVCodecContext {
1251
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1252
     * information on struct for av_log
1253
     * - set by avcodec_alloc_context3
1254
     */
1255
    const AVClass *av_class;
1256 1257 1258
    int log_level_offset;

    enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
1259
    const struct AVCodec  *codec;
1260 1261 1262 1263 1264
#if FF_API_CODEC_NAME
    /**
     * @deprecated this field is not used for anything in libavcodec
     */
    attribute_deprecated
1265
    char             codec_name[32];
1266
#endif
1267
    enum AVCodecID     codec_id; /* see AV_CODEC_ID_xxx */
1268 1269

    /**
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
     * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
     * This is used to work around some encoder bugs.
     * A demuxer should set this to what is stored in the field used to identify the codec.
     * If there are multiple such fields in a container then the demuxer should choose the one
     * which maximizes the information about the used codec.
     * If the codec tag field in a container is larger than 32 bits then the demuxer should
     * remap the longer ID to 32 bits with a table or other structure. Alternatively a new
     * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated
     * first.
     * - encoding: Set by user, if not then the default based on codec_id will be used.
     * - decoding: Set by user, will be converted to uppercase by libavcodec during init.
1281
     */
1282
    unsigned int codec_tag;
1283 1284

    /**
1285 1286 1287 1288
     * fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
     * This is used to work around some encoder bugs.
     * - encoding: unused
     * - decoding: Set by user, will be converted to uppercase by libavcodec during init.
1289
     */
1290
    unsigned int stream_codec_tag;
1291

1292 1293
    void *priv_data;

1294
    /**
1295 1296 1297 1298
     * Private context used for internal data.
     *
     * Unlike priv_data, this is not codec-specific. It is used in general
     * libavcodec functions.
1299
     */
1300
    struct AVCodecInternal *internal;
1301 1302

    /**
1303 1304 1305
     * Private data of the user, can be used to carry app specific stuff.
     * - encoding: Set by user.
     * - decoding: Set by user.
1306
     */
1307
    void *opaque;
1308

1309
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1310 1311 1312
     * the average bitrate
     * - encoding: Set by user; unused for constant quantizer encoding.
     * - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream.
1313
     */
Fabrice Bellard's avatar
Fabrice Bellard committed
1314
    int bit_rate;
1315

1316
    /**
1317
     * number of bits the bitstream is allowed to diverge from the reference.
1318
     *           the reference can be CBR (for CBR pass1) or VBR (for pass2)
Diego Biurrun's avatar
Diego Biurrun committed
1319
     * - encoding: Set by user; unused for constant quantizer encoding.
1320
     * - decoding: unused
1321
     */
1322 1323
    int bit_rate_tolerance;

1324
    /**
1325 1326
     * Global quality for codecs which cannot change it per frame.
     * This should be proportional to MPEG-1/2/4 qscale.
Diego Biurrun's avatar
Diego Biurrun committed
1327
     * - encoding: Set by user.
1328
     * - decoding: unused
1329
     */
1330
    int global_quality;
1331 1332

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1333
     * - encoding: Set by user.
1334
     * - decoding: unused
1335
     */
1336 1337
    int compression_level;
#define FF_COMPRESSION_DEFAULT -1
1338 1339

    /**
1340
     * CODEC_FLAG_*.
Diego Biurrun's avatar
Diego Biurrun committed
1341
     * - encoding: Set by user.
1342
     * - decoding: Set by user.
1343
     */
1344
    int flags;
1345

1346
    /**
1347 1348
     * CODEC_FLAG2_*
     * - encoding: Set by user.
Diego Biurrun's avatar
Diego Biurrun committed
1349
     * - decoding: Set by user.
1350
     */
1351
    int flags2;
1352

1353
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1354 1355
     * some codecs need / can use extradata like Huffman tables.
     * mjpeg: Huffman tables
1356
     * rv10: additional flags
1357
     * mpeg4: global headers (they can be in the bitstream or here)
Diego Biurrun's avatar
Diego Biurrun committed
1358
     * The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger
1359
     * than extradata_size to avoid problems if it is read with the bitstream reader.
Diego Biurrun's avatar
Diego Biurrun committed
1360 1361 1362
     * The bytewise contents of extradata must not depend on the architecture or CPU endianness.
     * - encoding: Set/allocated/freed by libavcodec.
     * - decoding: Set/allocated/freed by user.
1363
     */
1364
    uint8_t *extradata;
1365
    int extradata_size;
1366 1367

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1368 1369
     * This is the fundamental unit of time (in seconds) in terms
     * of which frame timestamps are represented. For fixed-fps content,
1370 1371
     * timebase should be 1/framerate and timestamp increments should be
     * identically 1.
Diego Biurrun's avatar
Diego Biurrun committed
1372 1373
     * - encoding: MUST be set by user.
     * - decoding: Set by libavcodec.
1374
     */
1375
    AVRational time_base;
Fabrice Bellard's avatar
Fabrice Bellard committed
1376

1377
    /**
1378 1379 1380 1381 1382
     * For some codecs, the time base is closer to the field rate than the frame rate.
     * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration
     * if no telecine is used ...
     *
     * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.
1383
     */
1384
    int ticks_per_frame;
1385

1386
    /**
1387
     * Codec delay.
1388
     *
1389 1390 1391 1392
     * Encoding: Number of frames delay there will be from the encoder input to
     *           the decoder output. (we assume the decoder matches the spec)
     * Decoding: Number of frames delay in addition to what a standard decoder
     *           as specified in the spec would produce.
1393 1394 1395 1396 1397 1398
     *
     * Video:
     *   Number of frames the decoded output will be delayed relative to the
     *   encoded input.
     *
     * Audio:
1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409
     *   For encoding, this is the number of "priming" samples added by the
     *   encoder to the beginning of the stream. The decoded output will be
     *   delayed by this many samples relative to the input to the encoder (or
     *   more, if the decoder adds its own padding).
     *   The timestamps on the output packets are adjusted by the encoder so
     *   that they always refer to the first sample of the data actually
     *   contained in the packet, including any added padding.
     *   E.g. if the timebase is 1/samplerate and the timestamp of the first
     *   input sample is 0, the timestamp of the first output packet will be
     *   -delay.
     *
1410 1411 1412
     *   For decoding, this is the number of samples the decoder needs to
     *   output before the decoder's output is valid. When seeking, you should
     *   start decoding this many samples prior to your desired seek point.
1413
     *
Diego Biurrun's avatar
Diego Biurrun committed
1414
     * - encoding: Set by libavcodec.
1415
     * - decoding: Set by libavcodec.
1416 1417
     */
    int delay;
1418 1419


1420
    /* video only */
1421
    /**
1422
     * picture width / height.
1423
     * - encoding: MUST be set by user.
1424 1425 1426 1427
     * - decoding: May be set by the user before opening the decoder if known e.g.
     *             from the container. Some decoders will require the dimensions
     *             to be set by the caller. During decoding, the decoder may
     *             overwrite those values as required.
1428
     */
Fabrice Bellard's avatar
Fabrice Bellard committed
1429
    int width, height;
1430 1431

    /**
1432
     * Bitstream width / height, may be different from width/height e.g. when
1433
     * the decoded frame is cropped before being output or lowres is enabled.
1434
     * - encoding: unused
1435 1436 1437
     * - decoding: May be set by the user before opening the decoder if known
     *             e.g. from the container. During decoding, the decoder may
     *             overwrite those values as required.
1438 1439 1440
     */
    int coded_width, coded_height;

1441
#if FF_API_ASPECT_EXTENDED
1442
#define FF_ASPECT_EXTENDED 15
1443
#endif
1444 1445

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1446 1447
     * the number of pictures in a group of pictures, or 0 for intra_only
     * - encoding: Set by user.
1448
     * - decoding: unused
1449 1450 1451 1452
     */
    int gop_size;

    /**
1453
     * Pixel format, see AV_PIX_FMT_xxx.
1454
     * May be set by the demuxer if known from headers.
1455
     * May be overridden by the decoder if it knows better.
Diego Biurrun's avatar
Diego Biurrun committed
1456
     * - encoding: Set by user.
1457
     * - decoding: Set by user if known, overridden by libavcodec if known
1458
     */
1459
    enum AVPixelFormat pix_fmt;
1460

1461 1462 1463 1464 1465
    /**
     * Motion estimation algorithm used for video coding.
     * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex),
     * 8 (umh), 9 (iter), 10 (tesa) [7, 8, 10 are x264 specific, 9 is snow specific]
     * - encoding: MUST be set by user.
1466
     * - decoding: unused
1467
     */
1468 1469
    int me_method;

1470
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1471 1472
     * If non NULL, 'draw_horiz_band' is called by the libavcodec
     * decoder to draw a horizontal band. It improves cache usage. Not
1473
     * all codecs can do that. You must check the codec capabilities
Diego Biurrun's avatar
Diego Biurrun committed
1474
     * beforehand.
1475 1476 1477 1478
     * When multithreading is used, it may be called from multiple threads
     * at the same time; threads might draw different parts of the same AVFrame,
     * or multiple AVFrames, and there is no guarantee that slices will be drawn
     * in order.
1479 1480 1481 1482 1483 1484 1485
     * The function is also used by hardware acceleration APIs.
     * It is called at least once during frame decoding to pass
     * the data needed for hardware render.
     * In that mode instead of pixel data, AVFrame points to
     * a structure specific to the acceleration API. The application
     * reads the structure and can change some fields to indicate progress
     * or mark state.
1486
     * - encoding: unused
Diego Biurrun's avatar
Diego Biurrun committed
1487
     * - decoding: Set by user.
1488 1489 1490 1491
     * @param height the height of the slice
     * @param y the y position of the slice
     * @param type 1->top field, 2->bottom field, 3->frame
     * @param offset offset into the AVFrame.data from which the slice should be read
1492
     */
1493
    void (*draw_horiz_band)(struct AVCodecContext *s,
1494
                            const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
1495
                            int y, int type, int height);
1496

1497
    /**
1498 1499 1500 1501 1502 1503 1504
     * callback to negotiate the pixelFormat
     * @param fmt is the list of formats which are supported by the codec,
     * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality.
     * The first is always the native one.
     * @return the chosen format
     * - encoding: unused
     * - decoding: Set by user, if not set the native format will be chosen.
1505
     */
1506
    enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
1507 1508

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1509 1510 1511
     * maximum number of B-frames between non-B-frames
     * Note: The output will be delayed by max_b_frames+1 relative to the input.
     * - encoding: Set by user.
1512
     * - decoding: unused
1513 1514 1515 1516
     */
    int max_b_frames;

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1517
     * qscale factor between IP and B-frames
1518 1519
     * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset).
     * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
Diego Biurrun's avatar
Diego Biurrun committed
1520
     * - encoding: Set by user.
1521
     * - decoding: unused
1522 1523
     */
    float b_quant_factor;
1524

1525 1526
    /** obsolete FIXME remove */
    int rc_strategy;
1527 1528
#define FF_RC_STRATEGY_XVID 1

1529
    int b_frame_strategy;
1530

1531
    /**
1532
     * qscale offset between IP and B-frames
Diego Biurrun's avatar
Diego Biurrun committed
1533
     * - encoding: Set by user.
1534
     * - decoding: unused
1535
     */
1536
    float b_quant_offset;
1537

1538
    /**
1539 1540
     * Size of the frame reordering buffer in the decoder.
     * For MPEG-2 it is 1 IPB or 0 low delay IP.
Diego Biurrun's avatar
Diego Biurrun committed
1541
     * - encoding: Set by libavcodec.
1542
     * - decoding: Set by libavcodec.
1543
     */
1544
    int has_b_frames;
1545

1546
    /**
1547
     * 0-> h263 quant 1-> mpeg quant
Diego Biurrun's avatar
Diego Biurrun committed
1548
     * - encoding: Set by user.
1549
     * - decoding: unused
1550
     */
1551
    int mpeg_quant;
1552

1553
    /**
1554 1555
     * qscale factor between P and I-frames
     * If > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset).
1556
     * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
Diego Biurrun's avatar
Diego Biurrun committed
1557
     * - encoding: Set by user.
1558
     * - decoding: unused
1559
     */
1560
    float i_quant_factor;
1561

1562
    /**
1563 1564 1565
     * qscale offset between P and I-frames
     * - encoding: Set by user.
     * - decoding: unused
1566
     */
1567
    float i_quant_offset;
1568

1569
    /**
1570
     * luminance masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
1571
     * - encoding: Set by user.
1572
     * - decoding: unused
1573
     */
1574
    float lumi_masking;
1575

1576
    /**
1577
     * temporary complexity masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
1578
     * - encoding: Set by user.
1579
     * - decoding: unused
1580
     */
1581
    float temporal_cplx_masking;
1582

1583
    /**
1584
     * spatial complexity masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
1585
     * - encoding: Set by user.
1586
     * - decoding: unused
1587
     */
1588
    float spatial_cplx_masking;
1589

1590
    /**
1591
     * p block masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
1592
     * - encoding: Set by user.
1593
     * - decoding: unused
1594
     */
1595
    float p_masking;
1596

1597
    /**
1598
     * darkness masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
1599
     * - encoding: Set by user.
1600
     * - decoding: unused
1601
     */
1602
    float dark_masking;
1603

1604
    /**
1605 1606 1607
     * slice count
     * - encoding: Set by libavcodec.
     * - decoding: Set by user (or 0).
1608
     */
1609
    int slice_count;
1610
    /**
1611
     * prediction method (needed for huffyuv)
Diego Biurrun's avatar
Diego Biurrun committed
1612
     * - encoding: Set by user.
1613
     * - decoding: unused
1614
     */
1615 1616 1617 1618
     int prediction_method;
#define FF_PRED_LEFT   0
#define FF_PRED_PLANE  1
#define FF_PRED_MEDIAN 2
1619 1620

    /**
1621 1622 1623
     * slice offsets in the frame in bytes
     * - encoding: Set/allocated by libavcodec.
     * - decoding: Set/allocated by user (or NULL).
1624
     */
1625
    int *slice_offset;
1626

1627
    /**
1628 1629 1630
     * sample aspect ratio (0 if unknown)
     * That is the width of a pixel divided by the height of the pixel.
     * Numerator and denominator must be relatively prime and smaller than 256 for some video standards.
Diego Biurrun's avatar
Diego Biurrun committed
1631 1632
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
1633
     */
1634
    AVRational sample_aspect_ratio;
1635

1636
    /**
1637
     * motion estimation comparison function
Diego Biurrun's avatar
Diego Biurrun committed
1638
     * - encoding: Set by user.
1639
     * - decoding: unused
1640
     */
1641
    int me_cmp;
1642
    /**
1643
     * subpixel motion estimation comparison function
Diego Biurrun's avatar
Diego Biurrun committed
1644
     * - encoding: Set by user.
1645
     * - decoding: unused
1646
     */
1647
    int me_sub_cmp;
1648
    /**
1649
     * macroblock comparison function (not supported yet)
Diego Biurrun's avatar
Diego Biurrun committed
1650
     * - encoding: Set by user.
1651
     * - decoding: unused
1652
     */
1653
    int mb_cmp;
1654
    /**
1655
     * interlaced DCT comparison function
Diego Biurrun's avatar
Diego Biurrun committed
1656
     * - encoding: Set by user.
1657
     * - decoding: unused
1658
     */
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
    int ildct_cmp;
#define FF_CMP_SAD    0
#define FF_CMP_SSE    1
#define FF_CMP_SATD   2
#define FF_CMP_DCT    3
#define FF_CMP_PSNR   4
#define FF_CMP_BIT    5
#define FF_CMP_RD     6
#define FF_CMP_ZERO   7
#define FF_CMP_VSAD   8
#define FF_CMP_VSSE   9
#define FF_CMP_NSSE   10
#define FF_CMP_W53    11
#define FF_CMP_W97    12
#define FF_CMP_DCTMAX 13
#define FF_CMP_DCT264 14
#define FF_CMP_CHROMA 256
1676

1677
    /**
1678
     * ME diamond size & shape
Diego Biurrun's avatar
Diego Biurrun committed
1679
     * - encoding: Set by user.
1680
     * - decoding: unused
1681
     */
1682
    int dia_size;
1683

1684
    /**
1685
     * amount of previous MV predictors (2a+1 x 2a+1 square)
Diego Biurrun's avatar
Diego Biurrun committed
1686
     * - encoding: Set by user.
1687
     * - decoding: unused
1688
     */
1689
    int last_predictor_count;
1690

1691
    /**
1692
     * prepass for motion estimation
Diego Biurrun's avatar
Diego Biurrun committed
1693
     * - encoding: Set by user.
1694
     * - decoding: unused
1695
     */
1696
    int pre_me;
1697

1698
    /**
1699
     * motion estimation prepass comparison function
Diego Biurrun's avatar
Diego Biurrun committed
1700
     * - encoding: Set by user.
1701
     * - decoding: unused
1702
     */
1703
    int me_pre_cmp;
1704 1705

    /**
1706
     * ME prepass diamond size & shape
Diego Biurrun's avatar
Diego Biurrun committed
1707
     * - encoding: Set by user.
1708
     * - decoding: unused
1709
     */
1710
    int pre_dia_size;
1711

1712
    /**
1713
     * subpel ME quality
Diego Biurrun's avatar
Diego Biurrun committed
1714
     * - encoding: Set by user.
1715
     * - decoding: unused
1716
     */
1717
    int me_subpel_quality;
1718

1719
    /**
1720 1721 1722 1723 1724 1725
     * DTG active format information (additional aspect ratio
     * information only used in DVB MPEG-2 transport streams)
     * 0 if not set.
     *
     * - encoding: unused
     * - decoding: Set by decoder.
1726
     */
1727 1728 1729 1730 1731 1732 1733 1734
    int dtg_active_format;
#define FF_DTG_AFD_SAME         8
#define FF_DTG_AFD_4_3          9
#define FF_DTG_AFD_16_9         10
#define FF_DTG_AFD_14_9         11
#define FF_DTG_AFD_4_3_SP_14_9  13
#define FF_DTG_AFD_16_9_SP_14_9 14
#define FF_DTG_AFD_SP_4_3       15
1735

1736
    /**
1737 1738 1739
     * maximum motion estimation search range in subpel units
     * If 0 then no limit.
     *
Diego Biurrun's avatar
Diego Biurrun committed
1740
     * - encoding: Set by user.
1741
     * - decoding: unused
1742
     */
1743
    int me_range;
1744

1745
    /**
1746
     * intra quantizer bias
Diego Biurrun's avatar
Diego Biurrun committed
1747
     * - encoding: Set by user.
1748
     * - decoding: unused
1749
     */
1750 1751
    int intra_quant_bias;
#define FF_DEFAULT_QUANT_BIAS 999999
1752

1753
    /**
1754
     * inter quantizer bias
Diego Biurrun's avatar
Diego Biurrun committed
1755
     * - encoding: Set by user.
1756
     * - decoding: unused
1757
     */
1758
    int inter_quant_bias;
1759

1760
    /**
1761 1762 1763
     * slice flags
     * - encoding: unused
     * - decoding: Set by user.
1764
     */
1765 1766 1767 1768
    int slice_flags;
#define SLICE_FLAG_CODED_ORDER    0x0001 ///< draw_horiz_band() is called in coded order instead of display
#define SLICE_FLAG_ALLOW_FIELD    0x0002 ///< allow draw_horiz_band() with field slices (MPEG2 field pics)
#define SLICE_FLAG_ALLOW_PLANE    0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1)
1769

1770
#if FF_API_XVMC
1771
    /**
1772 1773 1774
     * XVideo Motion Acceleration
     * - encoding: forbidden
     * - decoding: set by decoder
1775
     * @deprecated XvMC doesn't need it anymore.
1776
     */
1777 1778
    attribute_deprecated int xvmc_acceleration;
#endif /* FF_API_XVMC */
1779

1780
    /**
1781
     * macroblock decision mode
Diego Biurrun's avatar
Diego Biurrun committed
1782
     * - encoding: Set by user.
1783
     * - decoding: unused
1784
     */
1785 1786 1787 1788
    int mb_decision;
#define FF_MB_DECISION_SIMPLE 0        ///< uses mb_cmp
#define FF_MB_DECISION_BITS   1        ///< chooses the one which needs the fewest bits
#define FF_MB_DECISION_RD     2        ///< rate distortion
1789

1790
    /**
1791 1792 1793
     * custom intra quantization matrix
     * - encoding: Set by user, can be NULL.
     * - decoding: Set by libavcodec.
1794
     */
1795
    uint16_t *intra_matrix;
1796

1797
    /**
1798 1799 1800
     * custom inter quantization matrix
     * - encoding: Set by user, can be NULL.
     * - decoding: Set by libavcodec.
1801
     */
1802
    uint16_t *inter_matrix;
1803

1804
    /**
1805 1806
     * scene change detection threshold
     * 0 is default, larger means fewer detected scene changes.
Diego Biurrun's avatar
Diego Biurrun committed
1807
     * - encoding: Set by user.
1808
     * - decoding: unused
1809
     */
1810
    int scenechange_threshold;
1811

1812
    /**
1813
     * noise reduction strength
Diego Biurrun's avatar
Diego Biurrun committed
1814
     * - encoding: Set by user.
1815
     * - decoding: unused
1816
     */
1817
    int noise_reduction;
1818

Michael Niedermayer's avatar
Michael Niedermayer committed
1819
    /**
1820 1821 1822
     * Motion estimation threshold below which no motion estimation is
     * performed, but instead the user specified motion vectors are used.
     *
Diego Biurrun's avatar
Diego Biurrun committed
1823
     * - encoding: Set by user.
1824
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
1825
     */
1826
    int me_threshold;
1827

1828
    /**
1829
     * Macroblock threshold below which the user specified macroblock types will be used.
Diego Biurrun's avatar
Diego Biurrun committed
1830
     * - encoding: Set by user.
1831
     * - decoding: unused
1832
     */
1833
    int mb_threshold;
Michael Niedermayer's avatar
Michael Niedermayer committed
1834 1835

    /**
1836
     * precision of the intra DC coefficient - 8
Diego Biurrun's avatar
Diego Biurrun committed
1837
     * - encoding: Set by user.
1838
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
1839
     */
1840
    int intra_dc_precision;
1841 1842

    /**
1843 1844
     * Number of macroblock rows at the top which are skipped.
     * - encoding: unused
Diego Biurrun's avatar
Diego Biurrun committed
1845
     * - decoding: Set by user.
1846
     */
1847
    int skip_top;
1848

1849
    /**
1850 1851
     * Number of macroblock rows at the bottom which are skipped.
     * - encoding: unused
Diego Biurrun's avatar
Diego Biurrun committed
1852
     * - decoding: Set by user.
1853
     */
1854
    int skip_bottom;
1855

1856
    /**
1857 1858
     * Border processing masking, raises the quantizer for mbs on the borders
     * of the picture.
Diego Biurrun's avatar
Diego Biurrun committed
1859
     * - encoding: Set by user.
1860
     * - decoding: unused
1861
     */
1862
    float border_masking;
1863

Michael Niedermayer's avatar
Michael Niedermayer committed
1864
    /**
1865
     * minimum MB lagrange multipler
Diego Biurrun's avatar
Diego Biurrun committed
1866
     * - encoding: Set by user.
1867
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
1868
     */
1869
    int mb_lmin;
1870

Michael Niedermayer's avatar
Michael Niedermayer committed
1871
    /**
1872
     * maximum MB lagrange multipler
Diego Biurrun's avatar
Diego Biurrun committed
1873
     * - encoding: Set by user.
1874
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
1875
     */
1876
    int mb_lmax;
1877

Michael Niedermayer's avatar
Michael Niedermayer committed
1878
    /**
1879
     *
Diego Biurrun's avatar
Diego Biurrun committed
1880
     * - encoding: Set by user.
1881
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
1882
     */
1883
    int me_penalty_compensation;
1884

1885
    /**
1886
     *
Diego Biurrun's avatar
Diego Biurrun committed
1887
     * - encoding: Set by user.
1888 1889
     * - decoding: unused
     */
1890
    int bidir_refine;
1891

Michael Niedermayer's avatar
Michael Niedermayer committed
1892
    /**
1893
     *
Diego Biurrun's avatar
Diego Biurrun committed
1894
     * - encoding: Set by user.
1895
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
1896
     */
1897
    int brd_scale;
1898 1899

    /**
1900
     * minimum GOP size
Diego Biurrun's avatar
Diego Biurrun committed
1901
     * - encoding: Set by user.
1902
     * - decoding: unused
1903
     */
1904
    int keyint_min;
1905

1906
    /**
1907 1908 1909
     * number of reference frames
     * - encoding: Set by user.
     * - decoding: Set by lavc.
Michael Niedermayer's avatar
Michael Niedermayer committed
1910
     */
1911
    int refs;
1912 1913

    /**
1914
     * chroma qp offset from luma
Diego Biurrun's avatar
Diego Biurrun committed
1915
     * - encoding: Set by user.
1916
     * - decoding: unused
1917
     */
1918
    int chromaoffset;
1919

1920
    /**
1921
     * Multiplied by qscale for each frame and added to scene_change_score.
Diego Biurrun's avatar
Diego Biurrun committed
1922
     * - encoding: Set by user.
1923
     * - decoding: unused
1924
     */
1925
    int scenechange_factor;
Michael Niedermayer's avatar
Michael Niedermayer committed
1926

1927
    /**
1928 1929
     *
     * Note: Value depends upon the compare function used for fullpel ME.
Diego Biurrun's avatar
Diego Biurrun committed
1930
     * - encoding: Set by user.
1931
     * - decoding: unused
1932
     */
1933
    int mv0_threshold;
1934

Michael Niedermayer's avatar
Michael Niedermayer committed
1935
    /**
1936
     * Adjust sensitivity of b_frame_strategy 1.
Diego Biurrun's avatar
Diego Biurrun committed
1937
     * - encoding: Set by user.
1938
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
1939
     */
1940
    int b_sensitivity;
Michael Niedermayer's avatar
Michael Niedermayer committed
1941

Michael Niedermayer's avatar
Michael Niedermayer committed
1942
    /**
1943 1944 1945
     * Chromaticity coordinates of the source primaries.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
Michael Niedermayer's avatar
Michael Niedermayer committed
1946
     */
1947
    enum AVColorPrimaries color_primaries;
1948 1949

    /**
1950 1951 1952
     * Color Transfer Characteristic.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
1953
     */
1954
    enum AVColorTransferCharacteristic color_trc;
1955

1956
    /**
1957 1958 1959
     * YUV colorspace type.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
1960
     */
1961
    enum AVColorSpace colorspace;
1962

1963
    /**
1964 1965 1966
     * MPEG vs JPEG YUV range.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
1967
     */
1968
    enum AVColorRange color_range;
1969 1970

    /**
1971 1972 1973
     * This defines the location of chroma samples.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
1974
     */
1975
    enum AVChromaLocation chroma_sample_location;
1976

Michael Niedermayer's avatar
Michael Niedermayer committed
1977
    /**
1978 1979 1980 1981
     * Number of slices.
     * Indicates number of picture subdivisions. Used for parallelized
     * decoding.
     * - encoding: Set by user
Michael Niedermayer's avatar
Michael Niedermayer committed
1982 1983
     * - decoding: unused
     */
1984
    int slices;
1985

1986 1987
    /** Field order
     * - encoding: set by libavcodec
1988
     * - decoding: Set by user.
Michael Niedermayer's avatar
Michael Niedermayer committed
1989
     */
1990 1991 1992 1993 1994
    enum AVFieldOrder field_order;

    /* audio only */
    int sample_rate; ///< samples per second
    int channels;    ///< number of audio channels
Michael Niedermayer's avatar
Michael Niedermayer committed
1995 1996

    /**
1997
     * audio sample format
Diego Biurrun's avatar
Diego Biurrun committed
1998
     * - encoding: Set by user.
1999
     * - decoding: Set by libavcodec.
Michael Niedermayer's avatar
Michael Niedermayer committed
2000
     */
2001
    enum AVSampleFormat sample_fmt;  ///< sample format
2002

2003
    /* The following data should not be initialized. */
2004
    /**
2005 2006 2007 2008 2009 2010 2011
     * Number of samples per channel in an audio frame.
     *
     * - encoding: set by libavcodec in avcodec_open2(). Each submitted frame
     *   except the last must contain exactly frame_size samples per channel.
     *   May be 0 when the codec has CODEC_CAP_VARIABLE_FRAME_SIZE set, then the
     *   frame size is not restricted.
     * - decoding: may be set by some decoders to indicate constant frame size
2012
     */
2013
    int frame_size;
2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024

    /**
     * Frame counter, set by libavcodec.
     *
     * - decoding: total number of frames returned from the decoder so far.
     * - encoding: total number of frames passed to the encoder so far.
     *
     *   @note the counter is not incremented if encoding/decoding resulted in
     *   an error.
     */
    int frame_number;
2025

Ivan Kalvachev's avatar
Ivan Kalvachev committed
2026
    /**
2027 2028
     * number of bytes per packet if constant and known or 0
     * Used by some WAV based audio codecs.
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2029
     */
2030
    int block_align;
2031

2032
    /**
2033
     * Audio cutoff bandwidth (0 means "automatic")
Diego Biurrun's avatar
Diego Biurrun committed
2034
     * - encoding: Set by user.
2035 2036
     * - decoding: unused
     */
2037
    int cutoff;
2038

2039
#if FF_API_REQUEST_CHANNELS
2040
    /**
2041 2042 2043 2044
     * Decoder should decode to this many channels if it can (0 for default)
     * - encoding: unused
     * - decoding: Set by user.
     * @deprecated Deprecated in favor of request_channel_layout.
2045
     */
2046
    attribute_deprecated int request_channels;
2047
#endif
2048 2049

    /**
2050 2051
     * Audio channel layout.
     * - encoding: set by user.
2052
     * - decoding: set by user, may be overwritten by libavcodec.
2053
     */
2054
    uint64_t channel_layout;
2055

2056
    /**
2057
     * Request decoder to use this channel layout if it can (0 for default)
2058
     * - encoding: unused
2059
     * - decoding: Set by user.
2060
     */
2061
    uint64_t request_channel_layout;
2062 2063

    /**
2064
     * Type of service that the audio stream conveys.
Diego Biurrun's avatar
Diego Biurrun committed
2065
     * - encoding: Set by user.
2066
     * - decoding: Set by libavcodec.
2067
     */
2068
    enum AVAudioServiceType audio_service_type;
2069 2070

    /**
2071 2072
     * desired sample format
     * - encoding: Not used.
2073
     * - decoding: Set by user.
2074
     * Decoder will decode to this format if it can.
2075
     */
2076
    enum AVSampleFormat request_sample_fmt;
2077

2078
#if FF_API_GET_BUFFER
2079
    /**
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120
     * Called at the beginning of each frame to get a buffer for it.
     *
     * The function will set AVFrame.data[], AVFrame.linesize[].
     * AVFrame.extended_data[] must also be set, but it should be the same as
     * AVFrame.data[] except for planar audio with more channels than can fit
     * in AVFrame.data[]. In that case, AVFrame.data[] shall still contain as
     * many data pointers as it can hold.
     *
     * if CODEC_CAP_DR1 is not set then get_buffer() must call
     * avcodec_default_get_buffer() instead of providing buffers allocated by
     * some other means.
     *
     * AVFrame.data[] should be 32- or 16-byte-aligned unless the CPU doesn't
     * need it. avcodec_default_get_buffer() aligns the output buffer properly,
     * but if get_buffer() is overridden then alignment considerations should
     * be taken into account.
     *
     * @see avcodec_default_get_buffer()
     *
     * Video:
     *
     * If pic.reference is set then the frame will be read later by libavcodec.
     * avcodec_align_dimensions2() should be used to find the required width and
     * height, as they normally need to be rounded up to the next multiple of 16.
     *
     * If frame multithreading is used and thread_safe_callbacks is set,
     * it may be called from a different thread, but not from more than one at
     * once. Does not need to be reentrant.
     *
     * @see release_buffer(), reget_buffer()
     * @see avcodec_align_dimensions2()
     *
     * Audio:
     *
     * Decoders request a buffer of a particular size by setting
     * AVFrame.nb_samples prior to calling get_buffer(). The decoder may,
     * however, utilize only part of the buffer by setting AVFrame.nb_samples
     * to a smaller value in the output frame.
     *
     * Decoders cannot use the buffer after returning from
     * avcodec_decode_audio4(), so they will not call release_buffer(), as it
2121 2122 2123 2124 2125 2126
     * is assumed to be released immediately upon return. In some rare cases,
     * a decoder may need to call get_buffer() more than once in a single
     * call to avcodec_decode_audio4(). In that case, when get_buffer() is
     * called again after it has already been called once, the previously
     * acquired buffer is assumed to be released at that time and may not be
     * reused by the decoder.
2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137
     *
     * As a convenience, av_samples_get_buffer_size() and
     * av_samples_fill_arrays() in libavutil may be used by custom get_buffer()
     * functions to find the required data size and to fill data pointers and
     * linesize. In AVFrame.linesize, only linesize[0] may be set for audio
     * since all planes must be the same size.
     *
     * @see av_samples_get_buffer_size(), av_samples_fill_arrays()
     *
     * - encoding: unused
     * - decoding: Set by libavcodec, user can override.
2138 2139
     *
     * @deprecated use get_buffer2()
2140
     */
2141
    attribute_deprecated
2142
    int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic);
2143

2144
    /**
2145 2146 2147 2148 2149 2150 2151
     * Called to release buffers which were allocated with get_buffer.
     * A released buffer can be reused in get_buffer().
     * pic.data[*] must be set to NULL.
     * May be called from a different thread if frame multithreading is used,
     * but not by more than one thread at once, so does not need to be reentrant.
     * - encoding: unused
     * - decoding: Set by libavcodec, user can override.
2152 2153
     *
     * @deprecated custom freeing callbacks should be set from get_buffer2()
2154
     */
2155
    attribute_deprecated
2156
    void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic);
2157

2158
    /**
Diego Biurrun's avatar
Diego Biurrun committed
2159 2160 2161
     * Called at the beginning of a frame to get cr buffer for it.
     * Buffer type (size, hints) must be the same. libavcodec won't check it.
     * libavcodec will pass previous buffer in pic, function should return
2162
     * same buffer or new buffer with old frame "painted" into it.
Diego Biurrun's avatar
Diego Biurrun committed
2163
     * If pic.data[0] == NULL must behave like get_buffer().
2164 2165 2166
     * if CODEC_CAP_DR1 is not set then reget_buffer() must call
     * avcodec_default_reget_buffer() instead of providing buffers allocated by
     * some other means.
2167
     * - encoding: unused
2168
     * - decoding: Set by libavcodec, user can override.
2169
     */
2170
    attribute_deprecated
2171
    int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic);
2172
#endif
2173

2174 2175 2176
    /**
     * This callback is called at the beginning of each frame to get data
     * buffer(s) for it. There may be one contiguous buffer for all the data or
2177 2178 2179 2180
     * there may be a buffer per each data plane or anything in between. What
     * this means is, you may set however many entries in buf[] you feel necessary.
     * Each buffer must be reference-counted using the AVBuffer API (see description
     * of buf[] below).
2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200
     *
     * The following fields will be set in the frame before this callback is
     * called:
     * - format
     * - width, height (video only)
     * - sample_rate, channel_layout, nb_samples (audio only)
     * Their values may differ from the corresponding values in
     * AVCodecContext. This callback must use the frame values, not the codec
     * context values, to calculate the required buffer size.
     *
     * This callback must fill the following fields in the frame:
     * - data[]
     * - linesize[]
     * - extended_data:
     *   * if the data is planar audio with more than 8 channels, then this
     *     callback must allocate and fill extended_data to contain all pointers
     *     to all data planes. data[] must hold as many pointers as it can.
     *     extended_data must be allocated with av_malloc() and will be freed in
     *     av_frame_unref().
     *   * otherwise exended_data must point to data
2201 2202 2203 2204 2205
     * - buf[] must contain one or more pointers to AVBufferRef structures. Each of
     *   the frame's data and extended_data pointers must be contained in these. That
     *   is, one AVBufferRef for each allocated chunk of memory, not necessarily one
     *   AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(),
     *   and av_buffer_ref().
2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227
     * - extended_buf and nb_extended_buf must be allocated with av_malloc() by
     *   this callback and filled with the extra buffers if there are more
     *   buffers than buf[] can hold. extended_buf will be freed in
     *   av_frame_unref().
     *
     * If CODEC_CAP_DR1 is not set then get_buffer2() must call
     * avcodec_default_get_buffer2() instead of providing buffers allocated by
     * some other means.
     *
     * Each data plane must be aligned to the maximum required by the target
     * CPU.
     *
     * @see avcodec_default_get_buffer2()
     *
     * Video:
     *
     * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused
     * (read and/or written to if it is writable) later by libavcodec.
     *
     * avcodec_align_dimensions2() should be used to find the required width and
     * height, as they normally need to be rounded up to the next multiple of 16.
     *
2228 2229
     * Some decoders do not support linesizes changing between frames.
     *
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267
     * If frame multithreading is used and thread_safe_callbacks is set,
     * this callback may be called from a different thread, but not from more
     * than one at once. Does not need to be reentrant.
     *
     * @see avcodec_align_dimensions2()
     *
     * Audio:
     *
     * Decoders request a buffer of a particular size by setting
     * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may,
     * however, utilize only part of the buffer by setting AVFrame.nb_samples
     * to a smaller value in the output frame.
     *
     * As a convenience, av_samples_get_buffer_size() and
     * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2()
     * functions to find the required data size and to fill data pointers and
     * linesize. In AVFrame.linesize, only linesize[0] may be set for audio
     * since all planes must be the same size.
     *
     * @see av_samples_get_buffer_size(), av_samples_fill_arrays()
     *
     * - encoding: unused
     * - decoding: Set by libavcodec, user can override.
     */
    int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);

    /**
     * If non-zero, the decoded audio and video frames returned from
     * avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted
     * and are valid indefinitely. The caller must free them with
     * av_frame_unref() when they are not needed anymore.
     * Otherwise, the decoded frames must not be freed by the caller and are
     * only valid until the next decode call.
     *
     * - encoding: unused
     * - decoding: set by the caller before avcodec_open2().
     */
    int refcounted_frames;
2268

2269 2270 2271
    /* - encoding parameters */
    float qcompress;  ///< amount of qscale change between easy & hard scenes (0.0-1.0)
    float qblur;      ///< amount of qscale smoothing over time (0.0-1.0)
2272 2273

    /**
2274
     * minimum quantizer
Diego Biurrun's avatar
Diego Biurrun committed
2275
     * - encoding: Set by user.
2276 2277
     * - decoding: unused
     */
2278
    int qmin;
2279 2280

    /**
2281
     * maximum quantizer
Diego Biurrun's avatar
Diego Biurrun committed
2282
     * - encoding: Set by user.
2283 2284
     * - decoding: unused
     */
2285
    int qmax;
2286 2287

    /**
2288
     * maximum quantizer difference between frames
Diego Biurrun's avatar
Diego Biurrun committed
2289
     * - encoding: Set by user.
2290
     * - decoding: unused
2291
     */
2292
    int max_qdiff;
2293 2294

    /**
2295
     * ratecontrol qmin qmax limiting method
2296
     * 0-> clipping, 1-> use a nice continuous function to limit qscale within qmin/qmax.
Diego Biurrun's avatar
Diego Biurrun committed
2297 2298
     * - encoding: Set by user.
     * - decoding: unused
2299
     */
2300
    float rc_qsquish;
2301

2302 2303
    float rc_qmod_amp;
    int rc_qmod_freq;
2304

2305
    /**
2306
     * decoder bitstream buffer size
Diego Biurrun's avatar
Diego Biurrun committed
2307
     * - encoding: Set by user.
2308 2309
     * - decoding: unused
     */
2310
    int rc_buffer_size;
2311 2312

    /**
2313 2314
     * ratecontrol override, see RcOverride
     * - encoding: Allocated/set/freed by user.
2315
     * - decoding: unused
2316
     */
2317 2318
    int rc_override_count;
    RcOverride *rc_override;
2319

2320
    /**
2321 2322
     * rate control equation
     * - encoding: Set by user
2323
     * - decoding: unused
2324
     */
2325
    const char *rc_eq;
2326 2327

    /**
2328
     * maximum bitrate
Diego Biurrun's avatar
Diego Biurrun committed
2329
     * - encoding: Set by user.
2330
     * - decoding: unused
2331
     */
2332
    int rc_max_rate;
2333 2334

    /**
2335
     * minimum bitrate
Diego Biurrun's avatar
Diego Biurrun committed
2336
     * - encoding: Set by user.
2337 2338
     * - decoding: unused
     */
2339
    int rc_min_rate;
2340

2341
    float rc_buffer_aggressivity;
2342 2343

    /**
2344
     * initial complexity for pass1 ratecontrol
Diego Biurrun's avatar
Diego Biurrun committed
2345
     * - encoding: Set by user.
2346 2347
     * - decoding: unused
     */
2348
    float rc_initial_cplx;
Michael Niedermayer's avatar
Michael Niedermayer committed
2349 2350

    /**
2351
     * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow.
Diego Biurrun's avatar
Diego Biurrun committed
2352
     * - encoding: Set by user.
2353
     * - decoding: unused.
Michael Niedermayer's avatar
Michael Niedermayer committed
2354
     */
2355
    float rc_max_available_vbv_use;
2356 2357

    /**
2358
     * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow.
Diego Biurrun's avatar
Diego Biurrun committed
2359
     * - encoding: Set by user.
2360
     * - decoding: unused.
2361
     */
2362
    float rc_min_vbv_overflow_use;
2363 2364

    /**
2365
     * Number of bits which should be loaded into the rc buffer before decoding starts.
Diego Biurrun's avatar
Diego Biurrun committed
2366
     * - encoding: Set by user.
Michael Niedermayer's avatar
Michael Niedermayer committed
2367
     * - decoding: unused
2368
     */
2369
    int rc_initial_buffer_occupancy;
2370

2371 2372 2373 2374 2375
#define FF_CODER_TYPE_VLC       0
#define FF_CODER_TYPE_AC        1
#define FF_CODER_TYPE_RAW       2
#define FF_CODER_TYPE_RLE       3
#define FF_CODER_TYPE_DEFLATE   4
2376
    /**
2377
     * coder type
Diego Biurrun's avatar
Diego Biurrun committed
2378
     * - encoding: Set by user.
2379
     * - decoding: unused
2380
     */
2381
    int coder_type;
2382

2383
    /**
2384
     * context model
Diego Biurrun's avatar
Diego Biurrun committed
2385
     * - encoding: Set by user.
2386
     * - decoding: unused
2387
     */
2388
    int context_model;
2389 2390

    /**
2391
     * minimum Lagrange multiplier
Diego Biurrun's avatar
Diego Biurrun committed
2392
     * - encoding: Set by user.
2393
     * - decoding: unused
2394
     */
2395
    int lmin;
2396 2397

    /**
2398
     * maximum Lagrange multiplier
Diego Biurrun's avatar
Diego Biurrun committed
2399
     * - encoding: Set by user.
2400
     * - decoding: unused
2401
     */
2402
    int lmax;
Michael Niedermayer's avatar
Michael Niedermayer committed
2403 2404 2405

    /**
     * frame skip threshold
Diego Biurrun's avatar
Diego Biurrun committed
2406
     * - encoding: Set by user.
Michael Niedermayer's avatar
Michael Niedermayer committed
2407 2408 2409 2410 2411 2412
     * - decoding: unused
     */
    int frame_skip_threshold;

    /**
     * frame skip factor
Diego Biurrun's avatar
Diego Biurrun committed
2413
     * - encoding: Set by user.
Michael Niedermayer's avatar
Michael Niedermayer committed
2414 2415 2416
     * - decoding: unused
     */
    int frame_skip_factor;
2417 2418 2419

    /**
     * frame skip exponent
Diego Biurrun's avatar
Diego Biurrun committed
2420
     * - encoding: Set by user.
2421 2422 2423 2424 2425
     * - decoding: unused
     */
    int frame_skip_exp;

    /**
Diego Biurrun's avatar
Diego Biurrun committed
2426 2427
     * frame skip comparison function
     * - encoding: Set by user.
2428 2429 2430
     * - decoding: unused
     */
    int frame_skip_cmp;
2431 2432

    /**
2433
     * trellis RD quantization
Diego Biurrun's avatar
Diego Biurrun committed
2434
     * - encoding: Set by user.
2435 2436
     * - decoding: unused
     */
2437
    int trellis;
2438 2439

    /**
Diego Biurrun's avatar
Diego Biurrun committed
2440
     * - encoding: Set by user.
2441 2442
     * - decoding: unused
     */
2443
    int min_prediction_order;
2444 2445

    /**
Diego Biurrun's avatar
Diego Biurrun committed
2446
     * - encoding: Set by user.
2447 2448
     * - decoding: unused
     */
2449
    int max_prediction_order;
2450 2451

    /**
2452 2453 2454
     * GOP timecode frame start number
     * - encoding: Set by user, in non drop frame format
     * - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
2455
     */
2456
    int64_t timecode_frame_start;
Michael Niedermayer's avatar
Michael Niedermayer committed
2457

2458 2459 2460 2461 2462 2463 2464
    /* The RTP callback: This function is called    */
    /* every time the encoder has a packet to send. */
    /* It depends on the encoder if the data starts */
    /* with a Start Code (it should). H.263 does.   */
    /* mb_nb contains the number of macroblocks     */
    /* encoded in the RTP payload.                  */
    void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
Michael Niedermayer's avatar
Michael Niedermayer committed
2465

2466 2467 2468 2469 2470 2471
    int rtp_payload_size;   /* The size of the RTP payload: the coder will  */
                            /* do its best to deliver a chunk with size     */
                            /* below rtp_payload_size, the chunk will start */
                            /* with a start code on some codecs like H.263. */
                            /* This doesn't take account of any particular  */
                            /* headers inside the transmitted RTP payload.  */
Michael Niedermayer's avatar
Michael Niedermayer committed
2472

2473 2474 2475 2476 2477 2478 2479 2480 2481
    /* statistics, used for 2-pass encoding */
    int mv_bits;
    int header_bits;
    int i_tex_bits;
    int p_tex_bits;
    int i_count;
    int p_count;
    int skip_count;
    int misc_bits;
2482 2483

    /**
2484 2485
     * number of bits used for the previously encoded frame
     * - encoding: Set by libavcodec.
2486 2487
     * - decoding: unused
     */
2488
    int frame_bits;
2489 2490

    /**
2491 2492
     * pass1 encoding statistics output buffer
     * - encoding: Set by libavcodec.
2493 2494
     * - decoding: unused
     */
2495
    char *stats_out;
Robert Swain's avatar
Robert Swain committed
2496 2497

    /**
2498 2499 2500
     * pass2 encoding statistics input buffer
     * Concatenated stuff from stats_out of pass1 should be placed here.
     * - encoding: Allocated/set/freed by user.
Robert Swain's avatar
Robert Swain committed
2501 2502
     * - decoding: unused
     */
2503
    char *stats_in;
Robert Swain's avatar
Robert Swain committed
2504 2505

    /**
2506 2507 2508
     * Work around bugs in encoders which sometimes cannot be detected automatically.
     * - encoding: Set by user
     * - decoding: Set by user
Robert Swain's avatar
Robert Swain committed
2509
     */
2510 2511
    int workaround_bugs;
#define FF_BUG_AUTODETECT       1  ///< autodetection
2512
#if FF_API_OLD_MSMPEG4
2513
#define FF_BUG_OLD_MSMPEG4      2
2514
#endif
2515 2516 2517 2518
#define FF_BUG_XVID_ILACE       4
#define FF_BUG_UMP4             8
#define FF_BUG_NO_PADDING       16
#define FF_BUG_AMV              32
2519
#if FF_API_AC_VLC
2520
#define FF_BUG_AC_VLC           0  ///< Will be removed, libavcodec can now handle these non-compliant files by default.
2521
#endif
2522 2523 2524 2525 2526 2527 2528 2529 2530
#define FF_BUG_QPEL_CHROMA      64
#define FF_BUG_STD_QPEL         128
#define FF_BUG_QPEL_CHROMA2     256
#define FF_BUG_DIRECT_BLOCKSIZE 512
#define FF_BUG_EDGE             1024
#define FF_BUG_HPEL_CHROMA      2048
#define FF_BUG_DC_CLIP          4096
#define FF_BUG_MS               8192 ///< Work around various bugs in Microsoft's broken decoders.
#define FF_BUG_TRUNCATED       16384
Robert Swain's avatar
Robert Swain committed
2531 2532

    /**
2533
     * strictly follow the standard (MPEG4, ...).
Diego Biurrun's avatar
Diego Biurrun committed
2534
     * - encoding: Set by user.
2535 2536 2537 2538 2539 2540 2541 2542
     * - decoding: Set by user.
     * Setting this to STRICT or higher means the encoder and decoder will
     * generally do stupid things, whereas setting it to unofficial or lower
     * will mean the encoder might produce output that is not supported by all
     * spec-compliant decoders. Decoders don't differentiate between normal,
     * unofficial and experimental (that is, they always try to decode things
     * when they can) unless they are explicitly asked to behave stupidly
     * (=strictly conform to the specs)
Robert Swain's avatar
Robert Swain committed
2543
     */
2544 2545 2546 2547 2548 2549
    int strict_std_compliance;
#define FF_COMPLIANCE_VERY_STRICT   2 ///< Strictly conform to an older more strict version of the spec or reference software.
#define FF_COMPLIANCE_STRICT        1 ///< Strictly conform to all the things in the spec no matter what consequences.
#define FF_COMPLIANCE_NORMAL        0
#define FF_COMPLIANCE_UNOFFICIAL   -1 ///< Allow unofficial extensions
#define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
Robert Swain's avatar
Robert Swain committed
2550 2551

    /**
2552 2553 2554
     * error concealment flags
     * - encoding: unused
     * - decoding: Set by user.
Robert Swain's avatar
Robert Swain committed
2555
     */
2556 2557 2558
    int error_concealment;
#define FF_EC_GUESS_MVS   1
#define FF_EC_DEBLOCK     2
2559
#define FF_EC_FAVOR_INTER 256
Robert Swain's avatar
Robert Swain committed
2560

2561
    /**
2562
     * debug
Diego Biurrun's avatar
Diego Biurrun committed
2563
     * - encoding: Set by user.
2564
     * - decoding: Set by user.
2565
     */
2566 2567 2568 2569 2570 2571
    int debug;
#define FF_DEBUG_PICT_INFO   1
#define FF_DEBUG_RC          2
#define FF_DEBUG_BITSTREAM   4
#define FF_DEBUG_MB_TYPE     8
#define FF_DEBUG_QP          16
2572 2573 2574 2575
#if FF_API_DEBUG_MV
/**
 * @deprecated this option does nothing
 */
2576
#define FF_DEBUG_MV          32
2577
#endif
2578 2579 2580 2581 2582 2583 2584
#define FF_DEBUG_DCT_COEFF   0x00000040
#define FF_DEBUG_SKIP        0x00000080
#define FF_DEBUG_STARTCODE   0x00000100
#define FF_DEBUG_PTS         0x00000200
#define FF_DEBUG_ER          0x00000400
#define FF_DEBUG_MMCO        0x00000800
#define FF_DEBUG_BUGS        0x00001000
2585
#if FF_API_DEBUG_MV
2586 2587
#define FF_DEBUG_VIS_QP      0x00002000 ///< only access through AVOptions from outside libavcodec
#define FF_DEBUG_VIS_MB_TYPE 0x00004000 ///< only access through AVOptions from outside libavcodec
2588
#endif
2589 2590
#define FF_DEBUG_BUFFERS     0x00008000
#define FF_DEBUG_THREADS     0x00010000
2591
#define FF_DEBUG_NOMC        0x01000000
2592

2593
#if FF_API_DEBUG_MV
2594
    /**
2595
     * debug
2596
     * Code outside libavcodec should access this field using AVOptions
Diego Biurrun's avatar
Diego Biurrun committed
2597
     * - encoding: Set by user.
2598
     * - decoding: Set by user.
2599
     */
2600 2601 2602 2603
    int debug_mv;
#define FF_DEBUG_VIS_MV_P_FOR  0x00000001 //visualize forward predicted MVs of P frames
#define FF_DEBUG_VIS_MV_B_FOR  0x00000002 //visualize forward predicted MVs of B frames
#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
2604
#endif
2605 2606

    /**
2607
     * Error recognition; may misdetect some more or less valid parts as errors.
2608 2609
     * - encoding: unused
     * - decoding: Set by user.
2610
     */
2611
    int err_recognition;
2612 2613 2614 2615 2616 2617 2618

/**
 * Verify checksums embedded in the bitstream (could be of either encoded or
 * decoded data, depending on the codec) and print an error message on mismatch.
 * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the
 * decoder returning an error.
 */
2619
#define AV_EF_CRCCHECK  (1<<0)
2620 2621 2622 2623
#define AV_EF_BITSTREAM (1<<1)          ///< detect bitstream specification deviations
#define AV_EF_BUFFER    (1<<2)          ///< detect improper bitstream length
#define AV_EF_EXPLODE   (1<<3)          ///< abort decoding on minor error detection

2624
#define AV_EF_IGNORE_ERR (1<<15)        ///< ignore errors and continue
2625
#define AV_EF_CAREFUL    (1<<16)        ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
2626
#define AV_EF_COMPLIANT  (1<<17)        ///< consider all spec non compliances as errors
2627
#define AV_EF_AGGRESSIVE (1<<18)        ///< consider things that a sane encoder should not do as an error
2628

2629 2630

    /**
2631 2632
     * opaque 64bit number (generally a PTS) that will be reordered and
     * output in AVFrame.reordered_opaque
2633
     * @deprecated in favor of pkt_pts
2634 2635
     * - encoding: unused
     * - decoding: Set by user.
2636
     */
2637
    int64_t reordered_opaque;
2638 2639

    /**
2640 2641 2642
     * Hardware accelerator in use
     * - encoding: unused.
     * - decoding: Set by libavcodec
2643
     */
2644
    struct AVHWAccel *hwaccel;
2645 2646

    /**
2647 2648 2649
     * Hardware accelerator context.
     * For some hardware accelerators, a global context needs to be
     * provided by the user. In that case, this holds display-dependent
2650 2651
     * data FFmpeg cannot instantiate itself. Please refer to the
     * FFmpeg HW accelerator documentation to know how to fill this
2652 2653 2654
     * is. e.g. for VA API, this is a struct vaapi_context.
     * - encoding: unused
     * - decoding: Set by user
2655
     */
2656
    void *hwaccel_context;
2657 2658

    /**
2659 2660
     * error
     * - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR.
Diego Biurrun's avatar
Diego Biurrun committed
2661
     * - decoding: unused
2662
     */
2663
    uint64_t error[AV_NUM_DATA_POINTERS];
2664 2665

    /**
2666
     * DCT algorithm, see FF_DCT_* below
Diego Biurrun's avatar
Diego Biurrun committed
2667 2668
     * - encoding: Set by user.
     * - decoding: unused
2669
     */
2670 2671 2672 2673 2674 2675 2676
    int dct_algo;
#define FF_DCT_AUTO    0
#define FF_DCT_FASTINT 1
#define FF_DCT_INT     2
#define FF_DCT_MMX     3
#define FF_DCT_ALTIVEC 5
#define FF_DCT_FAAN    6
2677

2678
    /**
2679
     * IDCT algorithm, see FF_IDCT_* below.
2680
     * - encoding: Set by user.
2681
     * - decoding: Set by user.
2682
     */
2683 2684 2685 2686 2687 2688 2689
    int idct_algo;
#define FF_IDCT_AUTO          0
#define FF_IDCT_INT           1
#define FF_IDCT_SIMPLE        2
#define FF_IDCT_SIMPLEMMX     3
#define FF_IDCT_ARM           7
#define FF_IDCT_ALTIVEC       8
2690
#if FF_API_ARCH_SH4
2691
#define FF_IDCT_SH4           9
2692
#endif
2693 2694 2695 2696 2697
#define FF_IDCT_SIMPLEARM     10
#define FF_IDCT_IPP           13
#define FF_IDCT_XVIDMMX       14
#define FF_IDCT_SIMPLEARMV5TE 16
#define FF_IDCT_SIMPLEARMV6   17
2698
#if FF_API_ARCH_SPARC
2699
#define FF_IDCT_SIMPLEVIS     18
2700
#endif
2701 2702
#define FF_IDCT_FAAN          20
#define FF_IDCT_SIMPLENEON    22
2703
#if FF_API_ARCH_ALPHA
2704
#define FF_IDCT_SIMPLEALPHA   23
2705
#endif
2706

2707
    /**
2708 2709
     * bits per sample/pixel from the demuxer (needed for huffyuv).
     * - encoding: Set by libavcodec.
2710 2711
     * - decoding: Set by user.
     */
2712
     int bits_per_coded_sample;
2713 2714 2715 2716 2717 2718 2719

    /**
     * Bits per sample/pixel of internal libavcodec pixel/sample format.
     * - encoding: set by user.
     * - decoding: set by libavcodec.
     */
    int bits_per_raw_sample;
2720

2721
#if FF_API_LOWRES
2722
    /**
2723
     * low resolution decoding, 1-> 1/2 size, 2->1/4 size
2724 2725
     * - encoding: unused
     * - decoding: Set by user.
2726 2727
     * Code outside libavcodec should access this field using:
     * av_codec_{get,set}_lowres(avctx)
2728
     */
Michael Niedermayer's avatar
Michael Niedermayer committed
2729
     int lowres;
2730
#endif
2731 2732

    /**
2733 2734
     * the picture in the bitstream
     * - encoding: Set by libavcodec.
2735
     * - decoding: unused
2736
     */
2737
    AVFrame *coded_frame;
2738 2739

    /**
2740 2741
     * thread count
     * is used to decide how many independent tasks should be passed to execute()
2742
     * - encoding: Set by user.
2743
     * - decoding: Set by user.
2744
     */
2745
    int thread_count;
2746 2747

    /**
2748 2749 2750
     * Which multithreading methods to use.
     * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread,
     * so clients which cannot provide future frames should not use it.
2751
     *
2752 2753
     * - encoding: Set by user, otherwise the default is used.
     * - decoding: Set by user, otherwise the default is used.
2754
     */
2755 2756 2757
    int thread_type;
#define FF_THREAD_FRAME   1 ///< Decode more than one frame at once
#define FF_THREAD_SLICE   2 ///< Decode more than one part of a single frame at once
2758 2759

    /**
2760 2761 2762
     * Which multithreading methods are in use by the codec.
     * - encoding: Set by libavcodec.
     * - decoding: Set by libavcodec.
2763
     */
2764
    int active_thread_type;
2765 2766

    /**
2767
     * Set by the client if its custom get_buffer() callback can be called
2768
     * synchronously from another thread, which allows faster multithreaded decoding.
2769 2770 2771 2772
     * draw_horiz_band() will be called from other threads regardless of this setting.
     * Ignored if the default get_buffer() is used.
     * - encoding: Set by user.
     * - decoding: Set by user.
2773
     */
2774
    int thread_safe_callbacks;
2775 2776

    /**
2777 2778 2779 2780 2781 2782 2783
     * The codec may call this to execute several independent things.
     * It will return only after finishing all tasks.
     * The user may replace this with some multithreaded implementation,
     * the default implementation will execute the parts serially.
     * @param count the number of things to execute
     * - encoding: Set by libavcodec, user can override.
     * - decoding: Set by libavcodec, user can override.
2784
     */
2785
    int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805

    /**
     * The codec may call this to execute several independent things.
     * It will return only after finishing all tasks.
     * The user may replace this with some multithreaded implementation,
     * the default implementation will execute the parts serially.
     * Also see avcodec_thread_init and e.g. the --enable-pthread configure option.
     * @param c context passed also to func
     * @param count the number of things to execute
     * @param arg2 argument passed unchanged to func
     * @param ret return values of executed functions, must have space for "count" values. May be NULL.
     * @param func function that will be called count times, with jobnr from 0 to count-1.
     *             threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no
     *             two instances of func executing at the same time will have the same threadnr.
     * @return always 0 currently, but code should handle a future improvement where when any call to func
     *         returns < 0 no further calls to func may be done and < 0 is returned.
     * - encoding: Set by libavcodec, user can override.
     * - decoding: Set by libavcodec, user can override.
     */
    int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count);
2806

2807
#if FF_API_THREAD_OPAQUE
2808
    /**
2809
     * @deprecated this field should not be used from outside of lavc
2810
     */
2811
    attribute_deprecated
2812
    void *thread_opaque;
2813
#endif
2814

2815
    /**
2816
     * noise vs. sse weight for the nsse comparison function
2817
     * - encoding: Set by user.
2818 2819
     * - decoding: unused
     */
2820
     int nsse_weight;
2821 2822

    /**
2823 2824 2825
     * profile
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
2826
     */
2827 2828 2829 2830 2831 2832 2833 2834
     int profile;
#define FF_PROFILE_UNKNOWN -99
#define FF_PROFILE_RESERVED -100

#define FF_PROFILE_AAC_MAIN 0
#define FF_PROFILE_AAC_LOW  1
#define FF_PROFILE_AAC_SSR  2
#define FF_PROFILE_AAC_LTP  3
2835 2836 2837 2838
#define FF_PROFILE_AAC_HE   4
#define FF_PROFILE_AAC_HE_V2 28
#define FF_PROFILE_AAC_LD   22
#define FF_PROFILE_AAC_ELD  38
2839 2840
#define FF_PROFILE_MPEG2_AAC_LOW 128
#define FF_PROFILE_MPEG2_AAC_HE  131
2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892

#define FF_PROFILE_DTS         20
#define FF_PROFILE_DTS_ES      30
#define FF_PROFILE_DTS_96_24   40
#define FF_PROFILE_DTS_HD_HRA  50
#define FF_PROFILE_DTS_HD_MA   60

#define FF_PROFILE_MPEG2_422    0
#define FF_PROFILE_MPEG2_HIGH   1
#define FF_PROFILE_MPEG2_SS     2
#define FF_PROFILE_MPEG2_SNR_SCALABLE  3
#define FF_PROFILE_MPEG2_MAIN   4
#define FF_PROFILE_MPEG2_SIMPLE 5

#define FF_PROFILE_H264_CONSTRAINED  (1<<9)  // 8+1; constraint_set1_flag
#define FF_PROFILE_H264_INTRA        (1<<11) // 8+3; constraint_set3_flag

#define FF_PROFILE_H264_BASELINE             66
#define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
#define FF_PROFILE_H264_MAIN                 77
#define FF_PROFILE_H264_EXTENDED             88
#define FF_PROFILE_H264_HIGH                 100
#define FF_PROFILE_H264_HIGH_10              110
#define FF_PROFILE_H264_HIGH_10_INTRA        (110|FF_PROFILE_H264_INTRA)
#define FF_PROFILE_H264_HIGH_422             122
#define FF_PROFILE_H264_HIGH_422_INTRA       (122|FF_PROFILE_H264_INTRA)
#define FF_PROFILE_H264_HIGH_444             144
#define FF_PROFILE_H264_HIGH_444_PREDICTIVE  244
#define FF_PROFILE_H264_HIGH_444_INTRA       (244|FF_PROFILE_H264_INTRA)
#define FF_PROFILE_H264_CAVLC_444            44

#define FF_PROFILE_VC1_SIMPLE   0
#define FF_PROFILE_VC1_MAIN     1
#define FF_PROFILE_VC1_COMPLEX  2
#define FF_PROFILE_VC1_ADVANCED 3

#define FF_PROFILE_MPEG4_SIMPLE                     0
#define FF_PROFILE_MPEG4_SIMPLE_SCALABLE            1
#define FF_PROFILE_MPEG4_CORE                       2
#define FF_PROFILE_MPEG4_MAIN                       3
#define FF_PROFILE_MPEG4_N_BIT                      4
#define FF_PROFILE_MPEG4_SCALABLE_TEXTURE           5
#define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION      6
#define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE     7
#define FF_PROFILE_MPEG4_HYBRID                     8
#define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME         9
#define FF_PROFILE_MPEG4_CORE_SCALABLE             10
#define FF_PROFILE_MPEG4_ADVANCED_CODING           11
#define FF_PROFILE_MPEG4_ADVANCED_CORE             12
#define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
#define FF_PROFILE_MPEG4_SIMPLE_STUDIO             14
#define FF_PROFILE_MPEG4_ADVANCED_SIMPLE           15
2893

2894 2895 2896 2897 2898 2899
#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0   0
#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1   1
#define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION  2
#define FF_PROFILE_JPEG2000_DCINEMA_2K              3
#define FF_PROFILE_JPEG2000_DCINEMA_4K              4

gcocherel's avatar
gcocherel committed
2900 2901 2902 2903 2904

#define FF_PROFILE_HEVC_MAIN                        1
#define FF_PROFILE_HEVC_MAIN_10                     2
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE          3

2905
    /**
2906 2907 2908
     * level
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
2909
     */
2910 2911
     int level;
#define FF_LEVEL_UNKNOWN -99
2912

2913
    /**
2914
     * Skip loop filtering for selected frames.
2915 2916
     * - encoding: unused
     * - decoding: Set by user.
2917
     */
2918
    enum AVDiscard skip_loop_filter;
2919 2920

    /**
2921
     * Skip IDCT/dequantization for selected frames.
2922 2923
     * - encoding: unused
     * - decoding: Set by user.
2924
     */
2925
    enum AVDiscard skip_idct;
2926 2927

    /**
2928
     * Skip decoding for selected frames.
2929
     * - encoding: unused
2930 2931
     * - decoding: Set by user.
     */
2932
    enum AVDiscard skip_frame;
2933

2934
    /**
2935 2936 2937 2938 2939 2940
     * Header containing style information for text subtitles.
     * For SUBTITLE_ASS subtitle type, it should contain the whole ASS
     * [Script Info] and [V4+ Styles] section, plus the [Events] line and
     * the Format line following. It shouldn't include any Dialogue line.
     * - encoding: Set/allocated/freed by user (before avcodec_open2())
     * - decoding: Set/allocated/freed by libavcodec (by avcodec_open2())
2941
     */
2942 2943
    uint8_t *subtitle_header;
    int subtitle_header_size;
2944

2945
#if FF_API_ERROR_RATE
2946
    /**
2947 2948
     * @deprecated use the 'error_rate' private AVOption of the mpegvideo
     * encoders
2949
     */
2950
    attribute_deprecated
2951
    int error_rate;
2952
#endif
2953

2954
#if FF_API_CODEC_PKT
2955
    /**
2956
     * @deprecated this field is not supposed to be accessed from outside lavc
2957
     */
2958
    attribute_deprecated
2959
    AVPacket *pkt;
2960
#endif
2961

2962
    /**
2963 2964 2965 2966
     * VBV delay coded in the last frame (in periods of a 27 MHz clock).
     * Used for compliant TS muxing.
     * - encoding: Set by libavcodec.
     * - decoding: unused.
2967
     */
2968
    uint64_t vbv_delay;
2969

2970 2971 2972
    /**
     * Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
     * Code outside libavcodec should access this field using:
2973
     * av_codec_{get,set}_pkt_timebase(avctx)
2974
     * - encoding unused.
2975
     * - decoding set by user.
2976 2977 2978
     */
    AVRational pkt_timebase;

2979 2980 2981
    /**
     * AVCodecDescriptor
     * Code outside libavcodec should access this field using:
2982
     * av_codec_{get,set}_codec_descriptor(avctx)
2983 2984 2985
     * - encoding: unused.
     * - decoding: set by libavcodec.
     */
2986
    const AVCodecDescriptor *codec_descriptor;
2987

2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998
#if !FF_API_LOWRES
    /**
     * low resolution decoding, 1-> 1/2 size, 2->1/4 size
     * - encoding: unused
     * - decoding: Set by user.
     * Code outside libavcodec should access this field using:
     * av_codec_{get,set}_lowres(avctx)
     */
     int lowres;
#endif

2999 3000
    /**
     * Current statistics for PTS correction.
3001
     * - decoding: maintained and used by libavcodec, not intended to be used by user apps
3002 3003 3004 3005 3006 3007
     * - encoding: unused
     */
    int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
    int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
    int64_t pts_correction_last_pts;       /// PTS of the last frame
    int64_t pts_correction_last_dts;       /// DTS of the last frame
3008

3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025
    /**
     * Character encoding of the input subtitles file.
     * - decoding: set by user
     * - encoding: unused
     */
    char *sub_charenc;

    /**
     * Subtitles character encoding mode. Formats or codecs might be adjusting
     * this setting (if they are doing the conversion themselves for instance).
     * - decoding: set by libavcodec
     * - encoding: unused
     */
    int sub_charenc_mode;
#define FF_SUB_CHARENC_MODE_DO_NOTHING  -1  ///< do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance)
#define FF_SUB_CHARENC_MODE_AUTOMATIC    0  ///< libavcodec will select the mode itself
#define FF_SUB_CHARENC_MODE_PRE_DECODER  1  ///< the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
3026

3027 3028 3029 3030 3031 3032 3033 3034
    /**
     * Skip processing alpha if supported by codec.
     * Note that if the format uses pre-multiplied alpha (common with VP6,
     * and recommended due to better video quality/compression)
     * the image will look as if alpha-blended onto a black background.
     * However for formats that do not use pre-multiplied alpha
     * there might be serious artefacts (though e.g. libswscale currently
     * assumes pre-multiplied alpha anyway).
3035
     * Code outside libavcodec should access this field using AVOptions
3036 3037 3038 3039 3040
     *
     * - decoding: set by user
     * - encoding: unused
     */
    int skip_alpha;
3041 3042 3043 3044 3045 3046 3047

    /**
     * Number of samples to skip after a discontinuity
     * - decoding: unused
     * - encoding: set by libavcodec
     */
    int seek_preroll;
3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060

#if !FF_API_DEBUG_MV
    /**
     * debug motion vectors
     * Code outside libavcodec should access this field using AVOptions
     * - encoding: Set by user.
     * - decoding: Set by user.
     */
    int debug_mv;
#define FF_DEBUG_VIS_MV_P_FOR  0x00000001 //visualize forward predicted MVs of P frames
#define FF_DEBUG_VIS_MV_B_FOR  0x00000002 //visualize forward predicted MVs of B frames
#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
#endif
3061 3062 3063 3064 3065 3066 3067 3068

    /**
     * custom intra quantization matrix
     * Code outside libavcodec should access this field using av_codec_g/set_chroma_intra_matrix()
     * - encoding: Set by user, can be NULL.
     * - decoding: unused.
     */
    uint16_t *chroma_intra_matrix;
Fabrice Bellard's avatar
Fabrice Bellard committed
3069 3070
} AVCodecContext;

3071 3072 3073
AVRational av_codec_get_pkt_timebase         (const AVCodecContext *avctx);
void       av_codec_set_pkt_timebase         (AVCodecContext *avctx, AVRational val);

3074 3075
const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx);
void                     av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc);
3076

3077 3078 3079
int  av_codec_get_lowres(const AVCodecContext *avctx);
void av_codec_set_lowres(AVCodecContext *avctx, int val);

3080 3081 3082
int  av_codec_get_seek_preroll(const AVCodecContext *avctx);
void av_codec_set_seek_preroll(AVCodecContext *avctx, int val);

3083 3084 3085
uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx);
void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val);

3086 3087 3088 3089 3090 3091 3092 3093
/**
 * AVProfile.
 */
typedef struct AVProfile {
    int profile;
    const char *name; ///< short name for the profile
} AVProfile;

3094 3095
typedef struct AVCodecDefault AVCodecDefault;

3096 3097
struct AVSubtitle;

3098 3099 3100
/**
 * AVCodec.
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
3101
typedef struct AVCodec {
3102 3103 3104 3105 3106 3107
    /**
     * Name of the codec implementation.
     * The name is globally unique among encoders and among decoders (but an
     * encoder and a decoder can share the same name).
     * This is the primary way to find a codec from the user perspective.
     */
3108
    const char *name;
3109 3110 3111 3112 3113
    /**
     * Descriptive name for the codec, meant to be more human readable than name.
     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
     */
    const char *long_name;
3114
    enum AVMediaType type;
3115
    enum AVCodecID id;
3116 3117 3118 3119
    /**
     * Codec capabilities.
     * see CODEC_CAP_*
     */
3120
    int capabilities;
3121
    const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
3122
    const enum AVPixelFormat *pix_fmts;     ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
3123
    const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
3124
    const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
3125
    const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
3126
#if FF_API_LOWRES
3127
    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder, no direct access, use av_codec_get_max_lowres()
3128
#endif
3129
    const AVClass *priv_class;              ///< AVClass for the private context
3130
    const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
3131

3132 3133 3134 3135 3136 3137 3138 3139 3140
    /*****************************************************************
     * No fields below this line are part of the public API. They
     * may not be used outside of libavcodec and can be changed and
     * removed at will.
     * New public fields should be added right above.
     *****************************************************************
     */
    int priv_data_size;
    struct AVCodec *next;
3141
    /**
3142
     * @name Frame-level threading support functions
3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159
     * @{
     */
    /**
     * If defined, called on thread contexts when they are created.
     * If the codec allocates writable tables in init(), re-allocate them here.
     * priv_data will be set to a copy of the original.
     */
    int (*init_thread_copy)(AVCodecContext *);
    /**
     * Copy necessary context variables from a previous thread context to the current one.
     * If not defined, the next thread will start automatically; otherwise, the codec
     * must call ff_thread_finish_setup().
     *
     * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
     */
    int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src);
    /** @} */
3160 3161 3162 3163 3164

    /**
     * Private codec-specific defaults.
     */
    const AVCodecDefault *defaults;
3165 3166 3167 3168 3169

    /**
     * Initialize codec static data, called from avcodec_register().
     */
    void (*init_static_data)(struct AVCodec *codec);
3170

3171
    int (*init)(AVCodecContext *);
3172 3173
    int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
                      const struct AVSubtitle *sub);
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
    /**
     * Encode data to an AVPacket.
     *
     * @param      avctx          codec context
     * @param      avpkt          output AVPacket (may contain a user-provided buffer)
     * @param[in]  frame          AVFrame containing the raw data to be encoded
     * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
     *                            non-empty packet was returned in avpkt.
     * @return 0 on success, negative error code on failure
     */
    int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
                   int *got_packet_ptr);
3186 3187 3188 3189 3190 3191 3192
    int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
    int (*close)(AVCodecContext *);
    /**
     * Flush buffers.
     * Will be called when seeking
     */
    void (*flush)(AVCodecContext *);
Fabrice Bellard's avatar
Fabrice Bellard committed
3193 3194
} AVCodec;

3195 3196
int av_codec_get_max_lowres(const AVCodec *codec);

3197 3198
struct MpegEncContext;

3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212
/**
 * AVHWAccel.
 */
typedef struct AVHWAccel {
    /**
     * Name of the hardware accelerated codec.
     * The name is globally unique among encoders and among decoders (but an
     * encoder and a decoder can share the same name).
     */
    const char *name;

    /**
     * Type of codec implemented by the hardware accelerator.
     *
3213
     * See AVMEDIA_TYPE_xxx
3214
     */
3215
    enum AVMediaType type;
3216 3217 3218 3219

    /**
     * Codec implemented by the hardware accelerator.
     *
3220
     * See AV_CODEC_ID_xxx
3221
     */
3222
    enum AVCodecID id;
3223 3224 3225 3226 3227 3228

    /**
     * Supported pixel format.
     *
     * Only hardware accelerated formats are supported here.
     */
3229
    enum AVPixelFormat pix_fmt;
3230 3231 3232 3233 3234 3235 3236

    /**
     * Hardware accelerated codec capabilities.
     * see FF_HWACCEL_CODEC_CAP_*
     */
    int capabilities;

3237 3238 3239 3240 3241 3242 3243
    /*****************************************************************
     * No fields below this line are part of the public API. They
     * may not be used outside of libavcodec and can be changed and
     * removed at will.
     * New public fields should be added right above.
     *****************************************************************
     */
3244 3245
    struct AVHWAccel *next;

3246 3247 3248 3249 3250
    /**
     * Allocate a custom buffer
     */
    int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);

3251 3252 3253 3254 3255 3256
    /**
     * Called at the beginning of each frame or field picture.
     *
     * Meaningful frame information (codec specific) is guaranteed to
     * be parsed at this point. This function is mandatory.
     *
3257
     * Note that buf can be NULL along with buf_size set to 0.
3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271
     * Otherwise, this means the whole frame is available at this point.
     *
     * @param avctx the codec context
     * @param buf the frame data buffer base
     * @param buf_size the size of the frame in bytes
     * @return zero if successful, a negative value otherwise
     */
    int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);

    /**
     * Callback for each slice.
     *
     * Meaningful slice information (codec specific) is guaranteed to
     * be parsed at this point. This function is mandatory.
3272
     * The only exception is XvMC, that works on MB level.
3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290
     *
     * @param avctx the codec context
     * @param buf the slice data buffer base
     * @param buf_size the size of the slice in bytes
     * @return zero if successful, a negative value otherwise
     */
    int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);

    /**
     * Called at the end of each frame or field picture.
     *
     * The whole picture is parsed at this point and can now be sent
     * to the hardware accelerator. This function is mandatory.
     *
     * @param avctx the codec context
     * @return zero if successful, a negative value otherwise
     */
    int (*end_frame)(AVCodecContext *avctx);
3291 3292

    /**
3293
     * Size of per-frame hardware accelerator private data.
3294
     *
3295 3296 3297
     * Private data is allocated with av_mallocz() before
     * AVCodecContext.get_buffer() and deallocated after
     * AVCodecContext.release_buffer().
3298
     */
3299
    int frame_priv_data_size;
3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310

    /**
     * Called for every Macroblock in a slice.
     *
     * XvMC uses it to replace the ff_MPV_decode_mb().
     * Instead of decoding to raw picture, MB parameters are
     * stored in an array provided by the video driver.
     *
     * @param s the mpeg context
     */
    void (*decode_mb)(struct MpegEncContext *s);
3311

3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333
    /**
     * Initialize the hwaccel private data.
     *
     * This will be called from ff_get_format(), after hwaccel and
     * hwaccel_context are set and the hwaccel private data in AVCodecInternal
     * is allocated.
     */
    int (*init)(AVCodecContext *avctx);

    /**
     * Uninitialize the hwaccel private data.
     *
     * This will be called from get_format() or avcodec_close(), after hwaccel
     * and hwaccel_context are already uninitialized.
     */
    int (*uninit)(AVCodecContext *avctx);

    /**
     * Size of the private data to allocate in
     * AVCodecInternal.hwaccel_priv_data.
     */
    int priv_data_size;
3334 3335
} AVHWAccel;

3336 3337 3338 3339 3340 3341 3342
/**
 * @defgroup lavc_picture AVPicture
 *
 * Functions for working with AVPicture
 * @{
 */

3343
/**
3344 3345 3346 3347
 * Picture data structure.
 *
 * Up to four components can be stored into it, the last component is
 * alpha.
3348
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
3349
typedef struct AVPicture {
3350
    uint8_t *data[AV_NUM_DATA_POINTERS];    ///< pointers to the image data planes
3351
    int linesize[AV_NUM_DATA_POINTERS];     ///< number of bytes per line
Fabrice Bellard's avatar
Fabrice Bellard committed
3352 3353
} AVPicture;

3354 3355 3356 3357
/**
 * @}
 */

3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375
enum AVSubtitleType {
    SUBTITLE_NONE,

    SUBTITLE_BITMAP,                ///< A bitmap, pict will be set

    /**
     * Plain text, the text field must be set by the decoder and is
     * authoritative. ass and pict fields may contain approximations.
     */
    SUBTITLE_TEXT,

    /**
     * Formatted text, the ass field must be set by the decoder and is
     * authoritative. pict and text fields may contain approximations.
     */
    SUBTITLE_ASS,
};

3376 3377
#define AV_SUBTITLE_FLAG_FORCED 0x00000001

3378
typedef struct AVSubtitleRect {
3379 3380 3381 3382 3383
    int x;         ///< top left corner  of pict, undefined when pict is not set
    int y;         ///< top left corner  of pict, undefined when pict is not set
    int w;         ///< width            of pict, undefined when pict is not set
    int h;         ///< height           of pict, undefined when pict is not set
    int nb_colors; ///< number of colors in pict, undefined when pict is not set
3384 3385 3386 3387 3388 3389

    /**
     * data+linesize for the bitmap of this subtitle.
     * can be set for text/ass as well once they where rendered
     */
    AVPicture pict;
3390 3391 3392 3393 3394 3395
    enum AVSubtitleType type;

    char *text;                     ///< 0 terminated plain UTF-8 text

    /**
     * 0 terminated ASS/SSA compatible event line.
3396
     * The presentation of this is unaffected by the other values in this
3397 3398 3399
     * struct.
     */
    char *ass;
3400

3401
    int flags;
3402 3403 3404 3405 3406 3407
} AVSubtitleRect;

typedef struct AVSubtitle {
    uint16_t format; /* 0 = graphics */
    uint32_t start_display_time; /* relative to packet pts, in ms */
    uint32_t end_display_time; /* relative to packet pts, in ms */
3408
    unsigned num_rects;
3409
    AVSubtitleRect **rects;
3410
    int64_t pts;    ///< Same as packet pts, in AV_TIME_BASE
3411 3412
} AVSubtitle;

3413
/**
3414 3415 3416
 * If c is NULL, returns the first registered codec,
 * if c is non-NULL, returns the next registered codec after c,
 * or NULL if c is the last one.
3417
 */
3418
AVCodec *av_codec_next(const AVCodec *c);
3419 3420

/**
3421
 * Return the LIBAVCODEC_VERSION_INT constant.
3422
 */
3423
unsigned avcodec_version(void);
3424 3425

/**
3426
 * Return the libavcodec build-time configuration.
3427
 */
3428
const char *avcodec_configuration(void);
3429 3430

/**
3431
 * Return the libavcodec license.
3432
 */
3433
const char *avcodec_license(void);
3434

3435
/**
3436
 * Register the codec codec and initialize libavcodec.
3437
 *
3438 3439 3440 3441
 * @warning either this function or avcodec_register_all() must be called
 * before any other libavcodec functions.
 *
 * @see avcodec_register_all()
3442
 */
3443
void avcodec_register(AVCodec *codec);
3444

3445
/**
3446 3447 3448 3449
 * Register all the codecs, parsers and bitstream filters which were enabled at
 * configuration time. If you do not call this function you can select exactly
 * which formats you want to support, by using the individual registration
 * functions.
3450
 *
3451 3452 3453
 * @see avcodec_register
 * @see av_register_codec_parser
 * @see av_register_bitstream_filter
3454
 */
3455
void avcodec_register_all(void);
3456

3457
/**
3458 3459 3460
 * Allocate an AVCodecContext and set its fields to default values.  The
 * resulting struct can be deallocated by calling avcodec_close() on it followed
 * by av_free().
3461
 *
3462 3463 3464 3465 3466 3467 3468 3469 3470
 * @param codec if non-NULL, allocate private data and initialize defaults
 *              for the given codec. It is illegal to then call avcodec_open2()
 *              with a different codec.
 *              If NULL, then the codec-specific defaults won't be initialized,
 *              which may result in suboptimal default settings (this is
 *              important mainly for encoders, e.g. libx264).
 *
 * @return An AVCodecContext filled with default values or NULL on failure.
 * @see avcodec_get_context_defaults
3471
 */
3472
AVCodecContext *avcodec_alloc_context3(const AVCodec *codec);
3473

3474
/**
3475 3476
 * Set the fields of the given AVCodecContext to default values corresponding
 * to the given codec (defaults may be codec-dependent).
3477
 *
3478 3479 3480 3481
 * Do not call this function if a non-NULL codec has been passed
 * to avcodec_alloc_context3() that allocated this AVCodecContext.
 * If codec is non-NULL, it is illegal to call avcodec_open2() with a
 * different codec on this AVCodecContext.
3482
 */
3483
int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec);
Fabrice Bellard's avatar
Fabrice Bellard committed
3484

3485
/**
3486 3487
 * Get the AVClass for AVCodecContext. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
3488
 *
3489
 * @see av_opt_find().
3490
 */
3491
const AVClass *avcodec_get_class(void);
3492 3493

/**
3494 3495
 * Get the AVClass for AVFrame. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
3496
 *
3497
 * @see av_opt_find().
3498
 */
3499
const AVClass *avcodec_get_frame_class(void);
3500

3501 3502 3503 3504 3505 3506 3507 3508
/**
 * Get the AVClass for AVSubtitleRect. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 *
 * @see av_opt_find().
 */
const AVClass *avcodec_get_subtitle_rect_class(void);

3509
/**
3510 3511 3512 3513 3514 3515
 * Copy the settings of the source AVCodecContext into the destination
 * AVCodecContext. The resulting destination codec context will be
 * unopened, i.e. you are required to call avcodec_open2() before you
 * can use this AVCodecContext to decode/encode video/audio data.
 *
 * @param dest target codec context, should be initialized with
3516
 *             avcodec_alloc_context3(NULL), but otherwise uninitialized
3517 3518
 * @param src source codec context
 * @return AVERROR() on error (e.g. memory allocation error), 0 on success
3519
 */
3520
int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src);
3521

3522
#if FF_API_AVFRAME_LAVC
3523
/**
3524
 * @deprecated use av_frame_alloc()
3525
 */
3526
attribute_deprecated
3527
AVFrame *avcodec_alloc_frame(void);
3528 3529

/**
3530
 * Set the fields of the given AVFrame to default values.
3531
 *
3532
 * @param frame The AVFrame of which the fields should be set to default values.
3533 3534
 *
 * @deprecated use av_frame_unref()
3535
 */
3536
attribute_deprecated
3537
void avcodec_get_frame_defaults(AVFrame *frame);
3538

3539 3540 3541 3542 3543 3544 3545 3546 3547
/**
 * Free the frame and any dynamically allocated objects in it,
 * e.g. extended_data.
 *
 * @param frame frame to be freed. The pointer will be set to NULL.
 *
 * @warning this function does NOT free the data buffers themselves
 * (it does not know how, since they might have been allocated with
 *  a custom get_buffer()).
3548 3549
 *
 * @deprecated use av_frame_free()
3550
 */
3551
attribute_deprecated
3552
void avcodec_free_frame(AVFrame **frame);
3553
#endif
3554

3555
/**
3556 3557
 * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
 * function the context has to be allocated with avcodec_alloc_context3().
3558
 *
3559 3560 3561
 * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),
 * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for
 * retrieving a codec.
3562
 *
3563 3564 3565 3566 3567
 * @warning This function is not thread safe!
 *
 * @code
 * avcodec_register_all();
 * av_dict_set(&opts, "b", "2.5M", 0);
3568
 * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589
 * if (!codec)
 *     exit(1);
 *
 * context = avcodec_alloc_context3(codec);
 *
 * if (avcodec_open2(context, codec, opts) < 0)
 *     exit(1);
 * @endcode
 *
 * @param avctx The context to initialize.
 * @param codec The codec to open this context for. If a non-NULL codec has been
 *              previously passed to avcodec_alloc_context3() or
 *              avcodec_get_context_defaults3() for this context, then this
 *              parameter MUST be either NULL or equal to the previously passed
 *              codec.
 * @param options A dictionary filled with AVCodecContext and codec-private options.
 *                On return this object will be filled with options that were not found.
 *
 * @return zero on success, a negative value on error
 * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(),
 *      av_dict_set(), av_opt_find().
3590
 */
3591
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
3592 3593

/**
3594 3595
 * Close a given AVCodecContext and free all the data associated with it
 * (but not the AVCodecContext itself).
3596
 *
3597 3598 3599 3600
 * Calling this function on an AVCodecContext that hasn't been opened will free
 * the codec-specific data allocated in avcodec_alloc_context3() /
 * avcodec_get_context_defaults3() with a non-NULL codec. Subsequent calls will
 * do nothing.
3601
 */
3602
int avcodec_close(AVCodecContext *avctx);
3603 3604

/**
3605
 * Free all allocated data in the given subtitle struct.
3606
 *
3607
 * @param sub AVSubtitle to free.
3608
 */
3609
void avsubtitle_free(AVSubtitle *sub);
3610

3611
/**
3612
 * @}
3613
 */
3614

3615
/**
3616 3617
 * @addtogroup lavc_packet
 * @{
3618
 */
3619

3620
#if FF_API_DESTRUCT_PACKET
3621 3622
/**
 * Default packet destructor.
3623
 * @deprecated use the AVBuffer API instead
3624
 */
3625
attribute_deprecated
3626
void av_destruct_packet(AVPacket *pkt);
3627
#endif
3628

3629
/**
3630
 * Initialize optional fields of a packet with default values.
3631
 *
3632 3633 3634
 * Note, this does not touch the data and size members, which have to be
 * initialized separately.
 *
3635
 * @param pkt packet
3636
 */
3637
void av_init_packet(AVPacket *pkt);
3638 3639

/**
3640 3641
 * Allocate the payload of a packet and initialize its fields with
 * default values.
3642
 *
3643 3644 3645
 * @param pkt packet
 * @param size wanted payload size
 * @return 0 if OK, AVERROR_xxx otherwise
3646
 */
3647
int av_new_packet(AVPacket *pkt, int size);
3648

3649
/**
3650
 * Reduce packet size, correctly zeroing padding
3651
 *
3652 3653
 * @param pkt packet
 * @param size new size
3654
 */
3655
void av_shrink_packet(AVPacket *pkt, int size);
Fabrice Bellard's avatar
Fabrice Bellard committed
3656

3657
/**
3658 3659 3660 3661
 * Increase packet size, correctly zeroing padding
 *
 * @param pkt packet
 * @param grow_by number of bytes by which to increase the size of the packet
3662
 */
3663
int av_grow_packet(AVPacket *pkt, int grow_by);
Fabrice Bellard's avatar
Fabrice Bellard committed
3664

3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679
/**
 * Initialize a reference-counted packet from av_malloc()ed data.
 *
 * @param pkt packet to be initialized. This function will set the data, size,
 *        buf and destruct fields, all others are left untouched.
 * @param data Data allocated by av_malloc() to be used as packet data. If this
 *        function returns successfully, the data is owned by the underlying AVBuffer.
 *        The caller may not access the data through other means.
 * @param size size of data in bytes, without the padding. I.e. the full buffer
 *        size is assumed to be size + FF_INPUT_BUFFER_PADDING_SIZE.
 *
 * @return 0 on success, a negative AVERROR on error
 */
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);

3680
/**
3681 3682
 * @warning This is a hack - the packet memory allocation stuff is broken. The
 * packet is allocated if it was not really allocated.
3683
 */
3684
int av_dup_packet(AVPacket *pkt);
3685

Andrey Utkin's avatar
Andrey Utkin committed
3686 3687 3688 3689 3690
/**
 * Copy packet, including contents
 *
 * @return 0 on success, negative AVERROR on fail
 */
3691
int av_copy_packet(AVPacket *dst, const AVPacket *src);
Andrey Utkin's avatar
Andrey Utkin committed
3692

3693 3694 3695 3696 3697
/**
 * Copy packet side data
 *
 * @return 0 on success, negative AVERROR on fail
 */
3698
int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
3699

3700
/**
3701
 * Free a packet.
3702
 *
3703
 * @param pkt packet to free
3704
 */
Ramiro Polla's avatar
Ramiro Polla committed
3705
void av_free_packet(AVPacket *pkt);
3706 3707

/**
3708
 * Allocate new information of a packet.
3709
 *
3710 3711 3712 3713
 * @param pkt packet
 * @param type side information type
 * @param size side information size
 * @return pointer to fresh allocated data or NULL otherwise
3714
 */
3715 3716
uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                                 int size);
Fabrice Bellard's avatar
Fabrice Bellard committed
3717

3718
/**
3719
 * Shrink the already allocated side data buffer
3720
 *
3721 3722 3723 3724
 * @param pkt packet
 * @param type side information type
 * @param size new side information size
 * @return 0 on success, < 0 on failure
3725
 */
3726 3727
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                               int size);
3728

3729
/**
3730
 * Get side information from packet.
3731
 *
3732 3733 3734 3735
 * @param pkt packet
 * @param type desired side information type
 * @param size pointer for side information size to store (optional)
 * @return pointer to data if present or NULL otherwise
3736
 */
3737 3738
uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                                 int *size);
3739

3740
int av_packet_merge_side_data(AVPacket *pkt);
3741

3742
int av_packet_split_side_data(AVPacket *pkt);
3743

3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761
/**
 * Pack a dictionary for use in side_data.
 *
 * @param dict The dictionary to pack.
 * @param size pointer to store the size of the returned data
 * @return pointer to data if successful, NULL otherwise
 */
uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size);
/**
 * Unpack a dictionary from side_data.
 *
 * @param data data from side_data
 * @param size size of the data
 * @param dict the metadata storage dictionary
 * @return 0 on success, < 0 on failure
 */
int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);

3762

3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786
/**
 * Convenience function to free all the side data stored.
 * All the other fields stay untouched.
 *
 * @param pkt packet
 */
void av_packet_free_side_data(AVPacket *pkt);

/**
 * Setup a new reference to the data described by a given packet
 *
 * If src is reference-counted, setup dst as a new reference to the
 * buffer in src. Otherwise allocate a new buffer in dst and copy the
 * data from src into it.
 *
 * All the other fields are copied from src.
 *
 * @see av_packet_unref
 *
 * @param dst Destination packet
 * @param src Source packet
 *
 * @return 0 on success, a negative AVERROR on error.
 */
3787
int av_packet_ref(AVPacket *dst, const AVPacket *src);
3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822

/**
 * Wipe the packet.
 *
 * Unreference the buffer referenced by the packet and reset the
 * remaining packet fields to their default values.
 *
 * @param pkt The packet to be unreferenced.
 */
void av_packet_unref(AVPacket *pkt);

/**
 * Move every field in src to dst and reset src.
 *
 * @see av_packet_unref
 *
 * @param src Source packet, will be reset
 * @param dst Destination packet
 */
void av_packet_move_ref(AVPacket *dst, AVPacket *src);

/**
 * Copy only "properties" fields from src to dst.
 *
 * Properties for the purpose of this function are all the fields
 * beside those related to the packet data (buf, data, size)
 *
 * @param dst Destination packet
 * @param src Source packet
 *
 * @return 0 on success AVERROR on failure.
 *
 */
int av_packet_copy_props(AVPacket *dst, const AVPacket *src);

3823
/**
3824
 * @}
3825
 */
3826

3827
/**
3828 3829
 * @addtogroup lavc_decoding
 * @{
3830 3831
 */

3832
/**
3833
 * Find a registered decoder with a matching codec ID.
3834
 *
3835
 * @param id AVCodecID of the requested decoder
3836
 * @return A decoder if one was found, NULL otherwise.
3837
 */
3838
AVCodec *avcodec_find_decoder(enum AVCodecID id);
3839 3840

/**
3841
 * Find a registered decoder with the specified name.
3842
 *
3843 3844
 * @param name name of the requested decoder
 * @return A decoder if one was found, NULL otherwise.
3845
 */
3846
AVCodec *avcodec_find_decoder_by_name(const char *name);
Michael Niedermayer's avatar
Michael Niedermayer committed
3847

3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859
#if FF_API_GET_BUFFER
attribute_deprecated int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic);
attribute_deprecated void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic);
attribute_deprecated int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic);
#endif

/**
 * The default callback for AVCodecContext.get_buffer2(). It is made public so
 * it can be called by custom get_buffer2() implementations for decoders without
 * CODEC_CAP_DR1 set.
 */
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags);
3860

3861
#if FF_API_EMU_EDGE
3862
/**
3863
 * Return the amount of padding in pixels which the get_buffer callback must
3864 3865 3866 3867
 * provide around the edge of the image for codecs which do not have the
 * CODEC_FLAG_EMU_EDGE flag.
 *
 * @return Required padding in pixels.
3868 3869 3870
 *
 * @deprecated CODEC_FLAG_EMU_EDGE is deprecated, so this function is no longer
 * needed
3871
 */
3872
attribute_deprecated
3873
unsigned avcodec_get_edge_width(void);
3874
#endif
3875

3876
/**
3877
 * Modify width and height values so that they will result in a memory
3878 3879
 * buffer that is acceptable for the codec if you do not use any horizontal
 * padding.
3880 3881
 *
 * May only be used if a codec with CODEC_CAP_DR1 has been opened.
3882
 */
3883
void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
Drew Hess's avatar
Drew Hess committed
3884

3885
/**
3886
 * Modify width and height values so that they will result in a memory
3887 3888
 * buffer that is acceptable for the codec if you also ensure that all
 * line sizes are a multiple of the respective linesize_align[i].
3889 3890
 *
 * May only be used if a codec with CODEC_CAP_DR1 has been opened.
3891 3892
 */
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
3893
                               int linesize_align[AV_NUM_DATA_POINTERS]);
3894

3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905
/**
 * Converts AVChromaLocation to swscale x/y chroma position.
 *
 * The positions represent the chroma (0,0) position in a coordinates system
 * with luma (0,0) representing the origin and luma(1,1) representing 256,256
 *
 * @param xpos  horizontal chroma sample position
 * @param ypos  vertical   chroma sample position
 */
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);

3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916
/**
 * Converts swscale x/y chroma position to AVChromaLocation.
 *
 * The positions represent the chroma (0,0) position in a coordinates system
 * with luma (0,0) representing the origin and luma(1,1) representing 256,256
 *
 * @param xpos  horizontal chroma sample position
 * @param ypos  vertical   chroma sample position
 */
enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);

3917
#if FF_API_OLD_DECODE_AUDIO
3918
/**
3919 3920 3921 3922
 * Wrapper function which calls avcodec_decode_audio4.
 *
 * @deprecated Use avcodec_decode_audio4 instead.
 *
3923
 * Decode the audio frame of size avpkt->size from avpkt->data into samples.
3924
 * Some decoders may support multiple frames in a single AVPacket, such
3925 3926 3927
 * decoders would then just decode the first frame. In this case,
 * avcodec_decode_audio3 has to be called again with an AVPacket that contains
 * the remaining data in order to decode the second frame etc.
3928
 * If no frame
3929
 * could be outputted, frame_size_ptr is zero. Otherwise, it is the
3930
 * decompressed frame size in bytes.
3931
 *
3932
 * @warning You must set frame_size_ptr to the allocated size of the
3933
 * output buffer before calling avcodec_decode_audio3().
3934
 *
3935
 * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
3936 3937 3938
 * the actual read bytes because some optimized bitstream readers read 32 or 64
 * bits at once and could read over the end.
 *
3939
 * @warning The end of the input buffer avpkt->data should be set to 0 to ensure that
3940
 * no overreading happens for damaged MPEG streams.
3941
 *
3942 3943 3944 3945 3946
 * @warning You must not provide a custom get_buffer() when using
 * avcodec_decode_audio3().  Doing so will override it with
 * avcodec_default_get_buffer.  Use avcodec_decode_audio4() instead,
 * which does allow the application to provide a custom get_buffer().
 *
3947
 * @note You might have to align the input buffer avpkt->data and output buffer
Diego Biurrun's avatar
Diego Biurrun committed
3948
 * samples. The alignment requirements depend on the CPU: On some CPUs it isn't
3949
 * necessary at all, on others it won't work at all if not aligned and on others
3950 3951 3952 3953 3954
 * it will work but it will have an impact on performance.
 *
 * In practice, avpkt->data should have 4 byte alignment at minimum and
 * samples should be 16 byte aligned unless the CPU doesn't need it
 * (AltiVec and SSE do).
3955
 *
3956 3957 3958 3959
 * @note Codecs which have the CODEC_CAP_DELAY capability set have a delay
 * between input and output, these need to be fed with avpkt->data=NULL,
 * avpkt->size=0 at the end to return the remaining frames.
 *
Diego Biurrun's avatar
Diego Biurrun committed
3960
 * @param avctx the codec context
3961
 * @param[out] samples the output buffer, sample type in avctx->sample_fmt
3962 3963
 *                     If the sample format is planar, each channel plane will
 *                     be the same size, with no padding between channels.
Diego Biurrun's avatar
Diego Biurrun committed
3964
 * @param[in,out] frame_size_ptr the output buffer size in bytes
3965
 * @param[in] avpkt The input AVPacket containing the input buffer.
3966 3967 3968
 *            You can create such packet with av_init_packet() and by then setting
 *            data and size, some decoders might in addition need other fields.
 *            All decoders are designed to use the least fields possible though.
3969
 * @return On error a negative value is returned, otherwise the number of bytes
3970
 * used or zero if no frame data was decompressed (used) from the input AVPacket.
3971
 */
3972
attribute_deprecated int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
Fabrice Bellard's avatar
Fabrice Bellard committed
3973
                         int *frame_size_ptr,
3974
                         AVPacket *avpkt);
3975 3976 3977 3978 3979 3980
#endif

/**
 * Decode the audio frame of size avpkt->size from avpkt->data into frame.
 *
 * Some decoders may support multiple frames in a single AVPacket. Such
3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994
 * decoders would then just decode the first frame and the return value would be
 * less than the packet size. In this case, avcodec_decode_audio4 has to be
 * called again with an AVPacket containing the remaining data in order to
 * decode the second frame, etc...  Even if no frames are returned, the packet
 * needs to be fed to the decoder with remaining data until it is completely
 * consumed or an error occurs.
 *
 * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input
 * and output. This means that for some packets they will not immediately
 * produce decoded output and need to be flushed at the end of decoding to get
 * all the decoded data. Flushing is done by calling this function with packets
 * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
 * returning samples. It is safe to flush even those decoders that are not
 * marked with CODEC_CAP_DELAY, then no samples will be returned.
3995 3996 3997 3998 3999 4000 4001
 *
 * @warning The input buffer, avpkt->data must be FF_INPUT_BUFFER_PADDING_SIZE
 *          larger than the actual read bytes because some optimized bitstream
 *          readers read 32 or 64 bits at once and could read over the end.
 *
 * @param      avctx the codec context
 * @param[out] frame The AVFrame in which to store decoded audio samples.
4002 4003 4004 4005 4006 4007 4008 4009 4010
 *                   The decoder will allocate a buffer for the decoded frame by
 *                   calling the AVCodecContext.get_buffer2() callback.
 *                   When AVCodecContext.refcounted_frames is set to 1, the frame is
 *                   reference counted and the returned reference belongs to the
 *                   caller. The caller must release the frame using av_frame_unref()
 *                   when the frame is no longer needed. The caller may safely write
 *                   to the frame if av_frame_is_writable() returns 1.
 *                   When AVCodecContext.refcounted_frames is set to 0, the returned
 *                   reference belongs to the decoder and is valid only until the
4011 4012
 *                   next call to this function or until closing or flushing the
 *                   decoder. The caller may not write to it.
4013
 * @param[out] got_frame_ptr Zero if no frame could be decoded, otherwise it is
4014 4015 4016 4017
 *                           non-zero. Note that this field being set to zero
 *                           does not mean that an error has occurred. For
 *                           decoders with CODEC_CAP_DELAY set, no given decode
 *                           call is guaranteed to produce a frame.
4018 4019 4020 4021 4022 4023 4024 4025
 * @param[in]  avpkt The input AVPacket containing the input buffer.
 *                   At least avpkt->data and avpkt->size should be set. Some
 *                   decoders might also require additional fields to be set.
 * @return A negative error code is returned if an error occurred during
 *         decoding, otherwise the number of bytes consumed from the input
 *         AVPacket is returned.
 */
int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
4026
                          int *got_frame_ptr, const AVPacket *avpkt);
4027

4028
/**
4029
 * Decode the video frame of size avpkt->size from avpkt->data into picture.
4030 4031
 * Some decoders may support multiple frames in a single AVPacket, such
 * decoders would then just decode the first frame.
4032
 *
4033
 * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
4034 4035 4036
 * the actual read bytes because some optimized bitstream readers read 32 or 64
 * bits at once and could read over the end.
 *
4037
 * @warning The end of the input buffer buf should be set to 0 to ensure that
4038 4039
 * no overreading happens for damaged MPEG streams.
 *
4040 4041 4042
 * @note Codecs which have the CODEC_CAP_DELAY capability set have a delay
 * between input and output, these need to be fed with avpkt->data=NULL,
 * avpkt->size=0 at the end to return the remaining frames.
4043
 *
Diego Biurrun's avatar
Diego Biurrun committed
4044
 * @param avctx the codec context
4045
 * @param[out] picture The AVFrame in which the decoded video frame will be stored.
4046 4047 4048 4049 4050 4051 4052 4053 4054 4055
 *             Use av_frame_alloc() to get an AVFrame. The codec will
 *             allocate memory for the actual bitmap by calling the
 *             AVCodecContext.get_buffer2() callback.
 *             When AVCodecContext.refcounted_frames is set to 1, the frame is
 *             reference counted and the returned reference belongs to the
 *             caller. The caller must release the frame using av_frame_unref()
 *             when the frame is no longer needed. The caller may safely write
 *             to the frame if av_frame_is_writable() returns 1.
 *             When AVCodecContext.refcounted_frames is set to 0, the returned
 *             reference belongs to the decoder and is valid only until the
4056 4057
 *             next call to this function or until closing or flushing the
 *             decoder. The caller may not write to it.
4058
 *
4059
 * @param[in] avpkt The input AVPacket containing the input buffer.
4060 4061
 *            You can create such packet with av_init_packet() and by then setting
 *            data and size, some decoders might in addition need other fields like
4062
 *            flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least
4063
 *            fields possible.
Diego Biurrun's avatar
Diego Biurrun committed
4064
 * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
4065 4066 4067
 * @return On error a negative value is returned, otherwise the number of bytes
 * used or zero if no frame could be decompressed.
 */
4068
int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
Fabrice Bellard's avatar
Fabrice Bellard committed
4069
                         int *got_picture_ptr,
4070
                         const AVPacket *avpkt);
4071

4072
/**
4073
 * Decode a subtitle message.
Måns Rullgård's avatar
Måns Rullgård committed
4074
 * Return a negative value on error, otherwise return the number of bytes used.
4075 4076
 * If no subtitle could be decompressed, got_sub_ptr is zero.
 * Otherwise, the subtitle is stored in *sub.
4077 4078 4079 4080
 * Note that CODEC_CAP_DR1 is not available for subtitle codecs. This is for
 * simplicity, because the performance difference is expect to be negligible
 * and reusing a get_buffer written for video codecs would probably perform badly
 * due to a potentially very different allocation pattern.
4081
 *
4082 4083 4084 4085 4086 4087 4088 4089
 * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input
 * and output. This means that for some packets they will not immediately
 * produce decoded output and need to be flushed at the end of decoding to get
 * all the decoded data. Flushing is done by calling this function with packets
 * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
 * returning subtitles. It is safe to flush even those decoders that are not
 * marked with CODEC_CAP_DELAY, then no subtitles will be returned.
 *
4090
 * @param avctx the codec context
4091 4092
 * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored, must be
                   freed with avsubtitle_free if *got_sub_ptr is set.
4093 4094 4095 4096 4097 4098
 * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
 * @param[in] avpkt The input AVPacket containing the input buffer.
 */
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
                            int *got_sub_ptr,
                            AVPacket *avpkt);
4099 4100

/**
4101 4102
 * @defgroup lavc_parsing Frame parsing
 * @{
4103 4104
 */

4105 4106 4107 4108 4109 4110 4111
enum AVPictureStructure {
    AV_PICTURE_STRUCTURE_UNKNOWN,      //< unknown
    AV_PICTURE_STRUCTURE_TOP_FIELD,    //< coded as top field
    AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field
    AV_PICTURE_STRUCTURE_FRAME,        //< coded as frame
};

4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149
typedef struct AVCodecParserContext {
    void *priv_data;
    struct AVCodecParser *parser;
    int64_t frame_offset; /* offset of the current frame */
    int64_t cur_offset; /* current offset
                           (incremented by each av_parser_parse()) */
    int64_t next_frame_offset; /* offset of the next frame */
    /* video info */
    int pict_type; /* XXX: Put it back in AVCodecContext. */
    /**
     * This field is used for proper frame duration computation in lavf.
     * It signals, how much longer the frame duration of the current frame
     * is compared to normal frame duration.
     *
     * frame_duration = (1 + repeat_pict) * time_base
     *
     * It is used by codecs like H.264 to display telecined material.
     */
    int repeat_pict; /* XXX: Put it back in AVCodecContext. */
    int64_t pts;     /* pts of the current frame */
    int64_t dts;     /* dts of the current frame */

    /* private data */
    int64_t last_pts;
    int64_t last_dts;
    int fetch_timestamp;

#define AV_PARSER_PTS_NB 4
    int cur_frame_start_index;
    int64_t cur_frame_offset[AV_PARSER_PTS_NB];
    int64_t cur_frame_pts[AV_PARSER_PTS_NB];
    int64_t cur_frame_dts[AV_PARSER_PTS_NB];

    int flags;
#define PARSER_FLAG_COMPLETE_FRAMES           0x0001
#define PARSER_FLAG_ONCE                      0x0002
/// Set if the parser has a valid file offset
#define PARSER_FLAG_FETCHED_OFFSET            0x0004
4150
#define PARSER_FLAG_USE_CODEC_TS              0x1000
4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245

    int64_t offset;      ///< byte offset from starting packet start
    int64_t cur_frame_end[AV_PARSER_PTS_NB];

    /**
     * Set by parser to 1 for key frames and 0 for non-key frames.
     * It is initialized to -1, so if the parser doesn't set this flag,
     * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames
     * will be used.
     */
    int key_frame;

    /**
     * Time difference in stream time base units from the pts of this
     * packet to the point at which the output from the decoder has converged
     * independent from the availability of previous frames. That is, the
     * frames are virtually identical no matter if decoding started from
     * the very first frame or from this keyframe.
     * Is AV_NOPTS_VALUE if unknown.
     * This field is not the display duration of the current frame.
     * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY
     * set.
     *
     * The purpose of this field is to allow seeking in streams that have no
     * keyframes in the conventional sense. It corresponds to the
     * recovery point SEI in H.264 and match_time_delta in NUT. It is also
     * essential for some types of subtitle streams to ensure that all
     * subtitles are correctly displayed after seeking.
     */
    int64_t convergence_duration;

    // Timestamp generation support:
    /**
     * Synchronization point for start of timestamp generation.
     *
     * Set to >0 for sync point, 0 for no sync point and <0 for undefined
     * (default).
     *
     * For example, this corresponds to presence of H.264 buffering period
     * SEI message.
     */
    int dts_sync_point;

    /**
     * Offset of the current timestamp against last timestamp sync point in
     * units of AVCodecContext.time_base.
     *
     * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
     * contain a valid timestamp offset.
     *
     * Note that the timestamp of sync point has usually a nonzero
     * dts_ref_dts_delta, which refers to the previous sync point. Offset of
     * the next frame after timestamp sync point will be usually 1.
     *
     * For example, this corresponds to H.264 cpb_removal_delay.
     */
    int dts_ref_dts_delta;

    /**
     * Presentation delay of current frame in units of AVCodecContext.time_base.
     *
     * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
     * contain valid non-negative timestamp delta (presentation time of a frame
     * must not lie in the past).
     *
     * This delay represents the difference between decoding and presentation
     * time of the frame.
     *
     * For example, this corresponds to H.264 dpb_output_delay.
     */
    int pts_dts_delta;

    /**
     * Position of the packet in file.
     *
     * Analogous to cur_frame_pts/dts
     */
    int64_t cur_frame_pos[AV_PARSER_PTS_NB];

    /**
     * Byte position of currently parsed frame in stream.
     */
    int64_t pos;

    /**
     * Previous frame byte position.
     */
    int64_t last_pos;

    /**
     * Duration of the current frame.
     * For audio, this is in units of 1 / AVCodecContext.sample_rate.
     * For all other types, this is in units of AVCodecContext.time_base.
     */
    int duration;
4246 4247

    enum AVFieldOrder field_order;
4248 4249 4250 4251 4252 4253 4254 4255 4256 4257

    /**
     * Indicate whether a picture is coded as a frame, top field or bottom field.
     *
     * For example, H.264 field_pic_flag equal to 0 corresponds to
     * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag
     * equal to 1 and bottom_field_flag equal to 0 corresponds to
     * AV_PICTURE_STRUCTURE_TOP_FIELD.
     */
    enum AVPictureStructure picture_structure;
4258 4259 4260 4261 4262 4263 4264 4265

    /**
     * Picture number incremented in presentation or output order.
     * This field may be reinitialized at the first picture of a new sequence.
     *
     * For example, this corresponds to H.264 PicOrderCnt.
     */
    int output_picture_number;
4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320
} AVCodecParserContext;

typedef struct AVCodecParser {
    int codec_ids[5]; /* several codec IDs are permitted */
    int priv_data_size;
    int (*parser_init)(AVCodecParserContext *s);
    int (*parser_parse)(AVCodecParserContext *s,
                        AVCodecContext *avctx,
                        const uint8_t **poutbuf, int *poutbuf_size,
                        const uint8_t *buf, int buf_size);
    void (*parser_close)(AVCodecParserContext *s);
    int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
    struct AVCodecParser *next;
} AVCodecParser;

AVCodecParser *av_parser_next(AVCodecParser *c);

void av_register_codec_parser(AVCodecParser *parser);
AVCodecParserContext *av_parser_init(int codec_id);

/**
 * Parse a packet.
 *
 * @param s             parser context.
 * @param avctx         codec context.
 * @param poutbuf       set to pointer to parsed buffer or NULL if not yet finished.
 * @param poutbuf_size  set to size of parsed buffer or zero if not yet finished.
 * @param buf           input buffer.
 * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output).
 * @param pts           input presentation timestamp.
 * @param dts           input decoding timestamp.
 * @param pos           input byte position in stream.
 * @return the number of bytes of the input bitstream used.
 *
 * Example:
 * @code
 *   while(in_len){
 *       len = av_parser_parse2(myparser, AVCodecContext, &data, &size,
 *                                        in_data, in_len,
 *                                        pts, dts, pos);
 *       in_data += len;
 *       in_len  -= len;
 *
 *       if(size)
 *          decode_frame(data, size);
 *   }
 * @endcode
 */
int av_parser_parse2(AVCodecParserContext *s,
                     AVCodecContext *avctx,
                     uint8_t **poutbuf, int *poutbuf_size,
                     const uint8_t *buf, int buf_size,
                     int64_t pts, int64_t dts,
                     int64_t pos);

4321 4322
/**
 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
Paul B Mahol's avatar
Paul B Mahol committed
4323
 * @deprecated use AVBitStreamFilter
4324
 */
4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335
int av_parser_change(AVCodecParserContext *s,
                     AVCodecContext *avctx,
                     uint8_t **poutbuf, int *poutbuf_size,
                     const uint8_t *buf, int buf_size, int keyframe);
void av_parser_close(AVCodecParserContext *s);

/**
 * @}
 * @}
 */

4336 4337 4338 4339 4340 4341 4342 4343
/**
 * @addtogroup lavc_encoding
 * @{
 */

/**
 * Find a registered encoder with a matching codec ID.
 *
4344
 * @param id AVCodecID of the requested encoder
4345 4346
 * @return An encoder if one was found, NULL otherwise.
 */
4347
AVCodec *avcodec_find_encoder(enum AVCodecID id);
4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371

/**
 * Find a registered encoder with the specified name.
 *
 * @param name name of the requested encoder
 * @return An encoder if one was found, NULL otherwise.
 */
AVCodec *avcodec_find_encoder_by_name(const char *name);

#if FF_API_OLD_ENCODE_AUDIO
/**
 * Encode an audio frame from samples into buf.
 *
 * @deprecated Use avcodec_encode_audio2 instead.
 *
 * @note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large.
 * However, for codecs with avctx->frame_size equal to 0 (e.g. PCM) the user
 * will know how much space is needed because it depends on the value passed
 * in buf_size as described below. In that case a lower value can be used.
 *
 * @param avctx the codec context
 * @param[out] buf the output buffer
 * @param[in] buf_size the output buffer size
 * @param[in] samples the input buffer containing the samples
4372
 * The number of samples read from this buffer is frame_size*channels,
4373
 * both of which are defined in avctx.
4374 4375 4376 4377 4378
 * For codecs which have avctx->frame_size equal to 0 (e.g. PCM) the number of
 * samples read from samples is equal to:
 * buf_size * 8 / (avctx->channels * av_get_bits_per_sample(avctx->codec_id))
 * This also implies that av_get_bits_per_sample() must not return 0 for these
 * codecs.
Diego Biurrun's avatar
Diego Biurrun committed
4379
 * @return On error a negative value is returned, on success zero or the number
4380
 * of bytes used to encode the data read from the input buffer.
4381
 */
4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399
int attribute_deprecated avcodec_encode_audio(AVCodecContext *avctx,
                                              uint8_t *buf, int buf_size,
                                              const short *samples);
#endif

/**
 * Encode a frame of audio.
 *
 * Takes input samples from frame and writes the next output packet, if
 * available, to avpkt. The output packet does not necessarily contain data for
 * the most recent frame, as encoders can delay, split, and combine input frames
 * internally as needed.
 *
 * @param avctx     codec context
 * @param avpkt     output AVPacket.
 *                  The user can supply an output buffer by setting
 *                  avpkt->data and avpkt->size prior to calling the
 *                  function, but if the size of the user-provided data is not
4400 4401 4402 4403 4404 4405
 *                  large enough, encoding will fail. If avpkt->data and
 *                  avpkt->size are set, avpkt->destruct must also be set. All
 *                  other AVPacket fields will be reset by the encoder using
 *                  av_init_packet(). If avpkt->data is NULL, the encoder will
 *                  allocate it. The encoder will set avpkt->size to the size
 *                  of the output packet.
4406 4407 4408 4409
 *
 *                  If this function fails or produces no output, avpkt will be
 *                  freed using av_free_packet() (i.e. avpkt->destruct will be
 *                  called to free the user supplied buffer).
4410 4411 4412 4413 4414
 * @param[in] frame AVFrame containing the raw audio data to be encoded.
 *                  May be NULL when flushing an encoder that has the
 *                  CODEC_CAP_DELAY capability set.
 *                  If CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
 *                  can have any number of samples.
4415 4416 4417
 *                  If it is not set, frame->nb_samples must be equal to
 *                  avctx->frame_size for all frames except the last.
 *                  The final frame may be smaller than avctx->frame_size.
4418 4419 4420 4421 4422 4423 4424 4425 4426 4427
 * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the
 *                            output packet is non-empty, and to 0 if it is
 *                            empty. If the function returns an error, the
 *                            packet can be assumed to be invalid, and the
 *                            value of got_packet_ptr is undefined and should
 *                            not be used.
 * @return          0 on success, negative error code on failure
 */
int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
                          const AVFrame *frame, int *got_packet_ptr);
4428

4429
#if FF_API_OLD_ENCODE_VIDEO
4430
/**
4431 4432
 * @deprecated use avcodec_encode_video2() instead.
 *
4433
 * Encode a video frame from pict into buf.
4434
 * The input picture should be
4435
 * stored using a specific format, namely avctx.pix_fmt.
4436
 *
Diego Biurrun's avatar
Diego Biurrun committed
4437 4438 4439 4440
 * @param avctx the codec context
 * @param[out] buf the output buffer for the bitstream of encoded frame
 * @param[in] buf_size the size of the output buffer in bytes
 * @param[in] pict the input picture to encode
4441
 * @return On error a negative value is returned, on success zero or the number
4442
 * of bytes used from the output buffer.
4443
 */
4444
attribute_deprecated
4445
int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
4446
                         const AVFrame *pict);
4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467
#endif

/**
 * Encode a frame of video.
 *
 * Takes input raw video data from frame and writes the next output packet, if
 * available, to avpkt. The output packet does not necessarily contain data for
 * the most recent frame, as encoders can delay and reorder input frames
 * internally as needed.
 *
 * @param avctx     codec context
 * @param avpkt     output AVPacket.
 *                  The user can supply an output buffer by setting
 *                  avpkt->data and avpkt->size prior to calling the
 *                  function, but if the size of the user-provided data is not
 *                  large enough, encoding will fail. All other AVPacket fields
 *                  will be reset by the encoder using av_init_packet(). If
 *                  avpkt->data is NULL, the encoder will allocate it.
 *                  The encoder will set avpkt->size to the size of the
 *                  output packet. The returned data (if any) belongs to the
 *                  caller, he is responsible for freeing it.
4468 4469 4470 4471
 *
 *                  If this function fails or produces no output, avpkt will be
 *                  freed using av_free_packet() (i.e. avpkt->destruct will be
 *                  called to free the user supplied buffer).
4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485
 * @param[in] frame AVFrame containing the raw video data to be encoded.
 *                  May be NULL when flushing an encoder that has the
 *                  CODEC_CAP_DELAY capability set.
 * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the
 *                            output packet is non-empty, and to 0 if it is
 *                            empty. If the function returns an error, the
 *                            packet can be assumed to be invalid, and the
 *                            value of got_packet_ptr is undefined and should
 *                            not be used.
 * @return          0 on success, negative error code on failure
 */
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,
                          const AVFrame *frame, int *got_packet_ptr);

4486
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
4487
                            const AVSubtitle *sub);
Fabrice Bellard's avatar
Fabrice Bellard committed
4488

4489

4490
/**
4491 4492 4493
 * @}
 */

4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590
#if FF_API_AVCODEC_RESAMPLE
/**
 * @defgroup lavc_resample Audio resampling
 * @ingroup libavc
 * @deprecated use libswresample instead
 *
 * @{
 */
struct ReSampleContext;
struct AVResampleContext;

typedef struct ReSampleContext ReSampleContext;

/**
 *  Initialize audio resampling context.
 *
 * @param output_channels  number of output channels
 * @param input_channels   number of input channels
 * @param output_rate      output sample rate
 * @param input_rate       input sample rate
 * @param sample_fmt_out   requested output sample format
 * @param sample_fmt_in    input sample format
 * @param filter_length    length of each FIR filter in the filterbank relative to the cutoff frequency
 * @param log2_phase_count log2 of the number of entries in the polyphase filterbank
 * @param linear           if 1 then the used FIR filter will be linearly interpolated
                           between the 2 closest, if 0 the closest will be used
 * @param cutoff           cutoff frequency, 1.0 corresponds to half the output sampling rate
 * @return allocated ReSampleContext, NULL if error occurred
 */
attribute_deprecated
ReSampleContext *av_audio_resample_init(int output_channels, int input_channels,
                                        int output_rate, int input_rate,
                                        enum AVSampleFormat sample_fmt_out,
                                        enum AVSampleFormat sample_fmt_in,
                                        int filter_length, int log2_phase_count,
                                        int linear, double cutoff);

attribute_deprecated
int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);

/**
 * Free resample context.
 *
 * @param s a non-NULL pointer to a resample context previously
 *          created with av_audio_resample_init()
 */
attribute_deprecated
void audio_resample_close(ReSampleContext *s);


/**
 * Initialize an audio resampler.
 * Note, if either rate is not an integer then simply scale both rates up so they are.
 * @param filter_length length of each FIR filter in the filterbank relative to the cutoff freq
 * @param log2_phase_count log2 of the number of entries in the polyphase filterbank
 * @param linear If 1 then the used FIR filter will be linearly interpolated
                 between the 2 closest, if 0 the closest will be used
 * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate
 */
attribute_deprecated
struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff);

/**
 * Resample an array of samples using a previously configured context.
 * @param src an array of unconsumed samples
 * @param consumed the number of samples of src which have been consumed are returned here
 * @param src_size the number of unconsumed samples available
 * @param dst_size the amount of space in samples available in dst
 * @param update_ctx If this is 0 then the context will not be modified, that way several channels can be resampled with the same context.
 * @return the number of samples written in dst or -1 if an error occurred
 */
attribute_deprecated
int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx);


/**
 * Compensate samplerate/timestamp drift. The compensation is done by changing
 * the resampler parameters, so no audible clicks or similar distortions occur
 * @param compensation_distance distance in output samples over which the compensation should be performed
 * @param sample_delta number of output samples which should be output less
 *
 * example: av_resample_compensate(c, 10, 500)
 * here instead of 510 samples only 500 samples would be output
 *
 * note, due to rounding the actual compensation might be slightly different,
 * especially if the compensation_distance is large and the in_rate used during init is small
 */
attribute_deprecated
void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance);
attribute_deprecated
void av_resample_close(struct AVResampleContext *c);

/**
 * @}
 */
#endif

4591 4592 4593 4594 4595
/**
 * @addtogroup lavc_picture
 * @{
 */

4596
/**
4597 4598 4599 4600
 * Allocate memory for the pixels of a picture and setup the AVPicture
 * fields for it.
 *
 * Call avpicture_free() to free it.
4601
 *
4602 4603 4604 4605 4606
 * @param picture            the picture structure to be filled in
 * @param pix_fmt            the pixel format of the picture
 * @param width              the width of the picture
 * @param height             the height of the picture
 * @return zero if successful, a negative error code otherwise
4607
 *
4608
 * @see av_image_alloc(), avpicture_fill()
4609
 */
4610
int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height);
4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621

/**
 * Free a picture previously allocated by avpicture_alloc().
 * The data buffer used by the AVPicture is freed, but the AVPicture structure
 * itself is not.
 *
 * @param picture the AVPicture to be freed
 */
void avpicture_free(AVPicture *picture);

/**
4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640
 * Setup the picture fields based on the specified image parameters
 * and the provided image data buffer.
 *
 * The picture fields are filled in by using the image data buffer
 * pointed to by ptr.
 *
 * If ptr is NULL, the function will fill only the picture linesize
 * array and return the required size for the image buffer.
 *
 * To allocate an image buffer and fill the picture data in one call,
 * use avpicture_alloc().
 *
 * @param picture       the picture to be filled in
 * @param ptr           buffer where the image data is stored, or NULL
 * @param pix_fmt       the pixel format of the image
 * @param width         the width of the image in pixels
 * @param height        the height of the image in pixels
 * @return the size in bytes required for src, a negative error code
 * in case of failure
4641
 *
4642
 * @see av_image_fill_arrays()
4643
 */
4644
int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
4645
                   enum AVPixelFormat pix_fmt, int width, int height);
4646 4647

/**
4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661
 * Copy pixel data from an AVPicture into a buffer.
 *
 * avpicture_get_size() can be used to compute the required size for
 * the buffer to fill.
 *
 * @param src        source picture with filled data
 * @param pix_fmt    picture pixel format
 * @param width      picture width
 * @param height     picture height
 * @param dest       destination buffer
 * @param dest_size  destination buffer size in bytes
 * @return the number of bytes written to dest, or a negative value
 * (error code) on error, for example if the destination buffer is not
 * big enough
4662
 *
4663
 * @see av_image_copy_to_buffer()
4664
 */
4665
int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt,
4666
                     int width, int height,
4667 4668 4669 4670 4671
                     unsigned char *dest, int dest_size);

/**
 * Calculate the size in bytes that a picture of the given width and height
 * would occupy if stored in the given picture format.
4672 4673 4674 4675 4676 4677
 *
 * @param pix_fmt    picture pixel format
 * @param width      picture width
 * @param height     picture height
 * @return the computed picture buffer size or a negative error code
 * in case of error
4678
 *
4679
 * @see av_image_get_buffer_size().
4680
 */
4681
int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
4682

4683
#if FF_API_DEINTERLACE
4684 4685
/**
 *  deinterlace - if not supported return -1
4686
 *
4687
 * @deprecated - use yadif (in libavfilter) instead
4688
 */
4689
attribute_deprecated
4690
int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
4691
                          enum AVPixelFormat pix_fmt, int width, int height);
4692
#endif
4693
/**
4694
 * Copy image src to dst. Wraps av_image_copy().
4695 4696
 */
void av_picture_copy(AVPicture *dst, const AVPicture *src,
4697
                     enum AVPixelFormat pix_fmt, int width, int height);
4698 4699 4700 4701 4702

/**
 * Crop image top and left side.
 */
int av_picture_crop(AVPicture *dst, const AVPicture *src,
4703
                    enum AVPixelFormat pix_fmt, int top_band, int left_band);
4704 4705 4706 4707

/**
 * Pad image.
 */
4708
int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt,
4709 4710 4711 4712 4713 4714
            int padtop, int padbottom, int padleft, int padright, int *color);

/**
 * @}
 */

4715 4716 4717 4718 4719 4720 4721 4722
/**
 * @defgroup lavc_misc Utility functions
 * @ingroup libavc
 *
 * Miscellaneous utility functions related to both encoding and decoding
 * (or neither).
 * @{
 */
4723

4724 4725 4726 4727 4728 4729 4730
/**
 * @defgroup lavc_misc_pixfmt Pixel formats
 *
 * Functions for working with pixel formats.
 * @{
 */

4731
/**
4732 4733 4734 4735 4736 4737 4738 4739
 * Utility function to access log2_chroma_w log2_chroma_h from
 * the pixel format AVPixFmtDescriptor.
 *
 * This function asserts that pix_fmt is valid. See av_pix_fmt_get_chroma_sub_sample
 * for one that returns a failure code and continues in case of invalid
 * pix_fmts.
 *
 * @param[in]  pix_fmt the pixel format
4740 4741
 * @param[out] h_shift store log2_chroma_w
 * @param[out] v_shift store log2_chroma_h
4742 4743
 *
 * @see av_pix_fmt_get_chroma_sub_sample
4744 4745
 */

4746
void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
4747 4748 4749 4750 4751 4752

/**
 * Return a value representing the fourCC code associated to the
 * pixel format pix_fmt, or 0 if no associated fourCC code can be
 * found.
 */
4753
unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt);
4754

4755 4756
/**
 * @deprecated see av_get_pix_fmt_loss()
4757
 */
4758
int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
4759
                             int has_alpha);
4760

4761 4762 4763 4764 4765
/**
 * Find the best pixel format to convert to given a certain source pixel
 * format.  When converting from one pixel format to another, information loss
 * may occur.  For example, when converting from RGB24 to GRAY, the color
 * information will be lost. Similarly, other losses occur when converting from
4766
 * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of
4767 4768 4769 4770 4771
 * the given pixel formats should be used to suffer the least amount of loss.
 * The pixel formats from which it chooses one, are determined by the
 * pix_fmt_list parameter.
 *
 *
4772
 * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from
4773 4774 4775 4776 4777
 * @param[in] src_pix_fmt source pixel format
 * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur.
 * @return The best pixel format to convert to or -1 if none was found.
 */
4778
enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list,
4779
                                            enum AVPixelFormat src_pix_fmt,
4780
                                            int has_alpha, int *loss_ptr);
4781

4782
/**
4783
 * @deprecated see av_find_best_pix_fmt_of_2()
4784
 */
4785 4786
enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
4787 4788

attribute_deprecated
4789
#if AV_HAVE_INCOMPATIBLE_LIBAV_ABI
4790
enum AVPixelFormat avcodec_find_best_pix_fmt2(const enum AVPixelFormat *pix_fmt_list,
4791 4792
                                              enum AVPixelFormat src_pix_fmt,
                                              int has_alpha, int *loss_ptr);
4793
#else
4794 4795
enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
4796 4797
#endif

4798

4799
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
4800 4801 4802 4803 4804

/**
 * @}
 */

4805 4806 4807 4808 4809
#if FF_API_SET_DIMENSIONS
/**
 * @deprecated this function is not supposed to be used from outside of lavc
 */
attribute_deprecated
4810
void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
4811
#endif
4812 4813 4814 4815

/**
 * Put a string representing the codec tag codec_tag in buf.
 *
4816
 * @param buf       buffer to place codec tag in
4817
 * @param buf_size size in bytes of buf
4818
 * @param codec_tag codec tag to assign
4819 4820 4821 4822
 * @return the length of the string that would have been generated if
 * enough space had been available, excluding the trailing null
 */
size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag);
4823 4824

void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
4825

4826
/**
4827
 * Return a name for the specified profile, if available.
4828
 *
4829 4830 4831
 * @param codec the codec that is searched for the given profile
 * @param profile the profile value for which a name is requested
 * @return A name for the profile if found, NULL otherwise.
4832
 */
4833 4834 4835 4836 4837
const char *av_get_profile_name(const AVCodec *codec, int profile);

int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size);
int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count);
//FIXME func typedef
4838

4839
/**
4840 4841 4842 4843 4844 4845
 * Fill AVFrame audio data and linesize pointers.
 *
 * The buffer buf must be a preallocated buffer with a size big enough
 * to contain the specified samples amount. The filled AVFrame data
 * pointers will point to this buffer.
 *
4846 4847
 * AVFrame extended_data channel pointers are allocated if necessary for
 * planar audio.
4848
 *
4849 4850 4851 4852 4853 4854 4855 4856
 * @param frame       the AVFrame
 *                    frame->nb_samples must be set prior to calling the
 *                    function. This function fills in frame->data,
 *                    frame->extended_data, frame->linesize[0].
 * @param nb_channels channel count
 * @param sample_fmt  sample format
 * @param buf         buffer to use for frame data
 * @param buf_size    size of buffer
4857
 * @param align       plane size sample alignment (0 = default)
4858
 * @return            >=0 on success, negative error code on failure
4859 4860
 * @todo return the size in bytes required to store the samples in
 * case of success, at the next libavutil bump
4861
 */
4862 4863 4864
int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
                             enum AVSampleFormat sample_fmt, const uint8_t *buf,
                             int buf_size, int align);
Fabrice Bellard's avatar
Fabrice Bellard committed
4865

4866
/**
4867 4868 4869 4870 4871 4872 4873
 * Reset the internal decoder state / flush internal buffers. Should be called
 * e.g. when seeking or when switching to a different stream.
 *
 * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0),
 * this invalidates the frames previously returned from the decoder. When
 * refcounted frames are used, the decoder just releases any references it might
 * keep internally, but the caller's reference remains valid.
4874
 */
4875 4876
void avcodec_flush_buffers(AVCodecContext *avctx);

4877
/**
4878
 * Return codec bits per sample.
4879
 *
Diego Biurrun's avatar
Diego Biurrun committed
4880
 * @param[in] codec_id the codec
4881
 * @return Number of bits per sample or zero if unknown for the given codec.
4882
 */
4883
int av_get_bits_per_sample(enum AVCodecID codec_id);
4884

4885 4886 4887 4888
/**
 * Return the PCM codec associated with a sample format.
 * @param be  endianness, 0 for little, 1 for big,
 *            -1 (or anything else) for native
4889
 * @return  AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
4890
 */
4891
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
4892

4893 4894 4895 4896 4897 4898 4899 4900
/**
 * Return codec bits per sample.
 * Only return non-zero if the bits per sample is exactly correct, not an
 * approximation.
 *
 * @param[in] codec_id the codec
 * @return Number of bits per sample or zero if unknown for the given codec.
 */
4901
int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
4902

4903 4904 4905 4906 4907 4908 4909 4910 4911 4912
/**
 * Return audio frame duration.
 *
 * @param avctx        codec context
 * @param frame_bytes  size of the frame, or 0 if unknown
 * @return             frame duration, in samples, if known. 0 if not able to
 *                     determine.
 */
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes);

4913 4914

typedef struct AVBitStreamFilterContext {
4915
    void *priv_data;
4916 4917 4918 4919 4920 4921 4922 4923
    struct AVBitStreamFilter *filter;
    AVCodecParserContext *parser;
    struct AVBitStreamFilterContext *next;
} AVBitStreamFilterContext;


typedef struct AVBitStreamFilter {
    const char *name;
4924
    int priv_data_size;
4925 4926 4927 4928
    int (*filter)(AVBitStreamFilterContext *bsfc,
                  AVCodecContext *avctx, const char *args,
                  uint8_t **poutbuf, int *poutbuf_size,
                  const uint8_t *buf, int buf_size, int keyframe);
4929
    void (*close)(AVBitStreamFilterContext *bsfc);
4930 4931 4932
    struct AVBitStreamFilter *next;
} AVBitStreamFilter;

4933 4934 4935 4936 4937 4938 4939 4940 4941
/**
 * Register a bitstream filter.
 *
 * The filter will be accessible to the application code through
 * av_bitstream_filter_next() or can be directly initialized with
 * av_bitstream_filter_init().
 *
 * @see avcodec_register_all()
 */
4942
void av_register_bitstream_filter(AVBitStreamFilter *bsf);
4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953

/**
 * Create and initialize a bitstream filter context given a bitstream
 * filter name.
 *
 * The returned context must be freed with av_bitstream_filter_close().
 *
 * @param name    the name of the bitstream filter
 * @return a bitstream filter context if a matching filter was found
 * and successfully initialized, NULL otherwise
 */
4954
AVBitStreamFilterContext *av_bitstream_filter_init(const char *name);
4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978

/**
 * Filter bitstream.
 *
 * This function filters the buffer buf with size buf_size, and places the
 * filtered buffer in the buffer pointed to by poutbuf.
 *
 * The output buffer must be freed by the caller.
 *
 * @param bsfc            bitstream filter context created by av_bitstream_filter_init()
 * @param avctx           AVCodecContext accessed by the filter, may be NULL.
 *                        If specified, this must point to the encoder context of the
 *                        output stream the packet is sent to.
 * @param args            arguments which specify the filter configuration, may be NULL
 * @param poutbuf         pointer which is updated to point to the filtered buffer
 * @param poutbuf_size    pointer which is updated to the filtered buffer size in bytes
 * @param buf             buffer containing the data to filter
 * @param buf_size        size in bytes of buf
 * @param keyframe        set to non-zero if the buffer to filter corresponds to a key-frame packet data
 * @return >= 0 in case of success, or a negative error code in case of failure
 *
 * If the return value is positive, an output buffer is allocated and
 * is availble in *poutbuf, and is distinct from the input buffer.
 *
4979 4980 4981 4982
 * If the return value is 0, the output buffer is not allocated and
 * should be considered identical to the input buffer, or in case
 * *poutbuf was set it points to the input buffer (not necessarily to
 * its starting address).
4983
 */
4984 4985 4986 4987
int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
                               AVCodecContext *avctx, const char *args,
                               uint8_t **poutbuf, int *poutbuf_size,
                               const uint8_t *buf, int buf_size, int keyframe);
4988 4989 4990 4991 4992 4993 4994

/**
 * Release bitstream filter context.
 *
 * @param bsf the bitstream filter context created with
 * av_bitstream_filter_init(), can be NULL
 */
4995 4996
void av_bitstream_filter_close(AVBitStreamFilterContext *bsf);

4997 4998 4999 5000 5001 5002 5003 5004
/**
 * If f is NULL, return the first registered bitstream filter,
 * if f is non-NULL, return the next registered bitstream filter
 * after f, or NULL if f is the last one.
 *
 * This function can be used to iterate over all registered bitstream
 * filters.
 */
5005
AVBitStreamFilter *av_bitstream_filter_next(AVBitStreamFilter *f);
5006

5007
/* memory */
5008

5009 5010
/**
 * Same behaviour av_fast_malloc but the buffer has additional
5011
 * FF_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0.
5012 5013 5014 5015 5016 5017
 *
 * In addition the whole buffer will initially and after resizes
 * be 0-initialized so that no uninitialized data will ever appear.
 */
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);

5018 5019 5020 5021 5022 5023
/**
 * Same behaviour av_fast_padded_malloc except that buffer will always
 * be 0-initialized after call.
 */
void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size);

5024
/**
5025
 * Encode extradata length to a buffer. Used by xiph codecs.
5026 5027 5028 5029 5030
 *
 * @param s buffer to write to; must be at least (v/255+1) bytes long
 * @param v size of extradata in bytes
 * @return number of bytes written to the buffer.
 */
5031
unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
5032

5033
#if FF_API_MISSING_SAMPLE
5034
/**
5035
 * Log a generic warning message about a missing feature. This function is
5036
 * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
5037
 * only, and would normally not be used by applications.
5038 5039 5040 5041 5042 5043 5044
 * @param[in] avc a pointer to an arbitrary struct of which the first field is
 * a pointer to an AVClass struct
 * @param[in] feature string containing the name of the missing feature
 * @param[in] want_sample indicates if samples are wanted which exhibit this feature.
 * If want_sample is non-zero, additional verbage will be added to the log
 * message which tells the user how to report samples to the development
 * mailing list.
5045
 * @deprecated Use avpriv_report_missing_feature() instead.
5046
 */
5047
attribute_deprecated
5048 5049 5050
void av_log_missing_feature(void *avc, const char *feature, int want_sample);

/**
5051
 * Log a generic warning message asking for a sample. This function is
5052 5053
 * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
 * only, and would normally not be used by applications.
5054 5055 5056
 * @param[in] avc a pointer to an arbitrary struct of which the first field is
 * a pointer to an AVClass struct
 * @param[in] msg string containing an optional message, or NULL if no message
5057
 * @deprecated Use avpriv_request_sample() instead.
5058
 */
5059
attribute_deprecated
5060
void av_log_ask_for_sample(void *avc, const char *msg, ...) av_printf_format(2, 3);
5061
#endif /* FF_API_MISSING_SAMPLE */
5062

5063
/**
5064
 * Register the hardware accelerator hwaccel.
5065 5066 5067 5068 5069 5070 5071 5072 5073 5074
 */
void av_register_hwaccel(AVHWAccel *hwaccel);

/**
 * If hwaccel is NULL, returns the first registered hardware accelerator,
 * if hwaccel is non-NULL, returns the next registered hardware accelerator
 * after hwaccel, or NULL if hwaccel is the last one.
 */
AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel);

5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087

/**
 * Lock operation used by lockmgr
 */
enum AVLockOp {
  AV_LOCK_CREATE,  ///< Create a mutex
  AV_LOCK_OBTAIN,  ///< Lock the mutex
  AV_LOCK_RELEASE, ///< Unlock the mutex
  AV_LOCK_DESTROY, ///< Free mutex resources
};

/**
 * Register a user provided lock manager supporting the operations
5088
 * specified by AVLockOp. mutex points to a (void *) where the
5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100
 * lockmgr should store/get a pointer to a user allocated mutex. It's
 * NULL upon AV_LOCK_CREATE and != NULL for all other ops.
 *
 * @param cb User defined callback. Note: FFmpeg may invoke calls to this
 *           callback during the call to av_lockmgr_register().
 *           Thus, the application must be prepared to handle that.
 *           If cb is set to NULL the lockmgr will be unregistered.
 *           Also note that during unregistration the previously registered
 *           lockmgr callback may also be invoked.
 */
int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op));

5101 5102 5103
/**
 * Get the type of the given codec.
 */
5104
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
5105

5106
/**
5107 5108
 * Get the name of a codec.
 * @return  a static string identifying the codec; never NULL
5109
 */
5110
const char *avcodec_get_name(enum AVCodecID id);
5111

5112 5113 5114 5115 5116 5117
/**
 * @return a positive value if s is open (i.e. avcodec_open2() was called on it
 * with no corresponding avcodec_close()), 0 otherwise.
 */
int avcodec_is_open(AVCodecContext *s);

5118 5119 5120
/**
 * @return a non-zero number if codec is an encoder, zero otherwise
 */
5121
int av_codec_is_encoder(const AVCodec *codec);
5122 5123 5124 5125

/**
 * @return a non-zero number if codec is a decoder, zero otherwise
 */
5126
int av_codec_is_decoder(const AVCodec *codec);
5127

5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141
/**
 * @return descriptor for given codec ID or NULL if no descriptor exists.
 */
const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);

/**
 * Iterate over all codec descriptors known to libavcodec.
 *
 * @param prev previous descriptor. NULL to get the first descriptor.
 *
 * @return next descriptor or NULL after the last descriptor
 */
const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);

5142 5143 5144 5145 5146 5147
/**
 * @return codec descriptor with the given name or NULL if no such descriptor
 *         exists.
 */
const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);

5148 5149 5150 5151
/**
 * @}
 */

5152
#endif /* AVCODEC_AVCODEC_H */