avcodec.h 209 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
 * @defgroup libavc libavcodec
 * Encoding/Decoding Library
 *
49 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
 * @{
 *
 * @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
 * @{
 * @}
 * @}
 */

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
/**
 * @ingroup libavc
 * @defgroup lavc_encdec send/receive encoding and decoding API overview
 * @{
 *
 * The avcodec_send_packet()/avcodec_receive_frame()/avcodec_send_frame()/
 * avcodec_receive_packet() functions provide an encode/decode API, which
 * decouples input and output.
 *
 * The API is very similar for encoding/decoding and audio/video, and works as
 * follows:
 * - Set up and open the AVCodecContext as usual.
 * - Send valid input:
 *   - For decoding, call avcodec_send_packet() to give the decoder raw
 *     compressed data in an AVPacket.
92
 *   - For encoding, call avcodec_send_frame() to give the encoder an AVFrame
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
 *     containing uncompressed audio or video.
 *   In both cases, it is recommended that AVPackets and AVFrames are
 *   refcounted, or libavcodec might have to copy the input data. (libavformat
 *   always returns refcounted AVPackets, and av_frame_get_buffer() allocates
 *   refcounted AVFrames.)
 * - Receive output in a loop. Periodically call one of the avcodec_receive_*()
 *   functions and process their output:
 *   - For decoding, call avcodec_receive_frame(). On success, it will return
 *     an AVFrame containing uncompressed audio or video data.
 *   - For encoding, call avcodec_receive_packet(). On success, it will return
 *     an AVPacket with a compressed frame.
 *   Repeat this call until it returns AVERROR(EAGAIN) or an error. The
 *   AVERROR(EAGAIN) return value means that new input data is required to
 *   return new output. In this case, continue with sending input. For each
 *   input frame/packet, the codec will typically return 1 output frame/packet,
 *   but it can also be 0 or more than 1.
 *
 * At the beginning of decoding or encoding, the codec might accept multiple
 * input frames/packets without returning a frame, until its internal buffers
 * are filled. This situation is handled transparently if you follow the steps
 * outlined above.
 *
115 116 117 118 119 120
 * In theory, sending input can result in EAGAIN - this should happen only if
 * not all output was received. You can use this to structure alternative decode
 * or encode loops other than the one suggested above. For example, you could
 * try sending new input on each iteration, and try to receive output if that
 * returns EAGAIN.
 *
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
 * End of stream situations. These require "flushing" (aka draining) the codec,
 * as the codec might buffer multiple frames or packets internally for
 * performance or out of necessity (consider B-frames).
 * This is handled as follows:
 * - Instead of valid input, send NULL to the avcodec_send_packet() (decoding)
 *   or avcodec_send_frame() (encoding) functions. This will enter draining
 *   mode.
 * - Call avcodec_receive_frame() (decoding) or avcodec_receive_packet()
 *   (encoding) in a loop until AVERROR_EOF is returned. The functions will
 *   not return AVERROR(EAGAIN), unless you forgot to enter draining mode.
 * - Before decoding can be resumed again, the codec has to be reset with
 *   avcodec_flush_buffers().
 *
 * Using the API as outlined above is highly recommended. But it is also
 * possible to call functions outside of this rigid schema. For example, you can
 * call avcodec_send_packet() repeatedly without calling
 * avcodec_receive_frame(). In this case, avcodec_send_packet() will succeed
 * until the codec's internal buffer has been filled up (which is typically of
 * size 1 per output frame, after initial input), and then reject input with
 * AVERROR(EAGAIN). Once it starts rejecting input, you have no choice but to
 * read at least some output.
 *
 * Not all codecs will follow a rigid and predictable dataflow; the only
 * guarantee is that an AVERROR(EAGAIN) return value on a send/receive call on
145 146 147
 * one end implies that a receive/send call on the other end will succeed, or
 * at least will not fail with AVERROR(EAGAIN). In general, no codec will
 * permit unlimited buffering of input or output.
148 149 150 151 152 153 154 155
 *
 * This API replaces the following legacy functions:
 * - avcodec_decode_video2() and avcodec_decode_audio4():
 *   Use avcodec_send_packet() to feed input to the decoder, then use
 *   avcodec_receive_frame() to receive decoded frames after each packet.
 *   Unlike with the old video decoding API, multiple frames might result from
 *   a packet. For audio, splitting the input packet into frames by partially
 *   decoding packets becomes transparent to the API user. You never need to
156 157
 *   feed an AVPacket to the API twice (unless it is rejected with EAGAIN - then
 *   no data was read from the packet).
158 159 160 161 162 163 164 165 166 167 168 169
 *   Additionally, sending a flush/draining packet is required only once.
 * - avcodec_encode_video2()/avcodec_encode_audio2():
 *   Use avcodec_send_frame() to feed input to the encoder, then use
 *   avcodec_receive_packet() to receive encoded packets.
 *   Providing user-allocated buffers for avcodec_receive_packet() is not
 *   possible.
 * - The new API does not handle subtitles yet.
 *
 * Mixing new and old function calls on the same AVCodecContext is not allowed,
 * and will result in undefined behavior.
 *
 * Some codecs might require using the new API; using the old API will return
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
 * an error when calling it. All codecs support the new API.
 *
 * A codec is not allowed to return EAGAIN for both sending and receiving. This
 * would be an invalid state, which could put the codec user into an endless
 * loop. The API has no concept of time either: it cannot happen that trying to
 * do avcodec_send_packet() results in EAGAIN, but a repeated call 1 second
 * later accepts the packet (with no other receive/flush API calls involved).
 * The API is a strict state machine, and the passage of time is not supposed
 * to influence it. Some timing-dependent behavior might still be deemed
 * acceptable in certain cases. But it must never result in both send/receive
 * returning EAGAIN at the same time at any point. It must also absolutely be
 * avoided that the current state is "unstable" and can "flip-flop" between
 * the send/receive APIs allowing progress. For example, it's not allowed that
 * the codec randomly decides that it actually wants to consume a packet now
 * instead of returning a frame, after it just returned EAGAIN on an
 * avcodec_send_packet() call.
186 187 188
 * @}
 */

189 190 191 192 193 194 195 196
/**
 * @defgroup lavc_core Core functions/structures.
 * @ingroup libavc
 *
 * Basic definitions, functions for querying libavcodec capabilities,
 * allocating core structures, etc.
 * @{
 */
197

198

199
/**
Måns Rullgård's avatar
Måns Rullgård committed
200
 * Identify the syntax and semantics of the bitstream.
201 202 203 204 205
 * 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.
206
 *
Diego Biurrun's avatar
Diego Biurrun committed
207
 * If you add a codec ID to this list, add it so that
Lou Logan's avatar
Lou Logan committed
208
 * 1. no value of an existing codec ID changes (that would break ABI),
209
 * 2. it is as close as possible to similar codecs
210 211 212
 *
 * After adding new codec IDs, do not forget to add an entry to the codec
 * descriptor list and bump libavcodec minor version.
213
 */
214 215
enum AVCodecID {
    AV_CODEC_ID_NONE,
216 217

    /* video codecs */
218 219
    AV_CODEC_ID_MPEG1VIDEO,
    AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
220
#if FF_API_XVMC
221
    AV_CODEC_ID_MPEG2VIDEO_XVMC,
222
#endif /* FF_API_XVMC */
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 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 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
    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,
357
#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
    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
387
    AV_CODEC_ID_MSS2,
Tom Finegan's avatar
Tom Finegan committed
388
    AV_CODEC_ID_VP9,
389
    AV_CODEC_ID_AIC,
390 391 392
    AV_CODEC_ID_ESCAPE130,
    AV_CODEC_ID_G2M,
    AV_CODEC_ID_WEBP,
393
    AV_CODEC_ID_HNM4_VIDEO,
394 395
    AV_CODEC_ID_HEVC,
#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
396
    AV_CODEC_ID_FIC,
397
    AV_CODEC_ID_ALIAS_PIX,
398 399 400 401 402 403 404 405
    AV_CODEC_ID_BRENDER_PIX,
    AV_CODEC_ID_PAF_VIDEO,
    AV_CODEC_ID_EXR,
    AV_CODEC_ID_VP7,
    AV_CODEC_ID_SANM,
    AV_CODEC_ID_SGIRLE,
    AV_CODEC_ID_MVC1,
    AV_CODEC_ID_MVC2,
Vittorio Giovara's avatar
Vittorio Giovara committed
406
    AV_CODEC_ID_HQX,
Vittorio Giovara's avatar
Vittorio Giovara committed
407
    AV_CODEC_ID_TDSC,
408
    AV_CODEC_ID_HQ_HQA,
409
    AV_CODEC_ID_HAP,
410
    AV_CODEC_ID_DDS,
Vittorio Giovara's avatar
Vittorio Giovara committed
411
    AV_CODEC_ID_DXV,
412
    AV_CODEC_ID_SCREENPRESSO,
413
    AV_CODEC_ID_RSCC,
414

415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
    AV_CODEC_ID_Y41P = 0x8000,
    AV_CODEC_ID_AVRP,
    AV_CODEC_ID_012V,
    AV_CODEC_ID_AVUI,
    AV_CODEC_ID_AYUV,
    AV_CODEC_ID_TARGA_Y216,
    AV_CODEC_ID_V308,
    AV_CODEC_ID_V408,
    AV_CODEC_ID_YUV4,
    AV_CODEC_ID_AVRN,
    AV_CODEC_ID_CPIA,
    AV_CODEC_ID_XFACE,
    AV_CODEC_ID_SNOW,
    AV_CODEC_ID_SMVJPEG,
    AV_CODEC_ID_APNG,
430
    AV_CODEC_ID_DAALA,
431
    AV_CODEC_ID_CFHD,
432
    AV_CODEC_ID_TRUEMOTION2RT,
433
    AV_CODEC_ID_M101,
434
    AV_CODEC_ID_MAGICYUV,
435
    AV_CODEC_ID_SHEERVIDEO,
436
    AV_CODEC_ID_YLC,
437
    AV_CODEC_ID_PSD,
438
    AV_CODEC_ID_PIXLET,
439
    AV_CODEC_ID_SPEEDHQ,
440
    AV_CODEC_ID_FMVC,
441
    AV_CODEC_ID_SCPR,
442
    AV_CODEC_ID_CLEARVIDEO,
443
    AV_CODEC_ID_XPM,
444
    AV_CODEC_ID_AV1,
445

Diego Biurrun's avatar
Diego Biurrun committed
446
    /* various PCM "codecs" */
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
    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,
476 477 478
    AV_CODEC_ID_PCM_S24LE_PLANAR,
    AV_CODEC_ID_PCM_S32LE_PLANAR,
    AV_CODEC_ID_PCM_S16BE_PLANAR,
479 480 481

    AV_CODEC_ID_PCM_S64LE = 0x10800,
    AV_CODEC_ID_PCM_S64BE,
482 483
    AV_CODEC_ID_PCM_F16LE,
    AV_CODEC_ID_PCM_F24LE,
484

Diego Biurrun's avatar
Diego Biurrun committed
485
    /* various ADPCM codecs */
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
    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,
516
    AV_CODEC_ID_ADPCM_VIMA,
517
#if FF_API_VIMA_DECODER
518
    AV_CODEC_ID_VIMA = AV_CODEC_ID_ADPCM_VIMA,
519
#endif
520 521 522 523 524 525 526

    AV_CODEC_ID_ADPCM_AFC = 0x11800,
    AV_CODEC_ID_ADPCM_IMA_OKI,
    AV_CODEC_ID_ADPCM_DTK,
    AV_CODEC_ID_ADPCM_IMA_RAD,
    AV_CODEC_ID_ADPCM_G726LE,
    AV_CODEC_ID_ADPCM_THP_LE,
527
    AV_CODEC_ID_ADPCM_PSX,
528
    AV_CODEC_ID_ADPCM_AICA,
529
    AV_CODEC_ID_ADPCM_IMA_DAT4,
530
    AV_CODEC_ID_ADPCM_MTAF,
531

532
    /* AMR */
533 534
    AV_CODEC_ID_AMR_NB = 0x12000,
    AV_CODEC_ID_AMR_WB,
535

536
    /* RealAudio codecs*/
537 538
    AV_CODEC_ID_RA_144 = 0x13000,
    AV_CODEC_ID_RA_288,
539 540

    /* various DPCM codecs */
541 542 543 544
    AV_CODEC_ID_ROQ_DPCM = 0x14000,
    AV_CODEC_ID_INTERPLAY_DPCM,
    AV_CODEC_ID_XAN_DPCM,
    AV_CODEC_ID_SOL_DPCM,
545

546 547
    AV_CODEC_ID_SDX2_DPCM = 0x14800,

548
    /* audio codecs */
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
    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,
581
#if FF_API_VOXWARE
582
    AV_CODEC_ID_VOXWARE,
583
#endif
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
    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,
612
    AV_CODEC_ID_OPUS,
613
    AV_CODEC_ID_COMFORT_NOISE,
614
    AV_CODEC_ID_TAK,
615
    AV_CODEC_ID_METASOUND,
616
    AV_CODEC_ID_PAF_AUDIO,
Kostya Shishkov's avatar
Kostya Shishkov committed
617
    AV_CODEC_ID_ON2AVC,
618
    AV_CODEC_ID_DSS_SP,
619 620 621 622 623 624 625 626 627 628 629

    AV_CODEC_ID_FFWAVESYNTH = 0x15800,
    AV_CODEC_ID_SONIC,
    AV_CODEC_ID_SONIC_LS,
    AV_CODEC_ID_EVRC,
    AV_CODEC_ID_SMV,
    AV_CODEC_ID_DSD_LSBF,
    AV_CODEC_ID_DSD_MSBF,
    AV_CODEC_ID_DSD_LSBF_PLANAR,
    AV_CODEC_ID_DSD_MSBF_PLANAR,
    AV_CODEC_ID_4GV,
630
    AV_CODEC_ID_INTERPLAY_ACM,
631 632
    AV_CODEC_ID_XMA1,
    AV_CODEC_ID_XMA2,
633
    AV_CODEC_ID_DST,
634 635
    AV_CODEC_ID_ATRAC3AL,
    AV_CODEC_ID_ATRAC3PAL,
636

637
    /* subtitle codecs */
638 639 640 641 642 643 644 645 646 647
    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,
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663

    AV_CODEC_ID_MICRODVD   = 0x17800,
    AV_CODEC_ID_EIA_608,
    AV_CODEC_ID_JACOSUB,
    AV_CODEC_ID_SAMI,
    AV_CODEC_ID_REALTEXT,
    AV_CODEC_ID_STL,
    AV_CODEC_ID_SUBVIEWER1,
    AV_CODEC_ID_SUBVIEWER,
    AV_CODEC_ID_SUBRIP,
    AV_CODEC_ID_WEBVTT,
    AV_CODEC_ID_MPL2,
    AV_CODEC_ID_VPLAYER,
    AV_CODEC_ID_PJS,
    AV_CODEC_ID_ASS,
    AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
664

Diego Biurrun's avatar
Diego Biurrun committed
665
    /* other specific kind of codecs (generally used for attachments) */
666 667
    AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
    AV_CODEC_ID_TTF = 0x18000,
668

669
    AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream.
670 671 672 673 674 675 676 677
    AV_CODEC_ID_BINTEXT    = 0x18800,
    AV_CODEC_ID_XBIN,
    AV_CODEC_ID_IDF,
    AV_CODEC_ID_OTF,
    AV_CODEC_ID_SMPTE_KLV,
    AV_CODEC_ID_DVD_NAV,
    AV_CODEC_ID_TIMED_ID3,
    AV_CODEC_ID_BIN_DATA,
678

679

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

682
    AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
Diego Biurrun's avatar
Diego Biurrun committed
683
                                * stream (only used by libavformat) */
684
    AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
685
                                * stream (only used by libavformat) */
686
    AV_CODEC_ID_FFMETADATA = 0x21000,   ///< Dummy codec for streams containing only metadata information.
687
    AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket
Fabrice Bellard's avatar
Fabrice Bellard committed
688
};
689

690 691 692
/**
 * This struct describes the properties of a single codec described by an
 * AVCodecID.
693
 * @see avcodec_descriptor_get()
694 695 696 697 698 699 700 701 702 703 704 705 706 707
 */
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;
708 709 710 711
    /**
     * Codec properties, a combination of AV_CODEC_PROP_* flags.
     */
    int             props;
712 713 714
    /**
     * MIME type(s) associated with the codec.
     * May be NULL; if not, a NULL-terminated array of MIME types.
Lou Logan's avatar
Lou Logan committed
715
     * The first item is always non-NULL and is the preferred MIME type.
716 717
     */
    const char *const *mime_types;
718 719 720 721 722
    /**
     * If non-NULL, an array of profiles recognized for this codec.
     * Terminated with FF_PROFILE_UNKNOWN.
     */
    const struct AVProfile *profiles;
723 724
} AVCodecDescriptor;

725 726 727 728 729
/**
 * Codec uses only intra compression.
 * Video codecs only.
 */
#define AV_CODEC_PROP_INTRA_ONLY    (1 << 0)
730 731 732 733 734 735 736 737 738 739
/**
 * 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)
740 741 742 743 744 745 746 747 748 749
/**
 * Codec supports frame reordering. That is, the coded order (the order in which
 * the encoded packets are output by the encoders / stored / input to the
 * decoders) may be different from the presentation order of the corresponding
 * frames.
 *
 * For codecs that do not have this property set, PTS and DTS should always be
 * equal.
 */
#define AV_CODEC_PROP_REORDER       (1 << 3)
750 751
/**
 * Subtitle codec is bitmap based
752
 * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
753 754
 */
#define AV_CODEC_PROP_BITMAP_SUB    (1 << 16)
755 756 757 758 759
/**
 * Subtitle codec is text based.
 * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
 */
#define AV_CODEC_PROP_TEXT_SUB      (1 << 17)
760

761
/**
762
 * @ingroup lavc_decoding
763
 * Required number of additionally allocated bytes at the end of the input bitstream for decoding.
764 765
 * 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
766 767
 * Note: If the first 23 bits of the additional bytes are not 0, then damaged
 * MPEG bitstreams could cause overread and segfault.
768
 */
769
#define AV_INPUT_BUFFER_PADDING_SIZE 32
770

771
/**
772
 * @ingroup lavc_encoding
Diego Biurrun's avatar
Diego Biurrun committed
773 774
 * minimum encoding buffer size
 * Used to avoid some checks during header writing.
775
 */
776
#define AV_INPUT_BUFFER_MIN_SIZE 16384
777

778
#if FF_API_WITHOUT_PREFIX
779 780 781
/**
 * @deprecated use AV_INPUT_BUFFER_PADDING_SIZE instead
 */
782
#define FF_INPUT_BUFFER_PADDING_SIZE 32
783

784 785 786 787
/**
 * @deprecated use AV_INPUT_BUFFER_MIN_SIZE instead
 */
#define FF_MIN_BUFFER_SIZE 16384
788
#endif /* FF_API_WITHOUT_PREFIX */
789

790
/**
791
 * @ingroup lavc_encoding
792
 * motion estimation type.
793
 * @deprecated use codec private option instead
794
 */
795
#if FF_API_MOTION_EST
796
enum Motion_Est_ID {
797
    ME_ZERO = 1,    ///< no search, that is use 0,0 vector whenever one is needed
798 799 800
    ME_FULL,
    ME_LOG,
    ME_PHODS,
801 802 803 804
    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
805
    ME_TESA,        ///< transformed exhaustive search algorithm
806
    ME_ITER=50,     ///< iterative search
807
};
808
#endif
809

810 811 812
/**
 * @ingroup lavc_decoding
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
813
enum AVDiscard{
Diego Biurrun's avatar
Diego Biurrun committed
814 815
    /* We leave some space between them for extensions (drop some
     * keyframes for intra-only or drop just some bidir frames). */
816 817 818 819
    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
820
    AVDISCARD_NONINTRA= 24, ///< discard all non intra frames
821 822
    AVDISCARD_NONKEY  = 32, ///< discard all frames except keyframes
    AVDISCARD_ALL     = 48, ///< discard all
Michael Niedermayer's avatar
Michael Niedermayer committed
823 824
};

825 826 827 828 829 830 831 832 833 834 835 836 837
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
};

838 839 840
/**
 * @ingroup lavc_encoding
 */
841 842 843
typedef struct RcOverride{
    int start_frame;
    int end_frame;
Diego Biurrun's avatar
Diego Biurrun committed
844
    int qscale; // If this is 0 then quality_factor will be used instead.
845 846 847
    float quality_factor;
} RcOverride;

