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