1 /* 2 * copyright (c) 2001 Fabrice Bellard 3 * 4 * This file is part of FFmpeg. 5 * 6 * FFmpeg is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * FFmpeg is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21 #ifndef AVCODEC_AVCODEC_H 22 #define AVCODEC_AVCODEC_H 23 24 /** 25 * @file 26 * @ingroup libavc 27 * 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/hwcontext.h" 40 #include "libavutil/log.h" 41 #include "libavutil/pixfmt.h" 42 #include "libavutil/rational.h" 43 44 #include "version.h" 45 46 /** 47 * @defgroup libavc libavcodec 48 * Encoding/Decoding Library 49 * 50 * @{ 51 * 52 * @defgroup lavc_decoding Decoding 53 * @{ 54 * @} 55 * 56 * @defgroup lavc_encoding Encoding 57 * @{ 58 * @} 59 * 60 * @defgroup lavc_codec Codecs 61 * @{ 62 * @defgroup lavc_codec_native Native Codecs 63 * @{ 64 * @} 65 * @defgroup lavc_codec_wrappers External library wrappers 66 * @{ 67 * @} 68 * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge 69 * @{ 70 * @} 71 * @} 72 * @defgroup lavc_internal Internal 73 * @{ 74 * @} 75 * @} 76 */ 77 78 /** 79 * @ingroup libavc 80 * @defgroup lavc_encdec send/receive encoding and decoding API overview 81 * @{ 82 * 83 * The avcodec_send_packet()/avcodec_receive_frame()/avcodec_send_frame()/ 84 * avcodec_receive_packet() functions provide an encode/decode API, which 85 * decouples input and output. 86 * 87 * The API is very similar for encoding/decoding and audio/video, and works as 88 * follows: 89 * - Set up and open the AVCodecContext as usual. 90 * - Send valid input: 91 * - For decoding, call avcodec_send_packet() to give the decoder raw 92 * compressed data in an AVPacket. 93 * - For encoding, call avcodec_send_frame() to give the encoder an AVFrame 94 * containing uncompressed audio or video. 95 * In both cases, it is recommended that AVPackets and AVFrames are 96 * refcounted, or libavcodec might have to copy the input data. (libavformat 97 * always returns refcounted AVPackets, and av_frame_get_buffer() allocates 98 * refcounted AVFrames.) 99 * - Receive output in a loop. Periodically call one of the avcodec_receive_*() 100 * functions and process their output: 101 * - For decoding, call avcodec_receive_frame(). On success, it will return 102 * an AVFrame containing uncompressed audio or video data. 103 * - For encoding, call avcodec_receive_packet(). On success, it will return 104 * an AVPacket with a compressed frame. 105 * Repeat this call until it returns AVERROR(EAGAIN) or an error. The 106 * AVERROR(EAGAIN) return value means that new input data is required to 107 * return new output. In this case, continue with sending input. For each 108 * input frame/packet, the codec will typically return 1 output frame/packet, 109 * but it can also be 0 or more than 1. 110 * 111 * At the beginning of decoding or encoding, the codec might accept multiple 112 * input frames/packets without returning a frame, until its internal buffers 113 * are filled. This situation is handled transparently if you follow the steps 114 * outlined above. 115 * 116 * In theory, sending input can result in EAGAIN - this should happen only if 117 * not all output was received. You can use this to structure alternative decode 118 * or encode loops other than the one suggested above. For example, you could 119 * try sending new input on each iteration, and try to receive output if that 120 * returns EAGAIN. 121 * 122 * End of stream situations. These require "flushing" (aka draining) the codec, 123 * as the codec might buffer multiple frames or packets internally for 124 * performance or out of necessity (consider B-frames). 125 * This is handled as follows: 126 * - Instead of valid input, send NULL to the avcodec_send_packet() (decoding) 127 * or avcodec_send_frame() (encoding) functions. This will enter draining 128 * mode. 129 * - Call avcodec_receive_frame() (decoding) or avcodec_receive_packet() 130 * (encoding) in a loop until AVERROR_EOF is returned. The functions will 131 * not return AVERROR(EAGAIN), unless you forgot to enter draining mode. 132 * - Before decoding can be resumed again, the codec has to be reset with 133 * avcodec_flush_buffers(). 134 * 135 * Using the API as outlined above is highly recommended. But it is also 136 * possible to call functions outside of this rigid schema. For example, you can 137 * call avcodec_send_packet() repeatedly without calling 138 * avcodec_receive_frame(). In this case, avcodec_send_packet() will succeed 139 * until the codec's internal buffer has been filled up (which is typically of 140 * size 1 per output frame, after initial input), and then reject input with 141 * AVERROR(EAGAIN). Once it starts rejecting input, you have no choice but to 142 * read at least some output. 143 * 144 * Not all codecs will follow a rigid and predictable dataflow; the only 145 * guarantee is that an AVERROR(EAGAIN) return value on a send/receive call on 146 * one end implies that a receive/send call on the other end will succeed, or 147 * at least will not fail with AVERROR(EAGAIN). In general, no codec will 148 * permit unlimited buffering of input or output. 149 * 150 * This API replaces the following legacy functions: 151 * - avcodec_decode_video2() and avcodec_decode_audio4(): 152 * Use avcodec_send_packet() to feed input to the decoder, then use 153 * avcodec_receive_frame() to receive decoded frames after each packet. 154 * Unlike with the old video decoding API, multiple frames might result from 155 * a packet. For audio, splitting the input packet into frames by partially 156 * decoding packets becomes transparent to the API user. You never need to 157 * feed an AVPacket to the API twice (unless it is rejected with AVERROR(EAGAIN) - then 158 * no data was read from the packet). 159 * Additionally, sending a flush/draining packet is required only once. 160 * - avcodec_encode_video2()/avcodec_encode_audio2(): 161 * Use avcodec_send_frame() to feed input to the encoder, then use 162 * avcodec_receive_packet() to receive encoded packets. 163 * Providing user-allocated buffers for avcodec_receive_packet() is not 164 * possible. 165 * - The new API does not handle subtitles yet. 166 * 167 * Mixing new and old function calls on the same AVCodecContext is not allowed, 168 * and will result in undefined behavior. 169 * 170 * Some codecs might require using the new API; using the old API will return 171 * an error when calling it. All codecs support the new API. 172 * 173 * A codec is not allowed to return AVERROR(EAGAIN) for both sending and receiving. This 174 * would be an invalid state, which could put the codec user into an endless 175 * loop. The API has no concept of time either: it cannot happen that trying to 176 * do avcodec_send_packet() results in AVERROR(EAGAIN), but a repeated call 1 second 177 * later accepts the packet (with no other receive/flush API calls involved). 178 * The API is a strict state machine, and the passage of time is not supposed 179 * to influence it. Some timing-dependent behavior might still be deemed 180 * acceptable in certain cases. But it must never result in both send/receive 181 * returning EAGAIN at the same time at any point. It must also absolutely be 182 * avoided that the current state is "unstable" and can "flip-flop" between 183 * the send/receive APIs allowing progress. For example, it's not allowed that 184 * the codec randomly decides that it actually wants to consume a packet now 185 * instead of returning a frame, after it just returned AVERROR(EAGAIN) on an 186 * avcodec_send_packet() call. 187 * @} 188 */ 189 190 /** 191 * @defgroup lavc_core Core functions/structures. 192 * @ingroup libavc 193 * 194 * Basic definitions, functions for querying libavcodec capabilities, 195 * allocating core structures, etc. 196 * @{ 197 */ 198 199 200 /** 201 * Identify the syntax and semantics of the bitstream. 202 * The principle is roughly: 203 * Two decoders with the same ID can decode the same streams. 204 * Two encoders with the same ID can encode compatible streams. 205 * There may be slight deviations from the principle due to implementation 206 * details. 207 * 208 * If you add a codec ID to this list, add it so that 209 * 1. no value of an existing codec ID changes (that would break ABI), 210 * 2. it is as close as possible to similar codecs 211 * 212 * After adding new codec IDs, do not forget to add an entry to the codec 213 * descriptor list and bump libavcodec minor version. 214 */ 215 enum AVCodecID { 216 AV_CODEC_ID_NONE, 217 218 /* video codecs */ 219 AV_CODEC_ID_MPEG1VIDEO, 220 AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding 221 AV_CODEC_ID_H261, 222 AV_CODEC_ID_H263, 223 AV_CODEC_ID_RV10, 224 AV_CODEC_ID_RV20, 225 AV_CODEC_ID_MJPEG, 226 AV_CODEC_ID_MJPEGB, 227 AV_CODEC_ID_LJPEG, 228 AV_CODEC_ID_SP5X, 229 AV_CODEC_ID_JPEGLS, 230 AV_CODEC_ID_MPEG4, 231 AV_CODEC_ID_RAWVIDEO, 232 AV_CODEC_ID_MSMPEG4V1, 233 AV_CODEC_ID_MSMPEG4V2, 234 AV_CODEC_ID_MSMPEG4V3, 235 AV_CODEC_ID_WMV1, 236 AV_CODEC_ID_WMV2, 237 AV_CODEC_ID_H263P, 238 AV_CODEC_ID_H263I, 239 AV_CODEC_ID_FLV1, 240 AV_CODEC_ID_SVQ1, 241 AV_CODEC_ID_SVQ3, 242 AV_CODEC_ID_DVVIDEO, 243 AV_CODEC_ID_HUFFYUV, 244 AV_CODEC_ID_CYUV, 245 AV_CODEC_ID_H264, 246 AV_CODEC_ID_INDEO3, 247 AV_CODEC_ID_VP3, 248 AV_CODEC_ID_THEORA, 249 AV_CODEC_ID_ASV1, 250 AV_CODEC_ID_ASV2, 251 AV_CODEC_ID_FFV1, 252 AV_CODEC_ID_4XM, 253 AV_CODEC_ID_VCR1, 254 AV_CODEC_ID_CLJR, 255 AV_CODEC_ID_MDEC, 256 AV_CODEC_ID_ROQ, 257 AV_CODEC_ID_INTERPLAY_VIDEO, 258 AV_CODEC_ID_XAN_WC3, 259 AV_CODEC_ID_XAN_WC4, 260 AV_CODEC_ID_RPZA, 261 AV_CODEC_ID_CINEPAK, 262 AV_CODEC_ID_WS_VQA, 263 AV_CODEC_ID_MSRLE, 264 AV_CODEC_ID_MSVIDEO1, 265 AV_CODEC_ID_IDCIN, 266 AV_CODEC_ID_8BPS, 267 AV_CODEC_ID_SMC, 268 AV_CODEC_ID_FLIC, 269 AV_CODEC_ID_TRUEMOTION1, 270 AV_CODEC_ID_VMDVIDEO, 271 AV_CODEC_ID_MSZH, 272 AV_CODEC_ID_ZLIB, 273 AV_CODEC_ID_QTRLE, 274 AV_CODEC_ID_TSCC, 275 AV_CODEC_ID_ULTI, 276 AV_CODEC_ID_QDRAW, 277 AV_CODEC_ID_VIXL, 278 AV_CODEC_ID_QPEG, 279 AV_CODEC_ID_PNG, 280 AV_CODEC_ID_PPM, 281 AV_CODEC_ID_PBM, 282 AV_CODEC_ID_PGM, 283 AV_CODEC_ID_PGMYUV, 284 AV_CODEC_ID_PAM, 285 AV_CODEC_ID_FFVHUFF, 286 AV_CODEC_ID_RV30, 287 AV_CODEC_ID_RV40, 288 AV_CODEC_ID_VC1, 289 AV_CODEC_ID_WMV3, 290 AV_CODEC_ID_LOCO, 291 AV_CODEC_ID_WNV1, 292 AV_CODEC_ID_AASC, 293 AV_CODEC_ID_INDEO2, 294 AV_CODEC_ID_FRAPS, 295 AV_CODEC_ID_TRUEMOTION2, 296 AV_CODEC_ID_BMP, 297 AV_CODEC_ID_CSCD, 298 AV_CODEC_ID_MMVIDEO, 299 AV_CODEC_ID_ZMBV, 300 AV_CODEC_ID_AVS, 301 AV_CODEC_ID_SMACKVIDEO, 302 AV_CODEC_ID_NUV, 303 AV_CODEC_ID_KMVC, 304 AV_CODEC_ID_FLASHSV, 305 AV_CODEC_ID_CAVS, 306 AV_CODEC_ID_JPEG2000, 307 AV_CODEC_ID_VMNC, 308 AV_CODEC_ID_VP5, 309 AV_CODEC_ID_VP6, 310 AV_CODEC_ID_VP6F, 311 AV_CODEC_ID_TARGA, 312 AV_CODEC_ID_DSICINVIDEO, 313 AV_CODEC_ID_TIERTEXSEQVIDEO, 314 AV_CODEC_ID_TIFF, 315 AV_CODEC_ID_GIF, 316 AV_CODEC_ID_DXA, 317 AV_CODEC_ID_DNXHD, 318 AV_CODEC_ID_THP, 319 AV_CODEC_ID_SGI, 320 AV_CODEC_ID_C93, 321 AV_CODEC_ID_BETHSOFTVID, 322 AV_CODEC_ID_PTX, 323 AV_CODEC_ID_TXD, 324 AV_CODEC_ID_VP6A, 325 AV_CODEC_ID_AMV, 326 AV_CODEC_ID_VB, 327 AV_CODEC_ID_PCX, 328 AV_CODEC_ID_SUNRAST, 329 AV_CODEC_ID_INDEO4, 330 AV_CODEC_ID_INDEO5, 331 AV_CODEC_ID_MIMIC, 332 AV_CODEC_ID_RL2, 333 AV_CODEC_ID_ESCAPE124, 334 AV_CODEC_ID_DIRAC, 335 AV_CODEC_ID_BFI, 336 AV_CODEC_ID_CMV, 337 AV_CODEC_ID_MOTIONPIXELS, 338 AV_CODEC_ID_TGV, 339 AV_CODEC_ID_TGQ, 340 AV_CODEC_ID_TQI, 341 AV_CODEC_ID_AURA, 342 AV_CODEC_ID_AURA2, 343 AV_CODEC_ID_V210X, 344 AV_CODEC_ID_TMV, 345 AV_CODEC_ID_V210, 346 AV_CODEC_ID_DPX, 347 AV_CODEC_ID_MAD, 348 AV_CODEC_ID_FRWU, 349 AV_CODEC_ID_FLASHSV2, 350 AV_CODEC_ID_CDGRAPHICS, 351 AV_CODEC_ID_R210, 352 AV_CODEC_ID_ANM, 353 AV_CODEC_ID_BINKVIDEO, 354 AV_CODEC_ID_IFF_ILBM, 355 #define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM 356 AV_CODEC_ID_KGV1, 357 AV_CODEC_ID_YOP, 358 AV_CODEC_ID_VP8, 359 AV_CODEC_ID_PICTOR, 360 AV_CODEC_ID_ANSI, 361 AV_CODEC_ID_A64_MULTI, 362 AV_CODEC_ID_A64_MULTI5, 363 AV_CODEC_ID_R10K, 364 AV_CODEC_ID_MXPEG, 365 AV_CODEC_ID_LAGARITH, 366 AV_CODEC_ID_PRORES, 367 AV_CODEC_ID_JV, 368 AV_CODEC_ID_DFA, 369 AV_CODEC_ID_WMV3IMAGE, 370 AV_CODEC_ID_VC1IMAGE, 371 AV_CODEC_ID_UTVIDEO, 372 AV_CODEC_ID_BMV_VIDEO, 373 AV_CODEC_ID_VBLE, 374 AV_CODEC_ID_DXTORY, 375 AV_CODEC_ID_V410, 376 AV_CODEC_ID_XWD, 377 AV_CODEC_ID_CDXL, 378 AV_CODEC_ID_XBM, 379 AV_CODEC_ID_ZEROCODEC, 380 AV_CODEC_ID_MSS1, 381 AV_CODEC_ID_MSA1, 382 AV_CODEC_ID_TSCC2, 383 AV_CODEC_ID_MTS2, 384 AV_CODEC_ID_CLLC, 385 AV_CODEC_ID_MSS2, 386 AV_CODEC_ID_VP9, 387 AV_CODEC_ID_AIC, 388 AV_CODEC_ID_ESCAPE130, 389 AV_CODEC_ID_G2M, 390 AV_CODEC_ID_WEBP, 391 AV_CODEC_ID_HNM4_VIDEO, 392 AV_CODEC_ID_HEVC, 393 #define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC 394 AV_CODEC_ID_FIC, 395 AV_CODEC_ID_ALIAS_PIX, 396 AV_CODEC_ID_BRENDER_PIX, 397 AV_CODEC_ID_PAF_VIDEO, 398 AV_CODEC_ID_EXR, 399 AV_CODEC_ID_VP7, 400 AV_CODEC_ID_SANM, 401 AV_CODEC_ID_SGIRLE, 402 AV_CODEC_ID_MVC1, 403 AV_CODEC_ID_MVC2, 404 AV_CODEC_ID_HQX, 405 AV_CODEC_ID_TDSC, 406 AV_CODEC_ID_HQ_HQA, 407 AV_CODEC_ID_HAP, 408 AV_CODEC_ID_DDS, 409 AV_CODEC_ID_DXV, 410 AV_CODEC_ID_SCREENPRESSO, 411 AV_CODEC_ID_RSCC, 412 413 AV_CODEC_ID_Y41P = 0x8000, 414 AV_CODEC_ID_AVRP, 415 AV_CODEC_ID_012V, 416 AV_CODEC_ID_AVUI, 417 AV_CODEC_ID_AYUV, 418 AV_CODEC_ID_TARGA_Y216, 419 AV_CODEC_ID_V308, 420 AV_CODEC_ID_V408, 421 AV_CODEC_ID_YUV4, 422 AV_CODEC_ID_AVRN, 423 AV_CODEC_ID_CPIA, 424 AV_CODEC_ID_XFACE, 425 AV_CODEC_ID_SNOW, 426 AV_CODEC_ID_SMVJPEG, 427 AV_CODEC_ID_APNG, 428 AV_CODEC_ID_DAALA, 429 AV_CODEC_ID_CFHD, 430 AV_CODEC_ID_TRUEMOTION2RT, 431 AV_CODEC_ID_M101, 432 AV_CODEC_ID_MAGICYUV, 433 AV_CODEC_ID_SHEERVIDEO, 434 AV_CODEC_ID_YLC, 435 AV_CODEC_ID_PSD, 436 AV_CODEC_ID_PIXLET, 437 AV_CODEC_ID_SPEEDHQ, 438 AV_CODEC_ID_FMVC, 439 AV_CODEC_ID_SCPR, 440 AV_CODEC_ID_CLEARVIDEO, 441 AV_CODEC_ID_XPM, 442 AV_CODEC_ID_AV1, 443 AV_CODEC_ID_BITPACKED, 444 AV_CODEC_ID_MSCC, 445 AV_CODEC_ID_SRGC, 446 AV_CODEC_ID_SVG, 447 AV_CODEC_ID_GDV, 448 AV_CODEC_ID_FITS, 449 450 /* various PCM "codecs" */ 451 AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs 452 AV_CODEC_ID_PCM_S16LE = 0x10000, 453 AV_CODEC_ID_PCM_S16BE, 454 AV_CODEC_ID_PCM_U16LE, 455 AV_CODEC_ID_PCM_U16BE, 456 AV_CODEC_ID_PCM_S8, 457 AV_CODEC_ID_PCM_U8, 458 AV_CODEC_ID_PCM_MULAW, 459 AV_CODEC_ID_PCM_ALAW, 460 AV_CODEC_ID_PCM_S32LE, 461 AV_CODEC_ID_PCM_S32BE, 462 AV_CODEC_ID_PCM_U32LE, 463 AV_CODEC_ID_PCM_U32BE, 464 AV_CODEC_ID_PCM_S24LE, 465 AV_CODEC_ID_PCM_S24BE, 466 AV_CODEC_ID_PCM_U24LE, 467 AV_CODEC_ID_PCM_U24BE, 468 AV_CODEC_ID_PCM_S24DAUD, 469 AV_CODEC_ID_PCM_ZORK, 470 AV_CODEC_ID_PCM_S16LE_PLANAR, 471 AV_CODEC_ID_PCM_DVD, 472 AV_CODEC_ID_PCM_F32BE, 473 AV_CODEC_ID_PCM_F32LE, 474 AV_CODEC_ID_PCM_F64BE, 475 AV_CODEC_ID_PCM_F64LE, 476 AV_CODEC_ID_PCM_BLURAY, 477 AV_CODEC_ID_PCM_LXF, 478 AV_CODEC_ID_S302M, 479 AV_CODEC_ID_PCM_S8_PLANAR, 480 AV_CODEC_ID_PCM_S24LE_PLANAR, 481 AV_CODEC_ID_PCM_S32LE_PLANAR, 482 AV_CODEC_ID_PCM_S16BE_PLANAR, 483 484 AV_CODEC_ID_PCM_S64LE = 0x10800, 485 AV_CODEC_ID_PCM_S64BE, 486 AV_CODEC_ID_PCM_F16LE, 487 AV_CODEC_ID_PCM_F24LE, 488 489 /* various ADPCM codecs */ 490 AV_CODEC_ID_ADPCM_IMA_QT = 0x11000, 491 AV_CODEC_ID_ADPCM_IMA_WAV, 492 AV_CODEC_ID_ADPCM_IMA_DK3, 493 AV_CODEC_ID_ADPCM_IMA_DK4, 494 AV_CODEC_ID_ADPCM_IMA_WS, 495 AV_CODEC_ID_ADPCM_IMA_SMJPEG, 496 AV_CODEC_ID_ADPCM_MS, 497 AV_CODEC_ID_ADPCM_4XM, 498 AV_CODEC_ID_ADPCM_XA, 499 AV_CODEC_ID_ADPCM_ADX, 500 AV_CODEC_ID_ADPCM_EA, 501 AV_CODEC_ID_ADPCM_G726, 502 AV_CODEC_ID_ADPCM_CT, 503 AV_CODEC_ID_ADPCM_SWF, 504 AV_CODEC_ID_ADPCM_YAMAHA, 505 AV_CODEC_ID_ADPCM_SBPRO_4, 506 AV_CODEC_ID_ADPCM_SBPRO_3, 507 AV_CODEC_ID_ADPCM_SBPRO_2, 508 AV_CODEC_ID_ADPCM_THP, 509 AV_CODEC_ID_ADPCM_IMA_AMV, 510 AV_CODEC_ID_ADPCM_EA_R1, 511 AV_CODEC_ID_ADPCM_EA_R3, 512 AV_CODEC_ID_ADPCM_EA_R2, 513 AV_CODEC_ID_ADPCM_IMA_EA_SEAD, 514 AV_CODEC_ID_ADPCM_IMA_EA_EACS, 515 AV_CODEC_ID_ADPCM_EA_XAS, 516 AV_CODEC_ID_ADPCM_EA_MAXIS_XA, 517 AV_CODEC_ID_ADPCM_IMA_ISS, 518 AV_CODEC_ID_ADPCM_G722, 519 AV_CODEC_ID_ADPCM_IMA_APC, 520 AV_CODEC_ID_ADPCM_VIMA, 521 522 AV_CODEC_ID_ADPCM_AFC = 0x11800, 523 AV_CODEC_ID_ADPCM_IMA_OKI, 524 AV_CODEC_ID_ADPCM_DTK, 525 AV_CODEC_ID_ADPCM_IMA_RAD, 526 AV_CODEC_ID_ADPCM_G726LE, 527 AV_CODEC_ID_ADPCM_THP_LE, 528 AV_CODEC_ID_ADPCM_PSX, 529 AV_CODEC_ID_ADPCM_AICA, 530 AV_CODEC_ID_ADPCM_IMA_DAT4, 531 AV_CODEC_ID_ADPCM_MTAF, 532 533 /* AMR */ 534 AV_CODEC_ID_AMR_NB = 0x12000, 535 AV_CODEC_ID_AMR_WB, 536 537 /* RealAudio codecs*/ 538 AV_CODEC_ID_RA_144 = 0x13000, 539 AV_CODEC_ID_RA_288, 540 541 /* various DPCM codecs */ 542 AV_CODEC_ID_ROQ_DPCM = 0x14000, 543 AV_CODEC_ID_INTERPLAY_DPCM, 544 AV_CODEC_ID_XAN_DPCM, 545 AV_CODEC_ID_SOL_DPCM, 546 547 AV_CODEC_ID_SDX2_DPCM = 0x14800, 548 AV_CODEC_ID_GREMLIN_DPCM, 549 550 /* audio codecs */ 551 AV_CODEC_ID_MP2 = 0x15000, 552 AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3 553 AV_CODEC_ID_AAC, 554 AV_CODEC_ID_AC3, 555 AV_CODEC_ID_DTS, 556 AV_CODEC_ID_VORBIS, 557 AV_CODEC_ID_DVAUDIO, 558 AV_CODEC_ID_WMAV1, 559 AV_CODEC_ID_WMAV2, 560 AV_CODEC_ID_MACE3, 561 AV_CODEC_ID_MACE6, 562 AV_CODEC_ID_VMDAUDIO, 563 AV_CODEC_ID_FLAC, 564 AV_CODEC_ID_MP3ADU, 565 AV_CODEC_ID_MP3ON4, 566 AV_CODEC_ID_SHORTEN, 567 AV_CODEC_ID_ALAC, 568 AV_CODEC_ID_WESTWOOD_SND1, 569 AV_CODEC_ID_GSM, ///< as in Berlin toast format 570 AV_CODEC_ID_QDM2, 571 AV_CODEC_ID_COOK, 572 AV_CODEC_ID_TRUESPEECH, 573 AV_CODEC_ID_TTA, 574 AV_CODEC_ID_SMACKAUDIO, 575 AV_CODEC_ID_QCELP, 576 AV_CODEC_ID_WAVPACK, 577 AV_CODEC_ID_DSICINAUDIO, 578 AV_CODEC_ID_IMC, 579 AV_CODEC_ID_MUSEPACK7, 580 AV_CODEC_ID_MLP, 581 AV_CODEC_ID_GSM_MS, /* as found in WAV */ 582 AV_CODEC_ID_ATRAC3, 583 AV_CODEC_ID_APE, 584 AV_CODEC_ID_NELLYMOSER, 585 AV_CODEC_ID_MUSEPACK8, 586 AV_CODEC_ID_SPEEX, 587 AV_CODEC_ID_WMAVOICE, 588 AV_CODEC_ID_WMAPRO, 589 AV_CODEC_ID_WMALOSSLESS, 590 AV_CODEC_ID_ATRAC3P, 591 AV_CODEC_ID_EAC3, 592 AV_CODEC_ID_SIPR, 593 AV_CODEC_ID_MP1, 594 AV_CODEC_ID_TWINVQ, 595 AV_CODEC_ID_TRUEHD, 596 AV_CODEC_ID_MP4ALS, 597 AV_CODEC_ID_ATRAC1, 598 AV_CODEC_ID_BINKAUDIO_RDFT, 599 AV_CODEC_ID_BINKAUDIO_DCT, 600 AV_CODEC_ID_AAC_LATM, 601 AV_CODEC_ID_QDMC, 602 AV_CODEC_ID_CELT, 603 AV_CODEC_ID_G723_1, 604 AV_CODEC_ID_G729, 605 AV_CODEC_ID_8SVX_EXP, 606 AV_CODEC_ID_8SVX_FIB, 607 AV_CODEC_ID_BMV_AUDIO, 608 AV_CODEC_ID_RALF, 609 AV_CODEC_ID_IAC, 610 AV_CODEC_ID_ILBC, 611 AV_CODEC_ID_OPUS, 612 AV_CODEC_ID_COMFORT_NOISE, 613 AV_CODEC_ID_TAK, 614 AV_CODEC_ID_METASOUND, 615 AV_CODEC_ID_PAF_AUDIO, 616 AV_CODEC_ID_ON2AVC, 617 AV_CODEC_ID_DSS_SP, 618 AV_CODEC_ID_CODEC2, 619 620 AV_CODEC_ID_FFWAVESYNTH = 0x15800, 621 AV_CODEC_ID_SONIC, 622 AV_CODEC_ID_SONIC_LS, 623 AV_CODEC_ID_EVRC, 624 AV_CODEC_ID_SMV, 625 AV_CODEC_ID_DSD_LSBF, 626 AV_CODEC_ID_DSD_MSBF, 627 AV_CODEC_ID_DSD_LSBF_PLANAR, 628 AV_CODEC_ID_DSD_MSBF_PLANAR, 629 AV_CODEC_ID_4GV, 630 AV_CODEC_ID_INTERPLAY_ACM, 631 AV_CODEC_ID_XMA1, 632 AV_CODEC_ID_XMA2, 633 AV_CODEC_ID_DST, 634 AV_CODEC_ID_ATRAC3AL, 635 AV_CODEC_ID_ATRAC3PAL, 636 AV_CODEC_ID_DOLBY_E, 637 AV_CODEC_ID_APTX, 638 AV_CODEC_ID_APTX_HD, 639 AV_CODEC_ID_SBC, 640 641 /* subtitle codecs */ 642 AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs. 643 AV_CODEC_ID_DVD_SUBTITLE = 0x17000, 644 AV_CODEC_ID_DVB_SUBTITLE, 645 AV_CODEC_ID_TEXT, ///< raw UTF-8 text 646 AV_CODEC_ID_XSUB, 647 AV_CODEC_ID_SSA, 648 AV_CODEC_ID_MOV_TEXT, 649 AV_CODEC_ID_HDMV_PGS_SUBTITLE, 650 AV_CODEC_ID_DVB_TELETEXT, 651 AV_CODEC_ID_SRT, 652 653 AV_CODEC_ID_MICRODVD = 0x17800, 654 AV_CODEC_ID_EIA_608, 655 AV_CODEC_ID_JACOSUB, 656 AV_CODEC_ID_SAMI, 657 AV_CODEC_ID_REALTEXT, 658 AV_CODEC_ID_STL, 659 AV_CODEC_ID_SUBVIEWER1, 660 AV_CODEC_ID_SUBVIEWER, 661 AV_CODEC_ID_SUBRIP, 662 AV_CODEC_ID_WEBVTT, 663 AV_CODEC_ID_MPL2, 664 AV_CODEC_ID_VPLAYER, 665 AV_CODEC_ID_PJS, 666 AV_CODEC_ID_ASS, 667 AV_CODEC_ID_HDMV_TEXT_SUBTITLE, 668 669 /* other specific kind of codecs (generally used for attachments) */ 670 AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs. 671 AV_CODEC_ID_TTF = 0x18000, 672 673 AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream. 674 AV_CODEC_ID_BINTEXT = 0x18800, 675 AV_CODEC_ID_XBIN, 676 AV_CODEC_ID_IDF, 677 AV_CODEC_ID_OTF, 678 AV_CODEC_ID_SMPTE_KLV, 679 AV_CODEC_ID_DVD_NAV, 680 AV_CODEC_ID_TIMED_ID3, 681 AV_CODEC_ID_BIN_DATA, 682 683 684 AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it 685 686 AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS 687 * stream (only used by libavformat) */ 688 AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems 689 * stream (only used by libavformat) */ 690 AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information. 691 AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket 692 }; 693 694 /** 695 * This struct describes the properties of a single codec described by an 696 * AVCodecID. 697 * @see avcodec_descriptor_get() 698 */ 699 typedef struct AVCodecDescriptor { 700 enum AVCodecID id; 701 enum AVMediaType type; 702 /** 703 * Name of the codec described by this descriptor. It is non-empty and 704 * unique for each codec descriptor. It should contain alphanumeric 705 * characters and '_' only. 706 */ 707 const char *name; 708 /** 709 * A more descriptive name for this codec. May be NULL. 710 */ 711 const char *long_name; 712 /** 713 * Codec properties, a combination of AV_CODEC_PROP_* flags. 714 */ 715 int props; 716 /** 717 * MIME type(s) associated with the codec. 718 * May be NULL; if not, a NULL-terminated array of MIME types. 719 * The first item is always non-NULL and is the preferred MIME type. 720 */ 721 const char *const *mime_types; 722 /** 723 * If non-NULL, an array of profiles recognized for this codec. 724 * Terminated with FF_PROFILE_UNKNOWN. 725 */ 726 const struct AVProfile *profiles; 727 } AVCodecDescriptor; 728 729 /** 730 * Codec uses only intra compression. 731 * Video and audio codecs only. 732 */ 733 #define AV_CODEC_PROP_INTRA_ONLY (1 << 0) 734 /** 735 * Codec supports lossy compression. Audio and video codecs only. 736 * @note a codec may support both lossy and lossless 737 * compression modes 738 */ 739 #define AV_CODEC_PROP_LOSSY (1 << 1) 740 /** 741 * Codec supports lossless compression. Audio and video codecs only. 742 */ 743 #define AV_CODEC_PROP_LOSSLESS (1 << 2) 744 /** 745 * Codec supports frame reordering. That is, the coded order (the order in which 746 * the encoded packets are output by the encoders / stored / input to the 747 * decoders) may be different from the presentation order of the corresponding 748 * frames. 749 * 750 * For codecs that do not have this property set, PTS and DTS should always be 751 * equal. 752 */ 753 #define AV_CODEC_PROP_REORDER (1 << 3) 754 /** 755 * Subtitle codec is bitmap based 756 * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field. 757 */ 758 #define AV_CODEC_PROP_BITMAP_SUB (1 << 16) 759 /** 760 * Subtitle codec is text based. 761 * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field. 762 */ 763 #define AV_CODEC_PROP_TEXT_SUB (1 << 17) 764 765 /** 766 * @ingroup lavc_decoding 767 * Required number of additionally allocated bytes at the end of the input bitstream for decoding. 768 * This is mainly needed because some optimized bitstream readers read 769 * 32 or 64 bit at once and could read over the end.<br> 770 * Note: If the first 23 bits of the additional bytes are not 0, then damaged 771 * MPEG bitstreams could cause overread and segfault. 772 */ 773 #define AV_INPUT_BUFFER_PADDING_SIZE 64 774 775 /** 776 * @ingroup lavc_encoding 777 * minimum encoding buffer size 778 * Used to avoid some checks during header writing. 779 */ 780 #define AV_INPUT_BUFFER_MIN_SIZE 16384 781 782 /** 783 * @ingroup lavc_decoding 784 */ 785 enum AVDiscard{ 786 /* We leave some space between them for extensions (drop some 787 * keyframes for intra-only or drop just some bidir frames). */ 788 AVDISCARD_NONE =-16, ///< discard nothing 789 AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi 790 AVDISCARD_NONREF = 8, ///< discard all non reference 791 AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames 792 AVDISCARD_NONINTRA= 24, ///< discard all non intra frames 793 AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes 794 AVDISCARD_ALL = 48, ///< discard all 795 }; 796 797 enum AVAudioServiceType { 798 AV_AUDIO_SERVICE_TYPE_MAIN = 0, 799 AV_AUDIO_SERVICE_TYPE_EFFECTS = 1, 800 AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2, 801 AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3, 802 AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4, 803 AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5, 804 AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6, 805 AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7, 806 AV_AUDIO_SERVICE_TYPE_KARAOKE = 8, 807 AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI 808 }; 809 810 /** 811 * @ingroup lavc_encoding 812 */ 813 typedef struct RcOverride{ 814 int start_frame; 815 int end_frame; 816 int qscale; // If this is 0 then quality_factor will be used instead. 817 float quality_factor; 818 } RcOverride; 819 820 /* encoding support 821 These flags can be passed in AVCodecContext.flags before initialization. 822 Note: Not everything is supported yet. 823 */ 824 825 /** 826 * Allow decoders to produce frames with data planes that are not aligned 827 * to CPU requirements (e.g. due to cropping). 828 */ 829 #define AV_CODEC_FLAG_UNALIGNED (1 << 0) 830 /** 831 * Use fixed qscale. 832 */ 833 #define AV_CODEC_FLAG_QSCALE (1 << 1) 834 /** 835 * 4 MV per MB allowed / advanced prediction for H.263. 836 */ 837 #define AV_CODEC_FLAG_4MV (1 << 2) 838 /** 839 * Output even those frames that might be corrupted. 840 */ 841 #define AV_CODEC_FLAG_OUTPUT_CORRUPT (1 << 3) 842 /** 843 * Use qpel MC. 844 */ 845 #define AV_CODEC_FLAG_QPEL (1 << 4) 846 /** 847 * Use internal 2pass ratecontrol in first pass mode. 848 */ 849 #define AV_CODEC_FLAG_PASS1 (1 << 9) 850 /** 851 * Use internal 2pass ratecontrol in second pass mode. 852 */ 853 #define AV_CODEC_FLAG_PASS2 (1 << 10) 854 /** 855 * loop filter. 856 */ 857 #define AV_CODEC_FLAG_LOOP_FILTER (1 << 11) 858 /** 859 * Only decode/encode grayscale. 860 */ 861 #define AV_CODEC_FLAG_GRAY (1 << 13) 862 /** 863 * error[?] variables will be set during encoding. 864 */ 865 #define AV_CODEC_FLAG_PSNR (1 << 15) 866 /** 867 * Input bitstream might be truncated at a random location 868 * instead of only at frame boundaries. 869 */ 870 #define AV_CODEC_FLAG_TRUNCATED (1 << 16) 871 /** 872 * Use interlaced DCT. 873 */ 874 #define AV_CODEC_FLAG_INTERLACED_DCT (1 << 18) 875 /** 876 * Force low delay. 877 */ 878 #define AV_CODEC_FLAG_LOW_DELAY (1 << 19) 879 /** 880 * Place global headers in extradata instead of every keyframe. 881 */ 882 #define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22) 883 /** 884 * Use only bitexact stuff (except (I)DCT). 885 */ 886 #define AV_CODEC_FLAG_BITEXACT (1 << 23) 887 /* Fx : Flag for H.263+ extra options */ 888 /** 889 * H.263 advanced intra coding / MPEG-4 AC prediction 890 */ 891 #define AV_CODEC_FLAG_AC_PRED (1 << 24) 892 /** 893 * interlaced motion estimation 894 */ 895 #define AV_CODEC_FLAG_INTERLACED_ME (1 << 29) 896 #define AV_CODEC_FLAG_CLOSED_GOP (1U << 31) 897 898 /** 899 * Allow non spec compliant speedup tricks. 900 */ 901 #define AV_CODEC_FLAG2_FAST (1 << 0) 902 /** 903 * Skip bitstream encoding. 904 */ 905 #define AV_CODEC_FLAG2_NO_OUTPUT (1 << 2) 906 /** 907 * Place global headers at every keyframe instead of in extradata. 908 */ 909 #define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3) 910 911 /** 912 * timecode is in drop frame format. DEPRECATED!!!! 913 */ 914 #define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13) 915 916 /** 917 * Input bitstream might be truncated at a packet boundaries 918 * instead of only at frame boundaries. 919 */ 920 #define AV_CODEC_FLAG2_CHUNKS (1 << 15) 921 /** 922 * Discard cropping information from SPS. 923 */ 924 #define AV_CODEC_FLAG2_IGNORE_CROP (1 << 16) 925 926 /** 927 * Show all frames before the first keyframe 928 */ 929 #define AV_CODEC_FLAG2_SHOW_ALL (1 << 22) 930 /** 931 * Export motion vectors through frame side data 932 */ 933 #define AV_CODEC_FLAG2_EXPORT_MVS (1 << 28) 934 /** 935 * Do not skip samples and export skip information as frame side data 936 */ 937 #define AV_CODEC_FLAG2_SKIP_MANUAL (1 << 29) 938 /** 939 * Do not reset ASS ReadOrder field on flush (subtitles decoding) 940 */ 941 #define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30) 942 943 /* Unsupported options : 944 * Syntax Arithmetic coding (SAC) 945 * Reference Picture Selection 946 * Independent Segment Decoding */ 947 /* /Fx */ 948 /* codec capabilities */ 949 950 /** 951 * Decoder can use draw_horiz_band callback. 952 */ 953 #define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0) 954 /** 955 * Codec uses get_buffer() for allocating buffers and supports custom allocators. 956 * If not set, it might not use get_buffer() at all or use operations that 957 * assume the buffer was allocated by avcodec_default_get_buffer. 958 */ 959 #define AV_CODEC_CAP_DR1 (1 << 1) 960 #define AV_CODEC_CAP_TRUNCATED (1 << 3) 961 /** 962 * Encoder or decoder requires flushing with NULL input at the end in order to 963 * give the complete and correct output. 964 * 965 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with 966 * with NULL data. The user can still send NULL data to the public encode 967 * or decode function, but libavcodec will not pass it along to the codec 968 * unless this flag is set. 969 * 970 * Decoders: 971 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL, 972 * avpkt->size=0 at the end to get the delayed data until the decoder no longer 973 * returns frames. 974 * 975 * Encoders: 976 * The encoder needs to be fed with NULL data at the end of encoding until the 977 * encoder no longer returns data. 978 * 979 * NOTE: For encoders implementing the AVCodec.encode2() function, setting this 980 * flag also means that the encoder must set the pts and duration for 981 * each output packet. If this flag is not set, the pts and duration will 982 * be determined by libavcodec from the input frame. 983 */ 984 #define AV_CODEC_CAP_DELAY (1 << 5) 985 /** 986 * Codec can be fed a final frame with a smaller size. 987 * This can be used to prevent truncation of the last audio samples. 988 */ 989 #define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6) 990 991 /** 992 * Codec can output multiple frames per AVPacket 993 * Normally demuxers return one frame at a time, demuxers which do not do 994 * are connected to a parser to split what they return into proper frames. 995 * This flag is reserved to the very rare category of codecs which have a 996 * bitstream that cannot be split into frames without timeconsuming 997 * operations like full decoding. Demuxers carrying such bitstreams thus 998 * may return multiple frames in a packet. This has many disadvantages like 999 * prohibiting stream copy in many cases thus it should only be considered 1000 * as a last resort. 1001 */ 1002 #define AV_CODEC_CAP_SUBFRAMES (1 << 8) 1003 /** 1004 * Codec is experimental and is thus avoided in favor of non experimental 1005 * encoders 1006 */ 1007 #define AV_CODEC_CAP_EXPERIMENTAL (1 << 9) 1008 /** 1009 * Codec should fill in channel configuration and samplerate instead of container 1010 */ 1011 #define AV_CODEC_CAP_CHANNEL_CONF (1 << 10) 1012 /** 1013 * Codec supports frame-level multithreading. 1014 */ 1015 #define AV_CODEC_CAP_FRAME_THREADS (1 << 12) 1016 /** 1017 * Codec supports slice-based (or partition-based) multithreading. 1018 */ 1019 #define AV_CODEC_CAP_SLICE_THREADS (1 << 13) 1020 /** 1021 * Codec supports changed parameters at any point. 1022 */ 1023 #define AV_CODEC_CAP_PARAM_CHANGE (1 << 14) 1024 /** 1025 * Codec supports avctx->thread_count == 0 (auto). 1026 */ 1027 #define AV_CODEC_CAP_AUTO_THREADS (1 << 15) 1028 /** 1029 * Audio encoder supports receiving a different number of samples in each call. 1030 */ 1031 #define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16) 1032 /** 1033 * Decoder is not a preferred choice for probing. 1034 * This indicates that the decoder is not a good choice for probing. 1035 * It could for example be an expensive to spin up hardware decoder, 1036 * or it could simply not provide a lot of useful information about 1037 * the stream. 1038 * A decoder marked with this flag should only be used as last resort 1039 * choice for probing. 1040 */ 1041 #define AV_CODEC_CAP_AVOID_PROBING (1 << 17) 1042 /** 1043 * Codec is intra only. 1044 */ 1045 #define AV_CODEC_CAP_INTRA_ONLY 0x40000000 1046 /** 1047 * Codec is lossless. 1048 */ 1049 #define AV_CODEC_CAP_LOSSLESS 0x80000000 1050 1051 /** 1052 * Codec is backed by a hardware implementation. Typically used to 1053 * identify a non-hwaccel hardware decoder. For information about hwaccels, use 1054 * avcodec_get_hw_config() instead. 1055 */ 1056 #define AV_CODEC_CAP_HARDWARE (1 << 18) 1057 1058 /** 1059 * Codec is potentially backed by a hardware implementation, but not 1060 * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the 1061 * implementation provides some sort of internal fallback. 1062 */ 1063 #define AV_CODEC_CAP_HYBRID (1 << 19) 1064 1065 /** 1066 * Pan Scan area. 1067 * This specifies the area which should be displayed. 1068 * Note there may be multiple such areas for one frame. 1069 */ 1070 typedef struct AVPanScan { 1071 /** 1072 * id 1073 * - encoding: Set by user. 1074 * - decoding: Set by libavcodec. 1075 */ 1076 int id; 1077 1078 /** 1079 * width and height in 1/16 pel 1080 * - encoding: Set by user. 1081 * - decoding: Set by libavcodec. 1082 */ 1083 int width; 1084 int height; 1085 1086 /** 1087 * position of the top left corner in 1/16 pel for up to 3 fields/frames 1088 * - encoding: Set by user. 1089 * - decoding: Set by libavcodec. 1090 */ 1091 int16_t position[3][2]; 1092 } AVPanScan; 1093 1094 /** 1095 * This structure describes the bitrate properties of an encoded bitstream. It 1096 * roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD 1097 * parameters for H.264/HEVC. 1098 */ 1099 typedef struct AVCPBProperties { 1100 /** 1101 * Maximum bitrate of the stream, in bits per second. 1102 * Zero if unknown or unspecified. 1103 */ 1104 int max_bitrate; 1105 /** 1106 * Minimum bitrate of the stream, in bits per second. 1107 * Zero if unknown or unspecified. 1108 */ 1109 int min_bitrate; 1110 /** 1111 * Average bitrate of the stream, in bits per second. 1112 * Zero if unknown or unspecified. 1113 */ 1114 int avg_bitrate; 1115 1116 /** 1117 * The size of the buffer to which the ratecontrol is applied, in bits. 1118 * Zero if unknown or unspecified. 1119 */ 1120 int buffer_size; 1121 1122 /** 1123 * The delay between the time the packet this structure is associated with 1124 * is received and the time when it should be decoded, in periods of a 27MHz 1125 * clock. 1126 * 1127 * UINT64_MAX when unknown or unspecified. 1128 */ 1129 uint64_t vbv_delay; 1130 } AVCPBProperties; 1131 1132 /** 1133 * The decoder will keep a reference to the frame and may reuse it later. 1134 */ 1135 #define AV_GET_BUFFER_FLAG_REF (1 << 0) 1136 1137 /** 1138 * @defgroup lavc_packet AVPacket 1139 * 1140 * Types and functions for working with AVPacket. 1141 * @{ 1142 */ 1143 enum AVPacketSideDataType { 1144 /** 1145 * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE 1146 * bytes worth of palette. This side data signals that a new palette is 1147 * present. 1148 */ 1149 AV_PKT_DATA_PALETTE, 1150 1151 /** 1152 * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format 1153 * that the extradata buffer was changed and the receiving side should 1154 * act upon it appropriately. The new extradata is embedded in the side 1155 * data buffer and should be immediately used for processing the current 1156 * frame or packet. 1157 */ 1158 AV_PKT_DATA_NEW_EXTRADATA, 1159 1160 /** 1161 * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows: 1162 * @code 1163 * u32le param_flags 1164 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) 1165 * s32le channel_count 1166 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) 1167 * u64le channel_layout 1168 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) 1169 * s32le sample_rate 1170 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) 1171 * s32le width 1172 * s32le height 1173 * @endcode 1174 */ 1175 AV_PKT_DATA_PARAM_CHANGE, 1176 1177 /** 1178 * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of 1179 * structures with info about macroblocks relevant to splitting the 1180 * packet into smaller packets on macroblock edges (e.g. as for RFC 2190). 1181 * That is, it does not necessarily contain info about all macroblocks, 1182 * as long as the distance between macroblocks in the info is smaller 1183 * than the target payload size. 1184 * Each MB info structure is 12 bytes, and is laid out as follows: 1185 * @code 1186 * u32le bit offset from the start of the packet 1187 * u8 current quantizer at the start of the macroblock 1188 * u8 GOB number 1189 * u16le macroblock address within the GOB 1190 * u8 horizontal MV predictor 1191 * u8 vertical MV predictor 1192 * u8 horizontal MV predictor for block number 3 1193 * u8 vertical MV predictor for block number 3 1194 * @endcode 1195 */ 1196 AV_PKT_DATA_H263_MB_INFO, 1197 1198 /** 1199 * This side data should be associated with an audio stream and contains 1200 * ReplayGain information in form of the AVReplayGain struct. 1201 */ 1202 AV_PKT_DATA_REPLAYGAIN, 1203 1204 /** 1205 * This side data contains a 3x3 transformation matrix describing an affine 1206 * transformation that needs to be applied to the decoded video frames for 1207 * correct presentation. 1208 * 1209 * See libavutil/display.h for a detailed description of the data. 1210 */ 1211 AV_PKT_DATA_DISPLAYMATRIX, 1212 1213 /** 1214 * This side data should be associated with a video stream and contains 1215 * Stereoscopic 3D information in form of the AVStereo3D struct. 1216 */ 1217 AV_PKT_DATA_STEREO3D, 1218 1219 /** 1220 * This side data should be associated with an audio stream and corresponds 1221 * to enum AVAudioServiceType. 1222 */ 1223 AV_PKT_DATA_AUDIO_SERVICE_TYPE, 1224 1225 /** 1226 * This side data contains quality related information from the encoder. 1227 * @code 1228 * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad). 1229 * u8 picture type 1230 * u8 error count 1231 * u16 reserved 1232 * u64le[error count] sum of squared differences between encoder in and output 1233 * @endcode 1234 */ 1235 AV_PKT_DATA_QUALITY_STATS, 1236 1237 /** 1238 * This side data contains an integer value representing the stream index 1239 * of a "fallback" track. A fallback track indicates an alternate 1240 * track to use when the current track can not be decoded for some reason. 1241 * e.g. no decoder available for codec. 1242 */ 1243 AV_PKT_DATA_FALLBACK_TRACK, 1244 1245 /** 1246 * This side data corresponds to the AVCPBProperties struct. 1247 */ 1248 AV_PKT_DATA_CPB_PROPERTIES, 1249 1250 /** 1251 * Recommmends skipping the specified number of samples 1252 * @code 1253 * u32le number of samples to skip from start of this packet 1254 * u32le number of samples to skip from end of this packet 1255 * u8 reason for start skip 1256 * u8 reason for end skip (0=padding silence, 1=convergence) 1257 * @endcode 1258 */ 1259 AV_PKT_DATA_SKIP_SAMPLES, 1260 1261 /** 1262 * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that 1263 * the packet may contain "dual mono" audio specific to Japanese DTV 1264 * and if it is true, recommends only the selected channel to be used. 1265 * @code 1266 * u8 selected channels (0=mail/left, 1=sub/right, 2=both) 1267 * @endcode 1268 */ 1269 AV_PKT_DATA_JP_DUALMONO, 1270 1271 /** 1272 * A list of zero terminated key/value strings. There is no end marker for 1273 * the list, so it is required to rely on the side data size to stop. 1274 */ 1275 AV_PKT_DATA_STRINGS_METADATA, 1276 1277 /** 1278 * Subtitle event position 1279 * @code 1280 * u32le x1 1281 * u32le y1 1282 * u32le x2 1283 * u32le y2 1284 * @endcode 1285 */ 1286 AV_PKT_DATA_SUBTITLE_POSITION, 1287 1288 /** 1289 * Data found in BlockAdditional element of matroska container. There is 1290 * no end marker for the data, so it is required to rely on the side data 1291 * size to recognize the end. 8 byte id (as found in BlockAddId) followed 1292 * by data. 1293 */ 1294 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, 1295 1296 /** 1297 * The optional first identifier line of a WebVTT cue. 1298 */ 1299 AV_PKT_DATA_WEBVTT_IDENTIFIER, 1300 1301 /** 1302 * The optional settings (rendering instructions) that immediately 1303 * follow the timestamp specifier of a WebVTT cue. 1304 */ 1305 AV_PKT_DATA_WEBVTT_SETTINGS, 1306 1307 /** 1308 * A list of zero terminated key/value strings. There is no end marker for 1309 * the list, so it is required to rely on the side data size to stop. This 1310 * side data includes updated metadata which appeared in the stream. 1311 */ 1312 AV_PKT_DATA_METADATA_UPDATE, 1313 1314 /** 1315 * MPEGTS stream ID, this is required to pass the stream ID 1316 * information from the demuxer to the corresponding muxer. 1317 */ 1318 AV_PKT_DATA_MPEGTS_STREAM_ID, 1319 1320 /** 1321 * Mastering display metadata (based on SMPTE-2086:2014). This metadata 1322 * should be associated with a video stream and contains data in the form 1323 * of the AVMasteringDisplayMetadata struct. 1324 */ 1325 AV_PKT_DATA_MASTERING_DISPLAY_METADATA, 1326 1327 /** 1328 * This side data should be associated with a video stream and corresponds 1329 * to the AVSphericalMapping structure. 1330 */ 1331 AV_PKT_DATA_SPHERICAL, 1332 1333 /** 1334 * Content light level (based on CTA-861.3). This metadata should be 1335 * associated with a video stream and contains data in the form of the 1336 * AVContentLightMetadata struct. 1337 */ 1338 AV_PKT_DATA_CONTENT_LIGHT_LEVEL, 1339 1340 /** 1341 * ATSC A53 Part 4 Closed Captions. This metadata should be associated with 1342 * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data. 1343 * The number of bytes of CC data is AVPacketSideData.size. 1344 */ 1345 AV_PKT_DATA_A53_CC, 1346 1347 /** 1348 * This side data is encryption initialization data. 1349 * The format is not part of ABI, use av_encryption_init_info_* methods to 1350 * access. 1351 */ 1352 AV_PKT_DATA_ENCRYPTION_INIT_INFO, 1353 1354 /** 1355 * This side data contains encryption info for how to decrypt the packet. 1356 * The format is not part of ABI, use av_encryption_info_* methods to access. 1357 */ 1358 AV_PKT_DATA_ENCRYPTION_INFO, 1359 1360 /** 1361 * The number of side data types. 1362 * This is not part of the public API/ABI in the sense that it may 1363 * change when new side data types are added. 1364 * This must stay the last enum value. 1365 * If its value becomes huge, some code using it 1366 * needs to be updated as it assumes it to be smaller than other limits. 1367 */ 1368 AV_PKT_DATA_NB 1369 }; 1370 1371 #define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED 1372 1373 typedef struct AVPacketSideData { 1374 uint8_t *data; 1375 int size; 1376 enum AVPacketSideDataType type; 1377 } AVPacketSideData; 1378 1379 /** 1380 * This structure stores compressed data. It is typically exported by demuxers 1381 * and then passed as input to decoders, or received as output from encoders and 1382 * then passed to muxers. 1383 * 1384 * For video, it should typically contain one compressed frame. For audio it may 1385 * contain several compressed frames. Encoders are allowed to output empty 1386 * packets, with no compressed data, containing only side data 1387 * (e.g. to update some stream parameters at the end of encoding). 1388 * 1389 * AVPacket is one of the few structs in FFmpeg, whose size is a part of public 1390 * ABI. Thus it may be allocated on stack and no new fields can be added to it 1391 * without libavcodec and libavformat major bump. 1392 * 1393 * The semantics of data ownership depends on the buf field. 1394 * If it is set, the packet data is dynamically allocated and is 1395 * valid indefinitely until a call to av_packet_unref() reduces the 1396 * reference count to 0. 1397 * 1398 * If the buf field is not set av_packet_ref() would make a copy instead 1399 * of increasing the reference count. 1400 * 1401 * The side data is always allocated with av_malloc(), copied by 1402 * av_packet_ref() and freed by av_packet_unref(). 1403 * 1404 * @see av_packet_ref 1405 * @see av_packet_unref 1406 */ 1407 typedef struct AVPacket { 1408 /** 1409 * A reference to the reference-counted buffer where the packet data is 1410 * stored. 1411 * May be NULL, then the packet data is not reference-counted. 1412 */ 1413 AVBufferRef *buf; 1414 /** 1415 * Presentation timestamp in AVStream->time_base units; the time at which 1416 * the decompressed packet will be presented to the user. 1417 * Can be AV_NOPTS_VALUE if it is not stored in the file. 1418 * pts MUST be larger or equal to dts as presentation cannot happen before 1419 * decompression, unless one wants to view hex dumps. Some formats misuse 1420 * the terms dts and pts/cts to mean something different. Such timestamps 1421 * must be converted to true pts/dts before they are stored in AVPacket. 1422 */ 1423 int64_t pts; 1424 /** 1425 * Decompression timestamp in AVStream->time_base units; the time at which 1426 * the packet is decompressed. 1427 * Can be AV_NOPTS_VALUE if it is not stored in the file. 1428 */ 1429 int64_t dts; 1430 uint8_t *data; 1431 int size; 1432 int stream_index; 1433 /** 1434 * A combination of AV_PKT_FLAG values 1435 */ 1436 int flags; 1437 /** 1438 * Additional packet data that can be provided by the container. 1439 * Packet can contain several types of side information. 1440 */ 1441 AVPacketSideData *side_data; 1442 int side_data_elems; 1443 1444 /** 1445 * Duration of this packet in AVStream->time_base units, 0 if unknown. 1446 * Equals next_pts - this_pts in presentation order. 1447 */ 1448 int64_t duration; 1449 1450 int64_t pos; ///< byte position in stream, -1 if unknown 1451 1452 #if FF_API_CONVERGENCE_DURATION 1453 /** 1454 * @deprecated Same as the duration field, but as int64_t. This was required 1455 * for Matroska subtitles, whose duration values could overflow when the 1456 * duration field was still an int. 1457 */ 1458 attribute_deprecated 1459 int64_t convergence_duration; 1460 #endif 1461 } AVPacket; 1462 #define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe 1463 #define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted 1464 /** 1465 * Flag is used to discard packets which are required to maintain valid 1466 * decoder state but are not required for output and should be dropped 1467 * after decoding. 1468 **/ 1469 #define AV_PKT_FLAG_DISCARD 0x0004 1470 /** 1471 * The packet comes from a trusted source. 1472 * 1473 * Otherwise-unsafe constructs such as arbitrary pointers to data 1474 * outside the packet may be followed. 1475 */ 1476 #define AV_PKT_FLAG_TRUSTED 0x0008 1477 /** 1478 * Flag is used to indicate packets that contain frames that can 1479 * be discarded by the decoder. I.e. Non-reference frames. 1480 */ 1481 #define AV_PKT_FLAG_DISPOSABLE 0x0010 1482 1483 1484 enum AVSideDataParamChangeFlags { 1485 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001, 1486 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002, 1487 AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004, 1488 AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008, 1489 }; 1490 /** 1491 * @} 1492 */ 1493 1494 struct AVCodecInternal; 1495 1496 enum AVFieldOrder { 1497 AV_FIELD_UNKNOWN, 1498 AV_FIELD_PROGRESSIVE, 1499 AV_FIELD_TT, //< Top coded_first, top displayed first 1500 AV_FIELD_BB, //< Bottom coded first, bottom displayed first 1501 AV_FIELD_TB, //< Top coded first, bottom displayed first 1502 AV_FIELD_BT, //< Bottom coded first, top displayed first 1503 }; 1504 1505 /** 1506 * main external API structure. 1507 * New fields can be added to the end with minor version bumps. 1508 * Removal, reordering and changes to existing fields require a major 1509 * version bump. 1510 * You can use AVOptions (av_opt* / av_set/get*()) to access these fields from user 1511 * applications. 1512 * The name string for AVOptions options matches the associated command line 1513 * parameter name and can be found in libavcodec/options_table.h 1514 * The AVOption/command line parameter names differ in some cases from the C 1515 * structure field names for historic reasons or brevity. 1516 * sizeof(AVCodecContext) must not be used outside libav*. 1517 */ 1518 typedef struct AVCodecContext { 1519 /** 1520 * information on struct for av_log 1521 * - set by avcodec_alloc_context3 1522 */ 1523 const AVClass *av_class; 1524 int log_level_offset; 1525 1526 enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */ 1527 const struct AVCodec *codec; 1528 enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */ 1529 1530 /** 1531 * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). 1532 * This is used to work around some encoder bugs. 1533 * A demuxer should set this to what is stored in the field used to identify the codec. 1534 * If there are multiple such fields in a container then the demuxer should choose the one 1535 * which maximizes the information about the used codec. 1536 * If the codec tag field in a container is larger than 32 bits then the demuxer should 1537 * remap the longer ID to 32 bits with a table or other structure. Alternatively a new 1538 * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated 1539 * first. 1540 * - encoding: Set by user, if not then the default based on codec_id will be used. 1541 * - decoding: Set by user, will be converted to uppercase by libavcodec during init. 1542 */ 1543 unsigned int codec_tag; 1544 1545 void *priv_data; 1546 1547 /** 1548 * Private context used for internal data. 1549 * 1550 * Unlike priv_data, this is not codec-specific. It is used in general 1551 * libavcodec functions. 1552 */ 1553 struct AVCodecInternal *internal; 1554 1555 /** 1556 * Private data of the user, can be used to carry app specific stuff. 1557 * - encoding: Set by user. 1558 * - decoding: Set by user. 1559 */ 1560 void *opaque; 1561 1562 /** 1563 * the average bitrate 1564 * - encoding: Set by user; unused for constant quantizer encoding. 1565 * - decoding: Set by user, may be overwritten by libavcodec 1566 * if this info is available in the stream 1567 */ 1568 int64_t bit_rate; 1569 1570 /** 1571 * number of bits the bitstream is allowed to diverge from the reference. 1572 * the reference can be CBR (for CBR pass1) or VBR (for pass2) 1573 * - encoding: Set by user; unused for constant quantizer encoding. 1574 * - decoding: unused 1575 */ 1576 int bit_rate_tolerance; 1577 1578 /** 1579 * Global quality for codecs which cannot change it per frame. 1580 * This should be proportional to MPEG-1/2/4 qscale. 1581 * - encoding: Set by user. 1582 * - decoding: unused 1583 */ 1584 int global_quality; 1585 1586 /** 1587 * - encoding: Set by user. 1588 * - decoding: unused 1589 */ 1590 int compression_level; 1591 #define FF_COMPRESSION_DEFAULT -1 1592 1593 /** 1594 * AV_CODEC_FLAG_*. 1595 * - encoding: Set by user. 1596 * - decoding: Set by user. 1597 */ 1598 int flags; 1599 1600 /** 1601 * AV_CODEC_FLAG2_* 1602 * - encoding: Set by user. 1603 * - decoding: Set by user. 1604 */ 1605 int flags2; 1606 1607 /** 1608 * some codecs need / can use extradata like Huffman tables. 1609 * MJPEG: Huffman tables 1610 * rv10: additional flags 1611 * MPEG-4: global headers (they can be in the bitstream or here) 1612 * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger 1613 * than extradata_size to avoid problems if it is read with the bitstream reader. 1614 * The bytewise contents of extradata must not depend on the architecture or CPU endianness. 1615 * - encoding: Set/allocated/freed by libavcodec. 1616 * - decoding: Set/allocated/freed by user. 1617 */ 1618 uint8_t *extradata; 1619 int extradata_size; 1620 1621 /** 1622 * This is the fundamental unit of time (in seconds) in terms 1623 * of which frame timestamps are represented. For fixed-fps content, 1624 * timebase should be 1/framerate and timestamp increments should be 1625 * identically 1. 1626 * This often, but not always is the inverse of the frame rate or field rate 1627 * for video. 1/time_base is not the average frame rate if the frame rate is not 1628 * constant. 1629 * 1630 * Like containers, elementary streams also can store timestamps, 1/time_base 1631 * is the unit in which these timestamps are specified. 1632 * As example of such codec time base see ISO/IEC 14496-2:2001(E) 1633 * vop_time_increment_resolution and fixed_vop_rate 1634 * (fixed_vop_rate == 0 implies that it is different from the framerate) 1635 * 1636 * - encoding: MUST be set by user. 1637 * - decoding: the use of this field for decoding is deprecated. 1638 * Use framerate instead. 1639 */ 1640 AVRational time_base; 1641 1642 /** 1643 * For some codecs, the time base is closer to the field rate than the frame rate. 1644 * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration 1645 * if no telecine is used ... 1646 * 1647 * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2. 1648 */ 1649 int ticks_per_frame; 1650 1651 /** 1652 * Codec delay. 1653 * 1654 * Encoding: Number of frames delay there will be from the encoder input to 1655 * the decoder output. (we assume the decoder matches the spec) 1656 * Decoding: Number of frames delay in addition to what a standard decoder 1657 * as specified in the spec would produce. 1658 * 1659 * Video: 1660 * Number of frames the decoded output will be delayed relative to the 1661 * encoded input. 1662 * 1663 * Audio: 1664 * For encoding, this field is unused (see initial_padding). 1665 * 1666 * For decoding, this is the number of samples the decoder needs to 1667 * output before the decoder's output is valid. When seeking, you should 1668 * start decoding this many samples prior to your desired seek point. 1669 * 1670 * - encoding: Set by libavcodec. 1671 * - decoding: Set by libavcodec. 1672 */ 1673 int delay; 1674 1675 1676 /* video only */ 1677 /** 1678 * picture width / height. 1679 * 1680 * @note Those fields may not match the values of the last 1681 * AVFrame output by avcodec_decode_video2 due frame 1682 * reordering. 1683 * 1684 * - encoding: MUST be set by user. 1685 * - decoding: May be set by the user before opening the decoder if known e.g. 1686 * from the container. Some decoders will require the dimensions 1687 * to be set by the caller. During decoding, the decoder may 1688 * overwrite those values as required while parsing the data. 1689 */ 1690 int width, height; 1691 1692 /** 1693 * Bitstream width / height, may be different from width/height e.g. when 1694 * the decoded frame is cropped before being output or lowres is enabled. 1695 * 1696 * @note Those field may not match the value of the last 1697 * AVFrame output by avcodec_receive_frame() due frame 1698 * reordering. 1699 * 1700 * - encoding: unused 1701 * - decoding: May be set by the user before opening the decoder if known 1702 * e.g. from the container. During decoding, the decoder may 1703 * overwrite those values as required while parsing the data. 1704 */ 1705 int coded_width, coded_height; 1706 1707 /** 1708 * the number of pictures in a group of pictures, or 0 for intra_only 1709 * - encoding: Set by user. 1710 * - decoding: unused 1711 */ 1712 int gop_size; 1713 1714 /** 1715 * Pixel format, see AV_PIX_FMT_xxx. 1716 * May be set by the demuxer if known from headers. 1717 * May be overridden by the decoder if it knows better. 1718 * 1719 * @note This field may not match the value of the last 1720 * AVFrame output by avcodec_receive_frame() due frame 1721 * reordering. 1722 * 1723 * - encoding: Set by user. 1724 * - decoding: Set by user if known, overridden by libavcodec while 1725 * parsing the data. 1726 */ 1727 enum AVPixelFormat pix_fmt; 1728 1729 /** 1730 * If non NULL, 'draw_horiz_band' is called by the libavcodec 1731 * decoder to draw a horizontal band. It improves cache usage. Not 1732 * all codecs can do that. You must check the codec capabilities 1733 * beforehand. 1734 * When multithreading is used, it may be called from multiple threads 1735 * at the same time; threads might draw different parts of the same AVFrame, 1736 * or multiple AVFrames, and there is no guarantee that slices will be drawn 1737 * in order. 1738 * The function is also used by hardware acceleration APIs. 1739 * It is called at least once during frame decoding to pass 1740 * the data needed for hardware render. 1741 * In that mode instead of pixel data, AVFrame points to 1742 * a structure specific to the acceleration API. The application 1743 * reads the structure and can change some fields to indicate progress 1744 * or mark state. 1745 * - encoding: unused 1746 * - decoding: Set by user. 1747 * @param height the height of the slice 1748 * @param y the y position of the slice 1749 * @param type 1->top field, 2->bottom field, 3->frame 1750 * @param offset offset into the AVFrame.data from which the slice should be read 1751 */ 1752 void (*draw_horiz_band)(struct AVCodecContext *s, 1753 const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], 1754 int y, int type, int height); 1755 1756 /** 1757 * callback to negotiate the pixelFormat 1758 * @param fmt is the list of formats which are supported by the codec, 1759 * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality. 1760 * The first is always the native one. 1761 * @note The callback may be called again immediately if initialization for 1762 * the selected (hardware-accelerated) pixel format failed. 1763 * @warning Behavior is undefined if the callback returns a value not 1764 * in the fmt list of formats. 1765 * @return the chosen format 1766 * - encoding: unused 1767 * - decoding: Set by user, if not set the native format will be chosen. 1768 */ 1769 enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt); 1770 1771 /** 1772 * maximum number of B-frames between non-B-frames 1773 * Note: The output will be delayed by max_b_frames+1 relative to the input. 1774 * - encoding: Set by user. 1775 * - decoding: unused 1776 */ 1777 int max_b_frames; 1778 1779 /** 1780 * qscale factor between IP and B-frames 1781 * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset). 1782 * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). 1783 * - encoding: Set by user. 1784 * - decoding: unused 1785 */ 1786 float b_quant_factor; 1787 1788 #if FF_API_PRIVATE_OPT 1789 /** @deprecated use encoder private options instead */ 1790 attribute_deprecated 1791 int b_frame_strategy; 1792 #endif 1793 1794 /** 1795 * qscale offset between IP and B-frames 1796 * - encoding: Set by user. 1797 * - decoding: unused 1798 */ 1799 float b_quant_offset; 1800 1801 /** 1802 * Size of the frame reordering buffer in the decoder. 1803 * For MPEG-2 it is 1 IPB or 0 low delay IP. 1804 * - encoding: Set by libavcodec. 1805 * - decoding: Set by libavcodec. 1806 */ 1807 int has_b_frames; 1808 1809 #if FF_API_PRIVATE_OPT 1810 /** @deprecated use encoder private options instead */ 1811 attribute_deprecated 1812 int mpeg_quant; 1813 #endif 1814 1815 /** 1816 * qscale factor between P- and I-frames 1817 * If > 0 then the last P-frame quantizer will be used (q = lastp_q * factor + offset). 1818 * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). 1819 * - encoding: Set by user. 1820 * - decoding: unused 1821 */ 1822 float i_quant_factor; 1823 1824 /** 1825 * qscale offset between P and I-frames 1826 * - encoding: Set by user. 1827 * - decoding: unused 1828 */ 1829 float i_quant_offset; 1830 1831 /** 1832 * luminance masking (0-> disabled) 1833 * - encoding: Set by user. 1834 * - decoding: unused 1835 */ 1836 float lumi_masking; 1837 1838 /** 1839 * temporary complexity masking (0-> disabled) 1840 * - encoding: Set by user. 1841 * - decoding: unused 1842 */ 1843 float temporal_cplx_masking; 1844 1845 /** 1846 * spatial complexity masking (0-> disabled) 1847 * - encoding: Set by user. 1848 * - decoding: unused 1849 */ 1850 float spatial_cplx_masking; 1851 1852 /** 1853 * p block masking (0-> disabled) 1854 * - encoding: Set by user. 1855 * - decoding: unused 1856 */ 1857 float p_masking; 1858 1859 /** 1860 * darkness masking (0-> disabled) 1861 * - encoding: Set by user. 1862 * - decoding: unused 1863 */ 1864 float dark_masking; 1865 1866 /** 1867 * slice count 1868 * - encoding: Set by libavcodec. 1869 * - decoding: Set by user (or 0). 1870 */ 1871 int slice_count; 1872 1873 #if FF_API_PRIVATE_OPT 1874 /** @deprecated use encoder private options instead */ 1875 attribute_deprecated 1876 int prediction_method; 1877 #define FF_PRED_LEFT 0 1878 #define FF_PRED_PLANE 1 1879 #define FF_PRED_MEDIAN 2 1880 #endif 1881 1882 /** 1883 * slice offsets in the frame in bytes 1884 * - encoding: Set/allocated by libavcodec. 1885 * - decoding: Set/allocated by user (or NULL). 1886 */ 1887 int *slice_offset; 1888 1889 /** 1890 * sample aspect ratio (0 if unknown) 1891 * That is the width of a pixel divided by the height of the pixel. 1892 * Numerator and denominator must be relatively prime and smaller than 256 for some video standards. 1893 * - encoding: Set by user. 1894 * - decoding: Set by libavcodec. 1895 */ 1896 AVRational sample_aspect_ratio; 1897 1898 /** 1899 * motion estimation comparison function 1900 * - encoding: Set by user. 1901 * - decoding: unused 1902 */ 1903 int me_cmp; 1904 /** 1905 * subpixel motion estimation comparison function 1906 * - encoding: Set by user. 1907 * - decoding: unused 1908 */ 1909 int me_sub_cmp; 1910 /** 1911 * macroblock comparison function (not supported yet) 1912 * - encoding: Set by user. 1913 * - decoding: unused 1914 */ 1915 int mb_cmp; 1916 /** 1917 * interlaced DCT comparison function 1918 * - encoding: Set by user. 1919 * - decoding: unused 1920 */ 1921 int ildct_cmp; 1922 #define FF_CMP_SAD 0 1923 #define FF_CMP_SSE 1 1924 #define FF_CMP_SATD 2 1925 #define FF_CMP_DCT 3 1926 #define FF_CMP_PSNR 4 1927 #define FF_CMP_BIT 5 1928 #define FF_CMP_RD 6 1929 #define FF_CMP_ZERO 7 1930 #define FF_CMP_VSAD 8 1931 #define FF_CMP_VSSE 9 1932 #define FF_CMP_NSSE 10 1933 #define FF_CMP_W53 11 1934 #define FF_CMP_W97 12 1935 #define FF_CMP_DCTMAX 13 1936 #define FF_CMP_DCT264 14 1937 #define FF_CMP_MEDIAN_SAD 15 1938 #define FF_CMP_CHROMA 256 1939 1940 /** 1941 * ME diamond size & shape 1942 * - encoding: Set by user. 1943 * - decoding: unused 1944 */ 1945 int dia_size; 1946 1947 /** 1948 * amount of previous MV predictors (2a+1 x 2a+1 square) 1949 * - encoding: Set by user. 1950 * - decoding: unused 1951 */ 1952 int last_predictor_count; 1953 1954 #if FF_API_PRIVATE_OPT 1955 /** @deprecated use encoder private options instead */ 1956 attribute_deprecated 1957 int pre_me; 1958 #endif 1959 1960 /** 1961 * motion estimation prepass comparison function 1962 * - encoding: Set by user. 1963 * - decoding: unused 1964 */ 1965 int me_pre_cmp; 1966 1967 /** 1968 * ME prepass diamond size & shape 1969 * - encoding: Set by user. 1970 * - decoding: unused 1971 */ 1972 int pre_dia_size; 1973 1974 /** 1975 * subpel ME quality 1976 * - encoding: Set by user. 1977 * - decoding: unused 1978 */ 1979 int me_subpel_quality; 1980 1981 /** 1982 * maximum motion estimation search range in subpel units 1983 * If 0 then no limit. 1984 * 1985 * - encoding: Set by user. 1986 * - decoding: unused 1987 */ 1988 int me_range; 1989 1990 /** 1991 * slice flags 1992 * - encoding: unused 1993 * - decoding: Set by user. 1994 */ 1995 int slice_flags; 1996 #define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display 1997 #define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG-2 field pics) 1998 #define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1) 1999 2000 /** 2001 * macroblock decision mode 2002 * - encoding: Set by user. 2003 * - decoding: unused 2004 */ 2005 int mb_decision; 2006 #define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp 2007 #define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits 2008 #define FF_MB_DECISION_RD 2 ///< rate distortion 2009 2010 /** 2011 * custom intra quantization matrix 2012 * - encoding: Set by user, can be NULL. 2013 * - decoding: Set by libavcodec. 2014 */ 2015 uint16_t *intra_matrix; 2016 2017 /** 2018 * custom inter quantization matrix 2019 * - encoding: Set by user, can be NULL. 2020 * - decoding: Set by libavcodec. 2021 */ 2022 uint16_t *inter_matrix; 2023 2024 #if FF_API_PRIVATE_OPT 2025 /** @deprecated use encoder private options instead */ 2026 attribute_deprecated 2027 int scenechange_threshold; 2028 2029 /** @deprecated use encoder private options instead */ 2030 attribute_deprecated 2031 int noise_reduction; 2032 #endif 2033 2034 /** 2035 * precision of the intra DC coefficient - 8 2036 * - encoding: Set by user. 2037 * - decoding: Set by libavcodec 2038 */ 2039 int intra_dc_precision; 2040 2041 /** 2042 * Number of macroblock rows at the top which are skipped. 2043 * - encoding: unused 2044 * - decoding: Set by user. 2045 */ 2046 int skip_top; 2047 2048 /** 2049 * Number of macroblock rows at the bottom which are skipped. 2050 * - encoding: unused 2051 * - decoding: Set by user. 2052 */ 2053 int skip_bottom; 2054 2055 /** 2056 * minimum MB Lagrange multiplier 2057 * - encoding: Set by user. 2058 * - decoding: unused 2059 */ 2060 int mb_lmin; 2061 2062 /** 2063 * maximum MB Lagrange multiplier 2064 * - encoding: Set by user. 2065 * - decoding: unused 2066 */ 2067 int mb_lmax; 2068 2069 #if FF_API_PRIVATE_OPT 2070 /** 2071 * @deprecated use encoder private options instead 2072 */ 2073 attribute_deprecated 2074 int me_penalty_compensation; 2075 #endif 2076 2077 /** 2078 * - encoding: Set by user. 2079 * - decoding: unused 2080 */ 2081 int bidir_refine; 2082 2083 #if FF_API_PRIVATE_OPT 2084 /** @deprecated use encoder private options instead */ 2085 attribute_deprecated 2086 int brd_scale; 2087 #endif 2088 2089 /** 2090 * minimum GOP size 2091 * - encoding: Set by user. 2092 * - decoding: unused 2093 */ 2094 int keyint_min; 2095 2096 /** 2097 * number of reference frames 2098 * - encoding: Set by user. 2099 * - decoding: Set by lavc. 2100 */ 2101 int refs; 2102 2103 #if FF_API_PRIVATE_OPT 2104 /** @deprecated use encoder private options instead */ 2105 attribute_deprecated 2106 int chromaoffset; 2107 #endif 2108 2109 /** 2110 * Note: Value depends upon the compare function used for fullpel ME. 2111 * - encoding: Set by user. 2112 * - decoding: unused 2113 */ 2114 int mv0_threshold; 2115 2116 #if FF_API_PRIVATE_OPT 2117 /** @deprecated use encoder private options instead */ 2118 attribute_deprecated 2119 int b_sensitivity; 2120 #endif 2121 2122 /** 2123 * Chromaticity coordinates of the source primaries. 2124 * - encoding: Set by user 2125 * - decoding: Set by libavcodec 2126 */ 2127 enum AVColorPrimaries color_primaries; 2128 2129 /** 2130 * Color Transfer Characteristic. 2131 * - encoding: Set by user 2132 * - decoding: Set by libavcodec 2133 */ 2134 enum AVColorTransferCharacteristic color_trc; 2135 2136 /** 2137 * YUV colorspace type. 2138 * - encoding: Set by user 2139 * - decoding: Set by libavcodec 2140 */ 2141 enum AVColorSpace colorspace; 2142 2143 /** 2144 * MPEG vs JPEG YUV range. 2145 * - encoding: Set by user 2146 * - decoding: Set by libavcodec 2147 */ 2148 enum AVColorRange color_range; 2149 2150 /** 2151 * This defines the location of chroma samples. 2152 * - encoding: Set by user 2153 * - decoding: Set by libavcodec 2154 */ 2155 enum AVChromaLocation chroma_sample_location; 2156 2157 /** 2158 * Number of slices. 2159 * Indicates number of picture subdivisions. Used for parallelized 2160 * decoding. 2161 * - encoding: Set by user 2162 * - decoding: unused 2163 */ 2164 int slices; 2165 2166 /** Field order 2167 * - encoding: set by libavcodec 2168 * - decoding: Set by user. 2169 */ 2170 enum AVFieldOrder field_order; 2171 2172 /* audio only */ 2173 int sample_rate; ///< samples per second 2174 int channels; ///< number of audio channels 2175 2176 /** 2177 * audio sample format 2178 * - encoding: Set by user. 2179 * - decoding: Set by libavcodec. 2180 */ 2181 enum AVSampleFormat sample_fmt; ///< sample format 2182 2183 /* The following data should not be initialized. */ 2184 /** 2185 * Number of samples per channel in an audio frame. 2186 * 2187 * - encoding: set by libavcodec in avcodec_open2(). Each submitted frame 2188 * except the last must contain exactly frame_size samples per channel. 2189 * May be 0 when the codec has AV_CODEC_CAP_VARIABLE_FRAME_SIZE set, then the 2190 * frame size is not restricted. 2191 * - decoding: may be set by some decoders to indicate constant frame size 2192 */ 2193 int frame_size; 2194 2195 /** 2196 * Frame counter, set by libavcodec. 2197 * 2198 * - decoding: total number of frames returned from the decoder so far. 2199 * - encoding: total number of frames passed to the encoder so far. 2200 * 2201 * @note the counter is not incremented if encoding/decoding resulted in 2202 * an error. 2203 */ 2204 int frame_number; 2205 2206 /** 2207 * number of bytes per packet if constant and known or 0 2208 * Used by some WAV based audio codecs. 2209 */ 2210 int block_align; 2211 2212 /** 2213 * Audio cutoff bandwidth (0 means "automatic") 2214 * - encoding: Set by user. 2215 * - decoding: unused 2216 */ 2217 int cutoff; 2218 2219 /** 2220 * Audio channel layout. 2221 * - encoding: set by user. 2222 * - decoding: set by user, may be overwritten by libavcodec. 2223 */ 2224 uint64_t channel_layout; 2225 2226 /** 2227 * Request decoder to use this channel layout if it can (0 for default) 2228 * - encoding: unused 2229 * - decoding: Set by user. 2230 */ 2231 uint64_t request_channel_layout; 2232 2233 /** 2234 * Type of service that the audio stream conveys. 2235 * - encoding: Set by user. 2236 * - decoding: Set by libavcodec. 2237 */ 2238 enum AVAudioServiceType audio_service_type; 2239 2240 /** 2241 * desired sample format 2242 * - encoding: Not used. 2243 * - decoding: Set by user. 2244 * Decoder will decode to this format if it can. 2245 */ 2246 enum AVSampleFormat request_sample_fmt; 2247 2248 /** 2249 * This callback is called at the beginning of each frame to get data 2250 * buffer(s) for it. There may be one contiguous buffer for all the data or 2251 * there may be a buffer per each data plane or anything in between. What 2252 * this means is, you may set however many entries in buf[] you feel necessary. 2253 * Each buffer must be reference-counted using the AVBuffer API (see description 2254 * of buf[] below). 2255 * 2256 * The following fields will be set in the frame before this callback is 2257 * called: 2258 * - format 2259 * - width, height (video only) 2260 * - sample_rate, channel_layout, nb_samples (audio only) 2261 * Their values may differ from the corresponding values in 2262 * AVCodecContext. This callback must use the frame values, not the codec 2263 * context values, to calculate the required buffer size. 2264 * 2265 * This callback must fill the following fields in the frame: 2266 * - data[] 2267 * - linesize[] 2268 * - extended_data: 2269 * * if the data is planar audio with more than 8 channels, then this 2270 * callback must allocate and fill extended_data to contain all pointers 2271 * to all data planes. data[] must hold as many pointers as it can. 2272 * extended_data must be allocated with av_malloc() and will be freed in 2273 * av_frame_unref(). 2274 * * otherwise extended_data must point to data 2275 * - buf[] must contain one or more pointers to AVBufferRef structures. Each of 2276 * the frame's data and extended_data pointers must be contained in these. That 2277 * is, one AVBufferRef for each allocated chunk of memory, not necessarily one 2278 * AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(), 2279 * and av_buffer_ref(). 2280 * - extended_buf and nb_extended_buf must be allocated with av_malloc() by 2281 * this callback and filled with the extra buffers if there are more 2282 * buffers than buf[] can hold. extended_buf will be freed in 2283 * av_frame_unref(). 2284 * 2285 * If AV_CODEC_CAP_DR1 is not set then get_buffer2() must call 2286 * avcodec_default_get_buffer2() instead of providing buffers allocated by 2287 * some other means. 2288 * 2289 * Each data plane must be aligned to the maximum required by the target 2290 * CPU. 2291 * 2292 * @see avcodec_default_get_buffer2() 2293 * 2294 * Video: 2295 * 2296 * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused 2297 * (read and/or written to if it is writable) later by libavcodec. 2298 * 2299 * avcodec_align_dimensions2() should be used to find the required width and 2300 * height, as they normally need to be rounded up to the next multiple of 16. 2301 * 2302 * Some decoders do not support linesizes changing between frames. 2303 * 2304 * If frame multithreading is used and thread_safe_callbacks is set, 2305 * this callback may be called from a different thread, but not from more 2306 * than one at once. Does not need to be reentrant. 2307 * 2308 * @see avcodec_align_dimensions2() 2309 * 2310 * Audio: 2311 * 2312 * Decoders request a buffer of a particular size by setting 2313 * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may, 2314 * however, utilize only part of the buffer by setting AVFrame.nb_samples 2315 * to a smaller value in the output frame. 2316 * 2317 * As a convenience, av_samples_get_buffer_size() and 2318 * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2() 2319 * functions to find the required data size and to fill data pointers and 2320 * linesize. In AVFrame.linesize, only linesize[0] may be set for audio 2321 * since all planes must be the same size. 2322 * 2323 * @see av_samples_get_buffer_size(), av_samples_fill_arrays() 2324 * 2325 * - encoding: unused 2326 * - decoding: Set by libavcodec, user can override. 2327 */ 2328 int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags); 2329 2330 /** 2331 * If non-zero, the decoded audio and video frames returned from 2332 * avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted 2333 * and are valid indefinitely. The caller must free them with 2334 * av_frame_unref() when they are not needed anymore. 2335 * Otherwise, the decoded frames must not be freed by the caller and are 2336 * only valid until the next decode call. 2337 * 2338 * This is always automatically enabled if avcodec_receive_frame() is used. 2339 * 2340 * - encoding: unused 2341 * - decoding: set by the caller before avcodec_open2(). 2342 */ 2343 attribute_deprecated 2344 int refcounted_frames; 2345 2346 /* - encoding parameters */ 2347 float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0) 2348 float qblur; ///< amount of qscale smoothing over time (0.0-1.0) 2349 2350 /** 2351 * minimum quantizer 2352 * - encoding: Set by user. 2353 * - decoding: unused 2354 */ 2355 int qmin; 2356 2357 /** 2358 * maximum quantizer 2359 * - encoding: Set by user. 2360 * - decoding: unused 2361 */ 2362 int qmax; 2363 2364 /** 2365 * maximum quantizer difference between frames 2366 * - encoding: Set by user. 2367 * - decoding: unused 2368 */ 2369 int max_qdiff; 2370 2371 /** 2372 * decoder bitstream buffer size 2373 * - encoding: Set by user. 2374 * - decoding: unused 2375 */ 2376 int rc_buffer_size; 2377 2378 /** 2379 * ratecontrol override, see RcOverride 2380 * - encoding: Allocated/set/freed by user. 2381 * - decoding: unused 2382 */ 2383 int rc_override_count; 2384 RcOverride *rc_override; 2385 2386 /** 2387 * maximum bitrate 2388 * - encoding: Set by user. 2389 * - decoding: Set by user, may be overwritten by libavcodec. 2390 */ 2391 int64_t rc_max_rate; 2392 2393 /** 2394 * minimum bitrate 2395 * - encoding: Set by user. 2396 * - decoding: unused 2397 */ 2398 int64_t rc_min_rate; 2399 2400 /** 2401 * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow. 2402 * - encoding: Set by user. 2403 * - decoding: unused. 2404 */ 2405 float rc_max_available_vbv_use; 2406 2407 /** 2408 * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow. 2409 * - encoding: Set by user. 2410 * - decoding: unused. 2411 */ 2412 float rc_min_vbv_overflow_use; 2413 2414 /** 2415 * Number of bits which should be loaded into the rc buffer before decoding starts. 2416 * - encoding: Set by user. 2417 * - decoding: unused 2418 */ 2419 int rc_initial_buffer_occupancy; 2420 2421 #if FF_API_CODER_TYPE 2422 #define FF_CODER_TYPE_VLC 0 2423 #define FF_CODER_TYPE_AC 1 2424 #define FF_CODER_TYPE_RAW 2 2425 #define FF_CODER_TYPE_RLE 3 2426 /** 2427 * @deprecated use encoder private options instead 2428 */ 2429 attribute_deprecated 2430 int coder_type; 2431 #endif /* FF_API_CODER_TYPE */ 2432 2433 #if FF_API_PRIVATE_OPT 2434 /** @deprecated use encoder private options instead */ 2435 attribute_deprecated 2436 int context_model; 2437 #endif 2438 2439 #if FF_API_PRIVATE_OPT 2440 /** @deprecated use encoder private options instead */ 2441 attribute_deprecated 2442 int frame_skip_threshold; 2443 2444 /** @deprecated use encoder private options instead */ 2445 attribute_deprecated 2446 int frame_skip_factor; 2447 2448 /** @deprecated use encoder private options instead */ 2449 attribute_deprecated 2450 int frame_skip_exp; 2451 2452 /** @deprecated use encoder private options instead */ 2453 attribute_deprecated 2454 int frame_skip_cmp; 2455 #endif /* FF_API_PRIVATE_OPT */ 2456 2457 /** 2458 * trellis RD quantization 2459 * - encoding: Set by user. 2460 * - decoding: unused 2461 */ 2462 int trellis; 2463 2464 #if FF_API_PRIVATE_OPT 2465 /** @deprecated use encoder private options instead */ 2466 attribute_deprecated 2467 int min_prediction_order; 2468 2469 /** @deprecated use encoder private options instead */ 2470 attribute_deprecated 2471 int max_prediction_order; 2472 2473 /** @deprecated use encoder private options instead */ 2474 attribute_deprecated 2475 int64_t timecode_frame_start; 2476 #endif 2477 2478 #if FF_API_RTP_CALLBACK 2479 /** 2480 * @deprecated unused 2481 */ 2482 /* The RTP callback: This function is called */ 2483 /* every time the encoder has a packet to send. */ 2484 /* It depends on the encoder if the data starts */ 2485 /* with a Start Code (it should). H.263 does. */ 2486 /* mb_nb contains the number of macroblocks */ 2487 /* encoded in the RTP payload. */ 2488 attribute_deprecated 2489 void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb); 2490 #endif 2491 2492 #if FF_API_PRIVATE_OPT 2493 /** @deprecated use encoder private options instead */ 2494 attribute_deprecated 2495 int rtp_payload_size; /* The size of the RTP payload: the coder will */ 2496 /* do its best to deliver a chunk with size */ 2497 /* below rtp_payload_size, the chunk will start */ 2498 /* with a start code on some codecs like H.263. */ 2499 /* This doesn't take account of any particular */ 2500 /* headers inside the transmitted RTP payload. */ 2501 #endif 2502 2503 #if FF_API_STAT_BITS 2504 /* statistics, used for 2-pass encoding */ 2505 attribute_deprecated 2506 int mv_bits; 2507 attribute_deprecated 2508 int header_bits; 2509 attribute_deprecated 2510 int i_tex_bits; 2511 attribute_deprecated 2512 int p_tex_bits; 2513 attribute_deprecated 2514 int i_count; 2515 attribute_deprecated 2516 int p_count; 2517 attribute_deprecated 2518 int skip_count; 2519 attribute_deprecated 2520 int misc_bits; 2521 2522 /** @deprecated this field is unused */ 2523 attribute_deprecated 2524 int frame_bits; 2525 #endif 2526 2527 /** 2528 * pass1 encoding statistics output buffer 2529 * - encoding: Set by libavcodec. 2530 * - decoding: unused 2531 */ 2532 char *stats_out; 2533 2534 /** 2535 * pass2 encoding statistics input buffer 2536 * Concatenated stuff from stats_out of pass1 should be placed here. 2537 * - encoding: Allocated/set/freed by user. 2538 * - decoding: unused 2539 */ 2540 char *stats_in; 2541 2542 /** 2543 * Work around bugs in encoders which sometimes cannot be detected automatically. 2544 * - encoding: Set by user 2545 * - decoding: Set by user 2546 */ 2547 int workaround_bugs; 2548 #define FF_BUG_AUTODETECT 1 ///< autodetection 2549 #define FF_BUG_XVID_ILACE 4 2550 #define FF_BUG_UMP4 8 2551 #define FF_BUG_NO_PADDING 16 2552 #define FF_BUG_AMV 32 2553 #define FF_BUG_QPEL_CHROMA 64 2554 #define FF_BUG_STD_QPEL 128 2555 #define FF_BUG_QPEL_CHROMA2 256 2556 #define FF_BUG_DIRECT_BLOCKSIZE 512 2557 #define FF_BUG_EDGE 1024 2558 #define FF_BUG_HPEL_CHROMA 2048 2559 #define FF_BUG_DC_CLIP 4096 2560 #define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders. 2561 #define FF_BUG_TRUNCATED 16384 2562 #define FF_BUG_IEDGE 32768 2563 2564 /** 2565 * strictly follow the standard (MPEG-4, ...). 2566 * - encoding: Set by user. 2567 * - decoding: Set by user. 2568 * Setting this to STRICT or higher means the encoder and decoder will 2569 * generally do stupid things, whereas setting it to unofficial or lower 2570 * will mean the encoder might produce output that is not supported by all 2571 * spec-compliant decoders. Decoders don't differentiate between normal, 2572 * unofficial and experimental (that is, they always try to decode things 2573 * when they can) unless they are explicitly asked to behave stupidly 2574 * (=strictly conform to the specs) 2575 */ 2576 int strict_std_compliance; 2577 #define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software. 2578 #define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences. 2579 #define FF_COMPLIANCE_NORMAL 0 2580 #define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions 2581 #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things. 2582 2583 /** 2584 * error concealment flags 2585 * - encoding: unused 2586 * - decoding: Set by user. 2587 */ 2588 int error_concealment; 2589 #define FF_EC_GUESS_MVS 1 2590 #define FF_EC_DEBLOCK 2 2591 #define FF_EC_FAVOR_INTER 256 2592 2593 /** 2594 * debug 2595 * - encoding: Set by user. 2596 * - decoding: Set by user. 2597 */ 2598 int debug; 2599 #define FF_DEBUG_PICT_INFO 1 2600 #define FF_DEBUG_RC 2 2601 #define FF_DEBUG_BITSTREAM 4 2602 #define FF_DEBUG_MB_TYPE 8 2603 #define FF_DEBUG_QP 16 2604 #if FF_API_DEBUG_MV 2605 /** 2606 * @deprecated this option does nothing 2607 */ 2608 #define FF_DEBUG_MV 32 2609 #endif 2610 #define FF_DEBUG_DCT_COEFF 0x00000040 2611 #define FF_DEBUG_SKIP 0x00000080 2612 #define FF_DEBUG_STARTCODE 0x00000100 2613 #define FF_DEBUG_ER 0x00000400 2614 #define FF_DEBUG_MMCO 0x00000800 2615 #define FF_DEBUG_BUGS 0x00001000 2616 #if FF_API_DEBUG_MV 2617 #define FF_DEBUG_VIS_QP 0x00002000 2618 #define FF_DEBUG_VIS_MB_TYPE 0x00004000 2619 #endif 2620 #define FF_DEBUG_BUFFERS 0x00008000 2621 #define FF_DEBUG_THREADS 0x00010000 2622 #define FF_DEBUG_GREEN_MD 0x00800000 2623 #define FF_DEBUG_NOMC 0x01000000 2624 2625 #if FF_API_DEBUG_MV 2626 /** 2627 * debug 2628 * - encoding: Set by user. 2629 * - decoding: Set by user. 2630 */ 2631 int debug_mv; 2632 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 // visualize forward predicted MVs of P-frames 2633 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 // visualize forward predicted MVs of B-frames 2634 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 // visualize backward predicted MVs of B-frames 2635 #endif 2636 2637 /** 2638 * Error recognition; may misdetect some more or less valid parts as errors. 2639 * - encoding: unused 2640 * - decoding: Set by user. 2641 */ 2642 int err_recognition; 2643 2644 /** 2645 * Verify checksums embedded in the bitstream (could be of either encoded or 2646 * decoded data, depending on the codec) and print an error message on mismatch. 2647 * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the 2648 * decoder returning an error. 2649 */ 2650 #define AV_EF_CRCCHECK (1<<0) 2651 #define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations 2652 #define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length 2653 #define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection 2654 2655 #define AV_EF_IGNORE_ERR (1<<15) ///< ignore errors and continue 2656 #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 2657 #define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliances as errors 2658 #define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder should not do as an error 2659 2660 2661 /** 2662 * opaque 64-bit number (generally a PTS) that will be reordered and 2663 * output in AVFrame.reordered_opaque 2664 * - encoding: unused 2665 * - decoding: Set by user. 2666 */ 2667 int64_t reordered_opaque; 2668 2669 /** 2670 * Hardware accelerator in use 2671 * - encoding: unused. 2672 * - decoding: Set by libavcodec 2673 */ 2674 const struct AVHWAccel *hwaccel; 2675 2676 /** 2677 * Hardware accelerator context. 2678 * For some hardware accelerators, a global context needs to be 2679 * provided by the user. In that case, this holds display-dependent 2680 * data FFmpeg cannot instantiate itself. Please refer to the 2681 * FFmpeg HW accelerator documentation to know how to fill this 2682 * is. e.g. for VA API, this is a struct vaapi_context. 2683 * - encoding: unused 2684 * - decoding: Set by user 2685 */ 2686 void *hwaccel_context; 2687 2688 /** 2689 * error 2690 * - encoding: Set by libavcodec if flags & AV_CODEC_FLAG_PSNR. 2691 * - decoding: unused 2692 */ 2693 uint64_t error[AV_NUM_DATA_POINTERS]; 2694 2695 /** 2696 * DCT algorithm, see FF_DCT_* below 2697 * - encoding: Set by user. 2698 * - decoding: unused 2699 */ 2700 int dct_algo; 2701 #define FF_DCT_AUTO 0 2702 #define FF_DCT_FASTINT 1 2703 #define FF_DCT_INT 2 2704 #define FF_DCT_MMX 3 2705 #define FF_DCT_ALTIVEC 5 2706 #define FF_DCT_FAAN 6 2707 2708 /** 2709 * IDCT algorithm, see FF_IDCT_* below. 2710 * - encoding: Set by user. 2711 * - decoding: Set by user. 2712 */ 2713 int idct_algo; 2714 #define FF_IDCT_AUTO 0 2715 #define FF_IDCT_INT 1 2716 #define FF_IDCT_SIMPLE 2 2717 #define FF_IDCT_SIMPLEMMX 3 2718 #define FF_IDCT_ARM 7 2719 #define FF_IDCT_ALTIVEC 8 2720 #define FF_IDCT_SIMPLEARM 10 2721 #define FF_IDCT_XVID 14 2722 #define FF_IDCT_SIMPLEARMV5TE 16 2723 #define FF_IDCT_SIMPLEARMV6 17 2724 #define FF_IDCT_FAAN 20 2725 #define FF_IDCT_SIMPLENEON 22 2726 #define FF_IDCT_NONE 24 /* Used by XvMC to extract IDCT coefficients with FF_IDCT_PERM_NONE */ 2727 #define FF_IDCT_SIMPLEAUTO 128 2728 2729 /** 2730 * bits per sample/pixel from the demuxer (needed for huffyuv). 2731 * - encoding: Set by libavcodec. 2732 * - decoding: Set by user. 2733 */ 2734 int bits_per_coded_sample; 2735 2736 /** 2737 * Bits per sample/pixel of internal libavcodec pixel/sample format. 2738 * - encoding: set by user. 2739 * - decoding: set by libavcodec. 2740 */ 2741 int bits_per_raw_sample; 2742 2743 #if FF_API_LOWRES 2744 /** 2745 * low resolution decoding, 1-> 1/2 size, 2->1/4 size 2746 * - encoding: unused 2747 * - decoding: Set by user. 2748 */ 2749 int lowres; 2750 #endif 2751 2752 #if FF_API_CODED_FRAME 2753 /** 2754 * the picture in the bitstream 2755 * - encoding: Set by libavcodec. 2756 * - decoding: unused 2757 * 2758 * @deprecated use the quality factor packet side data instead 2759 */ 2760 attribute_deprecated AVFrame *coded_frame; 2761 #endif 2762 2763 /** 2764 * thread count 2765 * is used to decide how many independent tasks should be passed to execute() 2766 * - encoding: Set by user. 2767 * - decoding: Set by user. 2768 */ 2769 int thread_count; 2770 2771 /** 2772 * Which multithreading methods to use. 2773 * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread, 2774 * so clients which cannot provide future frames should not use it. 2775 * 2776 * - encoding: Set by user, otherwise the default is used. 2777 * - decoding: Set by user, otherwise the default is used. 2778 */ 2779 int thread_type; 2780 #define FF_THREAD_FRAME 1 ///< Decode more than one frame at once 2781 #define FF_THREAD_SLICE 2 ///< Decode more than one part of a single frame at once 2782 2783 /** 2784 * Which multithreading methods are in use by the codec. 2785 * - encoding: Set by libavcodec. 2786 * - decoding: Set by libavcodec. 2787 */ 2788 int active_thread_type; 2789 2790 /** 2791 * Set by the client if its custom get_buffer() callback can be called 2792 * synchronously from another thread, which allows faster multithreaded decoding. 2793 * draw_horiz_band() will be called from other threads regardless of this setting. 2794 * Ignored if the default get_buffer() is used. 2795 * - encoding: Set by user. 2796 * - decoding: Set by user. 2797 */ 2798 int thread_safe_callbacks; 2799 2800 /** 2801 * The codec may call this to execute several independent things. 2802 * It will return only after finishing all tasks. 2803 * The user may replace this with some multithreaded implementation, 2804 * the default implementation will execute the parts serially. 2805 * @param count the number of things to execute 2806 * - encoding: Set by libavcodec, user can override. 2807 * - decoding: Set by libavcodec, user can override. 2808 */ 2809 int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size); 2810 2811 /** 2812 * The codec may call this to execute several independent things. 2813 * It will return only after finishing all tasks. 2814 * The user may replace this with some multithreaded implementation, 2815 * the default implementation will execute the parts serially. 2816 * Also see avcodec_thread_init and e.g. the --enable-pthread configure option. 2817 * @param c context passed also to func 2818 * @param count the number of things to execute 2819 * @param arg2 argument passed unchanged to func 2820 * @param ret return values of executed functions, must have space for "count" values. May be NULL. 2821 * @param func function that will be called count times, with jobnr from 0 to count-1. 2822 * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no 2823 * two instances of func executing at the same time will have the same threadnr. 2824 * @return always 0 currently, but code should handle a future improvement where when any call to func 2825 * returns < 0 no further calls to func may be done and < 0 is returned. 2826 * - encoding: Set by libavcodec, user can override. 2827 * - decoding: Set by libavcodec, user can override. 2828 */ 2829 int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count); 2830 2831 /** 2832 * noise vs. sse weight for the nsse comparison function 2833 * - encoding: Set by user. 2834 * - decoding: unused 2835 */ 2836 int nsse_weight; 2837 2838 /** 2839 * profile 2840 * - encoding: Set by user. 2841 * - decoding: Set by libavcodec. 2842 */ 2843 int profile; 2844 #define FF_PROFILE_UNKNOWN -99 2845 #define FF_PROFILE_RESERVED -100 2846 2847 #define FF_PROFILE_AAC_MAIN 0 2848 #define FF_PROFILE_AAC_LOW 1 2849 #define FF_PROFILE_AAC_SSR 2 2850 #define FF_PROFILE_AAC_LTP 3 2851 #define FF_PROFILE_AAC_HE 4 2852 #define FF_PROFILE_AAC_HE_V2 28 2853 #define FF_PROFILE_AAC_LD 22 2854 #define FF_PROFILE_AAC_ELD 38 2855 #define FF_PROFILE_MPEG2_AAC_LOW 128 2856 #define FF_PROFILE_MPEG2_AAC_HE 131 2857 2858 #define FF_PROFILE_DNXHD 0 2859 #define FF_PROFILE_DNXHR_LB 1 2860 #define FF_PROFILE_DNXHR_SQ 2 2861 #define FF_PROFILE_DNXHR_HQ 3 2862 #define FF_PROFILE_DNXHR_HQX 4 2863 #define FF_PROFILE_DNXHR_444 5 2864 2865 #define FF_PROFILE_DTS 20 2866 #define FF_PROFILE_DTS_ES 30 2867 #define FF_PROFILE_DTS_96_24 40 2868 #define FF_PROFILE_DTS_HD_HRA 50 2869 #define FF_PROFILE_DTS_HD_MA 60 2870 #define FF_PROFILE_DTS_EXPRESS 70 2871 2872 #define FF_PROFILE_MPEG2_422 0 2873 #define FF_PROFILE_MPEG2_HIGH 1 2874 #define FF_PROFILE_MPEG2_SS 2 2875 #define FF_PROFILE_MPEG2_SNR_SCALABLE 3 2876 #define FF_PROFILE_MPEG2_MAIN 4 2877 #define FF_PROFILE_MPEG2_SIMPLE 5 2878 2879 #define FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag 2880 #define FF_PROFILE_H264_INTRA (1<<11) // 8+3; constraint_set3_flag 2881 2882 #define FF_PROFILE_H264_BASELINE 66 2883 #define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED) 2884 #define FF_PROFILE_H264_MAIN 77 2885 #define FF_PROFILE_H264_EXTENDED 88 2886 #define FF_PROFILE_H264_HIGH 100 2887 #define FF_PROFILE_H264_HIGH_10 110 2888 #define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA) 2889 #define FF_PROFILE_H264_MULTIVIEW_HIGH 118 2890 #define FF_PROFILE_H264_HIGH_422 122 2891 #define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA) 2892 #define FF_PROFILE_H264_STEREO_HIGH 128 2893 #define FF_PROFILE_H264_HIGH_444 144 2894 #define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244 2895 #define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA) 2896 #define FF_PROFILE_H264_CAVLC_444 44 2897 2898 #define FF_PROFILE_VC1_SIMPLE 0 2899 #define FF_PROFILE_VC1_MAIN 1 2900 #define FF_PROFILE_VC1_COMPLEX 2 2901 #define FF_PROFILE_VC1_ADVANCED 3 2902 2903 #define FF_PROFILE_MPEG4_SIMPLE 0 2904 #define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1 2905 #define FF_PROFILE_MPEG4_CORE 2 2906 #define FF_PROFILE_MPEG4_MAIN 3 2907 #define FF_PROFILE_MPEG4_N_BIT 4 2908 #define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5 2909 #define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6 2910 #define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7 2911 #define FF_PROFILE_MPEG4_HYBRID 8 2912 #define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9 2913 #define FF_PROFILE_MPEG4_CORE_SCALABLE 10 2914 #define FF_PROFILE_MPEG4_ADVANCED_CODING 11 2915 #define FF_PROFILE_MPEG4_ADVANCED_CORE 12 2916 #define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13 2917 #define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14 2918 #define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15 2919 2920 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 1 2921 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 2 2922 #define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 32768 2923 #define FF_PROFILE_JPEG2000_DCINEMA_2K 3 2924 #define FF_PROFILE_JPEG2000_DCINEMA_4K 4 2925 2926 #define FF_PROFILE_VP9_0 0 2927 #define FF_PROFILE_VP9_1 1 2928 #define FF_PROFILE_VP9_2 2 2929 #define FF_PROFILE_VP9_3 3 2930 2931 #define FF_PROFILE_HEVC_MAIN 1 2932 #define FF_PROFILE_HEVC_MAIN_10 2 2933 #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3 2934 #define FF_PROFILE_HEVC_REXT 4 2935 2936 #define FF_PROFILE_AV1_MAIN 0 2937 #define FF_PROFILE_AV1_HIGH 1 2938 #define FF_PROFILE_AV1_PROFESSIONAL 2 2939 2940 #define FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT 0xc0 2941 #define FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT 0xc1 2942 #define FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT 0xc2 2943 #define FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS 0xc3 2944 #define FF_PROFILE_MJPEG_JPEG_LS 0xf7 2945 2946 #define FF_PROFILE_SBC_MSBC 1 2947 2948 /** 2949 * level 2950 * - encoding: Set by user. 2951 * - decoding: Set by libavcodec. 2952 */ 2953 int level; 2954 #define FF_LEVEL_UNKNOWN -99 2955 2956 /** 2957 * Skip loop filtering for selected frames. 2958 * - encoding: unused 2959 * - decoding: Set by user. 2960 */ 2961 enum AVDiscard skip_loop_filter; 2962 2963 /** 2964 * Skip IDCT/dequantization for selected frames. 2965 * - encoding: unused 2966 * - decoding: Set by user. 2967 */ 2968 enum AVDiscard skip_idct; 2969 2970 /** 2971 * Skip decoding for selected frames. 2972 * - encoding: unused 2973 * - decoding: Set by user. 2974 */ 2975 enum AVDiscard skip_frame; 2976 2977 /** 2978 * Header containing style information for text subtitles. 2979 * For SUBTITLE_ASS subtitle type, it should contain the whole ASS 2980 * [Script Info] and [V4+ Styles] section, plus the [Events] line and 2981 * the Format line following. It shouldn't include any Dialogue line. 2982 * - encoding: Set/allocated/freed by user (before avcodec_open2()) 2983 * - decoding: Set/allocated/freed by libavcodec (by avcodec_open2()) 2984 */ 2985 uint8_t *subtitle_header; 2986 int subtitle_header_size; 2987 2988 #if FF_API_VBV_DELAY 2989 /** 2990 * VBV delay coded in the last frame (in periods of a 27 MHz clock). 2991 * Used for compliant TS muxing. 2992 * - encoding: Set by libavcodec. 2993 * - decoding: unused. 2994 * @deprecated this value is now exported as a part of 2995 * AV_PKT_DATA_CPB_PROPERTIES packet side data 2996 */ 2997 attribute_deprecated 2998 uint64_t vbv_delay; 2999 #endif 3000 3001 #if FF_API_SIDEDATA_ONLY_PKT 3002 /** 3003 * Encoding only and set by default. Allow encoders to output packets 3004 * that do not contain any encoded data, only side data. 3005 * 3006 * Some encoders need to output such packets, e.g. to update some stream 3007 * parameters at the end of encoding. 3008 * 3009 * @deprecated this field disables the default behaviour and 3010 * it is kept only for compatibility. 3011 */ 3012 attribute_deprecated 3013 int side_data_only_packets; 3014 #endif 3015 3016 /** 3017 * Audio only. The number of "priming" samples (padding) inserted by the 3018 * encoder at the beginning of the audio. I.e. this number of leading 3019 * decoded samples must be discarded by the caller to get the original audio 3020 * without leading padding. 3021 * 3022 * - decoding: unused 3023 * - encoding: Set by libavcodec. The timestamps on the output packets are 3024 * adjusted by the encoder so that they always refer to the 3025 * first sample of the data actually contained in the packet, 3026 * including any added padding. E.g. if the timebase is 3027 * 1/samplerate and the timestamp of the first input sample is 3028 * 0, the timestamp of the first output packet will be 3029 * -initial_padding. 3030 */ 3031 int initial_padding; 3032 3033 /** 3034 * - decoding: For codecs that store a framerate value in the compressed 3035 * bitstream, the decoder may export it here. { 0, 1} when 3036 * unknown. 3037 * - encoding: May be used to signal the framerate of CFR content to an 3038 * encoder. 3039 */ 3040 AVRational framerate; 3041 3042 /** 3043 * Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx. 3044 * - encoding: unused. 3045 * - decoding: Set by libavcodec before calling get_format() 3046 */ 3047 enum AVPixelFormat sw_pix_fmt; 3048 3049 /** 3050 * Timebase in which pkt_dts/pts and AVPacket.dts/pts are. 3051 * - encoding unused. 3052 * - decoding set by user. 3053 */ 3054 AVRational pkt_timebase; 3055 3056 /** 3057 * AVCodecDescriptor 3058 * - encoding: unused. 3059 * - decoding: set by libavcodec. 3060 */ 3061 const AVCodecDescriptor *codec_descriptor; 3062 3063 #if !FF_API_LOWRES 3064 /** 3065 * low resolution decoding, 1-> 1/2 size, 2->1/4 size 3066 * - encoding: unused 3067 * - decoding: Set by user. 3068 */ 3069 int lowres; 3070 #endif 3071 3072 /** 3073 * Current statistics for PTS correction. 3074 * - decoding: maintained and used by libavcodec, not intended to be used by user apps 3075 * - encoding: unused 3076 */ 3077 int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far 3078 int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far 3079 int64_t pts_correction_last_pts; /// PTS of the last frame 3080 int64_t pts_correction_last_dts; /// DTS of the last frame 3081 3082 /** 3083 * Character encoding of the input subtitles file. 3084 * - decoding: set by user 3085 * - encoding: unused 3086 */ 3087 char *sub_charenc; 3088 3089 /** 3090 * Subtitles character encoding mode. Formats or codecs might be adjusting 3091 * this setting (if they are doing the conversion themselves for instance). 3092 * - decoding: set by libavcodec 3093 * - encoding: unused 3094 */ 3095 int sub_charenc_mode; 3096 #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) 3097 #define FF_SUB_CHARENC_MODE_AUTOMATIC 0 ///< libavcodec will select the mode itself 3098 #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 3099 #define FF_SUB_CHARENC_MODE_IGNORE 2 ///< neither convert the subtitles, nor check them for valid UTF-8 3100 3101 /** 3102 * Skip processing alpha if supported by codec. 3103 * Note that if the format uses pre-multiplied alpha (common with VP6, 3104 * and recommended due to better video quality/compression) 3105 * the image will look as if alpha-blended onto a black background. 3106 * However for formats that do not use pre-multiplied alpha 3107 * there might be serious artefacts (though e.g. libswscale currently 3108 * assumes pre-multiplied alpha anyway). 3109 * 3110 * - decoding: set by user 3111 * - encoding: unused 3112 */ 3113 int skip_alpha; 3114 3115 /** 3116 * Number of samples to skip after a discontinuity 3117 * - decoding: unused 3118 * - encoding: set by libavcodec 3119 */ 3120 int seek_preroll; 3121 3122 #if !FF_API_DEBUG_MV 3123 /** 3124 * debug motion vectors 3125 * - encoding: Set by user. 3126 * - decoding: Set by user. 3127 */ 3128 int debug_mv; 3129 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames 3130 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames 3131 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames 3132 #endif 3133 3134 /** 3135 * custom intra quantization matrix 3136 * - encoding: Set by user, can be NULL. 3137 * - decoding: unused. 3138 */ 3139 uint16_t *chroma_intra_matrix; 3140 3141 /** 3142 * dump format separator. 3143 * can be ", " or "\n " or anything else 3144 * - encoding: Set by user. 3145 * - decoding: Set by user. 3146 */ 3147 uint8_t *dump_separator; 3148 3149 /** 3150 * ',' separated list of allowed decoders. 3151 * If NULL then all are allowed 3152 * - encoding: unused 3153 * - decoding: set by user 3154 */ 3155 char *codec_whitelist; 3156 3157 /** 3158 * Properties of the stream that gets decoded 3159 * - encoding: unused 3160 * - decoding: set by libavcodec 3161 */ 3162 unsigned properties; 3163 #define FF_CODEC_PROPERTY_LOSSLESS 0x00000001 3164 #define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002 3165 3166 /** 3167 * Additional data associated with the entire coded stream. 3168 * 3169 * - decoding: unused 3170 * - encoding: may be set by libavcodec after avcodec_open2(). 3171 */ 3172 AVPacketSideData *coded_side_data; 3173 int nb_coded_side_data; 3174 3175 /** 3176 * A reference to the AVHWFramesContext describing the input (for encoding) 3177 * or output (decoding) frames. The reference is set by the caller and 3178 * afterwards owned (and freed) by libavcodec - it should never be read by 3179 * the caller after being set. 3180 * 3181 * - decoding: This field should be set by the caller from the get_format() 3182 * callback. The previous reference (if any) will always be 3183 * unreffed by libavcodec before the get_format() call. 3184 * 3185 * If the default get_buffer2() is used with a hwaccel pixel 3186 * format, then this AVHWFramesContext will be used for 3187 * allocating the frame buffers. 3188 * 3189 * - encoding: For hardware encoders configured to use a hwaccel pixel 3190 * format, this field should be set by the caller to a reference 3191 * to the AVHWFramesContext describing input frames. 3192 * AVHWFramesContext.format must be equal to 3193 * AVCodecContext.pix_fmt. 3194 * 3195 * This field should be set before avcodec_open2() is called. 3196 */ 3197 AVBufferRef *hw_frames_ctx; 3198 3199 /** 3200 * Control the form of AVSubtitle.rects[N]->ass 3201 * - decoding: set by user 3202 * - encoding: unused 3203 */ 3204 int sub_text_format; 3205 #define FF_SUB_TEXT_FMT_ASS 0 3206 #if FF_API_ASS_TIMING 3207 #define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS 1 3208 #endif 3209 3210 /** 3211 * Audio only. The amount of padding (in samples) appended by the encoder to 3212 * the end of the audio. I.e. this number of decoded samples must be 3213 * discarded by the caller from the end of the stream to get the original 3214 * audio without any trailing padding. 3215 * 3216 * - decoding: unused 3217 * - encoding: unused 3218 */ 3219 int trailing_padding; 3220 3221 /** 3222 * The number of pixels per image to maximally accept. 3223 * 3224 * - decoding: set by user 3225 * - encoding: set by user 3226 */ 3227 int64_t max_pixels; 3228 3229 /** 3230 * A reference to the AVHWDeviceContext describing the device which will 3231 * be used by a hardware encoder/decoder. The reference is set by the 3232 * caller and afterwards owned (and freed) by libavcodec. 3233 * 3234 * This should be used if either the codec device does not require 3235 * hardware frames or any that are used are to be allocated internally by 3236 * libavcodec. If the user wishes to supply any of the frames used as 3237 * encoder input or decoder output then hw_frames_ctx should be used 3238 * instead. When hw_frames_ctx is set in get_format() for a decoder, this 3239 * field will be ignored while decoding the associated stream segment, but 3240 * may again be used on a following one after another get_format() call. 3241 * 3242 * For both encoders and decoders this field should be set before 3243 * avcodec_open2() is called and must not be written to thereafter. 3244 * 3245 * Note that some decoders may require this field to be set initially in 3246 * order to support hw_frames_ctx at all - in that case, all frames 3247 * contexts used must be created on the same device. 3248 */ 3249 AVBufferRef *hw_device_ctx; 3250 3251 /** 3252 * Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated 3253 * decoding (if active). 3254 * - encoding: unused 3255 * - decoding: Set by user (either before avcodec_open2(), or in the 3256 * AVCodecContext.get_format callback) 3257 */ 3258 int hwaccel_flags; 3259 3260 /** 3261 * Video decoding only. Certain video codecs support cropping, meaning that 3262 * only a sub-rectangle of the decoded frame is intended for display. This 3263 * option controls how cropping is handled by libavcodec. 3264 * 3265 * When set to 1 (the default), libavcodec will apply cropping internally. 3266 * I.e. it will modify the output frame width/height fields and offset the 3267 * data pointers (only by as much as possible while preserving alignment, or 3268 * by the full amount if the AV_CODEC_FLAG_UNALIGNED flag is set) so that 3269 * the frames output by the decoder refer only to the cropped area. The 3270 * crop_* fields of the output frames will be zero. 3271 * 3272 * When set to 0, the width/height fields of the output frames will be set 3273 * to the coded dimensions and the crop_* fields will describe the cropping 3274 * rectangle. Applying the cropping is left to the caller. 3275 * 3276 * @warning When hardware acceleration with opaque output frames is used, 3277 * libavcodec is unable to apply cropping from the top/left border. 3278 * 3279 * @note when this option is set to zero, the width/height fields of the 3280 * AVCodecContext and output AVFrames have different meanings. The codec 3281 * context fields store display dimensions (with the coded dimensions in 3282 * coded_width/height), while the frame fields store the coded dimensions 3283 * (with the display dimensions being determined by the crop_* fields). 3284 */ 3285 int apply_cropping; 3286 3287 /* 3288 * Video decoding only. Sets the number of extra hardware frames which 3289 * the decoder will allocate for use by the caller. This must be set 3290 * before avcodec_open2() is called. 3291 * 3292 * Some hardware decoders require all frames that they will use for 3293 * output to be defined in advance before decoding starts. For such 3294 * decoders, the hardware frame pool must therefore be of a fixed size. 3295 * The extra frames set here are on top of any number that the decoder 3296 * needs internally in order to operate normally (for example, frames 3297 * used as reference pictures). 3298 */ 3299 int extra_hw_frames; 3300 } AVCodecContext; 3301 3302 #if FF_API_CODEC_GET_SET 3303 /** 3304 * Accessors for some AVCodecContext fields. These used to be provided for ABI 3305 * compatibility, and do not need to be used anymore. 3306 */ 3307 attribute_deprecated 3308 AVRational av_codec_get_pkt_timebase (const AVCodecContext *avctx); 3309 attribute_deprecated 3310 void av_codec_set_pkt_timebase (AVCodecContext *avctx, AVRational val); 3311 3312 attribute_deprecated 3313 const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx); 3314 attribute_deprecated 3315 void av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc); 3316 3317 attribute_deprecated 3318 unsigned av_codec_get_codec_properties(const AVCodecContext *avctx); 3319 3320 #if FF_API_LOWRES 3321 attribute_deprecated 3322 int av_codec_get_lowres(const AVCodecContext *avctx); 3323 attribute_deprecated 3324 void av_codec_set_lowres(AVCodecContext *avctx, int val); 3325 #endif 3326 3327 attribute_deprecated 3328 int av_codec_get_seek_preroll(const AVCodecContext *avctx); 3329 attribute_deprecated 3330 void av_codec_set_seek_preroll(AVCodecContext *avctx, int val); 3331 3332 attribute_deprecated 3333 uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx); 3334 attribute_deprecated 3335 void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val); 3336 #endif 3337 3338 /** 3339 * AVProfile. 3340 */ 3341 typedef struct AVProfile { 3342 int profile; 3343 const char *name; ///< short name for the profile 3344 } AVProfile; 3345 3346 enum { 3347 /** 3348 * The codec supports this format via the hw_device_ctx interface. 3349 * 3350 * When selecting this format, AVCodecContext.hw_device_ctx should 3351 * have been set to a device of the specified type before calling 3352 * avcodec_open2(). 3353 */ 3354 AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01, 3355 /** 3356 * The codec supports this format via the hw_frames_ctx interface. 3357 * 3358 * When selecting this format for a decoder, 3359 * AVCodecContext.hw_frames_ctx should be set to a suitable frames 3360 * context inside the get_format() callback. The frames context 3361 * must have been created on a device of the specified type. 3362 */ 3363 AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02, 3364 /** 3365 * The codec supports this format by some internal method. 3366 * 3367 * This format can be selected without any additional configuration - 3368 * no device or frames context is required. 3369 */ 3370 AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04, 3371 /** 3372 * The codec supports this format by some ad-hoc method. 3373 * 3374 * Additional settings and/or function calls are required. See the 3375 * codec-specific documentation for details. (Methods requiring 3376 * this sort of configuration are deprecated and others should be 3377 * used in preference.) 3378 */ 3379 AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08, 3380 }; 3381 3382 typedef struct AVCodecHWConfig { 3383 /** 3384 * A hardware pixel format which the codec can use. 3385 */ 3386 enum AVPixelFormat pix_fmt; 3387 /** 3388 * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible 3389 * setup methods which can be used with this configuration. 3390 */ 3391 int methods; 3392 /** 3393 * The device type associated with the configuration. 3394 * 3395 * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and 3396 * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused. 3397 */ 3398 enum AVHWDeviceType device_type; 3399 } AVCodecHWConfig; 3400 3401 typedef struct AVCodecDefault AVCodecDefault; 3402 3403 struct AVSubtitle; 3404 3405 /** 3406 * AVCodec. 3407 */ 3408 typedef struct AVCodec { 3409 /** 3410 * Name of the codec implementation. 3411 * The name is globally unique among encoders and among decoders (but an 3412 * encoder and a decoder can share the same name). 3413 * This is the primary way to find a codec from the user perspective. 3414 */ 3415 const char *name; 3416 /** 3417 * Descriptive name for the codec, meant to be more human readable than name. 3418 * You should use the NULL_IF_CONFIG_SMALL() macro to define it. 3419 */ 3420 const char *long_name; 3421 enum AVMediaType type; 3422 enum AVCodecID id; 3423 /** 3424 * Codec capabilities. 3425 * see AV_CODEC_CAP_* 3426 */ 3427 int capabilities; 3428 const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0} 3429 const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1 3430 const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0 3431 const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1 3432 const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0 3433 uint8_t max_lowres; ///< maximum value for lowres supported by the decoder 3434 const AVClass *priv_class; ///< AVClass for the private context 3435 const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN} 3436 3437 /** 3438 * Group name of the codec implementation. 3439 * This is a short symbolic name of the wrapper backing this codec. A 3440 * wrapper uses some kind of external implementation for the codec, such 3441 * as an external library, or a codec implementation provided by the OS or 3442 * the hardware. 3443 * If this field is NULL, this is a builtin, libavcodec native codec. 3444 * If non-NULL, this will be the suffix in AVCodec.name in most cases 3445 * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>"). 3446 */ 3447 const char *wrapper_name; 3448 3449 /***************************************************************** 3450 * No fields below this line are part of the public API. They 3451 * may not be used outside of libavcodec and can be changed and 3452 * removed at will. 3453 * New public fields should be added right above. 3454 ***************************************************************** 3455 */ 3456 int priv_data_size; 3457 struct AVCodec *next; 3458 /** 3459 * @name Frame-level threading support functions 3460 * @{ 3461 */ 3462 /** 3463 * If defined, called on thread contexts when they are created. 3464 * If the codec allocates writable tables in init(), re-allocate them here. 3465 * priv_data will be set to a copy of the original. 3466 */ 3467 int (*init_thread_copy)(AVCodecContext *); 3468 /** 3469 * Copy necessary context variables from a previous thread context to the current one. 3470 * If not defined, the next thread will start automatically; otherwise, the codec 3471 * must call ff_thread_finish_setup(). 3472 * 3473 * dst and src will (rarely) point to the same context, in which case memcpy should be skipped. 3474 */ 3475 int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src); 3476 /** @} */ 3477 3478 /** 3479 * Private codec-specific defaults. 3480 */ 3481 const AVCodecDefault *defaults; 3482 3483 /** 3484 * Initialize codec static data, called from avcodec_register(). 3485 * 3486 * This is not intended for time consuming operations as it is 3487 * run for every codec regardless of that codec being used. 3488 */ 3489 void (*init_static_data)(struct AVCodec *codec); 3490 3491 int (*init)(AVCodecContext *); 3492 int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size, 3493 const struct AVSubtitle *sub); 3494 /** 3495 * Encode data to an AVPacket. 3496 * 3497 * @param avctx codec context 3498 * @param avpkt output AVPacket (may contain a user-provided buffer) 3499 * @param[in] frame AVFrame containing the raw data to be encoded 3500 * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a 3501 * non-empty packet was returned in avpkt. 3502 * @return 0 on success, negative error code on failure 3503 */ 3504 int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, 3505 int *got_packet_ptr); 3506 int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt); 3507 int (*close)(AVCodecContext *); 3508 /** 3509 * Encode API with decoupled packet/frame dataflow. The API is the 3510 * same as the avcodec_ prefixed APIs (avcodec_send_frame() etc.), except 3511 * that: 3512 * - never called if the codec is closed or the wrong type, 3513 * - if AV_CODEC_CAP_DELAY is not set, drain frames are never sent, 3514 * - only one drain frame is ever passed down, 3515 */ 3516 int (*send_frame)(AVCodecContext *avctx, const AVFrame *frame); 3517 int (*receive_packet)(AVCodecContext *avctx, AVPacket *avpkt); 3518 3519 /** 3520 * Decode API with decoupled packet/frame dataflow. This function is called 3521 * to get one output frame. It should call ff_decode_get_packet() to obtain 3522 * input data. 3523 */ 3524 int (*receive_frame)(AVCodecContext *avctx, AVFrame *frame); 3525 /** 3526 * Flush buffers. 3527 * Will be called when seeking 3528 */ 3529 void (*flush)(AVCodecContext *); 3530 /** 3531 * Internal codec capabilities. 3532 * See FF_CODEC_CAP_* in internal.h 3533 */ 3534 int caps_internal; 3535 3536 /** 3537 * Decoding only, a comma-separated list of bitstream filters to apply to 3538 * packets before decoding. 3539 */ 3540 const char *bsfs; 3541 3542 /** 3543 * Array of pointers to hardware configurations supported by the codec, 3544 * or NULL if no hardware supported. The array is terminated by a NULL 3545 * pointer. 3546 * 3547 * The user can only access this field via avcodec_get_hw_config(). 3548 */ 3549 const struct AVCodecHWConfigInternal **hw_configs; 3550 } AVCodec; 3551 3552 #if FF_API_CODEC_GET_SET 3553 attribute_deprecated 3554 int av_codec_get_max_lowres(const AVCodec *codec); 3555 #endif 3556 3557 struct MpegEncContext; 3558 3559 /** 3560 * Retrieve supported hardware configurations for a codec. 3561 * 3562 * Values of index from zero to some maximum return the indexed configuration 3563 * descriptor; all other values return NULL. If the codec does not support 3564 * any hardware configurations then it will always return NULL. 3565 */ 3566 const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index); 3567 3568 /** 3569 * @defgroup lavc_hwaccel AVHWAccel 3570 * 3571 * @note Nothing in this structure should be accessed by the user. At some 3572 * point in future it will not be externally visible at all. 3573 * 3574 * @{ 3575 */ 3576 typedef struct AVHWAccel { 3577 /** 3578 * Name of the hardware accelerated codec. 3579 * The name is globally unique among encoders and among decoders (but an 3580 * encoder and a decoder can share the same name). 3581 */ 3582 const char *name; 3583 3584 /** 3585 * Type of codec implemented by the hardware accelerator. 3586 * 3587 * See AVMEDIA_TYPE_xxx 3588 */ 3589 enum AVMediaType type; 3590 3591 /** 3592 * Codec implemented by the hardware accelerator. 3593 * 3594 * See AV_CODEC_ID_xxx 3595 */ 3596 enum AVCodecID id; 3597 3598 /** 3599 * Supported pixel format. 3600 * 3601 * Only hardware accelerated formats are supported here. 3602 */ 3603 enum AVPixelFormat pix_fmt; 3604 3605 /** 3606 * Hardware accelerated codec capabilities. 3607 * see AV_HWACCEL_CODEC_CAP_* 3608 */ 3609 int capabilities; 3610 3611 /***************************************************************** 3612 * No fields below this line are part of the public API. They 3613 * may not be used outside of libavcodec and can be changed and 3614 * removed at will. 3615 * New public fields should be added right above. 3616 ***************************************************************** 3617 */ 3618 3619 /** 3620 * Allocate a custom buffer 3621 */ 3622 int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame); 3623 3624 /** 3625 * Called at the beginning of each frame or field picture. 3626 * 3627 * Meaningful frame information (codec specific) is guaranteed to 3628 * be parsed at this point. This function is mandatory. 3629 * 3630 * Note that buf can be NULL along with buf_size set to 0. 3631 * Otherwise, this means the whole frame is available at this point. 3632 * 3633 * @param avctx the codec context 3634 * @param buf the frame data buffer base 3635 * @param buf_size the size of the frame in bytes 3636 * @return zero if successful, a negative value otherwise 3637 */ 3638 int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); 3639 3640 /** 3641 * Callback for parameter data (SPS/PPS/VPS etc). 3642 * 3643 * Useful for hardware decoders which keep persistent state about the 3644 * video parameters, and need to receive any changes to update that state. 3645 * 3646 * @param avctx the codec context 3647 * @param type the nal unit type 3648 * @param buf the nal unit data buffer 3649 * @param buf_size the size of the nal unit in bytes 3650 * @return zero if successful, a negative value otherwise 3651 */ 3652 int (*decode_params)(AVCodecContext *avctx, int type, const uint8_t *buf, uint32_t buf_size); 3653 3654 /** 3655 * Callback for each slice. 3656 * 3657 * Meaningful slice information (codec specific) is guaranteed to 3658 * be parsed at this point. This function is mandatory. 3659 * The only exception is XvMC, that works on MB level. 3660 * 3661 * @param avctx the codec context 3662 * @param buf the slice data buffer base 3663 * @param buf_size the size of the slice in bytes 3664 * @return zero if successful, a negative value otherwise 3665 */ 3666 int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); 3667 3668 /** 3669 * Called at the end of each frame or field picture. 3670 * 3671 * The whole picture is parsed at this point and can now be sent 3672 * to the hardware accelerator. This function is mandatory. 3673 * 3674 * @param avctx the codec context 3675 * @return zero if successful, a negative value otherwise 3676 */ 3677 int (*end_frame)(AVCodecContext *avctx); 3678 3679 /** 3680 * Size of per-frame hardware accelerator private data. 3681 * 3682 * Private data is allocated with av_mallocz() before 3683 * AVCodecContext.get_buffer() and deallocated after 3684 * AVCodecContext.release_buffer(). 3685 */ 3686 int frame_priv_data_size; 3687 3688 /** 3689 * Called for every Macroblock in a slice. 3690 * 3691 * XvMC uses it to replace the ff_mpv_reconstruct_mb(). 3692 * Instead of decoding to raw picture, MB parameters are 3693 * stored in an array provided by the video driver. 3694 * 3695 * @param s the mpeg context 3696 */ 3697 void (*decode_mb)(struct MpegEncContext *s); 3698 3699 /** 3700 * Initialize the hwaccel private data. 3701 * 3702 * This will be called from ff_get_format(), after hwaccel and 3703 * hwaccel_context are set and the hwaccel private data in AVCodecInternal 3704 * is allocated. 3705 */ 3706 int (*init)(AVCodecContext *avctx); 3707 3708 /** 3709 * Uninitialize the hwaccel private data. 3710 * 3711 * This will be called from get_format() or avcodec_close(), after hwaccel 3712 * and hwaccel_context are already uninitialized. 3713 */ 3714 int (*uninit)(AVCodecContext *avctx); 3715 3716 /** 3717 * Size of the private data to allocate in 3718 * AVCodecInternal.hwaccel_priv_data. 3719 */ 3720 int priv_data_size; 3721 3722 /** 3723 * Internal hwaccel capabilities. 3724 */ 3725 int caps_internal; 3726 3727 /** 3728 * Fill the given hw_frames context with current codec parameters. Called 3729 * from get_format. Refer to avcodec_get_hw_frames_parameters() for 3730 * details. 3731 * 3732 * This CAN be called before AVHWAccel.init is called, and you must assume 3733 * that avctx->hwaccel_priv_data is invalid. 3734 */ 3735 int (*frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx); 3736 } AVHWAccel; 3737 3738 /** 3739 * HWAccel is experimental and is thus avoided in favor of non experimental 3740 * codecs 3741 */ 3742 #define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200 3743 3744 /** 3745 * Hardware acceleration should be used for decoding even if the codec level 3746 * used is unknown or higher than the maximum supported level reported by the 3747 * hardware driver. 3748 * 3749 * It's generally a good idea to pass this flag unless you have a specific 3750 * reason not to, as hardware tends to under-report supported levels. 3751 */ 3752 #define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0) 3753 3754 /** 3755 * Hardware acceleration can output YUV pixel formats with a different chroma 3756 * sampling than 4:2:0 and/or other than 8 bits per component. 3757 */ 3758 #define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1) 3759 3760 /** 3761 * Hardware acceleration should still be attempted for decoding when the 3762 * codec profile does not match the reported capabilities of the hardware. 3763 * 3764 * For example, this can be used to try to decode baseline profile H.264 3765 * streams in hardware - it will often succeed, because many streams marked 3766 * as baseline profile actually conform to constrained baseline profile. 3767 * 3768 * @warning If the stream is actually not supported then the behaviour is 3769 * undefined, and may include returning entirely incorrect output 3770 * while indicating success. 3771 */ 3772 #define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2) 3773 3774 /** 3775 * @} 3776 */ 3777 3778 #if FF_API_AVPICTURE 3779 /** 3780 * @defgroup lavc_picture AVPicture 3781 * 3782 * Functions for working with AVPicture 3783 * @{ 3784 */ 3785 3786 /** 3787 * Picture data structure. 3788 * 3789 * Up to four components can be stored into it, the last component is 3790 * alpha. 3791 * @deprecated use AVFrame or imgutils functions instead 3792 */ 3793 typedef struct AVPicture { 3794 attribute_deprecated 3795 uint8_t *data[AV_NUM_DATA_POINTERS]; ///< pointers to the image data planes 3796 attribute_deprecated 3797 int linesize[AV_NUM_DATA_POINTERS]; ///< number of bytes per line 3798 } AVPicture; 3799 3800 /** 3801 * @} 3802 */ 3803 #endif 3804 3805 enum AVSubtitleType { 3806 SUBTITLE_NONE, 3807 3808 SUBTITLE_BITMAP, ///< A bitmap, pict will be set 3809 3810 /** 3811 * Plain text, the text field must be set by the decoder and is 3812 * authoritative. ass and pict fields may contain approximations. 3813 */ 3814 SUBTITLE_TEXT, 3815 3816 /** 3817 * Formatted text, the ass field must be set by the decoder and is 3818 * authoritative. pict and text fields may contain approximations. 3819 */ 3820 SUBTITLE_ASS, 3821 }; 3822 3823 #define AV_SUBTITLE_FLAG_FORCED 0x00000001 3824 3825 typedef struct AVSubtitleRect { 3826 int x; ///< top left corner of pict, undefined when pict is not set 3827 int y; ///< top left corner of pict, undefined when pict is not set 3828 int w; ///< width of pict, undefined when pict is not set 3829 int h; ///< height of pict, undefined when pict is not set 3830 int nb_colors; ///< number of colors in pict, undefined when pict is not set 3831 3832 #if FF_API_AVPICTURE 3833 /** 3834 * @deprecated unused 3835 */ 3836 attribute_deprecated 3837 AVPicture pict; 3838 #endif 3839 /** 3840 * data+linesize for the bitmap of this subtitle. 3841 * Can be set for text/ass as well once they are rendered. 3842 */ 3843 uint8_t *data[4]; 3844 int linesize[4]; 3845 3846 enum AVSubtitleType type; 3847 3848 char *text; ///< 0 terminated plain UTF-8 text 3849 3850 /** 3851 * 0 terminated ASS/SSA compatible event line. 3852 * The presentation of this is unaffected by the other values in this 3853 * struct. 3854 */ 3855 char *ass; 3856 3857 int flags; 3858 } AVSubtitleRect; 3859 3860 typedef struct AVSubtitle { 3861 uint16_t format; /* 0 = graphics */ 3862 uint32_t start_display_time; /* relative to packet pts, in ms */ 3863 uint32_t end_display_time; /* relative to packet pts, in ms */ 3864 unsigned num_rects; 3865 AVSubtitleRect **rects; 3866 int64_t pts; ///< Same as packet pts, in AV_TIME_BASE 3867 } AVSubtitle; 3868 3869 /** 3870 * This struct describes the properties of an encoded stream. 3871 * 3872 * sizeof(AVCodecParameters) is not a part of the public ABI, this struct must 3873 * be allocated with avcodec_parameters_alloc() and freed with 3874 * avcodec_parameters_free(). 3875 */ 3876 typedef struct AVCodecParameters { 3877 /** 3878 * General type of the encoded data. 3879 */ 3880 enum AVMediaType codec_type; 3881 /** 3882 * Specific type of the encoded data (the codec used). 3883 */ 3884 enum AVCodecID codec_id; 3885 /** 3886 * Additional information about the codec (corresponds to the AVI FOURCC). 3887 */ 3888 uint32_t codec_tag; 3889 3890 /** 3891 * Extra binary data needed for initializing the decoder, codec-dependent. 3892 * 3893 * Must be allocated with av_malloc() and will be freed by 3894 * avcodec_parameters_free(). The allocated size of extradata must be at 3895 * least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding 3896 * bytes zeroed. 3897 */ 3898 uint8_t *extradata; 3899 /** 3900 * Size of the extradata content in bytes. 3901 */ 3902 int extradata_size; 3903 3904 /** 3905 * - video: the pixel format, the value corresponds to enum AVPixelFormat. 3906 * - audio: the sample format, the value corresponds to enum AVSampleFormat. 3907 */ 3908 int format; 3909 3910 /** 3911 * The average bitrate of the encoded data (in bits per second). 3912 */ 3913 int64_t bit_rate; 3914 3915 /** 3916 * The number of bits per sample in the codedwords. 3917 * 3918 * This is basically the bitrate per sample. It is mandatory for a bunch of 3919 * formats to actually decode them. It's the number of bits for one sample in 3920 * the actual coded bitstream. 3921 * 3922 * This could be for example 4 for ADPCM 3923 * For PCM formats this matches bits_per_raw_sample 3924 * Can be 0 3925 */ 3926 int bits_per_coded_sample; 3927 3928 /** 3929 * This is the number of valid bits in each output sample. If the 3930 * sample format has more bits, the least significant bits are additional 3931 * padding bits, which are always 0. Use right shifts to reduce the sample 3932 * to its actual size. For example, audio formats with 24 bit samples will 3933 * have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32. 3934 * To get the original sample use "(int32_t)sample >> 8"." 3935 * 3936 * For ADPCM this might be 12 or 16 or similar 3937 * Can be 0 3938 */ 3939 int bits_per_raw_sample; 3940 3941 /** 3942 * Codec-specific bitstream restrictions that the stream conforms to. 3943 */ 3944 int profile; 3945 int level; 3946 3947 /** 3948 * Video only. The dimensions of the video frame in pixels. 3949 */ 3950 int width; 3951 int height; 3952 3953 /** 3954 * Video only. The aspect ratio (width / height) which a single pixel 3955 * should have when displayed. 3956 * 3957 * When the aspect ratio is unknown / undefined, the numerator should be 3958 * set to 0 (the denominator may have any value). 3959 */ 3960 AVRational sample_aspect_ratio; 3961 3962 /** 3963 * Video only. The order of the fields in interlaced video. 3964 */ 3965 enum AVFieldOrder field_order; 3966 3967 /** 3968 * Video only. Additional colorspace characteristics. 3969 */ 3970 enum AVColorRange color_range; 3971 enum AVColorPrimaries color_primaries; 3972 enum AVColorTransferCharacteristic color_trc; 3973 enum AVColorSpace color_space; 3974 enum AVChromaLocation chroma_location; 3975 3976 /** 3977 * Video only. Number of delayed frames. 3978 */ 3979 int video_delay; 3980 3981 /** 3982 * Audio only. The channel layout bitmask. May be 0 if the channel layout is 3983 * unknown or unspecified, otherwise the number of bits set must be equal to 3984 * the channels field. 3985 */ 3986 uint64_t channel_layout; 3987 /** 3988 * Audio only. The number of audio channels. 3989 */ 3990 int channels; 3991 /** 3992 * Audio only. The number of audio samples per second. 3993 */ 3994 int sample_rate; 3995 /** 3996 * Audio only. The number of bytes per coded audio frame, required by some 3997 * formats. 3998 * 3999 * Corresponds to nBlockAlign in WAVEFORMATEX. 4000 */ 4001 int block_align; 4002 /** 4003 * Audio only. Audio frame size, if known. Required by some formats to be static. 4004 */ 4005 int frame_size; 4006 4007 /** 4008 * Audio only. The amount of padding (in samples) inserted by the encoder at 4009 * the beginning of the audio. I.e. this number of leading decoded samples 4010 * must be discarded by the caller to get the original audio without leading 4011 * padding. 4012 */ 4013 int initial_padding; 4014 /** 4015 * Audio only. The amount of padding (in samples) appended by the encoder to 4016 * the end of the audio. I.e. this number of decoded samples must be 4017 * discarded by the caller from the end of the stream to get the original 4018 * audio without any trailing padding. 4019 */ 4020 int trailing_padding; 4021 /** 4022 * Audio only. Number of samples to skip after a discontinuity. 4023 */ 4024 int seek_preroll; 4025 } AVCodecParameters; 4026 4027 /** 4028 * Iterate over all registered codecs. 4029 * 4030 * @param opaque a pointer where libavcodec will store the iteration state. Must 4031 * point to NULL to start the iteration. 4032 * 4033 * @return the next registered codec or NULL when the iteration is 4034 * finished 4035 */ 4036 const AVCodec *av_codec_iterate(void **opaque); 4037 4038 #if FF_API_NEXT 4039 /** 4040 * If c is NULL, returns the first registered codec, 4041 * if c is non-NULL, returns the next registered codec after c, 4042 * or NULL if c is the last one. 4043 */ 4044 attribute_deprecated 4045 AVCodec *av_codec_next(const AVCodec *c); 4046 #endif 4047 4048 /** 4049 * Return the LIBAVCODEC_VERSION_INT constant. 4050 */ 4051 unsigned avcodec_version(void); 4052 4053 /** 4054 * Return the libavcodec build-time configuration. 4055 */ 4056 const char *avcodec_configuration(void); 4057 4058 /** 4059 * Return the libavcodec license. 4060 */ 4061 const char *avcodec_license(void); 4062 4063 #if FF_API_NEXT 4064 /** 4065 * Register the codec codec and initialize libavcodec. 4066 * 4067 * @warning either this function or avcodec_register_all() must be called 4068 * before any other libavcodec functions. 4069 * 4070 * @see avcodec_register_all() 4071 */ 4072 attribute_deprecated 4073 void avcodec_register(AVCodec *codec); 4074 4075 /** 4076 * Register all the codecs, parsers and bitstream filters which were enabled at 4077 * configuration time. If you do not call this function you can select exactly 4078 * which formats you want to support, by using the individual registration 4079 * functions. 4080 * 4081 * @see avcodec_register 4082 * @see av_register_codec_parser 4083 * @see av_register_bitstream_filter 4084 */ 4085 attribute_deprecated 4086 void avcodec_register_all(void); 4087 #endif 4088 4089 /** 4090 * Allocate an AVCodecContext and set its fields to default values. The 4091 * resulting struct should be freed with avcodec_free_context(). 4092 * 4093 * @param codec if non-NULL, allocate private data and initialize defaults 4094 * for the given codec. It is illegal to then call avcodec_open2() 4095 * with a different codec. 4096 * If NULL, then the codec-specific defaults won't be initialized, 4097 * which may result in suboptimal default settings (this is 4098 * important mainly for encoders, e.g. libx264). 4099 * 4100 * @return An AVCodecContext filled with default values or NULL on failure. 4101 */ 4102 AVCodecContext *avcodec_alloc_context3(const AVCodec *codec); 4103 4104 /** 4105 * Free the codec context and everything associated with it and write NULL to 4106 * the provided pointer. 4107 */ 4108 void avcodec_free_context(AVCodecContext **avctx); 4109 4110 #if FF_API_GET_CONTEXT_DEFAULTS 4111 /** 4112 * @deprecated This function should not be used, as closing and opening a codec 4113 * context multiple time is not supported. A new codec context should be 4114 * allocated for each new use. 4115 */ 4116 int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec); 4117 #endif 4118 4119 /** 4120 * Get the AVClass for AVCodecContext. It can be used in combination with 4121 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 4122 * 4123 * @see av_opt_find(). 4124 */ 4125 const AVClass *avcodec_get_class(void); 4126 4127 #if FF_API_COPY_CONTEXT 4128 /** 4129 * Get the AVClass for AVFrame. It can be used in combination with 4130 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 4131 * 4132 * @see av_opt_find(). 4133 */ 4134 const AVClass *avcodec_get_frame_class(void); 4135 4136 /** 4137 * Get the AVClass for AVSubtitleRect. It can be used in combination with 4138 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 4139 * 4140 * @see av_opt_find(). 4141 */ 4142 const AVClass *avcodec_get_subtitle_rect_class(void); 4143 4144 /** 4145 * Copy the settings of the source AVCodecContext into the destination 4146 * AVCodecContext. The resulting destination codec context will be 4147 * unopened, i.e. you are required to call avcodec_open2() before you 4148 * can use this AVCodecContext to decode/encode video/audio data. 4149 * 4150 * @param dest target codec context, should be initialized with 4151 * avcodec_alloc_context3(NULL), but otherwise uninitialized 4152 * @param src source codec context 4153 * @return AVERROR() on error (e.g. memory allocation error), 0 on success 4154 * 4155 * @deprecated The semantics of this function are ill-defined and it should not 4156 * be used. If you need to transfer the stream parameters from one codec context 4157 * to another, use an intermediate AVCodecParameters instance and the 4158 * avcodec_parameters_from_context() / avcodec_parameters_to_context() 4159 * functions. 4160 */ 4161 attribute_deprecated 4162 int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src); 4163 #endif 4164 4165 /** 4166 * Allocate a new AVCodecParameters and set its fields to default values 4167 * (unknown/invalid/0). The returned struct must be freed with 4168 * avcodec_parameters_free(). 4169 */ 4170 AVCodecParameters *avcodec_parameters_alloc(void); 4171 4172 /** 4173 * Free an AVCodecParameters instance and everything associated with it and 4174 * write NULL to the supplied pointer. 4175 */ 4176 void avcodec_parameters_free(AVCodecParameters **par); 4177 4178 /** 4179 * Copy the contents of src to dst. Any allocated fields in dst are freed and 4180 * replaced with newly allocated duplicates of the corresponding fields in src. 4181 * 4182 * @return >= 0 on success, a negative AVERROR code on failure. 4183 */ 4184 int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src); 4185 4186 /** 4187 * Fill the parameters struct based on the values from the supplied codec 4188 * context. Any allocated fields in par are freed and replaced with duplicates 4189 * of the corresponding fields in codec. 4190 * 4191 * @return >= 0 on success, a negative AVERROR code on failure 4192 */ 4193 int avcodec_parameters_from_context(AVCodecParameters *par, 4194 const AVCodecContext *codec); 4195 4196 /** 4197 * Fill the codec context based on the values from the supplied codec 4198 * parameters. Any allocated fields in codec that have a corresponding field in 4199 * par are freed and replaced with duplicates of the corresponding field in par. 4200 * Fields in codec that do not have a counterpart in par are not touched. 4201 * 4202 * @return >= 0 on success, a negative AVERROR code on failure. 4203 */ 4204 int avcodec_parameters_to_context(AVCodecContext *codec, 4205 const AVCodecParameters *par); 4206 4207 /** 4208 * Initialize the AVCodecContext to use the given AVCodec. Prior to using this 4209 * function the context has to be allocated with avcodec_alloc_context3(). 4210 * 4211 * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(), 4212 * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for 4213 * retrieving a codec. 4214 * 4215 * @warning This function is not thread safe! 4216 * 4217 * @note Always call this function before using decoding routines (such as 4218 * @ref avcodec_receive_frame()). 4219 * 4220 * @code 4221 * avcodec_register_all(); 4222 * av_dict_set(&opts, "b", "2.5M", 0); 4223 * codec = avcodec_find_decoder(AV_CODEC_ID_H264); 4224 * if (!codec) 4225 * exit(1); 4226 * 4227 * context = avcodec_alloc_context3(codec); 4228 * 4229 * if (avcodec_open2(context, codec, opts) < 0) 4230 * exit(1); 4231 * @endcode 4232 * 4233 * @param avctx The context to initialize. 4234 * @param codec The codec to open this context for. If a non-NULL codec has been 4235 * previously passed to avcodec_alloc_context3() or 4236 * for this context, then this parameter MUST be either NULL or 4237 * equal to the previously passed codec. 4238 * @param options A dictionary filled with AVCodecContext and codec-private options. 4239 * On return this object will be filled with options that were not found. 4240 * 4241 * @return zero on success, a negative value on error 4242 * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(), 4243 * av_dict_set(), av_opt_find(). 4244 */ 4245 int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options); 4246 4247 /** 4248 * Close a given AVCodecContext and free all the data associated with it 4249 * (but not the AVCodecContext itself). 4250 * 4251 * Calling this function on an AVCodecContext that hasn't been opened will free 4252 * the codec-specific data allocated in avcodec_alloc_context3() with a non-NULL 4253 * codec. Subsequent calls will do nothing. 4254 * 4255 * @note Do not use this function. Use avcodec_free_context() to destroy a 4256 * codec context (either open or closed). Opening and closing a codec context 4257 * multiple times is not supported anymore -- use multiple codec contexts 4258 * instead. 4259 */ 4260 int avcodec_close(AVCodecContext *avctx); 4261 4262 /** 4263 * Free all allocated data in the given subtitle struct. 4264 * 4265 * @param sub AVSubtitle to free. 4266 */ 4267 void avsubtitle_free(AVSubtitle *sub); 4268 4269 /** 4270 * @} 4271 */ 4272 4273 /** 4274 * @addtogroup lavc_packet 4275 * @{ 4276 */ 4277 4278 /** 4279 * Allocate an AVPacket and set its fields to default values. The resulting 4280 * struct must be freed using av_packet_free(). 4281 * 4282 * @return An AVPacket filled with default values or NULL on failure. 4283 * 4284 * @note this only allocates the AVPacket itself, not the data buffers. Those 4285 * must be allocated through other means such as av_new_packet. 4286 * 4287 * @see av_new_packet 4288 */ 4289 AVPacket *av_packet_alloc(void); 4290 4291 /** 4292 * Create a new packet that references the same data as src. 4293 * 4294 * This is a shortcut for av_packet_alloc()+av_packet_ref(). 4295 * 4296 * @return newly created AVPacket on success, NULL on error. 4297 * 4298 * @see av_packet_alloc 4299 * @see av_packet_ref 4300 */ 4301 AVPacket *av_packet_clone(const AVPacket *src); 4302 4303 /** 4304 * Free the packet, if the packet is reference counted, it will be 4305 * unreferenced first. 4306 * 4307 * @param pkt packet to be freed. The pointer will be set to NULL. 4308 * @note passing NULL is a no-op. 4309 */ 4310 void av_packet_free(AVPacket **pkt); 4311 4312 /** 4313 * Initialize optional fields of a packet with default values. 4314 * 4315 * Note, this does not touch the data and size members, which have to be 4316 * initialized separately. 4317 * 4318 * @param pkt packet 4319 */ 4320 void av_init_packet(AVPacket *pkt); 4321 4322 /** 4323 * Allocate the payload of a packet and initialize its fields with 4324 * default values. 4325 * 4326 * @param pkt packet 4327 * @param size wanted payload size 4328 * @return 0 if OK, AVERROR_xxx otherwise 4329 */ 4330 int av_new_packet(AVPacket *pkt, int size); 4331 4332 /** 4333 * Reduce packet size, correctly zeroing padding 4334 * 4335 * @param pkt packet 4336 * @param size new size 4337 */ 4338 void av_shrink_packet(AVPacket *pkt, int size); 4339 4340 /** 4341 * Increase packet size, correctly zeroing padding 4342 * 4343 * @param pkt packet 4344 * @param grow_by number of bytes by which to increase the size of the packet 4345 */ 4346 int av_grow_packet(AVPacket *pkt, int grow_by); 4347 4348 /** 4349 * Initialize a reference-counted packet from av_malloc()ed data. 4350 * 4351 * @param pkt packet to be initialized. This function will set the data, size, 4352 * buf and destruct fields, all others are left untouched. 4353 * @param data Data allocated by av_malloc() to be used as packet data. If this 4354 * function returns successfully, the data is owned by the underlying AVBuffer. 4355 * The caller may not access the data through other means. 4356 * @param size size of data in bytes, without the padding. I.e. the full buffer 4357 * size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE. 4358 * 4359 * @return 0 on success, a negative AVERROR on error 4360 */ 4361 int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size); 4362 4363 #if FF_API_AVPACKET_OLD_API 4364 /** 4365 * @warning This is a hack - the packet memory allocation stuff is broken. The 4366 * packet is allocated if it was not really allocated. 4367 * 4368 * @deprecated Use av_packet_ref or av_packet_make_refcounted 4369 */ 4370 attribute_deprecated 4371 int av_dup_packet(AVPacket *pkt); 4372 /** 4373 * Copy packet, including contents 4374 * 4375 * @return 0 on success, negative AVERROR on fail 4376 * 4377 * @deprecated Use av_packet_ref 4378 */ 4379 attribute_deprecated 4380 int av_copy_packet(AVPacket *dst, const AVPacket *src); 4381 4382 /** 4383 * Copy packet side data 4384 * 4385 * @return 0 on success, negative AVERROR on fail 4386 * 4387 * @deprecated Use av_packet_copy_props 4388 */ 4389 attribute_deprecated 4390 int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src); 4391 4392 /** 4393 * Free a packet. 4394 * 4395 * @deprecated Use av_packet_unref 4396 * 4397 * @param pkt packet to free 4398 */ 4399 attribute_deprecated 4400 void av_free_packet(AVPacket *pkt); 4401 #endif 4402 /** 4403 * Allocate new information of a packet. 4404 * 4405 * @param pkt packet 4406 * @param type side information type 4407 * @param size side information size 4408 * @return pointer to fresh allocated data or NULL otherwise 4409 */ 4410 uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 4411 int size); 4412 4413 /** 4414 * Wrap an existing array as a packet side data. 4415 * 4416 * @param pkt packet 4417 * @param type side information type 4418 * @param data the side data array. It must be allocated with the av_malloc() 4419 * family of functions. The ownership of the data is transferred to 4420 * pkt. 4421 * @param size side information size 4422 * @return a non-negative number on success, a negative AVERROR code on 4423 * failure. On failure, the packet is unchanged and the data remains 4424 * owned by the caller. 4425 */ 4426 int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 4427 uint8_t *data, size_t size); 4428 4429 /** 4430 * Shrink the already allocated side data buffer 4431 * 4432 * @param pkt packet 4433 * @param type side information type 4434 * @param size new side information size 4435 * @return 0 on success, < 0 on failure 4436 */ 4437 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, 4438 int size); 4439 4440 /** 4441 * Get side information from packet. 4442 * 4443 * @param pkt packet 4444 * @param type desired side information type 4445 * @param size pointer for side information size to store (optional) 4446 * @return pointer to data if present or NULL otherwise 4447 */ 4448 uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, 4449 int *size); 4450 4451 #if FF_API_MERGE_SD_API 4452 attribute_deprecated 4453 int av_packet_merge_side_data(AVPacket *pkt); 4454 4455 attribute_deprecated 4456 int av_packet_split_side_data(AVPacket *pkt); 4457 #endif 4458 4459 const char *av_packet_side_data_name(enum AVPacketSideDataType type); 4460 4461 /** 4462 * Pack a dictionary for use in side_data. 4463 * 4464 * @param dict The dictionary to pack. 4465 * @param size pointer to store the size of the returned data 4466 * @return pointer to data if successful, NULL otherwise 4467 */ 4468 uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size); 4469 /** 4470 * Unpack a dictionary from side_data. 4471 * 4472 * @param data data from side_data 4473 * @param size size of the data 4474 * @param dict the metadata storage dictionary 4475 * @return 0 on success, < 0 on failure 4476 */ 4477 int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict); 4478 4479 4480 /** 4481 * Convenience function to free all the side data stored. 4482 * All the other fields stay untouched. 4483 * 4484 * @param pkt packet 4485 */ 4486 void av_packet_free_side_data(AVPacket *pkt); 4487 4488 /** 4489 * Setup a new reference to the data described by a given packet 4490 * 4491 * If src is reference-counted, setup dst as a new reference to the 4492 * buffer in src. Otherwise allocate a new buffer in dst and copy the 4493 * data from src into it. 4494 * 4495 * All the other fields are copied from src. 4496 * 4497 * @see av_packet_unref 4498 * 4499 * @param dst Destination packet 4500 * @param src Source packet 4501 * 4502 * @return 0 on success, a negative AVERROR on error. 4503 */ 4504 int av_packet_ref(AVPacket *dst, const AVPacket *src); 4505 4506 /** 4507 * Wipe the packet. 4508 * 4509 * Unreference the buffer referenced by the packet and reset the 4510 * remaining packet fields to their default values. 4511 * 4512 * @param pkt The packet to be unreferenced. 4513 */ 4514 void av_packet_unref(AVPacket *pkt); 4515 4516 /** 4517 * Move every field in src to dst and reset src. 4518 * 4519 * @see av_packet_unref 4520 * 4521 * @param src Source packet, will be reset 4522 * @param dst Destination packet 4523 */ 4524 void av_packet_move_ref(AVPacket *dst, AVPacket *src); 4525 4526 /** 4527 * Copy only "properties" fields from src to dst. 4528 * 4529 * Properties for the purpose of this function are all the fields 4530 * beside those related to the packet data (buf, data, size) 4531 * 4532 * @param dst Destination packet 4533 * @param src Source packet 4534 * 4535 * @return 0 on success AVERROR on failure. 4536 */ 4537 int av_packet_copy_props(AVPacket *dst, const AVPacket *src); 4538 4539 /** 4540 * Ensure the data described by a given packet is reference counted. 4541 * 4542 * @note This function does not ensure that the reference will be writable. 4543 * Use av_packet_make_writable instead for that purpose. 4544 * 4545 * @see av_packet_ref 4546 * @see av_packet_make_writable 4547 * 4548 * @param pkt packet whose data should be made reference counted. 4549 * 4550 * @return 0 on success, a negative AVERROR on error. On failure, the 4551 * packet is unchanged. 4552 */ 4553 int av_packet_make_refcounted(AVPacket *pkt); 4554 4555 /** 4556 * Create a writable reference for the data described by a given packet, 4557 * avoiding data copy if possible. 4558 * 4559 * @param pkt Packet whose data should be made writable. 4560 * 4561 * @return 0 on success, a negative AVERROR on failure. On failure, the 4562 * packet is unchanged. 4563 */ 4564 int av_packet_make_writable(AVPacket *pkt); 4565 4566 /** 4567 * Convert valid timing fields (timestamps / durations) in a packet from one 4568 * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be 4569 * ignored. 4570 * 4571 * @param pkt packet on which the conversion will be performed 4572 * @param tb_src source timebase, in which the timing fields in pkt are 4573 * expressed 4574 * @param tb_dst destination timebase, to which the timing fields will be 4575 * converted 4576 */ 4577 void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst); 4578 4579 /** 4580 * @} 4581 */ 4582 4583 /** 4584 * @addtogroup lavc_decoding 4585 * @{ 4586 */ 4587 4588 /** 4589 * Find a registered decoder with a matching codec ID. 4590 * 4591 * @param id AVCodecID of the requested decoder 4592 * @return A decoder if one was found, NULL otherwise. 4593 */ 4594 AVCodec *avcodec_find_decoder(enum AVCodecID id); 4595 4596 /** 4597 * Find a registered decoder with the specified name. 4598 * 4599 * @param name name of the requested decoder 4600 * @return A decoder if one was found, NULL otherwise. 4601 */ 4602 AVCodec *avcodec_find_decoder_by_name(const char *name); 4603 4604 /** 4605 * The default callback for AVCodecContext.get_buffer2(). It is made public so 4606 * it can be called by custom get_buffer2() implementations for decoders without 4607 * AV_CODEC_CAP_DR1 set. 4608 */ 4609 int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags); 4610 4611 /** 4612 * Modify width and height values so that they will result in a memory 4613 * buffer that is acceptable for the codec if you do not use any horizontal 4614 * padding. 4615 * 4616 * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened. 4617 */ 4618 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height); 4619 4620 /** 4621 * Modify width and height values so that they will result in a memory 4622 * buffer that is acceptable for the codec if you also ensure that all 4623 * line sizes are a multiple of the respective linesize_align[i]. 4624 * 4625 * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened. 4626 */ 4627 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, 4628 int linesize_align[AV_NUM_DATA_POINTERS]); 4629 4630 /** 4631 * Converts AVChromaLocation to swscale x/y chroma position. 4632 * 4633 * The positions represent the chroma (0,0) position in a coordinates system 4634 * with luma (0,0) representing the origin and luma(1,1) representing 256,256 4635 * 4636 * @param xpos horizontal chroma sample position 4637 * @param ypos vertical chroma sample position 4638 */ 4639 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos); 4640 4641 /** 4642 * Converts swscale x/y chroma position to AVChromaLocation. 4643 * 4644 * The positions represent the chroma (0,0) position in a coordinates system 4645 * with luma (0,0) representing the origin and luma(1,1) representing 256,256 4646 * 4647 * @param xpos horizontal chroma sample position 4648 * @param ypos vertical chroma sample position 4649 */ 4650 enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos); 4651 4652 /** 4653 * Decode the audio frame of size avpkt->size from avpkt->data into frame. 4654 * 4655 * Some decoders may support multiple frames in a single AVPacket. Such 4656 * decoders would then just decode the first frame and the return value would be 4657 * less than the packet size. In this case, avcodec_decode_audio4 has to be 4658 * called again with an AVPacket containing the remaining data in order to 4659 * decode the second frame, etc... Even if no frames are returned, the packet 4660 * needs to be fed to the decoder with remaining data until it is completely 4661 * consumed or an error occurs. 4662 * 4663 * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input 4664 * and output. This means that for some packets they will not immediately 4665 * produce decoded output and need to be flushed at the end of decoding to get 4666 * all the decoded data. Flushing is done by calling this function with packets 4667 * with avpkt->data set to NULL and avpkt->size set to 0 until it stops 4668 * returning samples. It is safe to flush even those decoders that are not 4669 * marked with AV_CODEC_CAP_DELAY, then no samples will be returned. 4670 * 4671 * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE 4672 * larger than the actual read bytes because some optimized bitstream 4673 * readers read 32 or 64 bits at once and could read over the end. 4674 * 4675 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 4676 * before packets may be fed to the decoder. 4677 * 4678 * @param avctx the codec context 4679 * @param[out] frame The AVFrame in which to store decoded audio samples. 4680 * The decoder will allocate a buffer for the decoded frame by 4681 * calling the AVCodecContext.get_buffer2() callback. 4682 * When AVCodecContext.refcounted_frames is set to 1, the frame is 4683 * reference counted and the returned reference belongs to the 4684 * caller. The caller must release the frame using av_frame_unref() 4685 * when the frame is no longer needed. The caller may safely write 4686 * to the frame if av_frame_is_writable() returns 1. 4687 * When AVCodecContext.refcounted_frames is set to 0, the returned 4688 * reference belongs to the decoder and is valid only until the 4689 * next call to this function or until closing or flushing the 4690 * decoder. The caller may not write to it. 4691 * @param[out] got_frame_ptr Zero if no frame could be decoded, otherwise it is 4692 * non-zero. Note that this field being set to zero 4693 * does not mean that an error has occurred. For 4694 * decoders with AV_CODEC_CAP_DELAY set, no given decode 4695 * call is guaranteed to produce a frame. 4696 * @param[in] avpkt The input AVPacket containing the input buffer. 4697 * At least avpkt->data and avpkt->size should be set. Some 4698 * decoders might also require additional fields to be set. 4699 * @return A negative error code is returned if an error occurred during 4700 * decoding, otherwise the number of bytes consumed from the input 4701 * AVPacket is returned. 4702 * 4703 * @deprecated Use avcodec_send_packet() and avcodec_receive_frame(). 4704 */ 4705 attribute_deprecated 4706 int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, 4707 int *got_frame_ptr, const AVPacket *avpkt); 4708 4709 /** 4710 * Decode the video frame of size avpkt->size from avpkt->data into picture. 4711 * Some decoders may support multiple frames in a single AVPacket, such 4712 * decoders would then just decode the first frame. 4713 * 4714 * @warning The input buffer must be AV_INPUT_BUFFER_PADDING_SIZE larger than 4715 * the actual read bytes because some optimized bitstream readers read 32 or 64 4716 * bits at once and could read over the end. 4717 * 4718 * @warning The end of the input buffer buf should be set to 0 to ensure that 4719 * no overreading happens for damaged MPEG streams. 4720 * 4721 * @note Codecs which have the AV_CODEC_CAP_DELAY capability set have a delay 4722 * between input and output, these need to be fed with avpkt->data=NULL, 4723 * avpkt->size=0 at the end to return the remaining frames. 4724 * 4725 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 4726 * before packets may be fed to the decoder. 4727 * 4728 * @param avctx the codec context 4729 * @param[out] picture The AVFrame in which the decoded video frame will be stored. 4730 * Use av_frame_alloc() to get an AVFrame. The codec will 4731 * allocate memory for the actual bitmap by calling the 4732 * AVCodecContext.get_buffer2() callback. 4733 * When AVCodecContext.refcounted_frames is set to 1, the frame is 4734 * reference counted and the returned reference belongs to the 4735 * caller. The caller must release the frame using av_frame_unref() 4736 * when the frame is no longer needed. The caller may safely write 4737 * to the frame if av_frame_is_writable() returns 1. 4738 * When AVCodecContext.refcounted_frames is set to 0, the returned 4739 * reference belongs to the decoder and is valid only until the 4740 * next call to this function or until closing or flushing the 4741 * decoder. The caller may not write to it. 4742 * 4743 * @param[in] avpkt The input AVPacket containing the input buffer. 4744 * You can create such packet with av_init_packet() and by then setting 4745 * data and size, some decoders might in addition need other fields like 4746 * flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least 4747 * fields possible. 4748 * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero. 4749 * @return On error a negative value is returned, otherwise the number of bytes 4750 * used or zero if no frame could be decompressed. 4751 * 4752 * @deprecated Use avcodec_send_packet() and avcodec_receive_frame(). 4753 */ 4754 attribute_deprecated 4755 int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, 4756 int *got_picture_ptr, 4757 const AVPacket *avpkt); 4758 4759 /** 4760 * Decode a subtitle message. 4761 * Return a negative value on error, otherwise return the number of bytes used. 4762 * If no subtitle could be decompressed, got_sub_ptr is zero. 4763 * Otherwise, the subtitle is stored in *sub. 4764 * Note that AV_CODEC_CAP_DR1 is not available for subtitle codecs. This is for 4765 * simplicity, because the performance difference is expect to be negligible 4766 * and reusing a get_buffer written for video codecs would probably perform badly 4767 * due to a potentially very different allocation pattern. 4768 * 4769 * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input 4770 * and output. This means that for some packets they will not immediately 4771 * produce decoded output and need to be flushed at the end of decoding to get 4772 * all the decoded data. Flushing is done by calling this function with packets 4773 * with avpkt->data set to NULL and avpkt->size set to 0 until it stops 4774 * returning subtitles. It is safe to flush even those decoders that are not 4775 * marked with AV_CODEC_CAP_DELAY, then no subtitles will be returned. 4776 * 4777 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 4778 * before packets may be fed to the decoder. 4779 * 4780 * @param avctx the codec context 4781 * @param[out] sub The Preallocated AVSubtitle in which the decoded subtitle will be stored, 4782 * must be freed with avsubtitle_free if *got_sub_ptr is set. 4783 * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero. 4784 * @param[in] avpkt The input AVPacket containing the input buffer. 4785 */ 4786 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, 4787 int *got_sub_ptr, 4788 AVPacket *avpkt); 4789 4790 /** 4791 * Supply raw packet data as input to a decoder. 4792 * 4793 * Internally, this call will copy relevant AVCodecContext fields, which can 4794 * influence decoding per-packet, and apply them when the packet is actually 4795 * decoded. (For example AVCodecContext.skip_frame, which might direct the 4796 * decoder to drop the frame contained by the packet sent with this function.) 4797 * 4798 * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE 4799 * larger than the actual read bytes because some optimized bitstream 4800 * readers read 32 or 64 bits at once and could read over the end. 4801 * 4802 * @warning Do not mix this API with the legacy API (like avcodec_decode_video2()) 4803 * on the same AVCodecContext. It will return unexpected results now 4804 * or in future libavcodec versions. 4805 * 4806 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 4807 * before packets may be fed to the decoder. 4808 * 4809 * @param avctx codec context 4810 * @param[in] avpkt The input AVPacket. Usually, this will be a single video 4811 * frame, or several complete audio frames. 4812 * Ownership of the packet remains with the caller, and the 4813 * decoder will not write to the packet. The decoder may create 4814 * a reference to the packet data (or copy it if the packet is 4815 * not reference-counted). 4816 * Unlike with older APIs, the packet is always fully consumed, 4817 * and if it contains multiple frames (e.g. some audio codecs), 4818 * will require you to call avcodec_receive_frame() multiple 4819 * times afterwards before you can send a new packet. 4820 * It can be NULL (or an AVPacket with data set to NULL and 4821 * size set to 0); in this case, it is considered a flush 4822 * packet, which signals the end of the stream. Sending the 4823 * first flush packet will return success. Subsequent ones are 4824 * unnecessary and will return AVERROR_EOF. If the decoder 4825 * still has frames buffered, it will return them after sending 4826 * a flush packet. 4827 * 4828 * @return 0 on success, otherwise negative error code: 4829 * AVERROR(EAGAIN): input is not accepted in the current state - user 4830 * must read output with avcodec_receive_frame() (once 4831 * all output is read, the packet should be resent, and 4832 * the call will not fail with EAGAIN). 4833 * AVERROR_EOF: the decoder has been flushed, and no new packets can 4834 * be sent to it (also returned if more than 1 flush 4835 * packet is sent) 4836 * AVERROR(EINVAL): codec not opened, it is an encoder, or requires flush 4837 * AVERROR(ENOMEM): failed to add packet to internal queue, or similar 4838 * other errors: legitimate decoding errors 4839 */ 4840 int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt); 4841 4842 /** 4843 * Return decoded output data from a decoder. 4844 * 4845 * @param avctx codec context 4846 * @param frame This will be set to a reference-counted video or audio 4847 * frame (depending on the decoder type) allocated by the 4848 * decoder. Note that the function will always call 4849 * av_frame_unref(frame) before doing anything else. 4850 * 4851 * @return 4852 * 0: success, a frame was returned 4853 * AVERROR(EAGAIN): output is not available in this state - user must try 4854 * to send new input 4855 * AVERROR_EOF: the decoder has been fully flushed, and there will be 4856 * no more output frames 4857 * AVERROR(EINVAL): codec not opened, or it is an encoder 4858 * other negative values: legitimate decoding errors 4859 */ 4860 int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame); 4861 4862 /** 4863 * Supply a raw video or audio frame to the encoder. Use avcodec_receive_packet() 4864 * to retrieve buffered output packets. 4865 * 4866 * @param avctx codec context 4867 * @param[in] frame AVFrame containing the raw audio or video frame to be encoded. 4868 * Ownership of the frame remains with the caller, and the 4869 * encoder will not write to the frame. The encoder may create 4870 * a reference to the frame data (or copy it if the frame is 4871 * not reference-counted). 4872 * It can be NULL, in which case it is considered a flush 4873 * packet. This signals the end of the stream. If the encoder 4874 * still has packets buffered, it will return them after this 4875 * call. Once flushing mode has been entered, additional flush 4876 * packets are ignored, and sending frames will return 4877 * AVERROR_EOF. 4878 * 4879 * For audio: 4880 * If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame 4881 * can have any number of samples. 4882 * If it is not set, frame->nb_samples must be equal to 4883 * avctx->frame_size for all frames except the last. 4884 * The final frame may be smaller than avctx->frame_size. 4885 * @return 0 on success, otherwise negative error code: 4886 * AVERROR(EAGAIN): input is not accepted in the current state - user 4887 * must read output with avcodec_receive_packet() (once 4888 * all output is read, the packet should be resent, and 4889 * the call will not fail with EAGAIN). 4890 * AVERROR_EOF: the encoder has been flushed, and no new frames can 4891 * be sent to it 4892 * AVERROR(EINVAL): codec not opened, refcounted_frames not set, it is a 4893 * decoder, or requires flush 4894 * AVERROR(ENOMEM): failed to add packet to internal queue, or similar 4895 * other errors: legitimate decoding errors 4896 */ 4897 int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame); 4898 4899 /** 4900 * Read encoded data from the encoder. 4901 * 4902 * @param avctx codec context 4903 * @param avpkt This will be set to a reference-counted packet allocated by the 4904 * encoder. Note that the function will always call 4905 * av_frame_unref(frame) before doing anything else. 4906 * @return 0 on success, otherwise negative error code: 4907 * AVERROR(EAGAIN): output is not available in the current state - user 4908 * must try to send input 4909 * AVERROR_EOF: the encoder has been fully flushed, and there will be 4910 * no more output packets 4911 * AVERROR(EINVAL): codec not opened, or it is an encoder 4912 * other errors: legitimate decoding errors 4913 */ 4914 int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt); 4915 4916 /** 4917 * Create and return a AVHWFramesContext with values adequate for hardware 4918 * decoding. This is meant to get called from the get_format callback, and is 4919 * a helper for preparing a AVHWFramesContext for AVCodecContext.hw_frames_ctx. 4920 * This API is for decoding with certain hardware acceleration modes/APIs only. 4921 * 4922 * The returned AVHWFramesContext is not initialized. The caller must do this 4923 * with av_hwframe_ctx_init(). 4924 * 4925 * Calling this function is not a requirement, but makes it simpler to avoid 4926 * codec or hardware API specific details when manually allocating frames. 4927 * 4928 * Alternatively to this, an API user can set AVCodecContext.hw_device_ctx, 4929 * which sets up AVCodecContext.hw_frames_ctx fully automatically, and makes 4930 * it unnecessary to call this function or having to care about 4931 * AVHWFramesContext initialization at all. 4932 * 4933 * There are a number of requirements for calling this function: 4934 * 4935 * - It must be called from get_format with the same avctx parameter that was 4936 * passed to get_format. Calling it outside of get_format is not allowed, and 4937 * can trigger undefined behavior. 4938 * - The function is not always supported (see description of return values). 4939 * Even if this function returns successfully, hwaccel initialization could 4940 * fail later. (The degree to which implementations check whether the stream 4941 * is actually supported varies. Some do this check only after the user's 4942 * get_format callback returns.) 4943 * - The hw_pix_fmt must be one of the choices suggested by get_format. If the 4944 * user decides to use a AVHWFramesContext prepared with this API function, 4945 * the user must return the same hw_pix_fmt from get_format. 4946 * - The device_ref passed to this function must support the given hw_pix_fmt. 4947 * - After calling this API function, it is the user's responsibility to 4948 * initialize the AVHWFramesContext (returned by the out_frames_ref parameter), 4949 * and to set AVCodecContext.hw_frames_ctx to it. If done, this must be done 4950 * before returning from get_format (this is implied by the normal 4951 * AVCodecContext.hw_frames_ctx API rules). 4952 * - The AVHWFramesContext parameters may change every time time get_format is 4953 * called. Also, AVCodecContext.hw_frames_ctx is reset before get_format. So 4954 * you are inherently required to go through this process again on every 4955 * get_format call. 4956 * - It is perfectly possible to call this function without actually using 4957 * the resulting AVHWFramesContext. One use-case might be trying to reuse a 4958 * previously initialized AVHWFramesContext, and calling this API function 4959 * only to test whether the required frame parameters have changed. 4960 * - Fields that use dynamically allocated values of any kind must not be set 4961 * by the user unless setting them is explicitly allowed by the documentation. 4962 * If the user sets AVHWFramesContext.free and AVHWFramesContext.user_opaque, 4963 * the new free callback must call the potentially set previous free callback. 4964 * This API call may set any dynamically allocated fields, including the free 4965 * callback. 4966 * 4967 * The function will set at least the following fields on AVHWFramesContext 4968 * (potentially more, depending on hwaccel API): 4969 * 4970 * - All fields set by av_hwframe_ctx_alloc(). 4971 * - Set the format field to hw_pix_fmt. 4972 * - Set the sw_format field to the most suited and most versatile format. (An 4973 * implication is that this will prefer generic formats over opaque formats 4974 * with arbitrary restrictions, if possible.) 4975 * - Set the width/height fields to the coded frame size, rounded up to the 4976 * API-specific minimum alignment. 4977 * - Only _if_ the hwaccel requires a pre-allocated pool: set the initial_pool_size 4978 * field to the number of maximum reference surfaces possible with the codec, 4979 * plus 1 surface for the user to work (meaning the user can safely reference 4980 * at most 1 decoded surface at a time), plus additional buffering introduced 4981 * by frame threading. If the hwaccel does not require pre-allocation, the 4982 * field is left to 0, and the decoder will allocate new surfaces on demand 4983 * during decoding. 4984 * - Possibly AVHWFramesContext.hwctx fields, depending on the underlying 4985 * hardware API. 4986 * 4987 * Essentially, out_frames_ref returns the same as av_hwframe_ctx_alloc(), but 4988 * with basic frame parameters set. 4989 * 4990 * The function is stateless, and does not change the AVCodecContext or the 4991 * device_ref AVHWDeviceContext. 4992 * 4993 * @param avctx The context which is currently calling get_format, and which 4994 * implicitly contains all state needed for filling the returned 4995 * AVHWFramesContext properly. 4996 * @param device_ref A reference to the AVHWDeviceContext describing the device 4997 * which will be used by the hardware decoder. 4998 * @param hw_pix_fmt The hwaccel format you are going to return from get_format. 4999 * @param out_frames_ref On success, set to a reference to an _uninitialized_ 5000 * AVHWFramesContext, created from the given device_ref. 5001 * Fields will be set to values required for decoding. 5002 * Not changed if an error is returned. 5003 * @return zero on success, a negative value on error. The following error codes 5004 * have special semantics: 5005 * AVERROR(ENOENT): the decoder does not support this functionality. Setup 5006 * is always manual, or it is a decoder which does not 5007 * support setting AVCodecContext.hw_frames_ctx at all, 5008 * or it is a software format. 5009 * AVERROR(EINVAL): it is known that hardware decoding is not supported for 5010 * this configuration, or the device_ref is not supported 5011 * for the hwaccel referenced by hw_pix_fmt. 5012 */ 5013 int avcodec_get_hw_frames_parameters(AVCodecContext *avctx, 5014 AVBufferRef *device_ref, 5015 enum AVPixelFormat hw_pix_fmt, 5016 AVBufferRef **out_frames_ref); 5017 5018 5019 5020 /** 5021 * @defgroup lavc_parsing Frame parsing 5022 * @{ 5023 */ 5024 5025 enum AVPictureStructure { 5026 AV_PICTURE_STRUCTURE_UNKNOWN, //< unknown 5027 AV_PICTURE_STRUCTURE_TOP_FIELD, //< coded as top field 5028 AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field 5029 AV_PICTURE_STRUCTURE_FRAME, //< coded as frame 5030 }; 5031 5032 typedef struct AVCodecParserContext { 5033 void *priv_data; 5034 struct AVCodecParser *parser; 5035 int64_t frame_offset; /* offset of the current frame */ 5036 int64_t cur_offset; /* current offset 5037 (incremented by each av_parser_parse()) */ 5038 int64_t next_frame_offset; /* offset of the next frame */ 5039 /* video info */ 5040 int pict_type; /* XXX: Put it back in AVCodecContext. */ 5041 /** 5042 * This field is used for proper frame duration computation in lavf. 5043 * It signals, how much longer the frame duration of the current frame 5044 * is compared to normal frame duration. 5045 * 5046 * frame_duration = (1 + repeat_pict) * time_base 5047 * 5048 * It is used by codecs like H.264 to display telecined material. 5049 */ 5050 int repeat_pict; /* XXX: Put it back in AVCodecContext. */ 5051 int64_t pts; /* pts of the current frame */ 5052 int64_t dts; /* dts of the current frame */ 5053 5054 /* private data */ 5055 int64_t last_pts; 5056 int64_t last_dts; 5057 int fetch_timestamp; 5058 5059 #define AV_PARSER_PTS_NB 4 5060 int cur_frame_start_index; 5061 int64_t cur_frame_offset[AV_PARSER_PTS_NB]; 5062 int64_t cur_frame_pts[AV_PARSER_PTS_NB]; 5063 int64_t cur_frame_dts[AV_PARSER_PTS_NB]; 5064 5065 int flags; 5066 #define PARSER_FLAG_COMPLETE_FRAMES 0x0001 5067 #define PARSER_FLAG_ONCE 0x0002 5068 /// Set if the parser has a valid file offset 5069 #define PARSER_FLAG_FETCHED_OFFSET 0x0004 5070 #define PARSER_FLAG_USE_CODEC_TS 0x1000 5071 5072 int64_t offset; ///< byte offset from starting packet start 5073 int64_t cur_frame_end[AV_PARSER_PTS_NB]; 5074 5075 /** 5076 * Set by parser to 1 for key frames and 0 for non-key frames. 5077 * It is initialized to -1, so if the parser doesn't set this flag, 5078 * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames 5079 * will be used. 5080 */ 5081 int key_frame; 5082 5083 #if FF_API_CONVERGENCE_DURATION 5084 /** 5085 * @deprecated unused 5086 */ 5087 attribute_deprecated 5088 int64_t convergence_duration; 5089 #endif 5090 5091 // Timestamp generation support: 5092 /** 5093 * Synchronization point for start of timestamp generation. 5094 * 5095 * Set to >0 for sync point, 0 for no sync point and <0 for undefined 5096 * (default). 5097 * 5098 * For example, this corresponds to presence of H.264 buffering period 5099 * SEI message. 5100 */ 5101 int dts_sync_point; 5102 5103 /** 5104 * Offset of the current timestamp against last timestamp sync point in 5105 * units of AVCodecContext.time_base. 5106 * 5107 * Set to INT_MIN when dts_sync_point unused. Otherwise, it must 5108 * contain a valid timestamp offset. 5109 * 5110 * Note that the timestamp of sync point has usually a nonzero 5111 * dts_ref_dts_delta, which refers to the previous sync point. Offset of 5112 * the next frame after timestamp sync point will be usually 1. 5113 * 5114 * For example, this corresponds to H.264 cpb_removal_delay. 5115 */ 5116 int dts_ref_dts_delta; 5117 5118 /** 5119 * Presentation delay of current frame in units of AVCodecContext.time_base. 5120 * 5121 * Set to INT_MIN when dts_sync_point unused. Otherwise, it must 5122 * contain valid non-negative timestamp delta (presentation time of a frame 5123 * must not lie in the past). 5124 * 5125 * This delay represents the difference between decoding and presentation 5126 * time of the frame. 5127 * 5128 * For example, this corresponds to H.264 dpb_output_delay. 5129 */ 5130 int pts_dts_delta; 5131 5132 /** 5133 * Position of the packet in file. 5134 * 5135 * Analogous to cur_frame_pts/dts 5136 */ 5137 int64_t cur_frame_pos[AV_PARSER_PTS_NB]; 5138 5139 /** 5140 * Byte position of currently parsed frame in stream. 5141 */ 5142 int64_t pos; 5143 5144 /** 5145 * Previous frame byte position. 5146 */ 5147 int64_t last_pos; 5148 5149 /** 5150 * Duration of the current frame. 5151 * For audio, this is in units of 1 / AVCodecContext.sample_rate. 5152 * For all other types, this is in units of AVCodecContext.time_base. 5153 */ 5154 int duration; 5155 5156 enum AVFieldOrder field_order; 5157 5158 /** 5159 * Indicate whether a picture is coded as a frame, top field or bottom field. 5160 * 5161 * For example, H.264 field_pic_flag equal to 0 corresponds to 5162 * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag 5163 * equal to 1 and bottom_field_flag equal to 0 corresponds to 5164 * AV_PICTURE_STRUCTURE_TOP_FIELD. 5165 */ 5166 enum AVPictureStructure picture_structure; 5167 5168 /** 5169 * Picture number incremented in presentation or output order. 5170 * This field may be reinitialized at the first picture of a new sequence. 5171 * 5172 * For example, this corresponds to H.264 PicOrderCnt. 5173 */ 5174 int output_picture_number; 5175 5176 /** 5177 * Dimensions of the decoded video intended for presentation. 5178 */ 5179 int width; 5180 int height; 5181 5182 /** 5183 * Dimensions of the coded video. 5184 */ 5185 int coded_width; 5186 int coded_height; 5187 5188 /** 5189 * The format of the coded data, corresponds to enum AVPixelFormat for video 5190 * and for enum AVSampleFormat for audio. 5191 * 5192 * Note that a decoder can have considerable freedom in how exactly it 5193 * decodes the data, so the format reported here might be different from the 5194 * one returned by a decoder. 5195 */ 5196 int format; 5197 } AVCodecParserContext; 5198 5199 typedef struct AVCodecParser { 5200 int codec_ids[5]; /* several codec IDs are permitted */ 5201 int priv_data_size; 5202 int (*parser_init)(AVCodecParserContext *s); 5203 /* This callback never returns an error, a negative value means that 5204 * the frame start was in a previous packet. */ 5205 int (*parser_parse)(AVCodecParserContext *s, 5206 AVCodecContext *avctx, 5207 const uint8_t **poutbuf, int *poutbuf_size, 5208 const uint8_t *buf, int buf_size); 5209 void (*parser_close)(AVCodecParserContext *s); 5210 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size); 5211 struct AVCodecParser *next; 5212 } AVCodecParser; 5213 5214 /** 5215 * Iterate over all registered codec parsers. 5216 * 5217 * @param opaque a pointer where libavcodec will store the iteration state. Must 5218 * point to NULL to start the iteration. 5219 * 5220 * @return the next registered codec parser or NULL when the iteration is 5221 * finished 5222 */ 5223 const AVCodecParser *av_parser_iterate(void **opaque); 5224 5225 attribute_deprecated 5226 AVCodecParser *av_parser_next(const AVCodecParser *c); 5227 5228 attribute_deprecated 5229 void av_register_codec_parser(AVCodecParser *parser); 5230 AVCodecParserContext *av_parser_init(int codec_id); 5231 5232 /** 5233 * Parse a packet. 5234 * 5235 * @param s parser context. 5236 * @param avctx codec context. 5237 * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished. 5238 * @param poutbuf_size set to size of parsed buffer or zero if not yet finished. 5239 * @param buf input buffer. 5240 * @param buf_size buffer size in bytes without the padding. I.e. the full buffer 5241 size is assumed to be buf_size + AV_INPUT_BUFFER_PADDING_SIZE. 5242 To signal EOF, this should be 0 (so that the last frame 5243 can be output). 5244 * @param pts input presentation timestamp. 5245 * @param dts input decoding timestamp. 5246 * @param pos input byte position in stream. 5247 * @return the number of bytes of the input bitstream used. 5248 * 5249 * Example: 5250 * @code 5251 * while(in_len){ 5252 * len = av_parser_parse2(myparser, AVCodecContext, &data, &size, 5253 * in_data, in_len, 5254 * pts, dts, pos); 5255 * in_data += len; 5256 * in_len -= len; 5257 * 5258 * if(size) 5259 * decode_frame(data, size); 5260 * } 5261 * @endcode 5262 */ 5263 int av_parser_parse2(AVCodecParserContext *s, 5264 AVCodecContext *avctx, 5265 uint8_t **poutbuf, int *poutbuf_size, 5266 const uint8_t *buf, int buf_size, 5267 int64_t pts, int64_t dts, 5268 int64_t pos); 5269 5270 /** 5271 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed 5272 * @deprecated use AVBitStreamFilter 5273 */ 5274 int av_parser_change(AVCodecParserContext *s, 5275 AVCodecContext *avctx, 5276 uint8_t **poutbuf, int *poutbuf_size, 5277 const uint8_t *buf, int buf_size, int keyframe); 5278 void av_parser_close(AVCodecParserContext *s); 5279 5280 /** 5281 * @} 5282 * @} 5283 */ 5284 5285 /** 5286 * @addtogroup lavc_encoding 5287 * @{ 5288 */ 5289 5290 /** 5291 * Find a registered encoder with a matching codec ID. 5292 * 5293 * @param id AVCodecID of the requested encoder 5294 * @return An encoder if one was found, NULL otherwise. 5295 */ 5296 AVCodec *avcodec_find_encoder(enum AVCodecID id); 5297 5298 /** 5299 * Find a registered encoder with the specified name. 5300 * 5301 * @param name name of the requested encoder 5302 * @return An encoder if one was found, NULL otherwise. 5303 */ 5304 AVCodec *avcodec_find_encoder_by_name(const char *name); 5305 5306 /** 5307 * Encode a frame of audio. 5308 * 5309 * Takes input samples from frame and writes the next output packet, if 5310 * available, to avpkt. The output packet does not necessarily contain data for 5311 * the most recent frame, as encoders can delay, split, and combine input frames 5312 * internally as needed. 5313 * 5314 * @param avctx codec context 5315 * @param avpkt output AVPacket. 5316 * The user can supply an output buffer by setting 5317 * avpkt->data and avpkt->size prior to calling the 5318 * function, but if the size of the user-provided data is not 5319 * large enough, encoding will fail. If avpkt->data and 5320 * avpkt->size are set, avpkt->destruct must also be set. All 5321 * other AVPacket fields will be reset by the encoder using 5322 * av_init_packet(). If avpkt->data is NULL, the encoder will 5323 * allocate it. The encoder will set avpkt->size to the size 5324 * of the output packet. 5325 * 5326 * If this function fails or produces no output, avpkt will be 5327 * freed using av_packet_unref(). 5328 * @param[in] frame AVFrame containing the raw audio data to be encoded. 5329 * May be NULL when flushing an encoder that has the 5330 * AV_CODEC_CAP_DELAY capability set. 5331 * If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame 5332 * can have any number of samples. 5333 * If it is not set, frame->nb_samples must be equal to 5334 * avctx->frame_size for all frames except the last. 5335 * The final frame may be smaller than avctx->frame_size. 5336 * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the 5337 * output packet is non-empty, and to 0 if it is 5338 * empty. If the function returns an error, the 5339 * packet can be assumed to be invalid, and the 5340 * value of got_packet_ptr is undefined and should 5341 * not be used. 5342 * @return 0 on success, negative error code on failure 5343 * 5344 * @deprecated use avcodec_send_frame()/avcodec_receive_packet() instead 5345 */ 5346 attribute_deprecated 5347 int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, 5348 const AVFrame *frame, int *got_packet_ptr); 5349 5350 /** 5351 * Encode a frame of video. 5352 * 5353 * Takes input raw video data from frame and writes the next output packet, if 5354 * available, to avpkt. The output packet does not necessarily contain data for 5355 * the most recent frame, as encoders can delay and reorder input frames 5356 * internally as needed. 5357 * 5358 * @param avctx codec context 5359 * @param avpkt output AVPacket. 5360 * The user can supply an output buffer by setting 5361 * avpkt->data and avpkt->size prior to calling the 5362 * function, but if the size of the user-provided data is not 5363 * large enough, encoding will fail. All other AVPacket fields 5364 * will be reset by the encoder using av_init_packet(). If 5365 * avpkt->data is NULL, the encoder will allocate it. 5366 * The encoder will set avpkt->size to the size of the 5367 * output packet. The returned data (if any) belongs to the 5368 * caller, he is responsible for freeing it. 5369 * 5370 * If this function fails or produces no output, avpkt will be 5371 * freed using av_packet_unref(). 5372 * @param[in] frame AVFrame containing the raw video data to be encoded. 5373 * May be NULL when flushing an encoder that has the 5374 * AV_CODEC_CAP_DELAY capability set. 5375 * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the 5376 * output packet is non-empty, and to 0 if it is 5377 * empty. If the function returns an error, the 5378 * packet can be assumed to be invalid, and the 5379 * value of got_packet_ptr is undefined and should 5380 * not be used. 5381 * @return 0 on success, negative error code on failure 5382 * 5383 * @deprecated use avcodec_send_frame()/avcodec_receive_packet() instead 5384 */ 5385 attribute_deprecated 5386 int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, 5387 const AVFrame *frame, int *got_packet_ptr); 5388 5389 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, 5390 const AVSubtitle *sub); 5391 5392 5393 /** 5394 * @} 5395 */ 5396 5397 #if FF_API_AVPICTURE 5398 /** 5399 * @addtogroup lavc_picture 5400 * @{ 5401 */ 5402 5403 /** 5404 * @deprecated unused 5405 */ 5406 attribute_deprecated 5407 int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height); 5408 5409 /** 5410 * @deprecated unused 5411 */ 5412 attribute_deprecated 5413 void avpicture_free(AVPicture *picture); 5414 5415 /** 5416 * @deprecated use av_image_fill_arrays() instead. 5417 */ 5418 attribute_deprecated 5419 int avpicture_fill(AVPicture *picture, const uint8_t *ptr, 5420 enum AVPixelFormat pix_fmt, int width, int height); 5421 5422 /** 5423 * @deprecated use av_image_copy_to_buffer() instead. 5424 */ 5425 attribute_deprecated 5426 int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt, 5427 int width, int height, 5428 unsigned char *dest, int dest_size); 5429 5430 /** 5431 * @deprecated use av_image_get_buffer_size() instead. 5432 */ 5433 attribute_deprecated 5434 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height); 5435 5436 /** 5437 * @deprecated av_image_copy() instead. 5438 */ 5439 attribute_deprecated 5440 void av_picture_copy(AVPicture *dst, const AVPicture *src, 5441 enum AVPixelFormat pix_fmt, int width, int height); 5442 5443 /** 5444 * @deprecated unused 5445 */ 5446 attribute_deprecated 5447 int av_picture_crop(AVPicture *dst, const AVPicture *src, 5448 enum AVPixelFormat pix_fmt, int top_band, int left_band); 5449 5450 /** 5451 * @deprecated unused 5452 */ 5453 attribute_deprecated 5454 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt, 5455 int padtop, int padbottom, int padleft, int padright, int *color); 5456 5457 /** 5458 * @} 5459 */ 5460 #endif 5461 5462 /** 5463 * @defgroup lavc_misc Utility functions 5464 * @ingroup libavc 5465 * 5466 * Miscellaneous utility functions related to both encoding and decoding 5467 * (or neither). 5468 * @{ 5469 */ 5470 5471 /** 5472 * @defgroup lavc_misc_pixfmt Pixel formats 5473 * 5474 * Functions for working with pixel formats. 5475 * @{ 5476 */ 5477 5478 #if FF_API_GETCHROMA 5479 /** 5480 * @deprecated Use av_pix_fmt_get_chroma_sub_sample 5481 */ 5482 5483 attribute_deprecated 5484 void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift); 5485 #endif 5486 5487 /** 5488 * Return a value representing the fourCC code associated to the 5489 * pixel format pix_fmt, or 0 if no associated fourCC code can be 5490 * found. 5491 */ 5492 unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt); 5493 5494 /** 5495 * @deprecated see av_get_pix_fmt_loss() 5496 */ 5497 int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt, 5498 int has_alpha); 5499 5500 /** 5501 * Find the best pixel format to convert to given a certain source pixel 5502 * format. When converting from one pixel format to another, information loss 5503 * may occur. For example, when converting from RGB24 to GRAY, the color 5504 * information will be lost. Similarly, other losses occur when converting from 5505 * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of 5506 * the given pixel formats should be used to suffer the least amount of loss. 5507 * The pixel formats from which it chooses one, are determined by the 5508 * pix_fmt_list parameter. 5509 * 5510 * 5511 * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from 5512 * @param[in] src_pix_fmt source pixel format 5513 * @param[in] has_alpha Whether the source pixel format alpha channel is used. 5514 * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur. 5515 * @return The best pixel format to convert to or -1 if none was found. 5516 */ 5517 enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list, 5518 enum AVPixelFormat src_pix_fmt, 5519 int has_alpha, int *loss_ptr); 5520 5521 /** 5522 * @deprecated see av_find_best_pix_fmt_of_2() 5523 */ 5524 enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2, 5525 enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr); 5526 5527 attribute_deprecated 5528 enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2, 5529 enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr); 5530 5531 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt); 5532 5533 /** 5534 * @} 5535 */ 5536 5537 #if FF_API_TAG_STRING 5538 /** 5539 * Put a string representing the codec tag codec_tag in buf. 5540 * 5541 * @param buf buffer to place codec tag in 5542 * @param buf_size size in bytes of buf 5543 * @param codec_tag codec tag to assign 5544 * @return the length of the string that would have been generated if 5545 * enough space had been available, excluding the trailing null 5546 * 5547 * @deprecated see av_fourcc_make_string() and av_fourcc2str(). 5548 */ 5549 attribute_deprecated 5550 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag); 5551 #endif 5552 5553 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode); 5554 5555 /** 5556 * Return a name for the specified profile, if available. 5557 * 5558 * @param codec the codec that is searched for the given profile 5559 * @param profile the profile value for which a name is requested 5560 * @return A name for the profile if found, NULL otherwise. 5561 */ 5562 const char *av_get_profile_name(const AVCodec *codec, int profile); 5563 5564 /** 5565 * Return a name for the specified profile, if available. 5566 * 5567 * @param codec_id the ID of the codec to which the requested profile belongs 5568 * @param profile the profile value for which a name is requested 5569 * @return A name for the profile if found, NULL otherwise. 5570 * 5571 * @note unlike av_get_profile_name(), which searches a list of profiles 5572 * supported by a specific decoder or encoder implementation, this 5573 * function searches the list of profiles from the AVCodecDescriptor 5574 */ 5575 const char *avcodec_profile_name(enum AVCodecID codec_id, int profile); 5576 5577 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size); 5578 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count); 5579 //FIXME func typedef 5580 5581 /** 5582 * Fill AVFrame audio data and linesize pointers. 5583 * 5584 * The buffer buf must be a preallocated buffer with a size big enough 5585 * to contain the specified samples amount. The filled AVFrame data 5586 * pointers will point to this buffer. 5587 * 5588 * AVFrame extended_data channel pointers are allocated if necessary for 5589 * planar audio. 5590 * 5591 * @param frame the AVFrame 5592 * frame->nb_samples must be set prior to calling the 5593 * function. This function fills in frame->data, 5594 * frame->extended_data, frame->linesize[0]. 5595 * @param nb_channels channel count 5596 * @param sample_fmt sample format 5597 * @param buf buffer to use for frame data 5598 * @param buf_size size of buffer 5599 * @param align plane size sample alignment (0 = default) 5600 * @return >=0 on success, negative error code on failure 5601 * @todo return the size in bytes required to store the samples in 5602 * case of success, at the next libavutil bump 5603 */ 5604 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, 5605 enum AVSampleFormat sample_fmt, const uint8_t *buf, 5606 int buf_size, int align); 5607 5608 /** 5609 * Reset the internal decoder state / flush internal buffers. Should be called 5610 * e.g. when seeking or when switching to a different stream. 5611 * 5612 * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0), 5613 * this invalidates the frames previously returned from the decoder. When 5614 * refcounted frames are used, the decoder just releases any references it might 5615 * keep internally, but the caller's reference remains valid. 5616 */ 5617 void avcodec_flush_buffers(AVCodecContext *avctx); 5618 5619 /** 5620 * Return codec bits per sample. 5621 * 5622 * @param[in] codec_id the codec 5623 * @return Number of bits per sample or zero if unknown for the given codec. 5624 */ 5625 int av_get_bits_per_sample(enum AVCodecID codec_id); 5626 5627 /** 5628 * Return the PCM codec associated with a sample format. 5629 * @param be endianness, 0 for little, 1 for big, 5630 * -1 (or anything else) for native 5631 * @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE 5632 */ 5633 enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be); 5634 5635 /** 5636 * Return codec bits per sample. 5637 * Only return non-zero if the bits per sample is exactly correct, not an 5638 * approximation. 5639 * 5640 * @param[in] codec_id the codec 5641 * @return Number of bits per sample or zero if unknown for the given codec. 5642 */ 5643 int av_get_exact_bits_per_sample(enum AVCodecID codec_id); 5644 5645 /** 5646 * Return audio frame duration. 5647 * 5648 * @param avctx codec context 5649 * @param frame_bytes size of the frame, or 0 if unknown 5650 * @return frame duration, in samples, if known. 0 if not able to 5651 * determine. 5652 */ 5653 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes); 5654 5655 /** 5656 * This function is the same as av_get_audio_frame_duration(), except it works 5657 * with AVCodecParameters instead of an AVCodecContext. 5658 */ 5659 int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes); 5660 5661 #if FF_API_OLD_BSF 5662 typedef struct AVBitStreamFilterContext { 5663 void *priv_data; 5664 const struct AVBitStreamFilter *filter; 5665 AVCodecParserContext *parser; 5666 struct AVBitStreamFilterContext *next; 5667 /** 5668 * Internal default arguments, used if NULL is passed to av_bitstream_filter_filter(). 5669 * Not for access by library users. 5670 */ 5671 char *args; 5672 } AVBitStreamFilterContext; 5673 #endif 5674 5675 typedef struct AVBSFInternal AVBSFInternal; 5676 5677 /** 5678 * The bitstream filter state. 5679 * 5680 * This struct must be allocated with av_bsf_alloc() and freed with 5681 * av_bsf_free(). 5682 * 5683 * The fields in the struct will only be changed (by the caller or by the 5684 * filter) as described in their documentation, and are to be considered 5685 * immutable otherwise. 5686 */ 5687 typedef struct AVBSFContext { 5688 /** 5689 * A class for logging and AVOptions 5690 */ 5691 const AVClass *av_class; 5692 5693 /** 5694 * The bitstream filter this context is an instance of. 5695 */ 5696 const struct AVBitStreamFilter *filter; 5697 5698 /** 5699 * Opaque libavcodec internal data. Must not be touched by the caller in any 5700 * way. 5701 */ 5702 AVBSFInternal *internal; 5703 5704 /** 5705 * Opaque filter-specific private data. If filter->priv_class is non-NULL, 5706 * this is an AVOptions-enabled struct. 5707 */ 5708 void *priv_data; 5709 5710 /** 5711 * Parameters of the input stream. This field is allocated in 5712 * av_bsf_alloc(), it needs to be filled by the caller before 5713 * av_bsf_init(). 5714 */ 5715 AVCodecParameters *par_in; 5716 5717 /** 5718 * Parameters of the output stream. This field is allocated in 5719 * av_bsf_alloc(), it is set by the filter in av_bsf_init(). 5720 */ 5721 AVCodecParameters *par_out; 5722 5723 /** 5724 * The timebase used for the timestamps of the input packets. Set by the 5725 * caller before av_bsf_init(). 5726 */ 5727 AVRational time_base_in; 5728 5729 /** 5730 * The timebase used for the timestamps of the output packets. Set by the 5731 * filter in av_bsf_init(). 5732 */ 5733 AVRational time_base_out; 5734 } AVBSFContext; 5735 5736 typedef struct AVBitStreamFilter { 5737 const char *name; 5738 5739 /** 5740 * A list of codec ids supported by the filter, terminated by 5741 * AV_CODEC_ID_NONE. 5742 * May be NULL, in that case the bitstream filter works with any codec id. 5743 */ 5744 const enum AVCodecID *codec_ids; 5745 5746 /** 5747 * A class for the private data, used to declare bitstream filter private 5748 * AVOptions. This field is NULL for bitstream filters that do not declare 5749 * any options. 5750 * 5751 * If this field is non-NULL, the first member of the filter private data 5752 * must be a pointer to AVClass, which will be set by libavcodec generic 5753 * code to this class. 5754 */ 5755 const AVClass *priv_class; 5756 5757 /***************************************************************** 5758 * No fields below this line are part of the public API. They 5759 * may not be used outside of libavcodec and can be changed and 5760 * removed at will. 5761 * New public fields should be added right above. 5762 ***************************************************************** 5763 */ 5764 5765 int priv_data_size; 5766 int (*init)(AVBSFContext *ctx); 5767 int (*filter)(AVBSFContext *ctx, AVPacket *pkt); 5768 void (*close)(AVBSFContext *ctx); 5769 } AVBitStreamFilter; 5770 5771 #if FF_API_OLD_BSF 5772 /** 5773 * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext) 5774 * is deprecated. Use the new bitstream filtering API (using AVBSFContext). 5775 */ 5776 attribute_deprecated 5777 void av_register_bitstream_filter(AVBitStreamFilter *bsf); 5778 /** 5779 * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext) 5780 * is deprecated. Use av_bsf_get_by_name(), av_bsf_alloc(), and av_bsf_init() 5781 * from the new bitstream filtering API (using AVBSFContext). 5782 */ 5783 attribute_deprecated 5784 AVBitStreamFilterContext *av_bitstream_filter_init(const char *name); 5785 /** 5786 * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext) 5787 * is deprecated. Use av_bsf_send_packet() and av_bsf_receive_packet() from the 5788 * new bitstream filtering API (using AVBSFContext). 5789 */ 5790 attribute_deprecated 5791 int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, 5792 AVCodecContext *avctx, const char *args, 5793 uint8_t **poutbuf, int *poutbuf_size, 5794 const uint8_t *buf, int buf_size, int keyframe); 5795 /** 5796 * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext) 5797 * is deprecated. Use av_bsf_free() from the new bitstream filtering API (using 5798 * AVBSFContext). 5799 */ 5800 attribute_deprecated 5801 void av_bitstream_filter_close(AVBitStreamFilterContext *bsf); 5802 /** 5803 * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext) 5804 * is deprecated. Use av_bsf_iterate() from the new bitstream filtering API (using 5805 * AVBSFContext). 5806 */ 5807 attribute_deprecated 5808 const AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f); 5809 #endif 5810 5811 /** 5812 * @return a bitstream filter with the specified name or NULL if no such 5813 * bitstream filter exists. 5814 */ 5815 const AVBitStreamFilter *av_bsf_get_by_name(const char *name); 5816 5817 /** 5818 * Iterate over all registered bitstream filters. 5819 * 5820 * @param opaque a pointer where libavcodec will store the iteration state. Must 5821 * point to NULL to start the iteration. 5822 * 5823 * @return the next registered bitstream filter or NULL when the iteration is 5824 * finished 5825 */ 5826 const AVBitStreamFilter *av_bsf_iterate(void **opaque); 5827 #if FF_API_NEXT 5828 attribute_deprecated 5829 const AVBitStreamFilter *av_bsf_next(void **opaque); 5830 #endif 5831 5832 /** 5833 * Allocate a context for a given bitstream filter. The caller must fill in the 5834 * context parameters as described in the documentation and then call 5835 * av_bsf_init() before sending any data to the filter. 5836 * 5837 * @param filter the filter for which to allocate an instance. 5838 * @param ctx a pointer into which the pointer to the newly-allocated context 5839 * will be written. It must be freed with av_bsf_free() after the 5840 * filtering is done. 5841 * 5842 * @return 0 on success, a negative AVERROR code on failure 5843 */ 5844 int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx); 5845 5846 /** 5847 * Prepare the filter for use, after all the parameters and options have been 5848 * set. 5849 */ 5850 int av_bsf_init(AVBSFContext *ctx); 5851 5852 /** 5853 * Submit a packet for filtering. 5854 * 5855 * After sending each packet, the filter must be completely drained by calling 5856 * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or 5857 * AVERROR_EOF. 5858 * 5859 * @param pkt the packet to filter. The bitstream filter will take ownership of 5860 * the packet and reset the contents of pkt. pkt is not touched if an error occurs. 5861 * This parameter may be NULL, which signals the end of the stream (i.e. no more 5862 * packets will be sent). That will cause the filter to output any packets it 5863 * may have buffered internally. 5864 * 5865 * @return 0 on success, a negative AVERROR on error. 5866 */ 5867 int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt); 5868 5869 /** 5870 * Retrieve a filtered packet. 5871 * 5872 * @param[out] pkt this struct will be filled with the contents of the filtered 5873 * packet. It is owned by the caller and must be freed using 5874 * av_packet_unref() when it is no longer needed. 5875 * This parameter should be "clean" (i.e. freshly allocated 5876 * with av_packet_alloc() or unreffed with av_packet_unref()) 5877 * when this function is called. If this function returns 5878 * successfully, the contents of pkt will be completely 5879 * overwritten by the returned data. On failure, pkt is not 5880 * touched. 5881 * 5882 * @return 0 on success. AVERROR(EAGAIN) if more packets need to be sent to the 5883 * filter (using av_bsf_send_packet()) to get more output. AVERROR_EOF if there 5884 * will be no further output from the filter. Another negative AVERROR value if 5885 * an error occurs. 5886 * 5887 * @note one input packet may result in several output packets, so after sending 5888 * a packet with av_bsf_send_packet(), this function needs to be called 5889 * repeatedly until it stops returning 0. It is also possible for a filter to 5890 * output fewer packets than were sent to it, so this function may return 5891 * AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call. 5892 */ 5893 int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt); 5894 5895 /** 5896 * Free a bitstream filter context and everything associated with it; write NULL 5897 * into the supplied pointer. 5898 */ 5899 void av_bsf_free(AVBSFContext **ctx); 5900 5901 /** 5902 * Get the AVClass for AVBSFContext. It can be used in combination with 5903 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 5904 * 5905 * @see av_opt_find(). 5906 */ 5907 const AVClass *av_bsf_get_class(void); 5908 5909 /** 5910 * Structure for chain/list of bitstream filters. 5911 * Empty list can be allocated by av_bsf_list_alloc(). 5912 */ 5913 typedef struct AVBSFList AVBSFList; 5914 5915 /** 5916 * Allocate empty list of bitstream filters. 5917 * The list must be later freed by av_bsf_list_free() 5918 * or finalized by av_bsf_list_finalize(). 5919 * 5920 * @return Pointer to @ref AVBSFList on success, NULL in case of failure 5921 */ 5922 AVBSFList *av_bsf_list_alloc(void); 5923 5924 /** 5925 * Free list of bitstream filters. 5926 * 5927 * @param lst Pointer to pointer returned by av_bsf_list_alloc() 5928 */ 5929 void av_bsf_list_free(AVBSFList **lst); 5930 5931 /** 5932 * Append bitstream filter to the list of bitstream filters. 5933 * 5934 * @param lst List to append to 5935 * @param bsf Filter context to be appended 5936 * 5937 * @return >=0 on success, negative AVERROR in case of failure 5938 */ 5939 int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf); 5940 5941 /** 5942 * Construct new bitstream filter context given it's name and options 5943 * and append it to the list of bitstream filters. 5944 * 5945 * @param lst List to append to 5946 * @param bsf_name Name of the bitstream filter 5947 * @param options Options for the bitstream filter, can be set to NULL 5948 * 5949 * @return >=0 on success, negative AVERROR in case of failure 5950 */ 5951 int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options); 5952 /** 5953 * Finalize list of bitstream filters. 5954 * 5955 * This function will transform @ref AVBSFList to single @ref AVBSFContext, 5956 * so the whole chain of bitstream filters can be treated as single filter 5957 * freshly allocated by av_bsf_alloc(). 5958 * If the call is successful, @ref AVBSFList structure is freed and lst 5959 * will be set to NULL. In case of failure, caller is responsible for 5960 * freeing the structure by av_bsf_list_free() 5961 * 5962 * @param lst Filter list structure to be transformed 5963 * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure 5964 * representing the chain of bitstream filters 5965 * 5966 * @return >=0 on success, negative AVERROR in case of failure 5967 */ 5968 int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf); 5969 5970 /** 5971 * Parse string describing list of bitstream filters and create single 5972 * @ref AVBSFContext describing the whole chain of bitstream filters. 5973 * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly 5974 * allocated by av_bsf_alloc(). 5975 * 5976 * @param str String describing chain of bitstream filters in format 5977 * `bsf1[=opt1=val1:opt2=val2][,bsf2]` 5978 * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure 5979 * representing the chain of bitstream filters 5980 * 5981 * @return >=0 on success, negative AVERROR in case of failure 5982 */ 5983 int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf); 5984 5985 /** 5986 * Get null/pass-through bitstream filter. 5987 * 5988 * @param[out] bsf Pointer to be set to new instance of pass-through bitstream filter 5989 * 5990 * @return 5991 */ 5992 int av_bsf_get_null_filter(AVBSFContext **bsf); 5993 5994 /* memory */ 5995 5996 /** 5997 * Same behaviour av_fast_malloc but the buffer has additional 5998 * AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0. 5999 * 6000 * In addition the whole buffer will initially and after resizes 6001 * be 0-initialized so that no uninitialized data will ever appear. 6002 */ 6003 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size); 6004 6005 /** 6006 * Same behaviour av_fast_padded_malloc except that buffer will always 6007 * be 0-initialized after call. 6008 */ 6009 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size); 6010 6011 /** 6012 * Encode extradata length to a buffer. Used by xiph codecs. 6013 * 6014 * @param s buffer to write to; must be at least (v/255+1) bytes long 6015 * @param v size of extradata in bytes 6016 * @return number of bytes written to the buffer. 6017 */ 6018 unsigned int av_xiphlacing(unsigned char *s, unsigned int v); 6019 6020 #if FF_API_USER_VISIBLE_AVHWACCEL 6021 /** 6022 * Register the hardware accelerator hwaccel. 6023 * 6024 * @deprecated This function doesn't do anything. 6025 */ 6026 attribute_deprecated 6027 void av_register_hwaccel(AVHWAccel *hwaccel); 6028 6029 /** 6030 * If hwaccel is NULL, returns the first registered hardware accelerator, 6031 * if hwaccel is non-NULL, returns the next registered hardware accelerator 6032 * after hwaccel, or NULL if hwaccel is the last one. 6033 * 6034 * @deprecated AVHWaccel structures contain no user-serviceable parts, so 6035 * this function should not be used. 6036 */ 6037 attribute_deprecated 6038 AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel); 6039 #endif 6040 6041 #if FF_API_LOCKMGR 6042 /** 6043 * Lock operation used by lockmgr 6044 * 6045 * @deprecated Deprecated together with av_lockmgr_register(). 6046 */ 6047 enum AVLockOp { 6048 AV_LOCK_CREATE, ///< Create a mutex 6049 AV_LOCK_OBTAIN, ///< Lock the mutex 6050 AV_LOCK_RELEASE, ///< Unlock the mutex 6051 AV_LOCK_DESTROY, ///< Free mutex resources 6052 }; 6053 6054 /** 6055 * Register a user provided lock manager supporting the operations 6056 * specified by AVLockOp. The "mutex" argument to the function points 6057 * to a (void *) where the lockmgr should store/get a pointer to a user 6058 * allocated mutex. It is NULL upon AV_LOCK_CREATE and equal to the 6059 * value left by the last call for all other ops. If the lock manager is 6060 * unable to perform the op then it should leave the mutex in the same 6061 * state as when it was called and return a non-zero value. However, 6062 * when called with AV_LOCK_DESTROY the mutex will always be assumed to 6063 * have been successfully destroyed. If av_lockmgr_register succeeds 6064 * it will return a non-negative value, if it fails it will return a 6065 * negative value and destroy all mutex and unregister all callbacks. 6066 * av_lockmgr_register is not thread-safe, it must be called from a 6067 * single thread before any calls which make use of locking are used. 6068 * 6069 * @param cb User defined callback. av_lockmgr_register invokes calls 6070 * to this callback and the previously registered callback. 6071 * The callback will be used to create more than one mutex 6072 * each of which must be backed by its own underlying locking 6073 * mechanism (i.e. do not use a single static object to 6074 * implement your lock manager). If cb is set to NULL the 6075 * lockmgr will be unregistered. 6076 * 6077 * @deprecated This function does nothing, and always returns 0. Be sure to 6078 * build with thread support to get basic thread safety. 6079 */ 6080 attribute_deprecated 6081 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op)); 6082 #endif 6083 6084 /** 6085 * Get the type of the given codec. 6086 */ 6087 enum AVMediaType avcodec_get_type(enum AVCodecID codec_id); 6088 6089 /** 6090 * Get the name of a codec. 6091 * @return a static string identifying the codec; never NULL 6092 */ 6093 const char *avcodec_get_name(enum AVCodecID id); 6094 6095 /** 6096 * @return a positive value if s is open (i.e. avcodec_open2() was called on it 6097 * with no corresponding avcodec_close()), 0 otherwise. 6098 */ 6099 int avcodec_is_open(AVCodecContext *s); 6100 6101 /** 6102 * @return a non-zero number if codec is an encoder, zero otherwise 6103 */ 6104 int av_codec_is_encoder(const AVCodec *codec); 6105 6106 /** 6107 * @return a non-zero number if codec is a decoder, zero otherwise 6108 */ 6109 int av_codec_is_decoder(const AVCodec *codec); 6110 6111 /** 6112 * @return descriptor for given codec ID or NULL if no descriptor exists. 6113 */ 6114 const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id); 6115 6116 /** 6117 * Iterate over all codec descriptors known to libavcodec. 6118 * 6119 * @param prev previous descriptor. NULL to get the first descriptor. 6120 * 6121 * @return next descriptor or NULL after the last descriptor 6122 */ 6123 const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev); 6124 6125 /** 6126 * @return codec descriptor with the given name or NULL if no such descriptor 6127 * exists. 6128 */ 6129 const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name); 6130 6131 /** 6132 * Allocate a CPB properties structure and initialize its fields to default 6133 * values. 6134 * 6135 * @param size if non-NULL, the size of the allocated struct will be written 6136 * here. This is useful for embedding it in side data. 6137 * 6138 * @return the newly allocated struct or NULL on failure 6139 */ 6140 AVCPBProperties *av_cpb_properties_alloc(size_t *size); 6141 6142 /** 6143 * @} 6144 */ 6145 6146 #endif /* AVCODEC_AVCODEC_H */ 6147