848 849 850 851
#if FF_API_MAX_BFRAMES
/**
 * @deprecated there is no libavcodec-wide limit on the number of B-frames
 */
852
#define FF_MAX_B_FRAMES 16
853
#endif
854

855
/* encoding support
Diego Biurrun's avatar
Diego Biurrun committed
856 857
   These flags can be passed in AVCodecContext.flags before initialization.
   Note: Not everything is supported yet.
858
*/
Fabrice Bellard's avatar
Fabrice Bellard committed
859

860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921
/**
 * Allow decoders to produce frames with data planes that are not aligned
 * to CPU requirements (e.g. due to cropping).
 */
#define AV_CODEC_FLAG_UNALIGNED       (1 <<  0)
/**
 * Use fixed qscale.
 */
#define AV_CODEC_FLAG_QSCALE          (1 <<  1)
/**
 * 4 MV per MB allowed / advanced prediction for H.263.
 */
#define AV_CODEC_FLAG_4MV             (1 <<  2)
/**
 * Output even those frames that might be corrupted.
 */
#define AV_CODEC_FLAG_OUTPUT_CORRUPT  (1 <<  3)
/**
 * Use qpel MC.
 */
#define AV_CODEC_FLAG_QPEL            (1 <<  4)
/**
 * Use internal 2pass ratecontrol in first pass mode.
 */
#define AV_CODEC_FLAG_PASS1           (1 <<  9)
/**
 * Use internal 2pass ratecontrol in second pass mode.
 */
#define AV_CODEC_FLAG_PASS2           (1 << 10)
/**
 * loop filter.
 */
#define AV_CODEC_FLAG_LOOP_FILTER     (1 << 11)
/**
 * Only decode/encode grayscale.
 */
#define AV_CODEC_FLAG_GRAY            (1 << 13)
/**
 * error[?] variables will be set during encoding.
 */
#define AV_CODEC_FLAG_PSNR            (1 << 15)
/**
 * Input bitstream might be truncated at a random location
 * instead of only at frame boundaries.
 */
#define AV_CODEC_FLAG_TRUNCATED       (1 << 16)
/**
 * Use interlaced DCT.
 */
#define AV_CODEC_FLAG_INTERLACED_DCT  (1 << 18)
/**
 * Force low delay.
 */
#define AV_CODEC_FLAG_LOW_DELAY       (1 << 19)
/**
 * Place global headers in extradata instead of every keyframe.
 */
#define AV_CODEC_FLAG_GLOBAL_HEADER   (1 << 22)
/**
 * Use only bitexact stuff (except (I)DCT).
 */
#define AV_CODEC_FLAG_BITEXACT        (1 << 23)
922
/* Fx : Flag for H.263+ extra options */
923 924 925 926 927 928 929 930
/**
 * H.263 advanced intra coding / MPEG-4 AC prediction
 */
#define AV_CODEC_FLAG_AC_PRED         (1 << 24)
/**
 * interlaced motion estimation
 */
#define AV_CODEC_FLAG_INTERLACED_ME   (1 << 29)
931
#define AV_CODEC_FLAG_CLOSED_GOP      (1U << 31)
932

933 934 935 936 937 938 939 940 941 942 943 944
/**
 * Allow non spec compliant speedup tricks.
 */
#define AV_CODEC_FLAG2_FAST           (1 <<  0)
/**
 * Skip bitstream encoding.
 */
#define AV_CODEC_FLAG2_NO_OUTPUT      (1 <<  2)
/**
 * Place global headers at every keyframe instead of in extradata.
 */
#define AV_CODEC_FLAG2_LOCAL_HEADER   (1 <<  3)
945 946 947 948

/**
 * timecode is in drop frame format. DEPRECATED!!!!
 */
949
#define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13)
950

951 952 953 954 955 956 957 958 959 960
/**
 * Input bitstream might be truncated at a packet boundaries
 * instead of only at frame boundaries.
 */
#define AV_CODEC_FLAG2_CHUNKS         (1 << 15)
/**
 * Discard cropping information from SPS.
 */
#define AV_CODEC_FLAG2_IGNORE_CROP    (1 << 16)

961 962 963
/**
 * Show all frames before the first keyframe
 */
964
#define AV_CODEC_FLAG2_SHOW_ALL       (1 << 22)
965 966 967
/**
 * Export motion vectors through frame side data
 */
968
#define AV_CODEC_FLAG2_EXPORT_MVS     (1 << 28)
969 970 971
/**
 * Do not skip samples and export skip information as frame side data
 */
972
#define AV_CODEC_FLAG2_SKIP_MANUAL    (1 << 29)
973 974 975 976
/**
 * Do not reset ASS ReadOrder field on flush (subtitles decoding)
 */
#define AV_CODEC_FLAG2_RO_FLUSH_NOOP  (1 << 30)
977

978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
/* Unsupported options :
 *              Syntax Arithmetic coding (SAC)
 *              Reference Picture Selection
 *              Independent Segment Decoding */
/* /Fx */
/* codec capabilities */

/**
 * Decoder can use draw_horiz_band callback.
 */
#define AV_CODEC_CAP_DRAW_HORIZ_BAND     (1 <<  0)
/**
 * Codec uses get_buffer() for allocating buffers and supports custom allocators.
 * If not set, it might not use get_buffer() at all or use operations that
 * assume the buffer was allocated by avcodec_default_get_buffer.
 */
#define AV_CODEC_CAP_DR1                 (1 <<  1)
#define AV_CODEC_CAP_TRUNCATED           (1 <<  3)
/**
 * 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,
 * avpkt->size=0 at the end to get the delayed data until the decoder no longer
 * returns frames.
 *
 * Encoders:
 * The encoder needs to be fed with NULL data at the end of encoding until the
 * encoder no longer returns data.
 *
 * 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.
 */
#define AV_CODEC_CAP_DELAY               (1 <<  5)
/**
 * Codec can be fed a final frame with a smaller size.
 * This can be used to prevent truncation of the last audio samples.
 */
#define AV_CODEC_CAP_SMALL_LAST_FRAME    (1 <<  6)
1025 1026 1027 1028 1029 1030 1031 1032

#if FF_API_CAP_VDPAU
/**
 * Codec can export data for HW decoding (VDPAU).
 */
#define AV_CODEC_CAP_HWACCEL_VDPAU       (1 <<  7)
#endif

1033 1034 1035 1036 1037 1038
/**
 * Codec can output multiple frames per AVPacket
 * Normally demuxers return one frame at a time, demuxers which do not do
 * are connected to a parser to split what they return into proper frames.
 * This flag is reserved to the very rare category of codecs which have a
 * bitstream that cannot be split into frames without timeconsuming
1039
 * operations like full decoding. Demuxers carrying such bitstreams thus
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
 * may return multiple frames in a packet. This has many disadvantages like
 * prohibiting stream copy in many cases thus it should only be considered
 * as a last resort.
 */
#define AV_CODEC_CAP_SUBFRAMES           (1 <<  8)
/**
 * Codec is experimental and is thus avoided in favor of non experimental
 * encoders
 */
#define AV_CODEC_CAP_EXPERIMENTAL        (1 <<  9)
/**
 * Codec should fill in channel configuration and samplerate instead of container
 */
#define AV_CODEC_CAP_CHANNEL_CONF        (1 << 10)
/**
 * Codec supports frame-level multithreading.
 */
#define AV_CODEC_CAP_FRAME_THREADS       (1 << 12)
/**
 * Codec supports slice-based (or partition-based) multithreading.
 */
#define AV_CODEC_CAP_SLICE_THREADS       (1 << 13)
/**
 * Codec supports changed parameters at any point.
 */
#define AV_CODEC_CAP_PARAM_CHANGE        (1 << 14)
/**
 * Codec supports avctx->thread_count == 0 (auto).
 */
#define AV_CODEC_CAP_AUTO_THREADS        (1 << 15)
/**
 * Audio encoder supports receiving a different number of samples in each call.
 */
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
/**
 * Decoder is not a preferred choice for probing.
 * This indicates that the decoder is not a good choice for probing.
 * It could for example be an expensive to spin up hardware decoder,
 * or it could simply not provide a lot of useful information about
 * the stream.
 * A decoder marked with this flag should only be used as last resort
 * choice for probing.
 */
#define AV_CODEC_CAP_AVOID_PROBING       (1 << 17)
1084 1085 1086 1087 1088 1089 1090 1091 1092
/**
 * Codec is intra only.
 */
#define AV_CODEC_CAP_INTRA_ONLY       0x40000000
/**
 * Codec is lossless.
 */
#define AV_CODEC_CAP_LOSSLESS         0x80000000

1093

1094
#if FF_API_WITHOUT_PREFIX
1095 1096 1097 1098
/**
 * Allow decoders to produce frames with data planes that are not aligned
 * to CPU requirements (e.g. due to cropping).
 */
1099 1100 1101 1102 1103
#define CODEC_FLAG_UNALIGNED AV_CODEC_FLAG_UNALIGNED
#define CODEC_FLAG_QSCALE AV_CODEC_FLAG_QSCALE
#define CODEC_FLAG_4MV    AV_CODEC_FLAG_4MV
#define CODEC_FLAG_OUTPUT_CORRUPT AV_CODEC_FLAG_OUTPUT_CORRUPT
#define CODEC_FLAG_QPEL   AV_CODEC_FLAG_QPEL
1104 1105 1106 1107
#if FF_API_GMC
/**
 * @deprecated use the "gmc" private option of the libxvid encoder
 */
Diego Biurrun's avatar
Diego Biurrun committed
1108
#define CODEC_FLAG_GMC    0x0020  ///< Use GMC.
1109
#endif
1110 1111 1112 1113 1114 1115 1116
#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
1117
#if FF_API_INPUT_PRESERVED
1118
/**
1119 1120
 * @deprecated passing reference-counted frames to the encoders replaces this
 * flag
1121
 */
1122
#define CODEC_FLAG_INPUT_PRESERVED 0x0100
1123
#endif
1124 1125 1126
#define CODEC_FLAG_PASS1           AV_CODEC_FLAG_PASS1
#define CODEC_FLAG_PASS2           AV_CODEC_FLAG_PASS2
#define CODEC_FLAG_GRAY            AV_CODEC_FLAG_GRAY
1127 1128 1129 1130 1131 1132 1133
#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
1134 1135 1136
#define CODEC_FLAG_PSNR            AV_CODEC_FLAG_PSNR
#define CODEC_FLAG_TRUNCATED       AV_CODEC_FLAG_TRUNCATED

1137 1138 1139 1140 1141 1142 1143
#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
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
#define CODEC_FLAG_INTERLACED_DCT AV_CODEC_FLAG_INTERLACED_DCT
#define CODEC_FLAG_LOW_DELAY      AV_CODEC_FLAG_LOW_DELAY
#define CODEC_FLAG_GLOBAL_HEADER  AV_CODEC_FLAG_GLOBAL_HEADER
#define CODEC_FLAG_BITEXACT       AV_CODEC_FLAG_BITEXACT
#define CODEC_FLAG_AC_PRED        AV_CODEC_FLAG_AC_PRED
#define CODEC_FLAG_LOOP_FILTER    AV_CODEC_FLAG_LOOP_FILTER
#define CODEC_FLAG_INTERLACED_ME  AV_CODEC_FLAG_INTERLACED_ME
#define CODEC_FLAG_CLOSED_GOP     AV_CODEC_FLAG_CLOSED_GOP
#define CODEC_FLAG2_FAST          AV_CODEC_FLAG2_FAST
#define CODEC_FLAG2_NO_OUTPUT     AV_CODEC_FLAG2_NO_OUTPUT
#define CODEC_FLAG2_LOCAL_HEADER  AV_CODEC_FLAG2_LOCAL_HEADER
#define CODEC_FLAG2_DROP_FRAME_TIMECODE AV_CODEC_FLAG2_DROP_FRAME_TIMECODE
#define CODEC_FLAG2_IGNORE_CROP   AV_CODEC_FLAG2_IGNORE_CROP

#define CODEC_FLAG2_CHUNKS        AV_CODEC_FLAG2_CHUNKS
#define CODEC_FLAG2_SHOW_ALL      AV_CODEC_FLAG2_SHOW_ALL
#define CODEC_FLAG2_EXPORT_MVS    AV_CODEC_FLAG2_EXPORT_MVS
#define CODEC_FLAG2_SKIP_MANUAL   AV_CODEC_FLAG2_SKIP_MANUAL
1162

1163
/* Unsupported options :
1164 1165
 *              Syntax Arithmetic coding (SAC)
 *              Reference Picture Selection
1166
 *              Independent Segment Decoding */
1167
/* /Fx */
1168 1169
/* codec capabilities */

1170
#define CODEC_CAP_DRAW_HORIZ_BAND AV_CODEC_CAP_DRAW_HORIZ_BAND ///< Decoder can use draw_horiz_band callback.
1171
/**
1172 1173 1174
 * 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.
1175
 */
1176 1177
#define CODEC_CAP_DR1             AV_CODEC_CAP_DR1
#define CODEC_CAP_TRUNCATED       AV_CODEC_CAP_TRUNCATED
1178
#if FF_API_XVMC
1179 1180 1181 1182 1183 1184 1185
/* 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.
 */
1186
#define CODEC_CAP_HWACCEL         0x0010
1187
#endif /* FF_API_XVMC */
1188
/**
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
 * 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,
1199
 * avpkt->size=0 at the end to get the delayed data until the decoder no longer
1200 1201 1202 1203 1204
 * returns frames.
 *
 * Encoders:
 * The encoder needs to be fed with NULL data at the end of encoding until the
 * encoder no longer returns data.
1205 1206 1207 1208 1209
 *
 * 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.
1210
 */
1211
#define CODEC_CAP_DELAY           AV_CODEC_CAP_DELAY
1212 1213 1214 1215
/**
 * Codec can be fed a final frame with a smaller size.
 * This can be used to prevent truncation of the last audio samples.
 */
1216
#define CODEC_CAP_SMALL_LAST_FRAME AV_CODEC_CAP_SMALL_LAST_FRAME
1217
#if FF_API_CAP_VDPAU
1218 1219 1220
/**
 * Codec can export data for HW decoding (VDPAU).
 */
1221
#define CODEC_CAP_HWACCEL_VDPAU    AV_CODEC_CAP_HWACCEL_VDPAU
1222
#endif
1223 1224
/**
 * Codec can output multiple frames per AVPacket
1225 1226 1227 1228
 * 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
1229
 * operations like full decoding. Demuxers carrying such bitstreams thus
1230 1231 1232
 * 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.
1233
 */
1234
#define CODEC_CAP_SUBFRAMES        AV_CODEC_CAP_SUBFRAMES
1235 1236 1237 1238
/**
 * Codec is experimental and is thus avoided in favor of non experimental
 * encoders
 */
1239
#define CODEC_CAP_EXPERIMENTAL     AV_CODEC_CAP_EXPERIMENTAL
1240 1241 1242
/**
 * Codec should fill in channel configuration and samplerate instead of container
 */
1243
#define CODEC_CAP_CHANNEL_CONF     AV_CODEC_CAP_CHANNEL_CONF
1244
#if FF_API_NEG_LINESIZES
1245
/**
1246
 * @deprecated no codecs use this capability
1247 1248
 */
#define CODEC_CAP_NEG_LINESIZES    0x0800
1249
#endif
1250 1251 1252
/**
 * Codec supports frame-level multithreading.
 */
1253
#define CODEC_CAP_FRAME_THREADS    AV_CODEC_CAP_FRAME_THREADS
1254 1255 1256
/**
 * Codec supports slice-based (or partition-based) multithreading.
 */
1257
#define CODEC_CAP_SLICE_THREADS    AV_CODEC_CAP_SLICE_THREADS
1258 1259 1260
/**
 * Codec supports changed parameters at any point.
 */
1261
#define CODEC_CAP_PARAM_CHANGE     AV_CODEC_CAP_PARAM_CHANGE
1262 1263 1264
/**
 * Codec supports avctx->thread_count == 0 (auto).
 */
1265
#define CODEC_CAP_AUTO_THREADS     AV_CODEC_CAP_AUTO_THREADS
1266 1267 1268
/**
 * Audio encoder supports receiving a different number of samples in each call.
 */
1269
#define CODEC_CAP_VARIABLE_FRAME_SIZE AV_CODEC_CAP_VARIABLE_FRAME_SIZE
1270 1271 1272
/**
 * Codec is intra only.
 */
1273
#define CODEC_CAP_INTRA_ONLY       AV_CODEC_CAP_INTRA_ONLY
1274 1275 1276
/**
 * Codec is lossless.
 */
1277
#define CODEC_CAP_LOSSLESS         AV_CODEC_CAP_LOSSLESS
1278

1279 1280 1281 1282 1283
/**
 * HWAccel is experimental and is thus avoided in favor of non experimental
 * codecs
 */
#define HWACCEL_CODEC_CAP_EXPERIMENTAL     0x0200
1284
#endif /* FF_API_WITHOUT_PREFIX */
1285

1286
#if FF_API_MB_TYPE
Diego Biurrun's avatar
Diego Biurrun committed
1287
//The following defines may change, don't expect compatibility if you use them.
1288
#define MB_TYPE_INTRA4x4   0x0001
Diego Biurrun's avatar
Diego Biurrun committed
1289 1290
#define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific
#define MB_TYPE_INTRA_PCM  0x0004 //FIXME H.264-specific
1291 1292 1293 1294 1295
#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
1296
#define MB_TYPE_DIRECT2    0x0100 //FIXME
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
#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
1309
// Note bits 24-31 are reserved for codec specific use (H.264 ref0, MPEG-1 0mv, ...)
1310
#endif
1311

1312 1313
/**
 * Pan Scan area.
Diego Biurrun's avatar
Diego Biurrun committed
1314 1315
 * This specifies the area which should be displayed.
 * Note there may be multiple such areas for one frame.
1316 1317 1318
 */
typedef struct AVPanScan{
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1319 1320 1321
     * id
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
1322 1323 1324 1325 1326
     */
    int id;

    /**
     * width and height in 1/16 pel
Diego Biurrun's avatar
Diego Biurrun committed
1327 1328
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
1329 1330 1331 1332 1333
     */
    int width;
    int height;

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1334 1335 1336
     * position of the top left corner in 1/16 pel for up to 3 fields/frames
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
1337 1338 1339 1340
     */
    int16_t position[3][2];
}AVPanScan;

1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378
/**
 * This structure describes the bitrate properties of an encoded bitstream. It
 * roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD
 * parameters for H.264/HEVC.
 */
typedef struct AVCPBProperties {
    /**
     * Maximum bitrate of the stream, in bits per second.
     * Zero if unknown or unspecified.
     */
    int max_bitrate;
    /**
     * Minimum bitrate of the stream, in bits per second.
     * Zero if unknown or unspecified.
     */
    int min_bitrate;
    /**
     * Average bitrate of the stream, in bits per second.
     * Zero if unknown or unspecified.
     */
    int avg_bitrate;

    /**
     * The size of the buffer to which the ratecontrol is applied, in bits.
     * Zero if unknown or unspecified.
     */
    int buffer_size;

    /**
     * The delay between the time the packet this structure is associated with
     * is received and the time when it should be decoded, in periods of a 27MHz
     * clock.
     *
     * UINT64_MAX when unknown or unspecified.
     */
    uint64_t vbv_delay;
} AVCPBProperties;

1379
#if FF_API_QSCALE_TYPE
1380 1381 1382
#define FF_QSCALE_TYPE_MPEG1 0
#define FF_QSCALE_TYPE_MPEG2 1
#define FF_QSCALE_TYPE_H264  2
1383
#define FF_QSCALE_TYPE_VP56  3
1384
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
1385

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

1391 1392 1393 1394 1395 1396
/**
 * @defgroup lavc_packet AVPacket
 *
 * Types and functions for working with AVPacket.
 * @{
 */
1397
enum AVPacketSideDataType {
1398 1399 1400 1401 1402
    /**
     * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
     * bytes worth of palette. This side data signals that a new palette is
     * present.
     */
1403
    AV_PKT_DATA_PALETTE,
1404 1405 1406 1407 1408 1409 1410 1411

    /**
     * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
     * that the extradata buffer was changed and the receiving side should
     * act upon it appropriately. The new extradata is embedded in the side
     * data buffer and should be immediately used for processing the current
     * frame or packet.
     */
1412
    AV_PKT_DATA_NEW_EXTRADATA,
1413 1414 1415

    /**
     * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
1416
     * @code
1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
     * 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
1427
     * @endcode
1428
     */
1429
    AV_PKT_DATA_PARAM_CHANGE,
1430 1431 1432 1433 1434 1435 1436 1437 1438

    /**
     * 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:
1439
     * @code
1440 1441 1442 1443 1444 1445 1446 1447
     * 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
1448
     * @endcode
1449
     */
1450
    AV_PKT_DATA_H263_MB_INFO,
1451

1452 1453 1454 1455 1456
    /**
     * This side data should be associated with an audio stream and contains
     * ReplayGain information in form of the AVReplayGain struct.
     */
    AV_PKT_DATA_REPLAYGAIN,
1457

1458 1459 1460 1461 1462 1463 1464 1465
    /**
     * This side data contains a 3x3 transformation matrix describing an affine
     * transformation that needs to be applied to the decoded video frames for
     * correct presentation.
     *
     * See libavutil/display.h for a detailed description of the data.
     */
    AV_PKT_DATA_DISPLAYMATRIX,
1466

1467
    /**
1468 1469 1470 1471
     * This side data should be associated with a video stream and contains
     * Stereoscopic 3D information in form of the AVStereo3D struct.
     */
    AV_PKT_DATA_STEREO3D,
1472

1473 1474 1475 1476 1477
    /**
     * This side data should be associated with an audio stream and corresponds
     * to enum AVAudioServiceType.
     */
    AV_PKT_DATA_AUDIO_SERVICE_TYPE,
1478

1479
    /**
1480 1481 1482 1483 1484 1485 1486 1487
     * This side data contains quality related information from the encoder.
     * @code
     * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
     * u8    picture type
     * u8    error count
     * u16   reserved
     * u64le[error count] sum of squared differences between encoder in and output
     * @endcode
1488
     */
1489
    AV_PKT_DATA_QUALITY_STATS,
1490

1491 1492 1493 1494 1495 1496 1497
    /**
     * This side data contains an integer value representing the stream index
     * of a "fallback" track.  A fallback track indicates an alternate
     * track to use when the current track can not be decoded for some reason.
     * e.g. no decoder available for codec.
     */
    AV_PKT_DATA_FALLBACK_TRACK,
1498

1499 1500 1501 1502
    /**
     * This side data corresponds to the AVCPBProperties struct.
     */
    AV_PKT_DATA_CPB_PROPERTIES,
1503

1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
    /**
     * 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,
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523

    /**
     * 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,
1524 1525 1526 1527 1528 1529

    /**
     * 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,
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540

    /**
     * Subtitle event position
     * @code
     * u32le x1
     * u32le y1
     * u32le x2
     * u32le y2
     * @endcode
     */
    AV_PKT_DATA_SUBTITLE_POSITION,
1541 1542 1543 1544 1545 1546 1547 1548

    /**
     * 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,
1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559

    /**
     * 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,
1560 1561 1562 1563 1564 1565 1566

    /**
     * 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,
1567 1568 1569 1570 1571 1572

    /**
     * MPEGTS stream ID, this is required to pass the stream ID
     * information from the demuxer to the corresponding muxer.
     */
    AV_PKT_DATA_MPEGTS_STREAM_ID,
1573 1574 1575 1576 1577 1578

    /**
     * Mastering display metadata (based on SMPTE-2086:2014). This metadata
     * should be associated with a video stream and containts data in the form
     * of the AVMasteringDisplayMetadata struct.
     */
1579 1580 1581 1582 1583 1584 1585
    AV_PKT_DATA_MASTERING_DISPLAY_METADATA,

    /**
     * This side data should be associated with a video stream and corresponds
     * to the AVSphericalMapping structure.
     */
    AV_PKT_DATA_SPHERICAL,
1586 1587
};

1588 1589
#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED

1590 1591 1592 1593 1594 1595
typedef struct AVPacketSideData {
    uint8_t *data;
    int      size;
    enum AVPacketSideDataType type;
} AVPacketSideData;

1596 1597 1598 1599 1600 1601
/**
 * 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
1602 1603 1604
 * contain several compressed frames. Encoders are allowed to output empty
 * packets, with no compressed data, containing only side data
 * (e.g. to update some stream parameters at the end of encoding).
1605
 *
1606
 * AVPacket is one of the few structs in FFmpeg, whose size is a part of public
1607 1608 1609
 * ABI. Thus it may be allocated on stack and no new fields can be added to it
 * without libavcodec and libavformat major bump.
 *
1610 1611 1612 1613
 * The semantics of data ownership depends on the buf field.
 * If it is set, the packet data is dynamically allocated and is
 * valid indefinitely until a call to av_packet_unref() reduces the
 * reference count to 0.
1614
 *
1615 1616 1617 1618 1619 1620 1621 1622
 * If the buf field is not set av_packet_ref() would make a copy instead
 * of increasing the reference count.
 *
 * The side data is always allocated with av_malloc(), copied by
 * av_packet_ref() and freed by av_packet_unref().
 *
 * @see av_packet_ref
 * @see av_packet_unref
1623
 */
1624
typedef struct AVPacket {
1625 1626 1627 1628 1629 1630
    /**
     * 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;
1631
    /**
1632 1633
     * Presentation timestamp in AVStream->time_base units; the time at which
     * the decompressed packet will be presented to the user.
1634 1635 1636 1637 1638 1639 1640 1641
     * 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;
    /**
1642 1643
     * Decompression timestamp in AVStream->time_base units; the time at which
     * the packet is decompressed.
1644 1645 1646 1647 1648 1649
     * Can be AV_NOPTS_VALUE if it is not stored in the file.
     */
    int64_t dts;
    uint8_t *data;
    int   size;
    int   stream_index;
1650 1651 1652
    /**
     * A combination of AV_PKT_FLAG values
     */
1653
    int   flags;
1654 1655 1656 1657
    /**
     * Additional packet data that can be provided by the container.
     * Packet can contain several types of side information.
     */
1658
    AVPacketSideData *side_data;
1659 1660
    int side_data_elems;

1661
    /**
1662
     * Duration of this packet in AVStream->time_base units, 0 if unknown.
1663 1664
     * Equals next_pts - this_pts in presentation order.
     */
1665
    int64_t duration;
1666

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

1669
#if FF_API_CONVERGENCE_DURATION
1670
    /**
1671 1672 1673
     * @deprecated Same as the duration field, but as int64_t. This was required
     * for Matroska subtitles, whose duration values could overflow when the
     * duration field was still an int.
1674
     */
1675
    attribute_deprecated
1676
    int64_t convergence_duration;
1677
#endif
1678
} AVPacket;
1679 1680
#define AV_PKT_FLAG_KEY     0x0001 ///< The packet contains a keyframe
#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
1681 1682 1683 1684 1685 1686
/**
 * Flag is used to discard packets which are required to maintain valid
 * decoder state but are not required for output and should be dropped
 * after decoding.
 **/
#define AV_PKT_FLAG_DISCARD   0x0004
1687

1688 1689 1690 1691 1692 1693
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,
};
1694 1695 1696
/**
 * @}
 */
1697

1698 1699
struct AVCodecInternal;

1700 1701 1702 1703 1704 1705 1706 1707 1708
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
1709
/**
1710 1711
 * main external API structure.
 * New fields can be added to the end with minor version bumps.
Diego Biurrun's avatar
Diego Biurrun committed
1712
 * Removal, reordering and changes to existing fields require a major
1713
 * version bump.
1714
 * You can use AVOptions (av_opt* / av_set/get*()) to access these fields from user
1715
 * applications.
1716 1717 1718 1719
 * The name string for AVOptions options matches the associated command line
 * parameter name and can be found in libavcodec/options_table.h
 * The AVOption/command line parameter names differ in some cases from the C
 * structure field names for historic reasons or brevity.
Diego Biurrun's avatar
Diego Biurrun committed
1720
 * sizeof(AVCodecContext) must not be used outside libav*.
Michael Niedermayer's avatar
Michael Niedermayer committed
1721
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
1722
typedef struct AVCodecContext {
1723
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1724
     * information on struct for av_log
1725
     * - set by avcodec_alloc_context3
1726
     */
1727
    const AVClass *av_class;
1728 1729 1730
    int log_level_offset;

    enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
1731
    const struct AVCodec  *codec;
1732 1733 1734 1735 1736
#if FF_API_CODEC_NAME
    /**
     * @deprecated this field is not used for anything in libavcodec
     */
    attribute_deprecated
1737
    char             codec_name[32];
1738
#endif
1739
    enum AVCodecID     codec_id; /* see AV_CODEC_ID_xxx */
1740 1741

    /**
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752
     * 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.
1753
     */
1754
    unsigned int codec_tag;
1755

1756
#if FF_API_STREAM_CODEC_TAG
1757
    /**
1758
     * @deprecated this field is unused
1759
     */
1760
    attribute_deprecated
1761
    unsigned int stream_codec_tag;
1762
#endif
1763

1764 1765
    void *priv_data;

1766
    /**
1767 1768 1769 1770
     * Private context used for internal data.
     *
     * Unlike priv_data, this is not codec-specific. It is used in general
     * libavcodec functions.
1771
     */
1772
    struct AVCodecInternal *internal;
1773 1774

    /**
1775 1776 1777
     * Private data of the user, can be used to carry app specific stuff.
     * - encoding: Set by user.
     * - decoding: Set by user.
1778
     */
1779
    void *opaque;
1780

1781
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1782 1783
     * the average bitrate
     * - encoding: Set by user; unused for constant quantizer encoding.
1784 1785
     * - decoding: Set by user, may be overwritten by libavcodec
     *             if this info is available in the stream
1786
     */
1787
    int64_t bit_rate;
1788

1789
    /**
1790
     * number of bits the bitstream is allowed to diverge from the reference.
1791
     *           the reference can be CBR (for CBR pass1) or VBR (for pass2)
Diego Biurrun's avatar
Diego Biurrun committed
1792
     * - encoding: Set by user; unused for constant quantizer encoding.
1793
     * - decoding: unused
1794
     */
1795 1796
    int bit_rate_tolerance;

1797
    /**
1798 1799
     * 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
1800
     * - encoding: Set by user.
1801
     * - decoding: unused
1802
     */
1803
    int global_quality;
1804 1805

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1806
     * - encoding: Set by user.
1807
     * - decoding: unused
1808
     */
1809 1810
    int compression_level;
#define FF_COMPRESSION_DEFAULT -1
1811 1812

    /**
1813
     * AV_CODEC_FLAG_*.
Diego Biurrun's avatar
Diego Biurrun committed
1814
     * - encoding: Set by user.
1815
     * - decoding: Set by user.
1816
     */
1817
    int flags;
1818

1819
    /**
1820
     * AV_CODEC_FLAG2_*
1821
     * - encoding: Set by user.
Diego Biurrun's avatar
Diego Biurrun committed
1822
     * - decoding: Set by user.
1823
     */
1824
    int flags2;
1825

1826
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1827
     * some codecs need / can use extradata like Huffman tables.
1828
     * MJPEG: Huffman tables
1829
     * rv10: additional flags
1830
     * MPEG-4: global headers (they can be in the bitstream or here)
1831
     * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger
1832
     * than extradata_size to avoid problems if it is read with the bitstream reader.
Diego Biurrun's avatar
Diego Biurrun committed
1833 1834 1835
     * 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.
1836
     */
1837
    uint8_t *extradata;
1838
    int extradata_size;
1839 1840

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1841 1842
     * This is the fundamental unit of time (in seconds) in terms
     * of which frame timestamps are represented. For fixed-fps content,
1843 1844
     * timebase should be 1/framerate and timestamp increments should be
     * identically 1.
1845
     * This often, but not always is the inverse of the frame rate or field rate
1846 1847 1848 1849 1850 1851 1852 1853 1854
     * for video. 1/time_base is not the average frame rate if the frame rate is not
     * constant.
     *
     * Like containers, elementary streams also can store timestamps, 1/time_base
     * is the unit in which these timestamps are specified.
     * As example of such codec time base see ISO/IEC 14496-2:2001(E)
     * vop_time_increment_resolution and fixed_vop_rate
     * (fixed_vop_rate == 0 implies that it is different from the framerate)
     *
Diego Biurrun's avatar
Diego Biurrun committed
1855
     * - encoding: MUST be set by user.
1856 1857
     * - decoding: the use of this field for decoding is deprecated.
     *             Use framerate instead.
1858
     */
1859
    AVRational time_base;
Fabrice Bellard's avatar
Fabrice Bellard committed
1860

1861
    /**
1862 1863 1864 1865 1866
     * 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.
1867
     */
1868
    int ticks_per_frame;
1869

1870
    /**
1871
     * Codec delay.
1872
     *
1873 1874 1875 1876
     * 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.
1877 1878 1879 1880 1881 1882
     *
     * Video:
     *   Number of frames the decoded output will be delayed relative to the
     *   encoded input.
     *
     * Audio:
1883
     *   For encoding, this field is unused (see initial_padding).
1884
     *
1885 1886 1887
     *   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.
1888
     *
Diego Biurrun's avatar
Diego Biurrun committed
1889
     * - encoding: Set by libavcodec.
1890
     * - decoding: Set by libavcodec.
1891 1892
     */
    int delay;
1893 1894


1895
    /* video only */
1896
    /**
1897
     * picture width / height.
1898 1899
     *
     * @note Those fields may not match the values of the last
1900
     * AVFrame output by avcodec_decode_video2 due frame
1901 1902
     * reordering.
     *
1903
     * - encoding: MUST be set by user.
1904 1905 1906
     * - 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
1907
     *             overwrite those values as required while parsing the data.
1908
     */
Fabrice Bellard's avatar
Fabrice Bellard committed
1909
    int width, height;
1910 1911

    /**
1912
     * Bitstream width / height, may be different from width/height e.g. when
1913
     * the decoded frame is cropped before being output or lowres is enabled.
1914 1915
     *
     * @note Those field may not match the value of the last
1916
     * AVFrame output by avcodec_receive_frame() due frame
1917 1918
     * reordering.
     *
1919
     * - encoding: unused
1920 1921
     * - decoding: May be set by the user before opening the decoder if known
     *             e.g. from the container. During decoding, the decoder may
1922
     *             overwrite those values as required while parsing the data.
1923 1924 1925
     */
    int coded_width, coded_height;

1926
#if FF_API_ASPECT_EXTENDED
1927
#define FF_ASPECT_EXTENDED 15
1928
#endif
1929 1930

    /**
Diego Biurrun's avatar
Diego Biurrun committed
1931 1932
     * the number of pictures in a group of pictures, or 0 for intra_only
     * - encoding: Set by user.
1933
     * - decoding: unused
1934 1935 1936 1937
     */
    int gop_size;

    /**
1938
     * Pixel format, see AV_PIX_FMT_xxx.
1939
     * May be set by the demuxer if known from headers.
1940
     * May be overridden by the decoder if it knows better.
1941 1942
     *
     * @note This field may not match the value of the last
1943
     * AVFrame output by avcodec_receive_frame() due frame
1944 1945
     * reordering.
     *
Diego Biurrun's avatar
Diego Biurrun committed
1946
     * - encoding: Set by user.
1947 1948
     * - decoding: Set by user if known, overridden by libavcodec while
     *             parsing the data.
1949
     */
1950
    enum AVPixelFormat pix_fmt;
1951

1952
#if FF_API_MOTION_EST
1953
    /**
1954 1955
     * This option does nothing
     * @deprecated use codec private options instead
1956
     */
1957 1958
    attribute_deprecated int me_method;
#endif
1959

1960
    /**
Diego Biurrun's avatar
Diego Biurrun committed
1961 1962
     * If non NULL, 'draw_horiz_band' is called by the libavcodec
     * decoder to draw a horizontal band. It improves cache usage. Not
1963
     * all codecs can do that. You must check the codec capabilities
Diego Biurrun's avatar
Diego Biurrun committed
1964
     * beforehand.
1965 1966 1967 1968
     * 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.
1969 1970 1971 1972 1973 1974 1975
     * 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.
1976
     * - encoding: unused
Diego Biurrun's avatar
Diego Biurrun committed
1977
     * - decoding: Set by user.
1978 1979 1980 1981
     * @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
1982
     */
1983
    void (*draw_horiz_band)(struct AVCodecContext *s,
1984
                            const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
1985
                            int y, int type, int height);
1986

1987
    /**
1988 1989 1990 1991
     * 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.
1992 1993 1994 1995
     * @note The callback may be called again immediately if initialization for
     * the selected (hardware-accelerated) pixel format failed.
     * @warning Behavior is undefined if the callback returns a value not
     * in the fmt list of formats.
1996 1997 1998
     * @return the chosen format
     * - encoding: unused
     * - decoding: Set by user, if not set the native format will be chosen.
1999
     */
2000
    enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
2001 2002

    /**
Diego Biurrun's avatar
Diego Biurrun committed
2003 2004 2005
     * 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.
2006
     * - decoding: unused
2007 2008 2009 2010
     */
    int max_b_frames;

    /**
Diego Biurrun's avatar
Diego Biurrun committed
2011
     * qscale factor between IP and B-frames
2012 2013
     * 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
2014
     * - encoding: Set by user.
2015
     * - decoding: unused
2016 2017
     */
    float b_quant_factor;
2018

2019 2020 2021
#if FF_API_RC_STRATEGY
    /** @deprecated use codec private option instead */
    attribute_deprecated int rc_strategy;
2022
#define FF_RC_STRATEGY_XVID 1
2023
#endif
2024

2025 2026 2027
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2028
    int b_frame_strategy;
2029
#endif
2030

2031
    /**
2032
     * qscale offset between IP and B-frames
Diego Biurrun's avatar
Diego Biurrun committed
2033
     * - encoding: Set by user.
2034
     * - decoding: unused
2035
     */
2036
    float b_quant_offset;
2037

2038
    /**
2039 2040
     * 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
2041
     * - encoding: Set by libavcodec.
2042
     * - decoding: Set by libavcodec.
2043
     */
2044
    int has_b_frames;
2045

2046 2047 2048
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2049
    int mpeg_quant;
2050
#endif
2051

2052
    /**
2053 2054
     * qscale factor between P- and I-frames
     * If > 0 then the last P-frame quantizer will be used (q = lastp_q * factor + offset).
2055
     * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
Diego Biurrun's avatar
Diego Biurrun committed
2056
     * - encoding: Set by user.
2057
     * - decoding: unused
2058
     */
2059
    float i_quant_factor;
2060

2061
    /**
2062 2063 2064
     * qscale offset between P and I-frames
     * - encoding: Set by user.
     * - decoding: unused
2065
     */
2066
    float i_quant_offset;
2067

2068
    /**
2069
     * luminance masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
2070
     * - encoding: Set by user.
2071
     * - decoding: unused
2072
     */
2073
    float lumi_masking;
2074

2075
    /**
2076
     * temporary complexity masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
2077
     * - encoding: Set by user.
2078
     * - decoding: unused
2079
     */
2080
    float temporal_cplx_masking;
2081

2082
    /**
2083
     * spatial complexity masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
2084
     * - encoding: Set by user.
2085
     * - decoding: unused
2086
     */
2087
    float spatial_cplx_masking;
2088

2089
    /**
2090
     * p block masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
2091
     * - encoding: Set by user.
2092
     * - decoding: unused
2093
     */
2094
    float p_masking;
2095

2096
    /**
2097
     * darkness masking (0-> disabled)
Diego Biurrun's avatar
Diego Biurrun committed
2098
     * - encoding: Set by user.
2099
     * - decoding: unused
2100
     */
2101
    float dark_masking;
2102

2103
    /**
2104 2105 2106
     * slice count
     * - encoding: Set by libavcodec.
     * - decoding: Set by user (or 0).
2107
     */
2108
    int slice_count;
2109 2110 2111 2112

#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2113 2114 2115 2116
     int prediction_method;
#define FF_PRED_LEFT   0
#define FF_PRED_PLANE  1
#define FF_PRED_MEDIAN 2
2117
#endif
2118 2119

    /**
2120 2121 2122
     * slice offsets in the frame in bytes
     * - encoding: Set/allocated by libavcodec.
     * - decoding: Set/allocated by user (or NULL).
2123
     */
2124
    int *slice_offset;
2125

2126
    /**
2127 2128 2129
     * 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
2130 2131
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
2132
     */
2133
    AVRational sample_aspect_ratio;
2134

2135
    /**
2136
     * motion estimation comparison function
Diego Biurrun's avatar
Diego Biurrun committed
2137
     * - encoding: Set by user.
2138
     * - decoding: unused
2139
     */
2140
    int me_cmp;
2141
    /**
2142
     * subpixel motion estimation comparison function
Diego Biurrun's avatar
Diego Biurrun committed
2143
     * - encoding: Set by user.
2144
     * - decoding: unused
2145
     */
2146
    int me_sub_cmp;
2147
    /**
2148
     * macroblock comparison function (not supported yet)
Diego Biurrun's avatar
Diego Biurrun committed
2149
     * - encoding: Set by user.
2150
     * - decoding: unused
2151
     */
2152
    int mb_cmp;
2153
    /**
2154
     * interlaced DCT comparison function
Diego Biurrun's avatar
Diego Biurrun committed
2155
     * - encoding: Set by user.
2156
     * - decoding: unused
2157
     */
2158
    int ildct_cmp;
2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175
#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_MEDIAN_SAD   15
#define FF_CMP_CHROMA       256
2176

2177
    /**
2178
     * ME diamond size & shape
Diego Biurrun's avatar
Diego Biurrun committed
2179
     * - encoding: Set by user.
2180
     * - decoding: unused
2181
     */
2182
    int dia_size;
2183

2184
    /**
2185
     * amount of previous MV predictors (2a+1 x 2a+1 square)
Diego Biurrun's avatar
Diego Biurrun committed
2186
     * - encoding: Set by user.
2187
     * - decoding: unused
2188
     */
2189
    int last_predictor_count;
2190

2191 2192 2193
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2194
    int pre_me;
2195
#endif
2196

2197
    /**
2198
     * motion estimation prepass comparison function
Diego Biurrun's avatar
Diego Biurrun committed
2199
     * - encoding: Set by user.
2200
     * - decoding: unused
2201
     */
2202
    int me_pre_cmp;
2203 2204

    /**
2205
     * ME prepass diamond size & shape
Diego Biurrun's avatar
Diego Biurrun committed
2206
     * - encoding: Set by user.
2207
     * - decoding: unused
2208
     */
2209
    int pre_dia_size;
2210

2211
    /**
2212
     * subpel ME quality
Diego Biurrun's avatar
Diego Biurrun committed
2213
     * - encoding: Set by user.
2214
     * - decoding: unused
2215
     */
2216
    int me_subpel_quality;
2217

2218
#if FF_API_AFD
2219
    /**
2220 2221 2222 2223 2224 2225
     * 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.
2226
     * @deprecated Deprecated in favor of AVSideData
2227
     */
2228
    attribute_deprecated int dtg_active_format;
2229 2230 2231 2232 2233 2234 2235
#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
2236
#endif /* FF_API_AFD */
2237

2238
    /**
2239 2240 2241
     * maximum motion estimation search range in subpel units
     * If 0 then no limit.
     *
Diego Biurrun's avatar
Diego Biurrun committed
2242
     * - encoding: Set by user.
2243
     * - decoding: unused
2244
     */
2245
    int me_range;
2246

2247
#if FF_API_QUANT_BIAS
2248
    /**
2249
     * @deprecated use encoder private option instead
2250
     */
2251
    attribute_deprecated int intra_quant_bias;
2252
#define FF_DEFAULT_QUANT_BIAS 999999
2253

2254
    /**
2255
     * @deprecated use encoder private option instead
2256
     */
2257 2258
    attribute_deprecated int inter_quant_bias;
#endif
2259

2260
    /**
2261 2262 2263
     * slice flags
     * - encoding: unused
     * - decoding: Set by user.
2264
     */
2265 2266
    int slice_flags;
#define SLICE_FLAG_CODED_ORDER    0x0001 ///< draw_horiz_band() is called in coded order instead of display
2267
#define SLICE_FLAG_ALLOW_FIELD    0x0002 ///< allow draw_horiz_band() with field slices (MPEG-2 field pics)
2268
#define SLICE_FLAG_ALLOW_PLANE    0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1)
2269

2270
#if FF_API_XVMC
2271
    /**
2272 2273 2274
     * XVideo Motion Acceleration
     * - encoding: forbidden
     * - decoding: set by decoder
2275
     * @deprecated XvMC doesn't need it anymore.
2276
     */
2277 2278
    attribute_deprecated int xvmc_acceleration;
#endif /* FF_API_XVMC */
2279

2280
    /**
2281
     * macroblock decision mode
Diego Biurrun's avatar
Diego Biurrun committed
2282
     * - encoding: Set by user.
2283
     * - decoding: unused
2284
     */
2285 2286 2287 2288
    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
2289

2290
    /**
2291 2292 2293
     * custom intra quantization matrix
     * - encoding: Set by user, can be NULL.
     * - decoding: Set by libavcodec.
2294
     */
2295
    uint16_t *intra_matrix;
2296

2297
    /**
2298 2299 2300
     * custom inter quantization matrix
     * - encoding: Set by user, can be NULL.
     * - decoding: Set by libavcodec.
2301
     */
2302
    uint16_t *inter_matrix;
2303

2304 2305 2306
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2307
    int scenechange_threshold;
2308

2309 2310
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2311
    int noise_reduction;
2312
#endif
2313

2314
#if FF_API_MPV_OPT
Michael Niedermayer's avatar
Michael Niedermayer committed
2315
    /**
2316
     * @deprecated this field is unused
Michael Niedermayer's avatar
Michael Niedermayer committed
2317
     */
2318
    attribute_deprecated
2319
    int me_threshold;
2320

2321
    /**
2322
     * @deprecated this field is unused
2323
     */
2324
    attribute_deprecated
2325
    int mb_threshold;
2326
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
2327 2328

    /**
2329
     * precision of the intra DC coefficient - 8
Diego Biurrun's avatar
Diego Biurrun committed
2330
     * - encoding: Set by user.
2331
     * - decoding: Set by libavcodec
Michael Niedermayer's avatar
Michael Niedermayer committed
2332
     */
2333
    int intra_dc_precision;
2334 2335

    /**
2336 2337
     * Number of macroblock rows at the top which are skipped.
     * - encoding: unused
Diego Biurrun's avatar
Diego Biurrun committed
2338
     * - decoding: Set by user.
2339
     */
2340
    int skip_top;
2341

2342
    /**
2343 2344
     * Number of macroblock rows at the bottom which are skipped.
     * - encoding: unused
Diego Biurrun's avatar
Diego Biurrun committed
2345
     * - decoding: Set by user.
2346
     */
2347
    int skip_bottom;
2348

2349
#if FF_API_MPV_OPT
2350
    /**
2351
     * @deprecated use encoder private options instead
2352
     */
2353
    attribute_deprecated
2354
    float border_masking;
2355
#endif
2356

Michael Niedermayer's avatar
Michael Niedermayer committed
2357
    /**
2358
     * minimum MB Lagrange multiplier
Diego Biurrun's avatar
Diego Biurrun committed
2359
     * - encoding: Set by user.
2360
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
2361
     */
2362
    int mb_lmin;
2363

Michael Niedermayer's avatar
Michael Niedermayer committed
2364
    /**
2365
     * maximum MB Lagrange multiplier
Diego Biurrun's avatar
Diego Biurrun committed
2366
     * - encoding: Set by user.
2367
     * - decoding: unused
Michael Niedermayer's avatar
Michael Niedermayer committed
2368
     */
2369
    int mb_lmax;
2370

2371
#if FF_API_PRIVATE_OPT
Michael Niedermayer's avatar
Michael Niedermayer committed
2372
    /**
2373
     * @deprecated use encoder private options instead
Michael Niedermayer's avatar
Michael Niedermayer committed
2374
     */
2375
    attribute_deprecated
2376
    int me_penalty_compensation;
2377
#endif
2378

2379
    /**
Diego Biurrun's avatar
Diego Biurrun committed
2380
     * - encoding: Set by user.
2381 2382
     * - decoding: unused
     */
2383
    int bidir_refine;
2384

2385 2386 2387
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2388
    int brd_scale;
2389
#endif
2390 2391

    /**
2392
     * minimum GOP size
Diego Biurrun's avatar
Diego Biurrun committed
2393
     * - encoding: Set by user.
2394
     * - decoding: unused
2395
     */
2396
    int keyint_min;
2397

2398
    /**
2399 2400 2401
     * number of reference frames
     * - encoding: Set by user.
     * - decoding: Set by lavc.
Michael Niedermayer's avatar
Michael Niedermayer committed
2402
     */
2403
    int refs;
2404

2405 2406 2407
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2408
    int chromaoffset;
2409
#endif
2410

2411
#if FF_API_UNUSED_MEMBERS
2412
    /**
2413
     * Multiplied by qscale for each frame and added to scene_change_score.
Diego Biurrun's avatar
Diego Biurrun committed
2414
     * - encoding: Set by user.
2415
     * - decoding: unused
2416
     */
2417 2418
    attribute_deprecated int scenechange_factor;
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
2419

2420
    /**
2421
     * Note: Value depends upon the compare function used for fullpel ME.
Diego Biurrun's avatar
Diego Biurrun committed
2422
     * - encoding: Set by user.
2423
     * - decoding: unused
2424
     */
2425
    int mv0_threshold;
2426

2427 2428 2429
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2430
    int b_sensitivity;
2431
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
2432

Michael Niedermayer's avatar
Michael Niedermayer committed
2433
    /**
2434 2435 2436
     * Chromaticity coordinates of the source primaries.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
Michael Niedermayer's avatar
Michael Niedermayer committed
2437
     */
2438
    enum AVColorPrimaries color_primaries;
2439 2440

    /**
2441 2442 2443
     * Color Transfer Characteristic.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
2444
     */
2445
    enum AVColorTransferCharacteristic color_trc;
2446

2447
    /**
2448 2449 2450
     * YUV colorspace type.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
2451
     */
2452
    enum AVColorSpace colorspace;
2453

2454
    /**
2455 2456 2457
     * MPEG vs JPEG YUV range.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
2458
     */
2459
    enum AVColorRange color_range;
2460 2461

    /**
2462 2463 2464
     * This defines the location of chroma samples.
     * - encoding: Set by user
     * - decoding: Set by libavcodec
2465
     */
2466
    enum AVChromaLocation chroma_sample_location;
2467

Michael Niedermayer's avatar
Michael Niedermayer committed
2468
    /**
2469 2470 2471 2472
     * Number of slices.
     * Indicates number of picture subdivisions. Used for parallelized
     * decoding.
     * - encoding: Set by user
Michael Niedermayer's avatar
Michael Niedermayer committed
2473 2474
     * - decoding: unused
     */
2475
    int slices;
2476

2477 2478
    /** Field order
     * - encoding: set by libavcodec
2479
     * - decoding: Set by user.
Michael Niedermayer's avatar
Michael Niedermayer committed
2480
     */
2481 2482 2483 2484 2485
    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
2486 2487

    /**
2488
     * audio sample format
Diego Biurrun's avatar
Diego Biurrun committed
2489
     * - encoding: Set by user.
2490
     * - decoding: Set by libavcodec.
Michael Niedermayer's avatar
Michael Niedermayer committed
2491
     */
2492
    enum AVSampleFormat sample_fmt;  ///< sample format
2493

2494
    /* The following data should not be initialized. */
2495
    /**
2496 2497 2498 2499
     * 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.
2500
     *   May be 0 when the codec has AV_CODEC_CAP_VARIABLE_FRAME_SIZE set, then the
2501 2502
     *   frame size is not restricted.
     * - decoding: may be set by some decoders to indicate constant frame size
2503
     */
2504
    int frame_size;
2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515

    /**
     * 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;
2516

Ivan Kalvachev's avatar
Ivan Kalvachev committed
2517
    /**
2518 2519
     * 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
2520
     */
2521
    int block_align;
2522

2523
    /**
2524
     * Audio cutoff bandwidth (0 means "automatic")
Diego Biurrun's avatar
Diego Biurrun committed
2525
     * - encoding: Set by user.
2526 2527
     * - decoding: unused
     */
2528
    int cutoff;
2529 2530

    /**
2531 2532
     * Audio channel layout.
     * - encoding: set by user.
2533
     * - decoding: set by user, may be overwritten by libavcodec.
2534
     */
2535
    uint64_t channel_layout;
2536

2537
    /**
2538
     * Request decoder to use this channel layout if it can (0 for default)
2539
     * - encoding: unused
2540
     * - decoding: Set by user.
2541
     */
2542
    uint64_t request_channel_layout;
2543 2544

    /**
2545
     * Type of service that the audio stream conveys.
Diego Biurrun's avatar
Diego Biurrun committed
2546
     * - encoding: Set by user.
2547
     * - decoding: Set by libavcodec.
2548
     */
2549
    enum AVAudioServiceType audio_service_type;
2550 2551

    /**
2552 2553
     * desired sample format
     * - encoding: Not used.
2554
     * - decoding: Set by user.
2555
     * Decoder will decode to this format if it can.
2556
     */
2557
    enum AVSampleFormat request_sample_fmt;
2558

2559 2560 2561
    /**
     * 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
2562 2563 2564 2565
     * 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).
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
     *
     * 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().
2585
     *   * otherwise extended_data must point to data
2586 2587 2588 2589 2590
     * - 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().
2591 2592 2593 2594 2595
     * - 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().
     *
2596
     * If AV_CODEC_CAP_DR1 is not set then get_buffer2() must call
2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612
     * 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.
     *
2613 2614
     * Some decoders do not support linesizes changing between frames.
     *
2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648
     * 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.
     *
2649 2650
     * This is always automatically enabled if avcodec_receive_frame() is used.
     *
2651 2652 2653 2654
     * - encoding: unused
     * - decoding: set by the caller before avcodec_open2().
     */
    int refcounted_frames;
2655

2656 2657 2658
    /* - 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)
2659 2660

    /**
2661
     * minimum quantizer
Diego Biurrun's avatar
Diego Biurrun committed
2662
     * - encoding: Set by user.
2663 2664
     * - decoding: unused
     */
2665
    int qmin;
2666 2667

    /**
2668
     * maximum quantizer
Diego Biurrun's avatar
Diego Biurrun committed
2669
     * - encoding: Set by user.
2670 2671
     * - decoding: unused
     */
2672
    int qmax;
2673 2674

    /**
2675
     * maximum quantizer difference between frames
Diego Biurrun's avatar
Diego Biurrun committed
2676
     * - encoding: Set by user.
2677
     * - decoding: unused
2678
     */
2679
    int max_qdiff;
2680

2681
#if FF_API_MPV_OPT
2682
    /**
2683
     * @deprecated use encoder private options instead
2684
     */
2685
    attribute_deprecated
2686
    float rc_qsquish;
2687

2688
    attribute_deprecated
2689
    float rc_qmod_amp;
2690
    attribute_deprecated
2691
    int rc_qmod_freq;
2692
#endif
2693

2694
    /**
2695
     * decoder bitstream buffer size
Diego Biurrun's avatar
Diego Biurrun committed
2696
     * - encoding: Set by user.
2697 2698
     * - decoding: unused
     */
2699
    int rc_buffer_size;
2700 2701

    /**
2702 2703
     * ratecontrol override, see RcOverride
     * - encoding: Allocated/set/freed by user.
2704
     * - decoding: unused
2705
     */
2706 2707
    int rc_override_count;
    RcOverride *rc_override;
2708

2709
#if FF_API_MPV_OPT
2710
    /**
2711
     * @deprecated use encoder private options instead
2712
     */
2713
    attribute_deprecated
2714
    const char *rc_eq;
2715
#endif
2716 2717

    /**
2718
     * maximum bitrate
Diego Biurrun's avatar
Diego Biurrun committed
2719
     * - encoding: Set by user.
2720
     * - decoding: Set by user, may be overwritten by libavcodec.
2721
     */
2722
    int64_t rc_max_rate;
2723 2724

    /**
2725
     * minimum bitrate
Diego Biurrun's avatar
Diego Biurrun committed
2726
     * - encoding: Set by user.
2727 2728
     * - decoding: unused
     */
2729
    int64_t rc_min_rate;
2730

2731
#if FF_API_MPV_OPT
2732
    /**
2733
     * @deprecated use encoder private options instead
2734
     */
2735 2736 2737 2738
    attribute_deprecated
    float rc_buffer_aggressivity;

    attribute_deprecated
2739
    float rc_initial_cplx;
2740
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
2741 2742

    /**
2743
     * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow.
Diego Biurrun's avatar
Diego Biurrun committed
2744
     * - encoding: Set by user.
2745
     * - decoding: unused.
Michael Niedermayer's avatar
Michael Niedermayer committed
2746
     */
2747
    float rc_max_available_vbv_use;
2748 2749

    /**
2750
     * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow.
Diego Biurrun's avatar
Diego Biurrun committed
2751
     * - encoding: Set by user.
2752
     * - decoding: unused.
2753
     */
2754
    float rc_min_vbv_overflow_use;
2755 2756

    /**
2757
     * Number of bits which should be loaded into the rc buffer before decoding starts.
Diego Biurrun's avatar
Diego Biurrun committed
2758
     * - encoding: Set by user.
Michael Niedermayer's avatar
Michael Niedermayer committed
2759
     * - decoding: unused
2760
     */
2761
    int rc_initial_buffer_occupancy;
2762

2763
#if FF_API_CODER_TYPE
2764 2765 2766 2767
#define FF_CODER_TYPE_VLC       0
#define FF_CODER_TYPE_AC        1
#define FF_CODER_TYPE_RAW       2
#define FF_CODER_TYPE_RLE       3
2768
#if FF_API_UNUSED_MEMBERS
2769
#define FF_CODER_TYPE_DEFLATE   4
2770
#endif /* FF_API_UNUSED_MEMBERS */
2771
    /**
2772
     * @deprecated use encoder private options instead
2773
     */
2774
    attribute_deprecated
2775
    int coder_type;
2776
#endif /* FF_API_CODER_TYPE */
2777

2778 2779 2780
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2781
    int context_model;
2782
#endif
2783

2784
#if FF_API_MPV_OPT
2785
    /**
2786
     * @deprecated use encoder private options instead
2787
     */
2788
    attribute_deprecated
2789
    int lmin;
2790 2791

    /**
2792
     * @deprecated use encoder private options instead
2793
     */
2794
    attribute_deprecated
2795
    int lmax;
2796
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
2797

2798 2799 2800
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
Michael Niedermayer's avatar
Michael Niedermayer committed
2801 2802
    int frame_skip_threshold;

2803 2804
    /** @deprecated use encoder private options instead */
    attribute_deprecated
Michael Niedermayer's avatar
Michael Niedermayer committed
2805
    int frame_skip_factor;
2806

2807 2808
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2809 2810
    int frame_skip_exp;

2811 2812
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2813
    int frame_skip_cmp;
2814
#endif /* FF_API_PRIVATE_OPT */
2815 2816

    /**
2817
     * trellis RD quantization
Diego Biurrun's avatar
Diego Biurrun committed
2818
     * - encoding: Set by user.
2819 2820
     * - decoding: unused
     */
2821
    int trellis;
2822

2823 2824 2825
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2826
    int min_prediction_order;
2827

2828 2829
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2830
    int max_prediction_order;
2831

2832 2833
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2834
    int64_t timecode_frame_start;
2835
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
2836

2837 2838 2839 2840
#if FF_API_RTP_CALLBACK
    /**
     * @deprecated unused
     */
2841 2842 2843 2844 2845 2846
    /* 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.                  */
2847
    attribute_deprecated
2848
    void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
2849
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
2850

2851 2852 2853
#if FF_API_PRIVATE_OPT
    /** @deprecated use encoder private options instead */
    attribute_deprecated
2854 2855 2856 2857 2858 2859
    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.  */
2860
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
2861

2862
#if FF_API_STAT_BITS
2863
    /* statistics, used for 2-pass encoding */
2864
    attribute_deprecated
2865
    int mv_bits;
2866
    attribute_deprecated
2867
    int header_bits;
2868
    attribute_deprecated
2869
    int i_tex_bits;
2870
    attribute_deprecated
2871
    int p_tex_bits;
2872
    attribute_deprecated
2873
    int i_count;
2874
    attribute_deprecated
2875
    int p_count;
2876
    attribute_deprecated
2877
    int skip_count;
2878
    attribute_deprecated
2879
    int misc_bits;
2880

2881 2882
    /** @deprecated this field is unused */
    attribute_deprecated
2883
    int frame_bits;
2884
#endif
2885 2886

    /**
2887 2888
     * pass1 encoding statistics output buffer
     * - encoding: Set by libavcodec.
2889 2890
     * - decoding: unused
     */
2891
    char *stats_out;
Robert Swain's avatar
Robert Swain committed
2892 2893

    /**
2894 2895 2896
     * 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
2897 2898
     * - decoding: unused
     */
2899
    char *stats_in;
Robert Swain's avatar
Robert Swain committed
2900 2901

    /**
2902 2903 2904
     * 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
2905
     */
2906 2907
    int workaround_bugs;
#define FF_BUG_AUTODETECT       1  ///< autodetection
2908
#if FF_API_OLD_MSMPEG4
2909
#define FF_BUG_OLD_MSMPEG4      2
2910
#endif
2911 2912 2913 2914
#define FF_BUG_XVID_ILACE       4
#define FF_BUG_UMP4             8
#define FF_BUG_NO_PADDING       16
#define FF_BUG_AMV              32
2915
#if FF_API_AC_VLC
2916
#define FF_BUG_AC_VLC           0  ///< Will be removed, libavcodec can now handle these non-compliant files by default.
2917
#endif
2918 2919 2920 2921 2922 2923 2924 2925 2926
#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
2927
#define FF_BUG_IEDGE           32768
Robert Swain's avatar
Robert Swain committed
2928 2929

    /**
2930
     * strictly follow the standard (MPEG-4, ...).
Diego Biurrun's avatar
Diego Biurrun committed
2931
     * - encoding: Set by user.
2932 2933 2934 2935 2936 2937 2938 2939
     * - 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
2940
     */
2941 2942 2943 2944 2945 2946
    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
2947 2948

    /**
2949 2950 2951
     * error concealment flags
     * - encoding: unused
     * - decoding: Set by user.
Robert Swain's avatar
Robert Swain committed
2952
     */
2953 2954 2955
    int error_concealment;
#define FF_EC_GUESS_MVS   1
#define FF_EC_DEBLOCK     2
2956
#define FF_EC_FAVOR_INTER 256
Robert Swain's avatar
Robert Swain committed
2957

2958
    /**
2959
     * debug
Diego Biurrun's avatar
Diego Biurrun committed
2960
     * - encoding: Set by user.
2961
     * - decoding: Set by user.
2962
     */
2963 2964 2965 2966 2967 2968
    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
2969 2970 2971 2972
#if FF_API_DEBUG_MV
/**
 * @deprecated this option does nothing
 */
2973
#define FF_DEBUG_MV          32
2974
#endif
2975 2976 2977
#define FF_DEBUG_DCT_COEFF   0x00000040
#define FF_DEBUG_SKIP        0x00000080
#define FF_DEBUG_STARTCODE   0x00000100
2978
#if FF_API_UNUSED_MEMBERS
2979
#define FF_DEBUG_PTS         0x00000200
2980
#endif /* FF_API_UNUSED_MEMBERS */
2981 2982 2983
#define FF_DEBUG_ER          0x00000400
#define FF_DEBUG_MMCO        0x00000800
#define FF_DEBUG_BUGS        0x00001000
2984
#if FF_API_DEBUG_MV
2985 2986
#define FF_DEBUG_VIS_QP      0x00002000
#define FF_DEBUG_VIS_MB_TYPE 0x00004000
2987
#endif
2988 2989
#define FF_DEBUG_BUFFERS     0x00008000
#define FF_DEBUG_THREADS     0x00010000
2990
#define FF_DEBUG_GREEN_MD    0x00800000
2991
#define FF_DEBUG_NOMC        0x01000000
2992

2993
#if FF_API_DEBUG_MV
2994
    /**
2995
     * debug
Diego Biurrun's avatar
Diego Biurrun committed
2996
     * - encoding: Set by user.
2997
     * - decoding: Set by user.
2998
     */
2999
    int debug_mv;
3000 3001 3002
#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
3003
#endif
3004 3005

    /**
3006
     * Error recognition; may misdetect some more or less valid parts as errors.
3007 3008
     * - encoding: unused
     * - decoding: Set by user.
3009
     */
3010
    int err_recognition;
3011 3012 3013 3014 3015 3016 3017

/**
 * 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.
 */
3018
#define AV_EF_CRCCHECK  (1<<0)
3019 3020 3021 3022
#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

3023
#define AV_EF_IGNORE_ERR (1<<15)        ///< ignore errors and continue
3024
#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
3025
#define AV_EF_COMPLIANT  (1<<17)        ///< consider all spec non compliances as errors
3026
#define AV_EF_AGGRESSIVE (1<<18)        ///< consider things that a sane encoder should not do as an error
3027

3028 3029

    /**
3030
     * opaque 64-bit number (generally a PTS) that will be reordered and
3031 3032 3033
     * output in AVFrame.reordered_opaque
     * - encoding: unused
     * - decoding: Set by user.
3034
     */
3035
    int64_t reordered_opaque;
3036 3037

    /**
3038 3039 3040
     * Hardware accelerator in use
     * - encoding: unused.
     * - decoding: Set by libavcodec
3041
     */
3042
    struct AVHWAccel *hwaccel;
3043 3044

    /**
3045 3046 3047
     * Hardware accelerator context.
     * For some hardware accelerators, a global context needs to be
     * provided by the user. In that case, this holds display-dependent
3048 3049
     * data FFmpeg cannot instantiate itself. Please refer to the
     * FFmpeg HW accelerator documentation to know how to fill this
3050 3051 3052
     * is. e.g. for VA API, this is a struct vaapi_context.
     * - encoding: unused
     * - decoding: Set by user
3053
     */
3054
    void *hwaccel_context;
3055 3056

    /**
3057
     * error
3058
     * - encoding: Set by libavcodec if flags & AV_CODEC_FLAG_PSNR.
Diego Biurrun's avatar
Diego Biurrun committed
3059
     * - decoding: unused
3060
     */
3061
    uint64_t error[AV_NUM_DATA_POINTERS];
3062 3063

    /**
3064
     * DCT algorithm, see FF_DCT_* below
Diego Biurrun's avatar
Diego Biurrun committed
3065 3066
     * - encoding: Set by user.
     * - decoding: unused
3067
     */
3068 3069 3070 3071 3072 3073 3074
    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
3075

3076
    /**
3077
     * IDCT algorithm, see FF_IDCT_* below.
3078
     * - encoding: Set by user.
3079
     * - decoding: Set by user.
3080
     */
3081 3082 3083 3084 3085 3086 3087
    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
3088
#if FF_API_ARCH_SH4
3089
#define FF_IDCT_SH4           9
3090
#endif
3091
#define FF_IDCT_SIMPLEARM     10
3092
#if FF_API_UNUSED_MEMBERS
3093
#define FF_IDCT_IPP           13
3094
#endif /* FF_API_UNUSED_MEMBERS */
3095 3096
#define FF_IDCT_XVID          14
#if FF_API_IDCT_XVIDMMX
3097
#define FF_IDCT_XVIDMMX       14
3098
#endif /* FF_API_IDCT_XVIDMMX */
3099 3100
#define FF_IDCT_SIMPLEARMV5TE 16
#define FF_IDCT_SIMPLEARMV6   17
3101
#if FF_API_ARCH_SPARC
3102
#define FF_IDCT_SIMPLEVIS     18
3103
#endif
3104 3105
#define FF_IDCT_FAAN          20
#define FF_IDCT_SIMPLENEON    22
3106
#if FF_API_ARCH_ALPHA
3107
#define FF_IDCT_SIMPLEALPHA   23
3108
#endif
3109
#define FF_IDCT_SIMPLEAUTO    128
3110

3111
    /**
3112 3113
     * bits per sample/pixel from the demuxer (needed for huffyuv).
     * - encoding: Set by libavcodec.
3114 3115
     * - decoding: Set by user.
     */
3116
     int bits_per_coded_sample;
3117 3118 3119 3120 3121 3122 3123

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

3125
#if FF_API_LOWRES
3126
    /**
3127
     * low resolution decoding, 1-> 1/2 size, 2->1/4 size
3128 3129 3130
     * - encoding: unused
     * - decoding: Set by user.
     */
Michael Niedermayer's avatar
Michael Niedermayer committed
3131
     int lowres;
3132
#endif
3133

3134
#if FF_API_CODED_FRAME
3135
    /**
3136 3137
     * the picture in the bitstream
     * - encoding: Set by libavcodec.
3138
     * - decoding: unused
3139 3140
     *
     * @deprecated use the quality factor packet side data instead
3141
     */
3142 3143
    attribute_deprecated AVFrame *coded_frame;
#endif
3144 3145

    /**
3146 3147
     * thread count
     * is used to decide how many independent tasks should be passed to execute()
3148
     * - encoding: Set by user.
3149
     * - decoding: Set by user.
3150
     */
3151
    int thread_count;
3152 3153

    /**
3154 3155 3156
     * 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.
3157
     *
3158 3159
     * - encoding: Set by user, otherwise the default is used.
     * - decoding: Set by user, otherwise the default is used.
3160
     */
3161 3162 3163
    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
3164 3165

    /**
3166 3167 3168
     * Which multithreading methods are in use by the codec.
     * - encoding: Set by libavcodec.
     * - decoding: Set by libavcodec.
3169
     */
3170
    int active_thread_type;
3171 3172

    /**
3173
     * Set by the client if its custom get_buffer() callback can be called
3174
     * synchronously from another thread, which allows faster multithreaded decoding.
3175 3176 3177 3178
     * 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.
3179
     */
3180
    int thread_safe_callbacks;
3181 3182

    /**
3183 3184 3185 3186 3187 3188 3189
     * 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.
3190
     */
3191
    int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211

    /**
     * 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);
3212

3213
    /**
3214
     * noise vs. sse weight for the nsse comparison function
3215
     * - encoding: Set by user.
3216 3217
     * - decoding: unused
     */
3218
     int nsse_weight;
3219 3220

    /**
3221 3222 3223
     * profile
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
3224
     */
3225 3226 3227 3228 3229 3230 3231 3232
     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
3233 3234 3235 3236
#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
3237 3238
#define FF_PROFILE_MPEG2_AAC_LOW 128
#define FF_PROFILE_MPEG2_AAC_HE  131
3239

3240 3241 3242 3243 3244 3245 3246
#define FF_PROFILE_DNXHD         0
#define FF_PROFILE_DNXHR_LB      1
#define FF_PROFILE_DNXHR_SQ      2
#define FF_PROFILE_DNXHR_HQ      3
#define FF_PROFILE_DNXHR_HQX     4
#define FF_PROFILE_DNXHR_444     5

3247 3248 3249 3250 3251
#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
3252
#define FF_PROFILE_DTS_EXPRESS 70
3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270

#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)
3271
#define FF_PROFILE_H264_MULTIVIEW_HIGH       118
3272 3273
#define FF_PROFILE_H264_HIGH_422             122
#define FF_PROFILE_H264_HIGH_422_INTRA       (122|FF_PROFILE_H264_INTRA)
3274
#define FF_PROFILE_H264_STEREO_HIGH          128
3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300
#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
3301

3302 3303 3304
#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0   1
#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1   2
#define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION  32768
3305 3306 3307
#define FF_PROFILE_JPEG2000_DCINEMA_2K              3
#define FF_PROFILE_JPEG2000_DCINEMA_4K              4

3308 3309 3310 3311
#define FF_PROFILE_VP9_0                            0
#define FF_PROFILE_VP9_1                            1
#define FF_PROFILE_VP9_2                            2
#define FF_PROFILE_VP9_3                            3
gcocherel's avatar
gcocherel committed
3312 3313 3314 3315

#define FF_PROFILE_HEVC_MAIN                        1
#define FF_PROFILE_HEVC_MAIN_10                     2
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE          3
3316
#define FF_PROFILE_HEVC_REXT                        4
gcocherel's avatar
gcocherel committed
3317

3318
    /**
3319 3320 3321
     * level
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
3322
     */
3323 3324
     int level;
#define FF_LEVEL_UNKNOWN -99
3325

3326
    /**
3327
     * Skip loop filtering for selected frames.
3328 3329
     * - encoding: unused
     * - decoding: Set by user.
3330
     */
3331
    enum AVDiscard skip_loop_filter;
3332 3333

    /**
3334
     * Skip IDCT/dequantization for selected frames.
3335 3336
     * - encoding: unused
     * - decoding: Set by user.
3337
     */
3338
    enum AVDiscard skip_idct;
3339 3340

    /**
3341
     * Skip decoding for selected frames.
3342
     * - encoding: unused
3343 3344
     * - decoding: Set by user.
     */
3345
    enum AVDiscard skip_frame;
3346

3347
    /**
3348 3349 3350 3351 3352 3353
     * 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())
3354
     */
3355 3356
    uint8_t *subtitle_header;
    int subtitle_header_size;
3357

3358
#if FF_API_ERROR_RATE
3359
    /**
3360 3361
     * @deprecated use the 'error_rate' private AVOption of the mpegvideo
     * encoders
3362
     */
3363
    attribute_deprecated
3364
    int error_rate;
3365
#endif
3366

3367
#if FF_API_VBV_DELAY
3368
    /**
3369 3370 3371 3372
     * 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.
3373 3374
     * @deprecated this value is now exported as a part of
     * AV_PKT_DATA_CPB_PROPERTIES packet side data
3375
     */
3376
    attribute_deprecated
3377
    uint64_t vbv_delay;
3378
#endif
3379

3380
#if FF_API_SIDEDATA_ONLY_PKT
3381
    /**
3382 3383
     * Encoding only and set by default. Allow encoders to output packets
     * that do not contain any encoded data, only side data.
3384 3385 3386 3387
     *
     * Some encoders need to output such packets, e.g. to update some stream
     * parameters at the end of encoding.
     *
3388 3389
     * @deprecated this field disables the default behaviour and
     *             it is kept only for compatibility.
3390
     */
3391
    attribute_deprecated
3392
    int side_data_only_packets;
3393
#endif
3394

3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410
    /**
     * Audio only. The number of "priming" samples (padding) inserted by the
     * encoder at the beginning of the audio. I.e. this number of leading
     * decoded samples must be discarded by the caller to get the original audio
     * without leading padding.
     *
     * - decoding: unused
     * - encoding: Set by libavcodec. 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
     *             -initial_padding.
     */
    int initial_padding;
3411

3412
    /**
3413 3414 3415
     * - decoding: For codecs that store a framerate value in the compressed
     *             bitstream, the decoder may export it here. { 0, 1} when
     *             unknown.
3416 3417
     * - encoding: May be used to signal the framerate of CFR content to an
     *             encoder.
3418 3419
     */
    AVRational framerate;
3420

3421 3422 3423 3424 3425 3426
    /**
     * Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
     * - encoding: unused.
     * - decoding: Set by libavcodec before calling get_format()
     */
    enum AVPixelFormat sw_pix_fmt;
3427

3428 3429 3430
    /**
     * Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
     * - encoding unused.
3431
     * - decoding set by user.
3432 3433 3434
     */
    AVRational pkt_timebase;

3435 3436 3437 3438 3439
    /**
     * AVCodecDescriptor
     * - encoding: unused.
     * - decoding: set by libavcodec.
     */
3440
    const AVCodecDescriptor *codec_descriptor;
3441

3442 3443 3444 3445 3446 3447 3448 3449 3450
#if !FF_API_LOWRES
    /**
     * low resolution decoding, 1-> 1/2 size, 2->1/4 size
     * - encoding: unused
     * - decoding: Set by user.
     */
     int lowres;
#endif

3451 3452
    /**
     * Current statistics for PTS correction.
3453
     * - decoding: maintained and used by libavcodec, not intended to be used by user apps
3454 3455 3456 3457 3458 3459
     * - 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
3460

3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477
    /**
     * 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
3478

3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491
    /**
     * 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).
     *
     * - decoding: set by user
     * - encoding: unused
     */
    int skip_alpha;
3492 3493 3494 3495 3496 3497 3498

    /**
     * Number of samples to skip after a discontinuity
     * - decoding: unused
     * - encoding: set by libavcodec
     */
    int seek_preroll;
3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510

#if !FF_API_DEBUG_MV
    /**
     * debug motion vectors
     * - 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
3511 3512 3513 3514 3515 3516 3517

    /**
     * custom intra quantization matrix
     * - encoding: Set by user, can be NULL.
     * - decoding: unused.
     */
    uint16_t *chroma_intra_matrix;
3518 3519

    /**
Michael Niedermayer's avatar
Michael Niedermayer committed
3520
     * dump format separator.
3521 3522 3523 3524 3525 3526
     * can be ", " or "\n      " or anything else
     * - encoding: Set by user.
     * - decoding: Set by user.
     */
    uint8_t *dump_separator;

3527
    /**
3528
     * ',' separated list of allowed decoders.
3529 3530
     * If NULL then all are allowed
     * - encoding: unused
3531
     * - decoding: set by user
3532 3533
     */
    char *codec_whitelist;
3534 3535 3536 3537 3538 3539 3540 3541 3542

    /*
     * Properties of the stream that gets decoded
     * - encoding: unused
     * - decoding: set by libavcodec
     */
    unsigned properties;
#define FF_CODEC_PROPERTY_LOSSLESS        0x00000001
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002
3543

3544 3545 3546 3547 3548 3549 3550 3551 3552
    /**
     * Additional data associated with the entire coded stream.
     *
     * - decoding: unused
     * - encoding: may be set by libavcodec after avcodec_open2().
     */
    AVPacketSideData *coded_side_data;
    int            nb_coded_side_data;

3553
    /**
3554 3555
     * A reference to the AVHWFramesContext describing the input (for encoding)
     * or output (decoding) frames. The reference is set by the caller and
3556 3557
     * afterwards owned (and freed) by libavcodec - it should never be read by
     * the caller after being set.
3558
     *
3559 3560 3561
     * - decoding: This field should be set by the caller from the get_format()
     *             callback. The previous reference (if any) will always be
     *             unreffed by libavcodec before the get_format() call.
3562
     *
3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573
     *             If the default get_buffer2() is used with a hwaccel pixel
     *             format, then this AVHWFramesContext will be used for
     *             allocating the frame buffers.
     *
     * - encoding: For hardware encoders configured to use a hwaccel pixel
     *             format, this field should be set by the caller to a reference
     *             to the AVHWFramesContext describing input frames.
     *             AVHWFramesContext.format must be equal to
     *             AVCodecContext.pix_fmt.
     *
     *             This field should be set before avcodec_open2() is called.
3574 3575
     */
    AVBufferRef *hw_frames_ctx;
3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587

    /**
     * Control the form of AVSubtitle.rects[N]->ass
     * - decoding: set by user
     * - encoding: unused
     */
    int sub_text_format;
#define FF_SUB_TEXT_FMT_ASS              0
#if FF_API_ASS_TIMING
#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS 1
#endif

3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598
    /**
     * Audio only. The amount of padding (in samples) appended by the encoder to
     * the end of the audio. I.e. this number of decoded samples must be
     * discarded by the caller from the end of the stream to get the original
     * audio without any trailing padding.
     *
     * - decoding: unused
     * - encoding: unused
     */
    int trailing_padding;

3599 3600 3601 3602 3603 3604 3605 3606
    /**
     * The number of pixels per image to maximally accept.
     *
     * - decoding: set by user
     * - encoding: set by user
     */
    int64_t max_pixels;

3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627
    /**
     * A reference to the AVHWDeviceContext describing the device which will
     * be used by a hardware encoder/decoder.  The reference is set by the
     * caller and afterwards owned (and freed) by libavcodec.
     *
     * This should be used if either the codec device does not require
     * hardware frames or any that are used are to be allocated internally by
     * libavcodec.  If the user wishes to supply any of the frames used as
     * encoder input or decoder output then hw_frames_ctx should be used
     * instead.  When hw_frames_ctx is set in get_format() for a decoder, this
     * field will be ignored while decoding the associated stream segment, but
     * may again be used on a following one after another get_format() call.
     *
     * For both encoders and decoders this field should be set before
     * avcodec_open2() is called and must not be written to thereafter.
     *
     * Note that some decoders may require this field to be set initially in
     * order to support hw_frames_ctx at all - in that case, all frames
     * contexts used must be created on the same device.
     */
    AVBufferRef *hw_device_ctx;
3628 3629 3630 3631 3632 3633 3634 3635 3636

    /**
     * Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated
     * decoding (if active).
     * - encoding: unused
     * - decoding: Set by user (either before avcodec_open2(), or in the
     *             AVCodecContext.get_format callback)
     */
    int hwaccel_flags;
Fabrice Bellard's avatar
Fabrice Bellard committed
3637 3638
} AVCodecContext;

3639 3640 3641
AVRational av_codec_get_pkt_timebase         (const AVCodecContext *avctx);
void       av_codec_set_pkt_timebase         (AVCodecContext *avctx, AVRational val);

3642 3643
const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx);
void                     av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc);
3644

3645 3646
unsigned av_codec_get_codec_properties(const AVCodecContext *avctx);

3647 3648 3649
int  av_codec_get_lowres(const AVCodecContext *avctx);
void av_codec_set_lowres(AVCodecContext *avctx, int val);

3650 3651 3652
int  av_codec_get_seek_preroll(const AVCodecContext *avctx);
void av_codec_set_seek_preroll(AVCodecContext *avctx, int val);

3653 3654 3655
uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx);
void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val);

3656 3657 3658 3659 3660 3661 3662 3663
/**
 * AVProfile.
 */
typedef struct AVProfile {
    int profile;
    const char *name; ///< short name for the profile
} AVProfile;

3664 3665
typedef struct AVCodecDefault AVCodecDefault;

3666 3667
struct AVSubtitle;

3668 3669 3670
/**
 * AVCodec.
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
3671
typedef struct AVCodec {
3672 3673 3674 3675 3676 3677
    /**
     * 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.
     */
3678
    const char *name;
3679 3680 3681 3682 3683
    /**
     * 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;
3684
    enum AVMediaType type;
3685
    enum AVCodecID id;
3686 3687
    /**
     * Codec capabilities.
3688
     * see AV_CODEC_CAP_*
3689
     */
3690
    int capabilities;
3691
    const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
3692
    const enum AVPixelFormat *pix_fmts;     ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
3693
    const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
3694
    const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
3695
    const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
3696
    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder
3697
    const AVClass *priv_class;              ///< AVClass for the private context
3698
    const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
3699

3700 3701 3702 3703 3704 3705 3706 3707 3708
    /*****************************************************************
     * 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;
3709
    /**
3710
     * @name Frame-level threading support functions
3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
     * @{
     */
    /**
     * 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);
    /** @} */
3728 3729 3730 3731 3732

    /**
     * Private codec-specific defaults.
     */
    const AVCodecDefault *defaults;
3733 3734 3735 3736 3737

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

3739
    int (*init)(AVCodecContext *);
3740 3741
    int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
                      const struct AVSubtitle *sub);
3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753
    /**
     * 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);
3754 3755
    int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
    int (*close)(AVCodecContext *);
3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770
    /**
     * Decode/encode API with decoupled packet/frame dataflow. The API is the
     * same as the avcodec_ prefixed APIs (avcodec_send_frame() etc.), except
     * that:
     * - never called if the codec is closed or the wrong type,
     * - AVPacket parameter change side data is applied right before calling
     *   AVCodec->send_packet,
     * - if AV_CODEC_CAP_DELAY is not set, drain packets or frames are never sent,
     * - only one drain packet is ever passed down (until the next flush()),
     * - a drain AVPacket is always NULL (no need to check for avpkt->size).
     */
    int (*send_frame)(AVCodecContext *avctx, const AVFrame *frame);
    int (*send_packet)(AVCodecContext *avctx, const AVPacket *avpkt);
    int (*receive_frame)(AVCodecContext *avctx, AVFrame *frame);
    int (*receive_packet)(AVCodecContext *avctx, AVPacket *avpkt);
3771 3772 3773 3774 3775
    /**
     * Flush buffers.
     * Will be called when seeking
     */
    void (*flush)(AVCodecContext *);
3776 3777 3778 3779 3780
    /**
     * Internal codec capabilities.
     * See FF_CODEC_CAP_* in internal.h
     */
    int caps_internal;
Fabrice Bellard's avatar
Fabrice Bellard committed
3781 3782
} AVCodec;

3783 3784
int av_codec_get_max_lowres(const AVCodec *codec);

3785 3786
struct MpegEncContext;

3787
/**
3788 3789
 * @defgroup lavc_hwaccel AVHWAccel
 * @{
3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801
 */
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.
     *
3802
     * See AVMEDIA_TYPE_xxx
3803
     */
3804
    enum AVMediaType type;
3805 3806 3807 3808

    /**
     * Codec implemented by the hardware accelerator.
     *
3809
     * See AV_CODEC_ID_xxx
3810
     */
3811
    enum AVCodecID id;
3812 3813 3814 3815 3816 3817

    /**
     * Supported pixel format.
     *
     * Only hardware accelerated formats are supported here.
     */
3818
    enum AVPixelFormat pix_fmt;
3819 3820 3821

    /**
     * Hardware accelerated codec capabilities.
3822
     * see HWACCEL_CODEC_CAP_*
3823 3824 3825
     */
    int capabilities;

3826 3827 3828 3829 3830 3831 3832
    /*****************************************************************
     * 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.
     *****************************************************************
     */
3833 3834
    struct AVHWAccel *next;

3835 3836 3837 3838 3839
    /**
     * Allocate a custom buffer
     */
    int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);

3840 3841 3842 3843 3844 3845
    /**
     * 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.
     *
3846
     * Note that buf can be NULL along with buf_size set to 0.
3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860
     * 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.
3861
     * The only exception is XvMC, that works on MB level.
3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879
     *
     * @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);
3880 3881

    /**
3882
     * Size of per-frame hardware accelerator private data.
3883
     *
3884 3885 3886
     * Private data is allocated with av_mallocz() before
     * AVCodecContext.get_buffer() and deallocated after
     * AVCodecContext.release_buffer().
3887
     */
3888
    int frame_priv_data_size;
3889 3890 3891 3892

    /**
     * Called for every Macroblock in a slice.
     *
3893
     * XvMC uses it to replace the ff_mpv_decode_mb().
3894 3895 3896 3897 3898 3899
     * 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);
3900

3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922
    /**
     * 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;
3923 3924 3925 3926 3927

    /**
     * Internal hwaccel capabilities.
     */
    int caps_internal;
3928 3929
} AVHWAccel;

3930 3931 3932 3933
/**
 * Hardware acceleration should be used for decoding even if the codec level
 * used is unknown or higher than the maximum supported level reported by the
 * hardware driver.
3934 3935 3936
 *
 * It's generally a good idea to pass this flag unless you have a specific
 * reason not to, as hardware tends to under-report supported levels.
3937 3938 3939
 */
#define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0)

3940 3941 3942 3943 3944 3945
/**
 * Hardware acceleration can output YUV pixel formats with a different chroma
 * sampling than 4:2:0 and/or other than 8 bits per component.
 */
#define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1)

3946 3947 3948 3949
/**
 * @}
 */

3950
#if FF_API_AVPICTURE
3951 3952 3953 3954 3955 3956 3957
/**
 * @defgroup lavc_picture AVPicture
 *
 * Functions for working with AVPicture
 * @{
 */

3958
/**
3959 3960 3961 3962
 * Picture data structure.
 *
 * Up to four components can be stored into it, the last component is
 * alpha.
3963
 * @deprecated use AVFrame or imgutils functions instead
3964
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
3965
typedef struct AVPicture {
3966
    attribute_deprecated
3967
    uint8_t *data[AV_NUM_DATA_POINTERS];    ///< pointers to the image data planes
3968
    attribute_deprecated
3969
    int linesize[AV_NUM_DATA_POINTERS];     ///< number of bytes per line
Fabrice Bellard's avatar
Fabrice Bellard committed
3970 3971
} AVPicture;

3972 3973 3974
/**
 * @}
 */
3975
#endif
3976

3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994
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,
};

3995 3996
#define AV_SUBTITLE_FLAG_FORCED 0x00000001

3997
typedef struct AVSubtitleRect {
3998 3999 4000 4001 4002
    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
4003

4004
#if FF_API_AVPICTURE
4005
    /**
4006
     * @deprecated unused
4007
     */
4008
    attribute_deprecated
4009
    AVPicture pict;
4010 4011 4012 4013 4014 4015 4016 4017
#endif
    /**
     * data+linesize for the bitmap of this subtitle.
     * Can be set for text/ass as well once they are rendered.
     */
    uint8_t *data[4];
    int linesize[4];

4018 4019 4020 4021 4022 4023
    enum AVSubtitleType type;

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

    /**
     * 0 terminated ASS/SSA compatible event line.
4024
     * The presentation of this is unaffected by the other values in this
4025 4026 4027
     * struct.
     */
    char *ass;
4028

4029
    int flags;
4030 4031 4032 4033 4034 4035
} 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 */
4036
    unsigned num_rects;
4037
    AVSubtitleRect **rects;
4038
    int64_t pts;    ///< Same as packet pts, in AV_TIME_BASE
4039 4040
} AVSubtitle;

4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084
/**
 * This struct describes the properties of an encoded stream.
 *
 * sizeof(AVCodecParameters) is not a part of the public ABI, this struct must
 * be allocated with avcodec_parameters_alloc() and freed with
 * avcodec_parameters_free().
 */
typedef struct AVCodecParameters {
    /**
     * General type of the encoded data.
     */
    enum AVMediaType codec_type;
    /**
     * Specific type of the encoded data (the codec used).
     */
    enum AVCodecID   codec_id;
    /**
     * Additional information about the codec (corresponds to the AVI FOURCC).
     */
    uint32_t         codec_tag;

    /**
     * Extra binary data needed for initializing the decoder, codec-dependent.
     *
     * Must be allocated with av_malloc() and will be freed by
     * avcodec_parameters_free(). The allocated size of extradata must be at
     * least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding
     * bytes zeroed.
     */
    uint8_t *extradata;
    /**
     * Size of the extradata content in bytes.
     */
    int      extradata_size;

    /**
     * - video: the pixel format, the value corresponds to enum AVPixelFormat.
     * - audio: the sample format, the value corresponds to enum AVSampleFormat.
     */
    int format;

    /**
     * The average bitrate of the encoded data (in bits per second).
     */
4085
    int64_t bit_rate;
4086

4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097
    /**
     * The number of bits per sample in the codedwords.
     *
     * This is basically the bitrate per sample. It is mandatory for a bunch of
     * formats to actually decode them. It's the number of bits for one sample in
     * the actual coded bitstream.
     *
     * This could be for example 4 for ADPCM
     * For PCM formats this matches bits_per_raw_sample
     * Can be 0
     */
4098 4099
    int bits_per_coded_sample;

4100 4101 4102 4103 4104
    /**
     * This is the number of valid bits in each output sample. If the
     * sample format has more bits, the least significant bits are additional
     * padding bits, which are always 0. Use right shifts to reduce the sample
     * to its actual size. For example, audio formats with 24 bit samples will
4105 4106
     * have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.
     * To get the original sample use "(int32_t)sample >> 8"."
4107 4108 4109 4110 4111 4112
     *
     * For ADPCM this might be 12 or 16 or similar
     * Can be 0
     */
    int bits_per_raw_sample;

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
    /**
     * Codec-specific bitstream restrictions that the stream conforms to.
     */
    int profile;
    int level;

    /**
     * Video only. The dimensions of the video frame in pixels.
     */
    int width;
    int height;

    /**
     * Video only. The aspect ratio (width / height) which a single pixel
     * should have when displayed.
     *
     * When the aspect ratio is unknown / undefined, the numerator should be
     * set to 0 (the denominator may have any value).
     */
    AVRational sample_aspect_ratio;

    /**
     * Video only. The order of the fields in interlaced video.
     */
    enum AVFieldOrder                  field_order;

    /**
     * Video only. Additional colorspace characteristics.
     */
    enum AVColorRange                  color_range;
    enum AVColorPrimaries              color_primaries;
    enum AVColorTransferCharacteristic color_trc;
    enum AVColorSpace                  color_space;
    enum AVChromaLocation              chroma_location;

4148 4149 4150 4151 4152
    /**
     * Video only. Number of delayed frames.
     */
    int video_delay;

4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173
    /**
     * Audio only. The channel layout bitmask. May be 0 if the channel layout is
     * unknown or unspecified, otherwise the number of bits set must be equal to
     * the channels field.
     */
    uint64_t channel_layout;
    /**
     * Audio only. The number of audio channels.
     */
    int      channels;
    /**
     * Audio only. The number of audio samples per second.
     */
    int      sample_rate;
    /**
     * Audio only. The number of bytes per coded audio frame, required by some
     * formats.
     *
     * Corresponds to nBlockAlign in WAVEFORMATEX.
     */
    int      block_align;
4174 4175 4176 4177
    /**
     * Audio only. Audio frame size, if known. Required by some formats to be static.
     */
    int      frame_size;
4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192

    /**
     * Audio only. The amount of padding (in samples) inserted by the encoder at
     * the beginning of the audio. I.e. this number of leading decoded samples
     * must be discarded by the caller to get the original audio without leading
     * padding.
     */
    int initial_padding;
    /**
     * Audio only. The amount of padding (in samples) appended by the encoder to
     * the end of the audio. I.e. this number of decoded samples must be
     * discarded by the caller from the end of the stream to get the original
     * audio without any trailing padding.
     */
    int trailing_padding;
4193 4194 4195 4196
    /**
     * Audio only. Number of samples to skip after a discontinuity.
     */
    int seek_preroll;
4197 4198
} AVCodecParameters;

4199
/**
4200 4201 4202
 * 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.
4203
 */
4204
AVCodec *av_codec_next(const AVCodec *c);
4205 4206

/**
4207
 * Return the LIBAVCODEC_VERSION_INT constant.
4208
 */
4209
unsigned avcodec_version(void);
4210 4211

/**
4212
 * Return the libavcodec build-time configuration.
4213
 */
4214
const char *avcodec_configuration(void);
4215 4216

/**
4217
 * Return the libavcodec license.
4218
 */
4219
const char *avcodec_license(void);
4220

4221
/**
4222
 * Register the codec codec and initialize libavcodec.
4223
 *
4224 4225 4226 4227
 * @warning either this function or avcodec_register_all() must be called
 * before any other libavcodec functions.
 *
 * @see avcodec_register_all()
4228
 */
4229
void avcodec_register(AVCodec *codec);
4230

4231
/**
4232 4233 4234 4235
 * 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.
4236
 *
4237 4238 4239
 * @see avcodec_register
 * @see av_register_codec_parser
 * @see av_register_bitstream_filter
4240
 */
4241
void avcodec_register_all(void);
4242

4243
/**
4244 4245
 * Allocate an AVCodecContext and set its fields to default values. The
 * resulting struct should be freed with avcodec_free_context().
4246
 *
4247 4248 4249 4250 4251 4252 4253 4254
 * @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.
4255
 */
4256
AVCodecContext *avcodec_alloc_context3(const AVCodec *codec);
4257

4258 4259 4260 4261 4262 4263
/**
 * Free the codec context and everything associated with it and write NULL to
 * the provided pointer.
 */
void avcodec_free_context(AVCodecContext **avctx);

4264
#if FF_API_GET_CONTEXT_DEFAULTS
4265
/**
4266 4267 4268
 * @deprecated This function should not be used, as closing and opening a codec
 * context multiple time is not supported. A new codec context should be
 * allocated for each new use.
4269
 */
4270
int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec);
4271
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
4272

4273
/**
4274 4275
 * Get the AVClass for AVCodecContext. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
4276
 *
4277
 * @see av_opt_find().
4278
 */
4279
const AVClass *avcodec_get_class(void);
4280

4281
#if FF_API_COPY_CONTEXT
4282
/**
4283 4284
 * Get the AVClass for AVFrame. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
4285
 *
4286
 * @see av_opt_find().
4287
 */
4288
const AVClass *avcodec_get_frame_class(void);
4289

4290 4291 4292 4293 4294 4295 4296 4297
/**
 * 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);

4298
/**
4299 4300 4301 4302 4303 4304
 * 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
4305
 *             avcodec_alloc_context3(NULL), but otherwise uninitialized
4306 4307
 * @param src source codec context
 * @return AVERROR() on error (e.g. memory allocation error), 0 on success
4308 4309 4310 4311 4312 4313
 *
 * @deprecated The semantics of this function are ill-defined and it should not
 * be used. If you need to transfer the stream parameters from one codec context
 * to another, use an intermediate AVCodecParameters instance and the
 * avcodec_parameters_from_context() / avcodec_parameters_to_context()
 * functions.
4314
 */
4315
attribute_deprecated
4316
int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src);
4317
#endif
4318

4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360
/**
 * Allocate a new AVCodecParameters and set its fields to default values
 * (unknown/invalid/0). The returned struct must be freed with
 * avcodec_parameters_free().
 */
AVCodecParameters *avcodec_parameters_alloc(void);

/**
 * Free an AVCodecParameters instance and everything associated with it and
 * write NULL to the supplied pointer.
 */
void avcodec_parameters_free(AVCodecParameters **par);

/**
 * Copy the contents of src to dst. Any allocated fields in dst are freed and
 * replaced with newly allocated duplicates of the corresponding fields in src.
 *
 * @return >= 0 on success, a negative AVERROR code on failure.
 */
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);

/**
 * Fill the parameters struct based on the values from the supplied codec
 * context. Any allocated fields in par are freed and replaced with duplicates
 * of the corresponding fields in codec.
 *
 * @return >= 0 on success, a negative AVERROR code on failure
 */
int avcodec_parameters_from_context(AVCodecParameters *par,
                                    const AVCodecContext *codec);

/**
 * Fill the codec context based on the values from the supplied codec
 * parameters. Any allocated fields in codec that have a corresponding field in
 * par are freed and replaced with duplicates of the corresponding field in par.
 * Fields in codec that do not have a counterpart in par are not touched.
 *
 * @return >= 0 on success, a negative AVERROR code on failure.
 */
int avcodec_parameters_to_context(AVCodecContext *codec,
                                  const AVCodecParameters *par);

4361
/**
4362 4363
 * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
 * function the context has to be allocated with avcodec_alloc_context3().
4364
 *
4365 4366 4367
 * 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.
4368
 *
4369 4370
 * @warning This function is not thread safe!
 *
4371
 * @note Always call this function before using decoding routines (such as
4372
 * @ref avcodec_receive_frame()).
4373
 *
4374 4375 4376
 * @code
 * avcodec_register_all();
 * av_dict_set(&opts, "b", "2.5M", 0);
4377
 * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389
 * 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
4390 4391
 *              for this context, then this parameter MUST be either NULL or
 *              equal to the previously passed codec.
4392 4393 4394 4395 4396 4397
 * @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().
4398
 */
4399
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
4400 4401

/**
4402 4403
 * Close a given AVCodecContext and free all the data associated with it
 * (but not the AVCodecContext itself).
4404
 *
4405
 * Calling this function on an AVCodecContext that hasn't been opened will free
4406 4407
 * the codec-specific data allocated in avcodec_alloc_context3() with a non-NULL
 * codec. Subsequent calls will do nothing.
4408 4409 4410 4411 4412
 *
 * @note Do not use this function. Use avcodec_free_context() to destroy a
 * codec context (either open or closed). Opening and closing a codec context
 * multiple times is not supported anymore -- use multiple codec contexts
 * instead.
4413
 */
4414
int avcodec_close(AVCodecContext *avctx);
4415 4416

/**
4417
 * Free all allocated data in the given subtitle struct.
4418
 *
4419
 * @param sub AVSubtitle to free.
4420
 */
4421
void avsubtitle_free(AVSubtitle *sub);
4422

4423
/**
4424
 * @}
4425
 */
4426

4427
/**
4428 4429
 * @addtogroup lavc_packet
 * @{
4430
 */
4431

4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465
/**
 * Allocate an AVPacket and set its fields to default values.  The resulting
 * struct must be freed using av_packet_free().
 *
 * @return An AVPacket filled with default values or NULL on failure.
 *
 * @note this only allocates the AVPacket itself, not the data buffers. Those
 * must be allocated through other means such as av_new_packet.
 *
 * @see av_new_packet
 */
AVPacket *av_packet_alloc(void);

/**
 * Create a new packet that references the same data as src.
 *
 * This is a shortcut for av_packet_alloc()+av_packet_ref().
 *
 * @return newly created AVPacket on success, NULL on error.
 *
 * @see av_packet_alloc
 * @see av_packet_ref
 */
AVPacket *av_packet_clone(AVPacket *src);

/**
 * Free the packet, if the packet is reference counted, it will be
 * unreferenced first.
 *
 * @param packet packet to be freed. The pointer will be set to NULL.
 * @note passing NULL is a no-op.
 */
void av_packet_free(AVPacket **pkt);

4466
/**
4467
 * Initialize optional fields of a packet with default values.
4468
 *
4469 4470 4471
 * Note, this does not touch the data and size members, which have to be
 * initialized separately.
 *
4472
 * @param pkt packet
4473
 */
4474
void av_init_packet(AVPacket *pkt);
4475 4476

/**
4477 4478
 * Allocate the payload of a packet and initialize its fields with
 * default values.
4479
 *
4480 4481 4482
 * @param pkt packet
 * @param size wanted payload size
 * @return 0 if OK, AVERROR_xxx otherwise
4483
 */
4484
int av_new_packet(AVPacket *pkt, int size);
4485

4486
/**
4487
 * Reduce packet size, correctly zeroing padding
4488
 *
4489 4490
 * @param pkt packet
 * @param size new size
4491
 */
4492
void av_shrink_packet(AVPacket *pkt, int size);
Fabrice Bellard's avatar
Fabrice Bellard committed
4493

4494
/**
4495 4496 4497 4498
 * Increase packet size, correctly zeroing padding
 *
 * @param pkt packet
 * @param grow_by number of bytes by which to increase the size of the packet
4499
 */
4500
int av_grow_packet(AVPacket *pkt, int grow_by);
Fabrice Bellard's avatar
Fabrice Bellard committed
4501

4502 4503 4504 4505 4506 4507 4508 4509 4510
/**
 * 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
4511
 *        size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.
4512 4513 4514 4515 4516
 *
 * @return 0 on success, a negative AVERROR on error
 */
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);

4517
#if FF_API_AVPACKET_OLD_API
4518
/**
4519 4520
 * @warning This is a hack - the packet memory allocation stuff is broken. The
 * packet is allocated if it was not really allocated.
4521 4522
 *
 * @deprecated Use av_packet_ref
4523
 */
4524
attribute_deprecated
4525
int av_dup_packet(AVPacket *pkt);
Andrey Utkin's avatar
Andrey Utkin committed
4526 4527 4528 4529 4530
/**
 * Copy packet, including contents
 *
 * @return 0 on success, negative AVERROR on fail
 */
4531
int av_copy_packet(AVPacket *dst, const AVPacket *src);
Andrey Utkin's avatar
Andrey Utkin committed
4532

4533 4534 4535 4536 4537
/**
 * Copy packet side data
 *
 * @return 0 on success, negative AVERROR on fail
 */
4538
int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
4539

4540
/**
4541
 * Free a packet.
4542
 *
4543 4544
 * @deprecated Use av_packet_unref
 *
4545
 * @param pkt packet to free
4546
 */
4547
attribute_deprecated
Ramiro Polla's avatar
Ramiro Polla committed
4548
void av_free_packet(AVPacket *pkt);
4549
#endif
4550
/**
4551
 * Allocate new information of a packet.
4552
 *
4553 4554 4555 4556
 * @param pkt packet
 * @param type side information type
 * @param size side information size
 * @return pointer to fresh allocated data or NULL otherwise
4557
 */
4558 4559
uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                                 int size);
Fabrice Bellard's avatar
Fabrice Bellard committed
4560

4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576
/**
 * Wrap an existing array as a packet side data.
 *
 * @param pkt packet
 * @param type side information type
 * @param data the side data array. It must be allocated with the av_malloc()
 *             family of functions. The ownership of the data is transferred to
 *             pkt.
 * @param size side information size
 * @return a non-negative number on success, a negative AVERROR code on
 *         failure. On failure, the packet is unchanged and the data remains
 *         owned by the caller.
 */
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                            uint8_t *data, size_t size);

4577
/**
4578
 * Shrink the already allocated side data buffer
4579
 *
4580 4581 4582 4583
 * @param pkt packet
 * @param type side information type
 * @param size new side information size
 * @return 0 on success, < 0 on failure
4584
 */
4585 4586
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                               int size);
4587

4588
/**
4589
 * Get side information from packet.
4590
 *
4591 4592 4593 4594
 * @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
4595
 */
4596
uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
4597
                                 int *size);
4598

4599 4600
#if FF_API_MERGE_SD_API
attribute_deprecated
4601
int av_packet_merge_side_data(AVPacket *pkt);
4602

4603
attribute_deprecated
4604
int av_packet_split_side_data(AVPacket *pkt);
4605
#endif
4606

4607 4608
const char *av_packet_side_data_name(enum AVPacketSideDataType type);

4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626
/**
 * 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);

4627

4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651
/**
 * 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.
 */
4652
int av_packet_ref(AVPacket *dst, const AVPacket *src);
4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686

/**
 * 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);

4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699
/**
 * Convert valid timing fields (timestamps / durations) in a packet from one
 * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
 * ignored.
 *
 * @param pkt packet on which the conversion will be performed
 * @param tb_src source timebase, in which the timing fields in pkt are
 *               expressed
 * @param tb_dst destination timebase, to which the timing fields will be
 *               converted
 */
void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);

4700
/**
4701
 * @}
4702
 */
4703

4704
/**
4705 4706
 * @addtogroup lavc_decoding
 * @{
4707 4708
 */

4709
/**
4710
 * Find a registered decoder with a matching codec ID.
4711
 *
4712
 * @param id AVCodecID of the requested decoder
4713
 * @return A decoder if one was found, NULL otherwise.
4714
 */
4715
AVCodec *avcodec_find_decoder(enum AVCodecID id);
4716 4717

/**
4718
 * Find a registered decoder with the specified name.
4719
 *
4720 4721
 * @param name name of the requested decoder
 * @return A decoder if one was found, NULL otherwise.
4722
 */
4723
AVCodec *avcodec_find_decoder_by_name(const char *name);
Michael Niedermayer's avatar
Michael Niedermayer committed
4724

4725 4726 4727
/**
 * The default callback for AVCodecContext.get_buffer2(). It is made public so
 * it can be called by custom get_buffer2() implementations for decoders without
4728
 * AV_CODEC_CAP_DR1 set.
4729 4730
 */
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags);
4731

4732
#if FF_API_EMU_EDGE
4733
/**
4734
 * Return the amount of padding in pixels which the get_buffer callback must
4735 4736 4737 4738
 * provide around the edge of the image for codecs which do not have the
 * CODEC_FLAG_EMU_EDGE flag.
 *
 * @return Required padding in pixels.
4739 4740 4741
 *
 * @deprecated CODEC_FLAG_EMU_EDGE is deprecated, so this function is no longer
 * needed
4742
 */
4743
attribute_deprecated
4744
unsigned avcodec_get_edge_width(void);
4745
#endif
4746

4747
/**
4748
 * Modify width and height values so that they will result in a memory
4749 4750
 * buffer that is acceptable for the codec if you do not use any horizontal
 * padding.
4751
 *
4752
 * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened.
4753
 */
4754
void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
Drew Hess's avatar
Drew Hess committed
4755

4756
/**
4757
 * Modify width and height values so that they will result in a memory
4758 4759
 * buffer that is acceptable for the codec if you also ensure that all
 * line sizes are a multiple of the respective linesize_align[i].
4760
 *
4761
 * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened.
4762 4763
 */
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
4764
                               int linesize_align[AV_NUM_DATA_POINTERS]);
4765

4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776
/**
 * 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);

4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787
/**
 * 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);

4788 4789 4790 4791
/**
 * Decode the audio frame of size avpkt->size from avpkt->data into frame.
 *
 * Some decoders may support multiple frames in a single AVPacket. Such
4792 4793 4794 4795 4796 4797 4798
 * 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.
 *
4799
 * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input
4800 4801 4802 4803 4804
 * 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
4805
 * marked with AV_CODEC_CAP_DELAY, then no samples will be returned.
4806
 *
4807
 * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE
4808 4809 4810
 *          larger than the actual read bytes because some optimized bitstream
 *          readers read 32 or 64 bits at once and could read over the end.
 *
4811 4812 4813
 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
 * before packets may be fed to the decoder.
 *
4814 4815
 * @param      avctx the codec context
 * @param[out] frame The AVFrame in which to store decoded audio samples.
4816 4817 4818 4819 4820 4821 4822 4823 4824
 *                   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
4825 4826
 *                   next call to this function or until closing or flushing the
 *                   decoder. The caller may not write to it.
4827
 * @param[out] got_frame_ptr Zero if no frame could be decoded, otherwise it is
4828 4829
 *                           non-zero. Note that this field being set to zero
 *                           does not mean that an error has occurred. For
4830
 *                           decoders with AV_CODEC_CAP_DELAY set, no given decode
4831
 *                           call is guaranteed to produce a frame.
4832 4833 4834 4835 4836 4837
 * @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.
4838 4839
 *
* @deprecated Use avcodec_send_packet() and avcodec_receive_frame().
4840
 */
4841
attribute_deprecated
4842
int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
4843
                          int *got_frame_ptr, const AVPacket *avpkt);
4844

4845
/**
4846
 * Decode the video frame of size avpkt->size from avpkt->data into picture.
4847 4848
 * Some decoders may support multiple frames in a single AVPacket, such
 * decoders would then just decode the first frame.
4849
 *
4850
 * @warning The input buffer must be AV_INPUT_BUFFER_PADDING_SIZE larger than
4851 4852 4853
 * the actual read bytes because some optimized bitstream readers read 32 or 64
 * bits at once and could read over the end.
 *
4854
 * @warning The end of the input buffer buf should be set to 0 to ensure that
4855 4856
 * no overreading happens for damaged MPEG streams.
 *
4857
 * @note Codecs which have the AV_CODEC_CAP_DELAY capability set have a delay
4858 4859
 * between input and output, these need to be fed with avpkt->data=NULL,
 * avpkt->size=0 at the end to return the remaining frames.
4860
 *
4861 4862 4863
 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
 * before packets may be fed to the decoder.
 *
Diego Biurrun's avatar
Diego Biurrun committed
4864
 * @param avctx the codec context
4865
 * @param[out] picture The AVFrame in which the decoded video frame will be stored.
4866 4867 4868 4869 4870 4871 4872 4873 4874 4875
 *             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
4876 4877
 *             next call to this function or until closing or flushing the
 *             decoder. The caller may not write to it.
4878
 *
4879
 * @param[in] avpkt The input AVPacket containing the input buffer.
4880 4881
 *            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
4882
 *            flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least
4883
 *            fields possible.
Diego Biurrun's avatar
Diego Biurrun committed
4884
 * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
4885 4886
 * @return On error a negative value is returned, otherwise the number of bytes
 * used or zero if no frame could be decompressed.
4887 4888
 *
 * @deprecated Use avcodec_send_packet() and avcodec_receive_frame().
4889
 */
4890
attribute_deprecated
4891
int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
Fabrice Bellard's avatar
Fabrice Bellard committed
4892
                         int *got_picture_ptr,
4893
                         const AVPacket *avpkt);
4894

4895
/**
4896
 * Decode a subtitle message.
Måns Rullgård's avatar
Måns Rullgård committed
4897
 * Return a negative value on error, otherwise return the number of bytes used.
4898 4899
 * If no subtitle could be decompressed, got_sub_ptr is zero.
 * Otherwise, the subtitle is stored in *sub.
4900
 * Note that AV_CODEC_CAP_DR1 is not available for subtitle codecs. This is for
4901 4902 4903
 * 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.
4904
 *
4905 4906 4907 4908 4909 4910 4911 4912
 * 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.
 *
4913 4914 4915
 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
 * before packets may be fed to the decoder.
 *
4916
 * @param avctx the codec context
4917 4918
 * @param[out] sub The Preallocated AVSubtitle in which the decoded subtitle will be stored,
 *                 must be freed with avsubtitle_free if *got_sub_ptr is set.
4919 4920 4921 4922 4923 4924
 * @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);
4925

4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964
/**
 * Supply raw packet data as input to a decoder.
 *
 * Internally, this call will copy relevant AVCodecContext fields, which can
 * influence decoding per-packet, and apply them when the packet is actually
 * decoded. (For example AVCodecContext.skip_frame, which might direct the
 * decoder to drop the frame contained by the packet sent with this function.)
 *
 * @warning The input buffer, avpkt->data must be AV_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.
 *
 * @warning Do not mix this API with the legacy API (like avcodec_decode_video2())
 *          on the same AVCodecContext. It will return unexpected results now
 *          or in future libavcodec versions.
 *
 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
 *       before packets may be fed to the decoder.
 *
 * @param avctx codec context
 * @param[in] avpkt The input AVPacket. Usually, this will be a single video
 *                  frame, or several complete audio frames.
 *                  Ownership of the packet remains with the caller, and the
 *                  decoder will not write to the packet. The decoder may create
 *                  a reference to the packet data (or copy it if the packet is
 *                  not reference-counted).
 *                  Unlike with older APIs, the packet is always fully consumed,
 *                  and if it contains multiple frames (e.g. some audio codecs),
 *                  will require you to call avcodec_receive_frame() multiple
 *                  times afterwards before you can send a new packet.
 *                  It can be NULL (or an AVPacket with data set to NULL and
 *                  size set to 0); in this case, it is considered a flush
 *                  packet, which signals the end of the stream. Sending the
 *                  first flush packet will return success. Subsequent ones are
 *                  unnecessary and will return AVERROR_EOF. If the decoder
 *                  still has frames buffered, it will return them after sending
 *                  a flush packet.
 *
 * @return 0 on success, otherwise negative error code:
4965 4966 4967 4968
 *      AVERROR(EAGAIN):   input is not accepted in the current state - user
 *                         must read output with avcodec_receive_frame() (once
 *                         all output is read, the packet should be resent, and
 *                         the call will not fail with EAGAIN).
4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988
 *      AVERROR_EOF:       the decoder has been flushed, and no new packets can
 *                         be sent to it (also returned if more than 1 flush
 *                         packet is sent)
 *      AVERROR(EINVAL):   codec not opened, it is an encoder, or requires flush
 *      AVERROR(ENOMEM):   failed to add packet to internal queue, or similar
 *      other errors: legitimate decoding errors
 */
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt);

/**
 * Return decoded output data from a decoder.
 *
 * @param avctx codec context
 * @param frame This will be set to a reference-counted video or audio
 *              frame (depending on the decoder type) allocated by the
 *              decoder. Note that the function will always call
 *              av_frame_unref(frame) before doing anything else.
 *
 * @return
 *      0:                 success, a frame was returned
4989
 *      AVERROR(EAGAIN):   output is not available in this state - user must try
4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021
 *                         to send new input
 *      AVERROR_EOF:       the decoder has been fully flushed, and there will be
 *                         no more output frames
 *      AVERROR(EINVAL):   codec not opened, or it is an encoder
 *      other negative values: legitimate decoding errors
 */
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);

/**
 * Supply a raw video or audio frame to the encoder. Use avcodec_receive_packet()
 * to retrieve buffered output packets.
 *
 * @param avctx     codec context
 * @param[in] frame AVFrame containing the raw audio or video frame to be encoded.
 *                  Ownership of the frame remains with the caller, and the
 *                  encoder will not write to the frame. The encoder may create
 *                  a reference to the frame data (or copy it if the frame is
 *                  not reference-counted).
 *                  It can be NULL, in which case it is considered a flush
 *                  packet.  This signals the end of the stream. If the encoder
 *                  still has packets buffered, it will return them after this
 *                  call. Once flushing mode has been entered, additional flush
 *                  packets are ignored, and sending frames will return
 *                  AVERROR_EOF.
 *
 *                  For audio:
 *                  If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
 *                  can have any number of samples.
 *                  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.
 * @return 0 on success, otherwise negative error code:
5022 5023 5024 5025
 *      AVERROR(EAGAIN):   input is not accepted in the current state - user
 *                         must read output with avcodec_receive_packet() (once
 *                         all output is read, the packet should be resent, and
 *                         the call will not fail with EAGAIN).
5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042
 *      AVERROR_EOF:       the encoder has been flushed, and no new frames can
 *                         be sent to it
 *      AVERROR(EINVAL):   codec not opened, refcounted_frames not set, it is a
 *                         decoder, or requires flush
 *      AVERROR(ENOMEM):   failed to add packet to internal queue, or similar
 *      other errors: legitimate decoding errors
 */
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);

/**
 * Read encoded data from the encoder.
 *
 * @param avctx codec context
 * @param avpkt This will be set to a reference-counted packet allocated by the
 *              encoder. Note that the function will always call
 *              av_frame_unref(frame) before doing anything else.
 * @return 0 on success, otherwise negative error code:
5043 5044
 *      AVERROR(EAGAIN):   output is not available in the current state - user
 *                         must try to send input
5045 5046 5047 5048 5049 5050 5051 5052
 *      AVERROR_EOF:       the encoder has been fully flushed, and there will be
 *                         no more output packets
 *      AVERROR(EINVAL):   codec not opened, or it is an encoder
 *      other errors: legitimate decoding errors
 */
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt);


5053
/**
5054 5055
 * @defgroup lavc_parsing Frame parsing
 * @{
5056 5057
 */

5058 5059 5060 5061 5062 5063 5064
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
};

5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102
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
5103
#define PARSER_FLAG_USE_CODEC_TS              0x1000
5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115

    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;

5116
#if FF_API_CONVERGENCE_DURATION
5117
    /**
5118
     * @deprecated unused
5119
     */
5120
    attribute_deprecated
5121
    int64_t convergence_duration;
5122
#endif
5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187

    // 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;
5188 5189

    enum AVFieldOrder field_order;
5190 5191 5192 5193 5194 5195 5196 5197 5198 5199

    /**
     * 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;
5200 5201 5202 5203 5204 5205 5206 5207

    /**
     * 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;
5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229

    /**
     * Dimensions of the decoded video intended for presentation.
     */
    int width;
    int height;

    /**
     * Dimensions of the coded video.
     */
    int coded_width;
    int coded_height;

    /**
     * The format of the coded data, corresponds to enum AVPixelFormat for video
     * and for enum AVSampleFormat for audio.
     *
     * Note that a decoder can have considerable freedom in how exactly it
     * decodes the data, so the format reported here might be different from the
     * one returned by a decoder.
     */
    int format;
5230 5231 5232 5233 5234 5235
} AVCodecParserContext;

typedef struct AVCodecParser {
    int codec_ids[5]; /* several codec IDs are permitted */
    int priv_data_size;
    int (*parser_init)(AVCodecParserContext *s);
5236 5237
    /* This callback never returns an error, a negative value means that
     * the frame start was in a previous packet. */
5238 5239 5240 5241 5242 5243 5244 5245 5246
    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;

5247
AVCodecParser *av_parser_next(const AVCodecParser *c);
5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259

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.
5260 5261 5262 5263
 * @param buf_size      buffer size in bytes without the padding. I.e. the full buffer
                        size is assumed to be buf_size + AV_INPUT_BUFFER_PADDING_SIZE.
                        To signal EOF, this should be 0 (so that the last frame
                        can be output).
5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289
 * @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);

5290 5291
/**
 * @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
5292
 * @deprecated use AVBitStreamFilter
5293
 */
5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304
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);

/**
 * @}
 * @}
 */

5305 5306 5307 5308 5309 5310 5311 5312
/**
 * @addtogroup lavc_encoding
 * @{
 */

/**
 * Find a registered encoder with a matching codec ID.
 *
5313
 * @param id AVCodecID of the requested encoder
5314 5315
 * @return An encoder if one was found, NULL otherwise.
 */
5316
AVCodec *avcodec_find_encoder(enum AVCodecID id);
5317 5318 5319 5320 5321 5322 5323 5324 5325

/**
 * 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);

5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338
/**
 * 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
5339 5340 5341 5342 5343 5344
 *                  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.
5345 5346
 *
 *                  If this function fails or produces no output, avpkt will be
5347
 *                  freed using av_packet_unref().
5348 5349
 * @param[in] frame AVFrame containing the raw audio data to be encoded.
 *                  May be NULL when flushing an encoder that has the
5350 5351
 *                  AV_CODEC_CAP_DELAY capability set.
 *                  If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
5352
 *                  can have any number of samples.
5353 5354 5355
 *                  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.
5356 5357 5358 5359 5360 5361 5362
 * @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
5363 5364
 *
 * @deprecated use avcodec_send_frame()/avcodec_receive_packet() instead
5365
 */
5366
attribute_deprecated
5367 5368
int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
                          const AVFrame *frame, int *got_packet_ptr);
5369

5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388
/**
 * 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.
5389 5390
 *
 *                  If this function fails or produces no output, avpkt will be
5391
 *                  freed using av_packet_unref().
5392 5393
 * @param[in] frame AVFrame containing the raw video data to be encoded.
 *                  May be NULL when flushing an encoder that has the
5394
 *                  AV_CODEC_CAP_DELAY capability set.
5395 5396 5397 5398 5399 5400 5401
 * @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
5402 5403
 *
 * @deprecated use avcodec_send_frame()/avcodec_receive_packet() instead
5404
 */
5405
attribute_deprecated
5406 5407 5408
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,
                          const AVFrame *frame, int *got_packet_ptr);

5409
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
5410
                            const AVSubtitle *sub);
Fabrice Bellard's avatar
Fabrice Bellard committed
5411

5412

5413
/**
5414 5415 5416
 * @}
 */

5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513
#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

5514
#if FF_API_AVPICTURE
5515 5516 5517 5518 5519
/**
 * @addtogroup lavc_picture
 * @{
 */

5520
/**
5521
 * @deprecated unused
5522
 */
5523
attribute_deprecated
5524
int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height);
5525 5526

/**
5527
 * @deprecated unused
5528
 */
5529
attribute_deprecated
5530 5531 5532
void avpicture_free(AVPicture *picture);

/**
5533
 * @deprecated use av_image_fill_arrays() instead.
5534
 */
5535
attribute_deprecated
5536
int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
5537
                   enum AVPixelFormat pix_fmt, int width, int height);
5538 5539

/**
5540
 * @deprecated use av_image_copy_to_buffer() instead.
5541
 */
5542
attribute_deprecated
5543
int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt,
5544
                     int width, int height,
5545 5546 5547
                     unsigned char *dest, int dest_size);

/**
5548
 * @deprecated use av_image_get_buffer_size() instead.
5549
 */
5550
attribute_deprecated
5551
int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
5552 5553

/**
5554
 * @deprecated av_image_copy() instead.
5555
 */
5556
attribute_deprecated
5557
void av_picture_copy(AVPicture *dst, const AVPicture *src,
5558
                     enum AVPixelFormat pix_fmt, int width, int height);
5559 5560

/**
5561
 * @deprecated unused
5562
 */
5563
attribute_deprecated
5564
int av_picture_crop(AVPicture *dst, const AVPicture *src,
5565
                    enum AVPixelFormat pix_fmt, int top_band, int left_band);
5566 5567

/**
5568
 * @deprecated unused
5569
 */
5570
attribute_deprecated
5571
int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt,
5572 5573 5574 5575 5576
            int padtop, int padbottom, int padleft, int padright, int *color);

/**
 * @}
 */
5577
#endif
5578

5579 5580 5581 5582 5583 5584 5585 5586
/**
 * @defgroup lavc_misc Utility functions
 * @ingroup libavc
 *
 * Miscellaneous utility functions related to both encoding and decoding
 * (or neither).
 * @{
 */
5587

5588 5589 5590 5591 5592 5593 5594
/**
 * @defgroup lavc_misc_pixfmt Pixel formats
 *
 * Functions for working with pixel formats.
 * @{
 */

5595
/**
5596 5597 5598 5599 5600 5601 5602 5603
 * 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
5604 5605
 * @param[out] h_shift store log2_chroma_w
 * @param[out] v_shift store log2_chroma_h
5606 5607
 *
 * @see av_pix_fmt_get_chroma_sub_sample
5608 5609
 */

5610
void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
5611 5612 5613 5614 5615 5616

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

5619 5620
/**
 * @deprecated see av_get_pix_fmt_loss()
5621
 */
5622
int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
5623
                             int has_alpha);
5624

5625 5626 5627 5628 5629
/**
 * 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
5630
 * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of
5631 5632 5633 5634 5635
 * 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.
 *
 *
5636
 * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from
5637 5638 5639 5640 5641
 * @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.
 */
5642
enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list,
5643
                                            enum AVPixelFormat src_pix_fmt,
5644
                                            int has_alpha, int *loss_ptr);
5645

5646
/**
5647
 * @deprecated see av_find_best_pix_fmt_of_2()
5648
 */
5649 5650
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);
5651 5652

attribute_deprecated
5653 5654
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);
5655

5656
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
5657 5658 5659 5660 5661

/**
 * @}
 */

5662 5663 5664 5665 5666
#if FF_API_SET_DIMENSIONS
/**
 * @deprecated this function is not supposed to be used from outside of lavc
 */
attribute_deprecated
5667
void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
5668
#endif
5669 5670 5671 5672

/**
 * Put a string representing the codec tag codec_tag in buf.
 *
5673
 * @param buf       buffer to place codec tag in
5674
 * @param buf_size size in bytes of buf
5675
 * @param codec_tag codec tag to assign
5676 5677 5678 5679
 * @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);
5680 5681

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

5683
/**
5684
 * Return a name for the specified profile, if available.
5685
 *
5686 5687 5688
 * @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.
5689
 */
5690 5691
const char *av_get_profile_name(const AVCodec *codec, int profile);

5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704
/**
 * Return a name for the specified profile, if available.
 *
 * @param codec_id the ID of the codec to which the requested profile belongs
 * @param profile the profile value for which a name is requested
 * @return A name for the profile if found, NULL otherwise.
 *
 * @note unlike av_get_profile_name(), which searches a list of profiles
 *       supported by a specific decoder or encoder implementation, this
 *       function searches the list of profiles from the AVCodecDescriptor
 */
const char *avcodec_profile_name(enum AVCodecID codec_id, int profile);

5705 5706 5707
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
5708

5709
/**
5710 5711 5712 5713 5714 5715
 * 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.
 *
5716 5717
 * AVFrame extended_data channel pointers are allocated if necessary for
 * planar audio.
5718
 *
5719 5720 5721 5722 5723 5724 5725 5726
 * @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
5727
 * @param align       plane size sample alignment (0 = default)
5728
 * @return            >=0 on success, negative error code on failure
5729 5730
 * @todo return the size in bytes required to store the samples in
 * case of success, at the next libavutil bump
5731
 */
5732 5733 5734
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
5735

5736
/**
5737 5738 5739 5740 5741 5742 5743
 * 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.
5744
 */
5745 5746
void avcodec_flush_buffers(AVCodecContext *avctx);

5747
/**
5748
 * Return codec bits per sample.
5749
 *
Diego Biurrun's avatar
Diego Biurrun committed
5750
 * @param[in] codec_id the codec
5751
 * @return Number of bits per sample or zero if unknown for the given codec.
5752
 */
5753
int av_get_bits_per_sample(enum AVCodecID codec_id);
5754

5755 5756 5757 5758
/**
 * Return the PCM codec associated with a sample format.
 * @param be  endianness, 0 for little, 1 for big,
 *            -1 (or anything else) for native
5759
 * @return  AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
5760
 */
5761
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
5762

5763 5764 5765 5766 5767 5768 5769 5770
/**
 * 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.
 */
5771
int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
5772

5773 5774 5775 5776 5777 5778 5779 5780 5781 5782
/**
 * 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);

5783 5784 5785 5786 5787 5788
/**
 * This function is the same as av_get_audio_frame_duration(), except it works
 * with AVCodecParameters instead of an AVCodecContext.
 */
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes);

5789
#if FF_API_OLD_BSF
5790
typedef struct AVBitStreamFilterContext {
5791
    void *priv_data;
5792
    const struct AVBitStreamFilter *filter;
5793 5794
    AVCodecParserContext *parser;
    struct AVBitStreamFilterContext *next;
5795 5796 5797 5798 5799
    /**
     * Internal default arguments, used if NULL is passed to av_bitstream_filter_filter().
     * Not for access by library users.
     */
    char *args;
5800
} AVBitStreamFilterContext;
5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836
#endif

typedef struct AVBSFInternal AVBSFInternal;

/**
 * The bitstream filter state.
 *
 * This struct must be allocated with av_bsf_alloc() and freed with
 * av_bsf_free().
 *
 * The fields in the struct will only be changed (by the caller or by the
 * filter) as described in their documentation, and are to be considered
 * immutable otherwise.
 */
typedef struct AVBSFContext {
    /**
     * A class for logging and AVOptions
     */
    const AVClass *av_class;

    /**
     * The bitstream filter this context is an instance of.
     */
    const struct AVBitStreamFilter *filter;

    /**
     * Opaque libavcodec internal data. Must not be touched by the caller in any
     * way.
     */
    AVBSFInternal *internal;

    /**
     * Opaque filter-specific private data. If filter->priv_class is non-NULL,
     * this is an AVOptions-enabled struct.
     */
    void *priv_data;
5837

5838
    /**
5839 5840 5841
     * Parameters of the input stream. This field is allocated in
     * av_bsf_alloc(), it needs to be filled by the caller before
     * av_bsf_init().
5842 5843
     */
    AVCodecParameters *par_in;
5844

5845
    /**
5846 5847
     * Parameters of the output stream. This field is allocated in
     * av_bsf_alloc(), it is set by the filter in av_bsf_init().
5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862
     */
    AVCodecParameters *par_out;

    /**
     * The timebase used for the timestamps of the input packets. Set by the
     * caller before av_bsf_init().
     */
    AVRational time_base_in;

    /**
     * The timebase used for the timestamps of the output packets. Set by the
     * filter in av_bsf_init().
     */
    AVRational time_base_out;
} AVBSFContext;
5863 5864 5865

typedef struct AVBitStreamFilter {
    const char *name;
5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892

    /**
     * A list of codec ids supported by the filter, terminated by
     * AV_CODEC_ID_NONE.
     * May be NULL, in that case the bitstream filter works with any codec id.
     */
    const enum AVCodecID *codec_ids;

    /**
     * A class for the private data, used to declare bitstream filter private
     * AVOptions. This field is NULL for bitstream filters that do not declare
     * any options.
     *
     * If this field is non-NULL, the first member of the filter private data
     * must be a pointer to AVClass, which will be set by libavcodec generic
     * code to this class.
     */
    const AVClass *priv_class;

    /*****************************************************************
     * 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.
     *****************************************************************
     */

5893
    int priv_data_size;
5894 5895 5896
    int (*init)(AVBSFContext *ctx);
    int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
    void (*close)(AVBSFContext *ctx);
5897 5898
} AVBitStreamFilter;

5899
#if FF_API_OLD_BSF
5900 5901 5902 5903 5904 5905 5906 5907 5908
/**
 * 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()
 */
5909
attribute_deprecated
5910
void av_register_bitstream_filter(AVBitStreamFilter *bsf);
5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921

/**
 * 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
 */
5922
attribute_deprecated
5923
AVBitStreamFilterContext *av_bitstream_filter_init(const char *name);
5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945

/**
 * 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
Lou Logan's avatar
Lou Logan committed
5946
 * is available in *poutbuf, and is distinct from the input buffer.
5947
 *
5948 5949 5950
 * 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
5951 5952
 * its starting address). A special case is if *poutbuf was set to NULL and
 * *poutbuf_size was set to 0, which indicates the packet should be dropped.
5953
 */
5954
attribute_deprecated
5955 5956 5957 5958
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);
5959 5960 5961 5962 5963 5964 5965

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

5969 5970 5971 5972 5973 5974 5975 5976
/**
 * 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.
 */
5977
attribute_deprecated
5978
AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f);
5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024
#endif

/**
 * @return a bitstream filter with the specified name or NULL if no such
 *         bitstream filter exists.
 */
const AVBitStreamFilter *av_bsf_get_by_name(const char *name);

/**
 * Iterate over all registered bitstream filters.
 *
 * @param opaque a pointer where libavcodec will store the iteration state. Must
 *               point to NULL to start the iteration.
 *
 * @return the next registered bitstream filter or NULL when the iteration is
 *         finished
 */
const AVBitStreamFilter *av_bsf_next(void **opaque);

/**
 * Allocate a context for a given bitstream filter. The caller must fill in the
 * context parameters as described in the documentation and then call
 * av_bsf_init() before sending any data to the filter.
 *
 * @param filter the filter for which to allocate an instance.
 * @param ctx a pointer into which the pointer to the newly-allocated context
 *            will be written. It must be freed with av_bsf_free() after the
 *            filtering is done.
 *
 * @return 0 on success, a negative AVERROR code on failure
 */
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);

/**
 * Prepare the filter for use, after all the parameters and options have been
 * set.
 */
int av_bsf_init(AVBSFContext *ctx);

/**
 * Submit a packet for filtering.
 *
 * After sending each packet, the filter must be completely drained by calling
 * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
 * AVERROR_EOF.
 *
6025 6026
 * @param pkt the packet to filter. pkt must contain some payload (i.e data or
 * side data must be present in pkt). The bitstream filter will take ownership of
6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074
 * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
 * This parameter may be NULL, which signals the end of the stream (i.e. no more
 * packets will be sent). That will cause the filter to output any packets it
 * may have buffered internally.
 *
 * @return 0 on success, a negative AVERROR on error.
 */
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);

/**
 * Retrieve a filtered packet.
 *
 * @param[out] pkt this struct will be filled with the contents of the filtered
 *                 packet. It is owned by the caller and must be freed using
 *                 av_packet_unref() when it is no longer needed.
 *                 This parameter should be "clean" (i.e. freshly allocated
 *                 with av_packet_alloc() or unreffed with av_packet_unref())
 *                 when this function is called. If this function returns
 *                 successfully, the contents of pkt will be completely
 *                 overwritten by the returned data. On failure, pkt is not
 *                 touched.
 *
 * @return 0 on success. AVERROR(EAGAIN) if more packets need to be sent to the
 * filter (using av_bsf_send_packet()) to get more output. AVERROR_EOF if there
 * will be no further output from the filter. Another negative AVERROR value if
 * an error occurs.
 *
 * @note one input packet may result in several output packets, so after sending
 * a packet with av_bsf_send_packet(), this function needs to be called
 * repeatedly until it stops returning 0. It is also possible for a filter to
 * output fewer packets than were sent to it, so this function may return
 * AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call.
 */
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);

/**
 * Free a bitstream filter context and everything associated with it; write NULL
 * into the supplied pointer.
 */
void av_bsf_free(AVBSFContext **ctx);

/**
 * Get the AVClass for AVBSFContext. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 *
 * @see av_opt_find().
 */
const AVClass *av_bsf_get_class(void);
6075

6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124
/**
 * Structure for chain/list of bitstream filters.
 * Empty list can be allocated by av_bsf_list_alloc().
 */
typedef struct AVBSFList AVBSFList;

/**
 * Allocate empty list of bitstream filters.
 * The list must be later freed by av_bsf_list_free()
 * or finalized by av_bsf_list_finalize().
 *
 * @return Pointer to @ref AVBSFList on success, NULL in case of failure
 */
AVBSFList *av_bsf_list_alloc(void);

/**
 * Free list of bitstream filters.
 *
 * @param lst Pointer to pointer returned by av_bsf_list_alloc()
 */
void av_bsf_list_free(AVBSFList **lst);

/**
 * Append bitstream filter to the list of bitstream filters.
 *
 * @param lst List to append to
 * @param bsf Filter context to be appended
 *
 * @return >=0 on success, negative AVERROR in case of failure
 */
int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf);

/**
 * Construct new bitstream filter context given it's name and options
 * and append it to the list of bitstream filters.
 *
 * @param lst      List to append to
 * @param bsf_name Name of the bitstream filter
 * @param options  Options for the bitstream filter, can be set to NULL
 *
 * @return >=0 on success, negative AVERROR in case of failure
 */
int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options);
/**
 * Finalize list of bitstream filters.
 *
 * This function will transform @ref AVBSFList to single @ref AVBSFContext,
 * so the whole chain of bitstream filters can be treated as single filter
 * freshly allocated by av_bsf_alloc().
6125
 * If the call is successful, @ref AVBSFList structure is freed and lst
6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160
 * will be set to NULL. In case of failure, caller is responsible for
 * freeing the structure by av_bsf_list_free()
 *
 * @param      lst Filter list structure to be transformed
 * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
 *                 representing the chain of bitstream filters
 *
 * @return >=0 on success, negative AVERROR in case of failure
 */
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf);

/**
 * Parse string describing list of bitstream filters and create single
 * @ref AVBSFContext describing the whole chain of bitstream filters.
 * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
 * allocated by av_bsf_alloc().
 *
 * @param      str String describing chain of bitstream filters in format
 *                 `bsf1[=opt1=val1:opt2=val2][,bsf2]`
 * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
 *                 representing the chain of bitstream filters
 *
 * @return >=0 on success, negative AVERROR in case of failure
 */
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf);

/**
 * Get null/pass-through bitstream filter.
 *
 * @param[out] bsf Pointer to be set to new instance of pass-through bitstream filter
 *
 * @return
 */
int av_bsf_get_null_filter(AVBSFContext **bsf);

6161
/* memory */
6162

6163 6164
/**
 * Same behaviour av_fast_malloc but the buffer has additional
6165
 * AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0.
6166 6167 6168 6169 6170 6171
 *
 * 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);

6172 6173 6174 6175 6176 6177
/**
 * 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);

6178
/**
6179
 * Encode extradata length to a buffer. Used by xiph codecs.
6180 6181 6182 6183 6184
 *
 * @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.
 */
6185
unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
6186

6187
#if FF_API_MISSING_SAMPLE
6188
/**
6189
 * Log a generic warning message about a missing feature. This function is
6190
 * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
6191
 * only, and would normally not be used by applications.
6192 6193 6194 6195
 * @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.
6196
 * If want_sample is non-zero, additional verbiage will be added to the log
6197 6198
 * message which tells the user how to report samples to the development
 * mailing list.
6199
 * @deprecated Use avpriv_report_missing_feature() instead.
6200
 */
6201
attribute_deprecated
6202 6203 6204
void av_log_missing_feature(void *avc, const char *feature, int want_sample);

/**
6205
 * Log a generic warning message asking for a sample. This function is
6206 6207
 * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
 * only, and would normally not be used by applications.
6208 6209 6210
 * @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
6211
 * @deprecated Use avpriv_request_sample() instead.
6212
 */
6213
attribute_deprecated
6214
void av_log_ask_for_sample(void *avc, const char *msg, ...) av_printf_format(2, 3);
6215
#endif /* FF_API_MISSING_SAMPLE */
6216

6217
/**
6218
 * Register the hardware accelerator hwaccel.
6219 6220 6221 6222 6223 6224 6225 6226
 */
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.
 */
6227
AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel);
6228

6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241

/**
 * 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
6242
 * specified by AVLockOp. The "mutex" argument to the function points
6243
 * to a (void *) where the lockmgr should store/get a pointer to a user
6244 6245
 * allocated mutex. It is NULL upon AV_LOCK_CREATE and equal to the
 * value left by the last call for all other ops. If the lock manager is
6246
 * unable to perform the op then it should leave the mutex in the same
6247
 * state as when it was called and return a non-zero value. However,
6248
 * when called with AV_LOCK_DESTROY the mutex will always be assumed to
6249
 * have been successfully destroyed. If av_lockmgr_register succeeds
6250 6251 6252 6253 6254
 * it will return a non-negative value, if it fails it will return a
 * negative value and destroy all mutex and unregister all callbacks.
 * av_lockmgr_register is not thread-safe, it must be called from a
 * single thread before any calls which make use of locking are used.
 *
6255
 * @param cb User defined callback. av_lockmgr_register invokes calls
6256 6257 6258 6259
 *           to this callback and the previously registered callback.
 *           The callback will be used to create more than one mutex
 *           each of which must be backed by its own underlying locking
 *           mechanism (i.e. do not use a single static object to
6260
 *           implement your lock manager). If cb is set to NULL the
6261
 *           lockmgr will be unregistered.
6262 6263 6264
 */
int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op));

6265 6266 6267
/**
 * Get the type of the given codec.
 */
6268
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
6269

6270
/**
6271 6272
 * Get the name of a codec.
 * @return  a static string identifying the codec; never NULL
6273
 */
6274
const char *avcodec_get_name(enum AVCodecID id);
6275

6276 6277 6278 6279 6280 6281
/**
 * @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);

6282 6283 6284
/**
 * @return a non-zero number if codec is an encoder, zero otherwise
 */
6285
int av_codec_is_encoder(const AVCodec *codec);
6286 6287 6288 6289

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

6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305
/**
 * @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);

6306 6307 6308 6309 6310 6311
/**
 * @return codec descriptor with the given name or NULL if no such descriptor
 *         exists.
 */
const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);

6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322
/**
 * Allocate a CPB properties structure and initialize its fields to default
 * values.
 *
 * @param size if non-NULL, the size of the allocated struct will be written
 *             here. This is useful for embedding it in side data.
 *
 * @return the newly allocated struct or NULL on failure
 */
AVCPBProperties *av_cpb_properties_alloc(size_t *size);

6323 6324 6325 6326
/**
 * @}
 */

6327
#endif /* AVCODEC_AVCODEC_H */