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 "libavutil/samplefmt.h" 31 #include "libavutil/attributes.h" 32 #include "libavutil/avutil.h" 33 #include "libavutil/buffer.h" 34 #include "libavutil/dict.h" 35 #include "libavutil/frame.h" 36 #include "libavutil/log.h" 37 #include "libavutil/pixfmt.h" 38 #include "libavutil/rational.h" 39 40 #include "codec.h" 41 #include "codec_desc.h" 42 #include "codec_par.h" 43 #include "codec_id.h" 44 #include "defs.h" 45 #include "packet.h" 46 #include "version_major.h" 47 #ifndef HAVE_AV_CONFIG_H 48 /* When included as part of the ffmpeg build, only include the major version 49 * to avoid unnecessary rebuilds. When included externally, keep including 50 * the full version information. */ 51 #include "version.h" 52 #endif 53 54 /** 55 * @defgroup libavc libavcodec 56 * Encoding/Decoding Library 57 * 58 * @{ 59 * 60 * @defgroup lavc_decoding Decoding 61 * @{ 62 * @} 63 * 64 * @defgroup lavc_encoding Encoding 65 * @{ 66 * @} 67 * 68 * @defgroup lavc_codec Codecs 69 * @{ 70 * @defgroup lavc_codec_native Native Codecs 71 * @{ 72 * @} 73 * @defgroup lavc_codec_wrappers External library wrappers 74 * @{ 75 * @} 76 * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge 77 * @{ 78 * @} 79 * @} 80 * @defgroup lavc_internal Internal 81 * @{ 82 * @} 83 * @} 84 */ 85 86 /** 87 * @ingroup libavc 88 * @defgroup lavc_encdec send/receive encoding and decoding API overview 89 * @{ 90 * 91 * The avcodec_send_packet()/avcodec_receive_frame()/avcodec_send_frame()/ 92 * avcodec_receive_packet() functions provide an encode/decode API, which 93 * decouples input and output. 94 * 95 * The API is very similar for encoding/decoding and audio/video, and works as 96 * follows: 97 * - Set up and open the AVCodecContext as usual. 98 * - Send valid input: 99 * - For decoding, call avcodec_send_packet() to give the decoder raw 100 * compressed data in an AVPacket. 101 * - For encoding, call avcodec_send_frame() to give the encoder an AVFrame 102 * containing uncompressed audio or video. 103 * 104 * In both cases, it is recommended that AVPackets and AVFrames are 105 * refcounted, or libavcodec might have to copy the input data. (libavformat 106 * always returns refcounted AVPackets, and av_frame_get_buffer() allocates 107 * refcounted AVFrames.) 108 * - Receive output in a loop. Periodically call one of the avcodec_receive_*() 109 * functions and process their output: 110 * - For decoding, call avcodec_receive_frame(). On success, it will return 111 * an AVFrame containing uncompressed audio or video data. 112 * - For encoding, call avcodec_receive_packet(). On success, it will return 113 * an AVPacket with a compressed frame. 114 * 115 * Repeat this call until it returns AVERROR(EAGAIN) or an error. The 116 * AVERROR(EAGAIN) return value means that new input data is required to 117 * return new output. In this case, continue with sending input. For each 118 * input frame/packet, the codec will typically return 1 output frame/packet, 119 * but it can also be 0 or more than 1. 120 * 121 * At the beginning of decoding or encoding, the codec might accept multiple 122 * input frames/packets without returning a frame, until its internal buffers 123 * are filled. This situation is handled transparently if you follow the steps 124 * outlined above. 125 * 126 * In theory, sending input can result in EAGAIN - this should happen only if 127 * not all output was received. You can use this to structure alternative decode 128 * or encode loops other than the one suggested above. For example, you could 129 * try sending new input on each iteration, and try to receive output if that 130 * returns EAGAIN. 131 * 132 * End of stream situations. These require "flushing" (aka draining) the codec, 133 * as the codec might buffer multiple frames or packets internally for 134 * performance or out of necessity (consider B-frames). 135 * This is handled as follows: 136 * - Instead of valid input, send NULL to the avcodec_send_packet() (decoding) 137 * or avcodec_send_frame() (encoding) functions. This will enter draining 138 * mode. 139 * - Call avcodec_receive_frame() (decoding) or avcodec_receive_packet() 140 * (encoding) in a loop until AVERROR_EOF is returned. The functions will 141 * not return AVERROR(EAGAIN), unless you forgot to enter draining mode. 142 * - Before decoding can be resumed again, the codec has to be reset with 143 * avcodec_flush_buffers(). 144 * 145 * Using the API as outlined above is highly recommended. But it is also 146 * possible to call functions outside of this rigid schema. For example, you can 147 * call avcodec_send_packet() repeatedly without calling 148 * avcodec_receive_frame(). In this case, avcodec_send_packet() will succeed 149 * until the codec's internal buffer has been filled up (which is typically of 150 * size 1 per output frame, after initial input), and then reject input with 151 * AVERROR(EAGAIN). Once it starts rejecting input, you have no choice but to 152 * read at least some output. 153 * 154 * Not all codecs will follow a rigid and predictable dataflow; the only 155 * guarantee is that an AVERROR(EAGAIN) return value on a send/receive call on 156 * one end implies that a receive/send call on the other end will succeed, or 157 * at least will not fail with AVERROR(EAGAIN). In general, no codec will 158 * permit unlimited buffering of input or output. 159 * 160 * A codec is not allowed to return AVERROR(EAGAIN) for both sending and receiving. This 161 * would be an invalid state, which could put the codec user into an endless 162 * loop. The API has no concept of time either: it cannot happen that trying to 163 * do avcodec_send_packet() results in AVERROR(EAGAIN), but a repeated call 1 second 164 * later accepts the packet (with no other receive/flush API calls involved). 165 * The API is a strict state machine, and the passage of time is not supposed 166 * to influence it. Some timing-dependent behavior might still be deemed 167 * acceptable in certain cases. But it must never result in both send/receive 168 * returning EAGAIN at the same time at any point. It must also absolutely be 169 * avoided that the current state is "unstable" and can "flip-flop" between 170 * the send/receive APIs allowing progress. For example, it's not allowed that 171 * the codec randomly decides that it actually wants to consume a packet now 172 * instead of returning a frame, after it just returned AVERROR(EAGAIN) on an 173 * avcodec_send_packet() call. 174 * @} 175 */ 176 177 /** 178 * @defgroup lavc_core Core functions/structures. 179 * @ingroup libavc 180 * 181 * Basic definitions, functions for querying libavcodec capabilities, 182 * allocating core structures, etc. 183 * @{ 184 */ 185 186 /** 187 * @ingroup lavc_encoding 188 * minimum encoding buffer size 189 * Used to avoid some checks during header writing. 190 */ 191 #define AV_INPUT_BUFFER_MIN_SIZE 16384 192 193 /** 194 * @ingroup lavc_encoding 195 */ 196 typedef struct RcOverride{ 197 int start_frame; 198 int end_frame; 199 int qscale; // If this is 0 then quality_factor will be used instead. 200 float quality_factor; 201 } RcOverride; 202 203 /* encoding support 204 These flags can be passed in AVCodecContext.flags before initialization. 205 Note: Not everything is supported yet. 206 */ 207 208 /** 209 * Allow decoders to produce frames with data planes that are not aligned 210 * to CPU requirements (e.g. due to cropping). 211 */ 212 #define AV_CODEC_FLAG_UNALIGNED (1 << 0) 213 /** 214 * Use fixed qscale. 215 */ 216 #define AV_CODEC_FLAG_QSCALE (1 << 1) 217 /** 218 * 4 MV per MB allowed / advanced prediction for H.263. 219 */ 220 #define AV_CODEC_FLAG_4MV (1 << 2) 221 /** 222 * Output even those frames that might be corrupted. 223 */ 224 #define AV_CODEC_FLAG_OUTPUT_CORRUPT (1 << 3) 225 /** 226 * Use qpel MC. 227 */ 228 #define AV_CODEC_FLAG_QPEL (1 << 4) 229 /** 230 * Don't output frames whose parameters differ from first 231 * decoded frame in stream. 232 */ 233 #define AV_CODEC_FLAG_DROPCHANGED (1 << 5) 234 /** 235 * Use internal 2pass ratecontrol in first pass mode. 236 */ 237 #define AV_CODEC_FLAG_PASS1 (1 << 9) 238 /** 239 * Use internal 2pass ratecontrol in second pass mode. 240 */ 241 #define AV_CODEC_FLAG_PASS2 (1 << 10) 242 /** 243 * loop filter. 244 */ 245 #define AV_CODEC_FLAG_LOOP_FILTER (1 << 11) 246 /** 247 * Only decode/encode grayscale. 248 */ 249 #define AV_CODEC_FLAG_GRAY (1 << 13) 250 /** 251 * error[?] variables will be set during encoding. 252 */ 253 #define AV_CODEC_FLAG_PSNR (1 << 15) 254 #if FF_API_FLAG_TRUNCATED 255 /** 256 * Input bitstream might be truncated at a random location 257 * instead of only at frame boundaries. 258 * 259 * @deprecated use codec parsers for packetizing input 260 */ 261 #define AV_CODEC_FLAG_TRUNCATED (1 << 16) 262 #endif 263 /** 264 * Use interlaced DCT. 265 */ 266 #define AV_CODEC_FLAG_INTERLACED_DCT (1 << 18) 267 /** 268 * Force low delay. 269 */ 270 #define AV_CODEC_FLAG_LOW_DELAY (1 << 19) 271 /** 272 * Place global headers in extradata instead of every keyframe. 273 */ 274 #define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22) 275 /** 276 * Use only bitexact stuff (except (I)DCT). 277 */ 278 #define AV_CODEC_FLAG_BITEXACT (1 << 23) 279 /* Fx : Flag for H.263+ extra options */ 280 /** 281 * H.263 advanced intra coding / MPEG-4 AC prediction 282 */ 283 #define AV_CODEC_FLAG_AC_PRED (1 << 24) 284 /** 285 * interlaced motion estimation 286 */ 287 #define AV_CODEC_FLAG_INTERLACED_ME (1 << 29) 288 #define AV_CODEC_FLAG_CLOSED_GOP (1U << 31) 289 290 /** 291 * Allow non spec compliant speedup tricks. 292 */ 293 #define AV_CODEC_FLAG2_FAST (1 << 0) 294 /** 295 * Skip bitstream encoding. 296 */ 297 #define AV_CODEC_FLAG2_NO_OUTPUT (1 << 2) 298 /** 299 * Place global headers at every keyframe instead of in extradata. 300 */ 301 #define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3) 302 303 /** 304 * timecode is in drop frame format. DEPRECATED!!!! 305 */ 306 #define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13) 307 308 /** 309 * Input bitstream might be truncated at a packet boundaries 310 * instead of only at frame boundaries. 311 */ 312 #define AV_CODEC_FLAG2_CHUNKS (1 << 15) 313 /** 314 * Discard cropping information from SPS. 315 */ 316 #define AV_CODEC_FLAG2_IGNORE_CROP (1 << 16) 317 318 /** 319 * Show all frames before the first keyframe 320 */ 321 #define AV_CODEC_FLAG2_SHOW_ALL (1 << 22) 322 /** 323 * Export motion vectors through frame side data 324 */ 325 #define AV_CODEC_FLAG2_EXPORT_MVS (1 << 28) 326 /** 327 * Do not skip samples and export skip information as frame side data 328 */ 329 #define AV_CODEC_FLAG2_SKIP_MANUAL (1 << 29) 330 /** 331 * Do not reset ASS ReadOrder field on flush (subtitles decoding) 332 */ 333 #define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30) 334 335 /* Unsupported options : 336 * Syntax Arithmetic coding (SAC) 337 * Reference Picture Selection 338 * Independent Segment Decoding */ 339 /* /Fx */ 340 /* codec capabilities */ 341 342 /* Exported side data. 343 These flags can be passed in AVCodecContext.export_side_data before initialization. 344 */ 345 /** 346 * Export motion vectors through frame side data 347 */ 348 #define AV_CODEC_EXPORT_DATA_MVS (1 << 0) 349 /** 350 * Export encoder Producer Reference Time through packet side data 351 */ 352 #define AV_CODEC_EXPORT_DATA_PRFT (1 << 1) 353 /** 354 * Decoding only. 355 * Export the AVVideoEncParams structure through frame side data. 356 */ 357 #define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS (1 << 2) 358 /** 359 * Decoding only. 360 * Do not apply film grain, export it instead. 361 */ 362 #define AV_CODEC_EXPORT_DATA_FILM_GRAIN (1 << 3) 363 364 /** 365 * The decoder will keep a reference to the frame and may reuse it later. 366 */ 367 #define AV_GET_BUFFER_FLAG_REF (1 << 0) 368 369 /** 370 * The encoder will keep a reference to the packet and may reuse it later. 371 */ 372 #define AV_GET_ENCODE_BUFFER_FLAG_REF (1 << 0) 373 374 struct AVCodecInternal; 375 376 /** 377 * main external API structure. 378 * New fields can be added to the end with minor version bumps. 379 * Removal, reordering and changes to existing fields require a major 380 * version bump. 381 * You can use AVOptions (av_opt* / av_set/get*()) to access these fields from user 382 * applications. 383 * The name string for AVOptions options matches the associated command line 384 * parameter name and can be found in libavcodec/options_table.h 385 * The AVOption/command line parameter names differ in some cases from the C 386 * structure field names for historic reasons or brevity. 387 * sizeof(AVCodecContext) must not be used outside libav*. 388 */ 389 typedef struct AVCodecContext { 390 /** 391 * information on struct for av_log 392 * - set by avcodec_alloc_context3 393 */ 394 const AVClass *av_class; 395 int log_level_offset; 396 397 enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */ 398 const struct AVCodec *codec; 399 enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */ 400 401 /** 402 * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). 403 * This is used to work around some encoder bugs. 404 * A demuxer should set this to what is stored in the field used to identify the codec. 405 * If there are multiple such fields in a container then the demuxer should choose the one 406 * which maximizes the information about the used codec. 407 * If the codec tag field in a container is larger than 32 bits then the demuxer should 408 * remap the longer ID to 32 bits with a table or other structure. Alternatively a new 409 * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated 410 * first. 411 * - encoding: Set by user, if not then the default based on codec_id will be used. 412 * - decoding: Set by user, will be converted to uppercase by libavcodec during init. 413 */ 414 unsigned int codec_tag; 415 416 void *priv_data; 417 418 /** 419 * Private context used for internal data. 420 * 421 * Unlike priv_data, this is not codec-specific. It is used in general 422 * libavcodec functions. 423 */ 424 struct AVCodecInternal *internal; 425 426 /** 427 * Private data of the user, can be used to carry app specific stuff. 428 * - encoding: Set by user. 429 * - decoding: Set by user. 430 */ 431 void *opaque; 432 433 /** 434 * the average bitrate 435 * - encoding: Set by user; unused for constant quantizer encoding. 436 * - decoding: Set by user, may be overwritten by libavcodec 437 * if this info is available in the stream 438 */ 439 int64_t bit_rate; 440 441 /** 442 * number of bits the bitstream is allowed to diverge from the reference. 443 * the reference can be CBR (for CBR pass1) or VBR (for pass2) 444 * - encoding: Set by user; unused for constant quantizer encoding. 445 * - decoding: unused 446 */ 447 int bit_rate_tolerance; 448 449 /** 450 * Global quality for codecs which cannot change it per frame. 451 * This should be proportional to MPEG-1/2/4 qscale. 452 * - encoding: Set by user. 453 * - decoding: unused 454 */ 455 int global_quality; 456 457 /** 458 * - encoding: Set by user. 459 * - decoding: unused 460 */ 461 int compression_level; 462 #define FF_COMPRESSION_DEFAULT -1 463 464 /** 465 * AV_CODEC_FLAG_*. 466 * - encoding: Set by user. 467 * - decoding: Set by user. 468 */ 469 int flags; 470 471 /** 472 * AV_CODEC_FLAG2_* 473 * - encoding: Set by user. 474 * - decoding: Set by user. 475 */ 476 int flags2; 477 478 /** 479 * some codecs need / can use extradata like Huffman tables. 480 * MJPEG: Huffman tables 481 * rv10: additional flags 482 * MPEG-4: global headers (they can be in the bitstream or here) 483 * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger 484 * than extradata_size to avoid problems if it is read with the bitstream reader. 485 * The bytewise contents of extradata must not depend on the architecture or CPU endianness. 486 * Must be allocated with the av_malloc() family of functions. 487 * - encoding: Set/allocated/freed by libavcodec. 488 * - decoding: Set/allocated/freed by user. 489 */ 490 uint8_t *extradata; 491 int extradata_size; 492 493 /** 494 * This is the fundamental unit of time (in seconds) in terms 495 * of which frame timestamps are represented. For fixed-fps content, 496 * timebase should be 1/framerate and timestamp increments should be 497 * identically 1. 498 * This often, but not always is the inverse of the frame rate or field rate 499 * for video. 1/time_base is not the average frame rate if the frame rate is not 500 * constant. 501 * 502 * Like containers, elementary streams also can store timestamps, 1/time_base 503 * is the unit in which these timestamps are specified. 504 * As example of such codec time base see ISO/IEC 14496-2:2001(E) 505 * vop_time_increment_resolution and fixed_vop_rate 506 * (fixed_vop_rate == 0 implies that it is different from the framerate) 507 * 508 * - encoding: MUST be set by user. 509 * - decoding: the use of this field for decoding is deprecated. 510 * Use framerate instead. 511 */ 512 AVRational time_base; 513 514 /** 515 * For some codecs, the time base is closer to the field rate than the frame rate. 516 * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration 517 * if no telecine is used ... 518 * 519 * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2. 520 */ 521 int ticks_per_frame; 522 523 /** 524 * Codec delay. 525 * 526 * Encoding: Number of frames delay there will be from the encoder input to 527 * the decoder output. (we assume the decoder matches the spec) 528 * Decoding: Number of frames delay in addition to what a standard decoder 529 * as specified in the spec would produce. 530 * 531 * Video: 532 * Number of frames the decoded output will be delayed relative to the 533 * encoded input. 534 * 535 * Audio: 536 * For encoding, this field is unused (see initial_padding). 537 * 538 * For decoding, this is the number of samples the decoder needs to 539 * output before the decoder's output is valid. When seeking, you should 540 * start decoding this many samples prior to your desired seek point. 541 * 542 * - encoding: Set by libavcodec. 543 * - decoding: Set by libavcodec. 544 */ 545 int delay; 546 547 548 /* video only */ 549 /** 550 * picture width / height. 551 * 552 * @note Those fields may not match the values of the last 553 * AVFrame output by avcodec_receive_frame() due frame 554 * reordering. 555 * 556 * - encoding: MUST be set by user. 557 * - decoding: May be set by the user before opening the decoder if known e.g. 558 * from the container. Some decoders will require the dimensions 559 * to be set by the caller. During decoding, the decoder may 560 * overwrite those values as required while parsing the data. 561 */ 562 int width, height; 563 564 /** 565 * Bitstream width / height, may be different from width/height e.g. when 566 * the decoded frame is cropped before being output or lowres is enabled. 567 * 568 * @note Those field may not match the value of the last 569 * AVFrame output by avcodec_receive_frame() due frame 570 * reordering. 571 * 572 * - encoding: unused 573 * - decoding: May be set by the user before opening the decoder if known 574 * e.g. from the container. During decoding, the decoder may 575 * overwrite those values as required while parsing the data. 576 */ 577 int coded_width, coded_height; 578 579 /** 580 * the number of pictures in a group of pictures, or 0 for intra_only 581 * - encoding: Set by user. 582 * - decoding: unused 583 */ 584 int gop_size; 585 586 /** 587 * Pixel format, see AV_PIX_FMT_xxx. 588 * May be set by the demuxer if known from headers. 589 * May be overridden by the decoder if it knows better. 590 * 591 * @note This field may not match the value of the last 592 * AVFrame output by avcodec_receive_frame() due frame 593 * reordering. 594 * 595 * - encoding: Set by user. 596 * - decoding: Set by user if known, overridden by libavcodec while 597 * parsing the data. 598 */ 599 enum AVPixelFormat pix_fmt; 600 601 /** 602 * If non NULL, 'draw_horiz_band' is called by the libavcodec 603 * decoder to draw a horizontal band. It improves cache usage. Not 604 * all codecs can do that. You must check the codec capabilities 605 * beforehand. 606 * When multithreading is used, it may be called from multiple threads 607 * at the same time; threads might draw different parts of the same AVFrame, 608 * or multiple AVFrames, and there is no guarantee that slices will be drawn 609 * in order. 610 * The function is also used by hardware acceleration APIs. 611 * It is called at least once during frame decoding to pass 612 * the data needed for hardware render. 613 * In that mode instead of pixel data, AVFrame points to 614 * a structure specific to the acceleration API. The application 615 * reads the structure and can change some fields to indicate progress 616 * or mark state. 617 * - encoding: unused 618 * - decoding: Set by user. 619 * @param height the height of the slice 620 * @param y the y position of the slice 621 * @param type 1->top field, 2->bottom field, 3->frame 622 * @param offset offset into the AVFrame.data from which the slice should be read 623 */ 624 void (*draw_horiz_band)(struct AVCodecContext *s, 625 const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], 626 int y, int type, int height); 627 628 /** 629 * Callback to negotiate the pixel format. Decoding only, may be set by the 630 * caller before avcodec_open2(). 631 * 632 * Called by some decoders to select the pixel format that will be used for 633 * the output frames. This is mainly used to set up hardware acceleration, 634 * then the provided format list contains the corresponding hwaccel pixel 635 * formats alongside the "software" one. The software pixel format may also 636 * be retrieved from \ref sw_pix_fmt. 637 * 638 * This callback will be called when the coded frame properties (such as 639 * resolution, pixel format, etc.) change and more than one output format is 640 * supported for those new properties. If a hardware pixel format is chosen 641 * and initialization for it fails, the callback may be called again 642 * immediately. 643 * 644 * This callback may be called from different threads if the decoder is 645 * multi-threaded, but not from more than one thread simultaneously. 646 * 647 * @param fmt list of formats which may be used in the current 648 * configuration, terminated by AV_PIX_FMT_NONE. 649 * @warning Behavior is undefined if the callback returns a value other 650 * than one of the formats in fmt or AV_PIX_FMT_NONE. 651 * @return the chosen format or AV_PIX_FMT_NONE 652 */ 653 enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt); 654 655 /** 656 * maximum number of B-frames between non-B-frames 657 * Note: The output will be delayed by max_b_frames+1 relative to the input. 658 * - encoding: Set by user. 659 * - decoding: unused 660 */ 661 int max_b_frames; 662 663 /** 664 * qscale factor between IP and B-frames 665 * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset). 666 * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). 667 * - encoding: Set by user. 668 * - decoding: unused 669 */ 670 float b_quant_factor; 671 672 /** 673 * qscale offset between IP and B-frames 674 * - encoding: Set by user. 675 * - decoding: unused 676 */ 677 float b_quant_offset; 678 679 /** 680 * Size of the frame reordering buffer in the decoder. 681 * For MPEG-2 it is 1 IPB or 0 low delay IP. 682 * - encoding: Set by libavcodec. 683 * - decoding: Set by libavcodec. 684 */ 685 int has_b_frames; 686 687 /** 688 * qscale factor between P- and I-frames 689 * If > 0 then the last P-frame quantizer will be used (q = lastp_q * factor + offset). 690 * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). 691 * - encoding: Set by user. 692 * - decoding: unused 693 */ 694 float i_quant_factor; 695 696 /** 697 * qscale offset between P and I-frames 698 * - encoding: Set by user. 699 * - decoding: unused 700 */ 701 float i_quant_offset; 702 703 /** 704 * luminance masking (0-> disabled) 705 * - encoding: Set by user. 706 * - decoding: unused 707 */ 708 float lumi_masking; 709 710 /** 711 * temporary complexity masking (0-> disabled) 712 * - encoding: Set by user. 713 * - decoding: unused 714 */ 715 float temporal_cplx_masking; 716 717 /** 718 * spatial complexity masking (0-> disabled) 719 * - encoding: Set by user. 720 * - decoding: unused 721 */ 722 float spatial_cplx_masking; 723 724 /** 725 * p block masking (0-> disabled) 726 * - encoding: Set by user. 727 * - decoding: unused 728 */ 729 float p_masking; 730 731 /** 732 * darkness masking (0-> disabled) 733 * - encoding: Set by user. 734 * - decoding: unused 735 */ 736 float dark_masking; 737 738 /** 739 * slice count 740 * - encoding: Set by libavcodec. 741 * - decoding: Set by user (or 0). 742 */ 743 int slice_count; 744 745 /** 746 * slice offsets in the frame in bytes 747 * - encoding: Set/allocated by libavcodec. 748 * - decoding: Set/allocated by user (or NULL). 749 */ 750 int *slice_offset; 751 752 /** 753 * sample aspect ratio (0 if unknown) 754 * That is the width of a pixel divided by the height of the pixel. 755 * Numerator and denominator must be relatively prime and smaller than 256 for some video standards. 756 * - encoding: Set by user. 757 * - decoding: Set by libavcodec. 758 */ 759 AVRational sample_aspect_ratio; 760 761 /** 762 * motion estimation comparison function 763 * - encoding: Set by user. 764 * - decoding: unused 765 */ 766 int me_cmp; 767 /** 768 * subpixel motion estimation comparison function 769 * - encoding: Set by user. 770 * - decoding: unused 771 */ 772 int me_sub_cmp; 773 /** 774 * macroblock comparison function (not supported yet) 775 * - encoding: Set by user. 776 * - decoding: unused 777 */ 778 int mb_cmp; 779 /** 780 * interlaced DCT comparison function 781 * - encoding: Set by user. 782 * - decoding: unused 783 */ 784 int ildct_cmp; 785 #define FF_CMP_SAD 0 786 #define FF_CMP_SSE 1 787 #define FF_CMP_SATD 2 788 #define FF_CMP_DCT 3 789 #define FF_CMP_PSNR 4 790 #define FF_CMP_BIT 5 791 #define FF_CMP_RD 6 792 #define FF_CMP_ZERO 7 793 #define FF_CMP_VSAD 8 794 #define FF_CMP_VSSE 9 795 #define FF_CMP_NSSE 10 796 #define FF_CMP_W53 11 797 #define FF_CMP_W97 12 798 #define FF_CMP_DCTMAX 13 799 #define FF_CMP_DCT264 14 800 #define FF_CMP_MEDIAN_SAD 15 801 #define FF_CMP_CHROMA 256 802 803 /** 804 * ME diamond size & shape 805 * - encoding: Set by user. 806 * - decoding: unused 807 */ 808 int dia_size; 809 810 /** 811 * amount of previous MV predictors (2a+1 x 2a+1 square) 812 * - encoding: Set by user. 813 * - decoding: unused 814 */ 815 int last_predictor_count; 816 817 /** 818 * motion estimation prepass comparison function 819 * - encoding: Set by user. 820 * - decoding: unused 821 */ 822 int me_pre_cmp; 823 824 /** 825 * ME prepass diamond size & shape 826 * - encoding: Set by user. 827 * - decoding: unused 828 */ 829 int pre_dia_size; 830 831 /** 832 * subpel ME quality 833 * - encoding: Set by user. 834 * - decoding: unused 835 */ 836 int me_subpel_quality; 837 838 /** 839 * maximum motion estimation search range in subpel units 840 * If 0 then no limit. 841 * 842 * - encoding: Set by user. 843 * - decoding: unused 844 */ 845 int me_range; 846 847 /** 848 * slice flags 849 * - encoding: unused 850 * - decoding: Set by user. 851 */ 852 int slice_flags; 853 #define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display 854 #define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG-2 field pics) 855 #define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1) 856 857 /** 858 * macroblock decision mode 859 * - encoding: Set by user. 860 * - decoding: unused 861 */ 862 int mb_decision; 863 #define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp 864 #define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits 865 #define FF_MB_DECISION_RD 2 ///< rate distortion 866 867 /** 868 * custom intra quantization matrix 869 * Must be allocated with the av_malloc() family of functions, and will be freed in 870 * avcodec_free_context(). 871 * - encoding: Set/allocated by user, freed by libavcodec. Can be NULL. 872 * - decoding: Set/allocated/freed by libavcodec. 873 */ 874 uint16_t *intra_matrix; 875 876 /** 877 * custom inter quantization matrix 878 * Must be allocated with the av_malloc() family of functions, and will be freed in 879 * avcodec_free_context(). 880 * - encoding: Set/allocated by user, freed by libavcodec. Can be NULL. 881 * - decoding: Set/allocated/freed by libavcodec. 882 */ 883 uint16_t *inter_matrix; 884 885 /** 886 * precision of the intra DC coefficient - 8 887 * - encoding: Set by user. 888 * - decoding: Set by libavcodec 889 */ 890 int intra_dc_precision; 891 892 /** 893 * Number of macroblock rows at the top which are skipped. 894 * - encoding: unused 895 * - decoding: Set by user. 896 */ 897 int skip_top; 898 899 /** 900 * Number of macroblock rows at the bottom which are skipped. 901 * - encoding: unused 902 * - decoding: Set by user. 903 */ 904 int skip_bottom; 905 906 /** 907 * minimum MB Lagrange multiplier 908 * - encoding: Set by user. 909 * - decoding: unused 910 */ 911 int mb_lmin; 912 913 /** 914 * maximum MB Lagrange multiplier 915 * - encoding: Set by user. 916 * - decoding: unused 917 */ 918 int mb_lmax; 919 920 /** 921 * - encoding: Set by user. 922 * - decoding: unused 923 */ 924 int bidir_refine; 925 926 /** 927 * minimum GOP size 928 * - encoding: Set by user. 929 * - decoding: unused 930 */ 931 int keyint_min; 932 933 /** 934 * number of reference frames 935 * - encoding: Set by user. 936 * - decoding: Set by lavc. 937 */ 938 int refs; 939 940 /** 941 * Note: Value depends upon the compare function used for fullpel ME. 942 * - encoding: Set by user. 943 * - decoding: unused 944 */ 945 int mv0_threshold; 946 947 /** 948 * Chromaticity coordinates of the source primaries. 949 * - encoding: Set by user 950 * - decoding: Set by libavcodec 951 */ 952 enum AVColorPrimaries color_primaries; 953 954 /** 955 * Color Transfer Characteristic. 956 * - encoding: Set by user 957 * - decoding: Set by libavcodec 958 */ 959 enum AVColorTransferCharacteristic color_trc; 960 961 /** 962 * YUV colorspace type. 963 * - encoding: Set by user 964 * - decoding: Set by libavcodec 965 */ 966 enum AVColorSpace colorspace; 967 968 /** 969 * MPEG vs JPEG YUV range. 970 * - encoding: Set by user 971 * - decoding: Set by libavcodec 972 */ 973 enum AVColorRange color_range; 974 975 /** 976 * This defines the location of chroma samples. 977 * - encoding: Set by user 978 * - decoding: Set by libavcodec 979 */ 980 enum AVChromaLocation chroma_sample_location; 981 982 /** 983 * Number of slices. 984 * Indicates number of picture subdivisions. Used for parallelized 985 * decoding. 986 * - encoding: Set by user 987 * - decoding: unused 988 */ 989 int slices; 990 991 /** Field order 992 * - encoding: set by libavcodec 993 * - decoding: Set by user. 994 */ 995 enum AVFieldOrder field_order; 996 997 /* audio only */ 998 int sample_rate; ///< samples per second 999 1000 #if FF_API_OLD_CHANNEL_LAYOUT 1001 /** 1002 * number of audio channels 1003 * @deprecated use ch_layout.nb_channels 1004 */ 1005 attribute_deprecated 1006 int channels; 1007 #endif 1008 1009 /** 1010 * audio sample format 1011 * - encoding: Set by user. 1012 * - decoding: Set by libavcodec. 1013 */ 1014 enum AVSampleFormat sample_fmt; ///< sample format 1015 1016 /* The following data should not be initialized. */ 1017 /** 1018 * Number of samples per channel in an audio frame. 1019 * 1020 * - encoding: set by libavcodec in avcodec_open2(). Each submitted frame 1021 * except the last must contain exactly frame_size samples per channel. 1022 * May be 0 when the codec has AV_CODEC_CAP_VARIABLE_FRAME_SIZE set, then the 1023 * frame size is not restricted. 1024 * - decoding: may be set by some decoders to indicate constant frame size 1025 */ 1026 int frame_size; 1027 1028 /** 1029 * Frame counter, set by libavcodec. 1030 * 1031 * - decoding: total number of frames returned from the decoder so far. 1032 * - encoding: total number of frames passed to the encoder so far. 1033 * 1034 * @note the counter is not incremented if encoding/decoding resulted in 1035 * an error. 1036 */ 1037 int frame_number; 1038 1039 /** 1040 * number of bytes per packet if constant and known or 0 1041 * Used by some WAV based audio codecs. 1042 */ 1043 int block_align; 1044 1045 /** 1046 * Audio cutoff bandwidth (0 means "automatic") 1047 * - encoding: Set by user. 1048 * - decoding: unused 1049 */ 1050 int cutoff; 1051 1052 #if FF_API_OLD_CHANNEL_LAYOUT 1053 /** 1054 * Audio channel layout. 1055 * - encoding: set by user. 1056 * - decoding: set by user, may be overwritten by libavcodec. 1057 * @deprecated use ch_layout 1058 */ 1059 attribute_deprecated 1060 uint64_t channel_layout; 1061 1062 /** 1063 * Request decoder to use this channel layout if it can (0 for default) 1064 * - encoding: unused 1065 * - decoding: Set by user. 1066 * @deprecated use "downmix" codec private option 1067 */ 1068 attribute_deprecated 1069 uint64_t request_channel_layout; 1070 #endif 1071 1072 /** 1073 * Type of service that the audio stream conveys. 1074 * - encoding: Set by user. 1075 * - decoding: Set by libavcodec. 1076 */ 1077 enum AVAudioServiceType audio_service_type; 1078 1079 /** 1080 * desired sample format 1081 * - encoding: Not used. 1082 * - decoding: Set by user. 1083 * Decoder will decode to this format if it can. 1084 */ 1085 enum AVSampleFormat request_sample_fmt; 1086 1087 /** 1088 * This callback is called at the beginning of each frame to get data 1089 * buffer(s) for it. There may be one contiguous buffer for all the data or 1090 * there may be a buffer per each data plane or anything in between. What 1091 * this means is, you may set however many entries in buf[] you feel necessary. 1092 * Each buffer must be reference-counted using the AVBuffer API (see description 1093 * of buf[] below). 1094 * 1095 * The following fields will be set in the frame before this callback is 1096 * called: 1097 * - format 1098 * - width, height (video only) 1099 * - sample_rate, channel_layout, nb_samples (audio only) 1100 * Their values may differ from the corresponding values in 1101 * AVCodecContext. This callback must use the frame values, not the codec 1102 * context values, to calculate the required buffer size. 1103 * 1104 * This callback must fill the following fields in the frame: 1105 * - data[] 1106 * - linesize[] 1107 * - extended_data: 1108 * * if the data is planar audio with more than 8 channels, then this 1109 * callback must allocate and fill extended_data to contain all pointers 1110 * to all data planes. data[] must hold as many pointers as it can. 1111 * extended_data must be allocated with av_malloc() and will be freed in 1112 * av_frame_unref(). 1113 * * otherwise extended_data must point to data 1114 * - buf[] must contain one or more pointers to AVBufferRef structures. Each of 1115 * the frame's data and extended_data pointers must be contained in these. That 1116 * is, one AVBufferRef for each allocated chunk of memory, not necessarily one 1117 * AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(), 1118 * and av_buffer_ref(). 1119 * - extended_buf and nb_extended_buf must be allocated with av_malloc() by 1120 * this callback and filled with the extra buffers if there are more 1121 * buffers than buf[] can hold. extended_buf will be freed in 1122 * av_frame_unref(). 1123 * 1124 * If AV_CODEC_CAP_DR1 is not set then get_buffer2() must call 1125 * avcodec_default_get_buffer2() instead of providing buffers allocated by 1126 * some other means. 1127 * 1128 * Each data plane must be aligned to the maximum required by the target 1129 * CPU. 1130 * 1131 * @see avcodec_default_get_buffer2() 1132 * 1133 * Video: 1134 * 1135 * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused 1136 * (read and/or written to if it is writable) later by libavcodec. 1137 * 1138 * avcodec_align_dimensions2() should be used to find the required width and 1139 * height, as they normally need to be rounded up to the next multiple of 16. 1140 * 1141 * Some decoders do not support linesizes changing between frames. 1142 * 1143 * If frame multithreading is used, this callback may be called from a 1144 * different thread, but not from more than one at once. Does not need to be 1145 * reentrant. 1146 * 1147 * @see avcodec_align_dimensions2() 1148 * 1149 * Audio: 1150 * 1151 * Decoders request a buffer of a particular size by setting 1152 * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may, 1153 * however, utilize only part of the buffer by setting AVFrame.nb_samples 1154 * to a smaller value in the output frame. 1155 * 1156 * As a convenience, av_samples_get_buffer_size() and 1157 * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2() 1158 * functions to find the required data size and to fill data pointers and 1159 * linesize. In AVFrame.linesize, only linesize[0] may be set for audio 1160 * since all planes must be the same size. 1161 * 1162 * @see av_samples_get_buffer_size(), av_samples_fill_arrays() 1163 * 1164 * - encoding: unused 1165 * - decoding: Set by libavcodec, user can override. 1166 */ 1167 int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags); 1168 1169 /* - encoding parameters */ 1170 float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0) 1171 float qblur; ///< amount of qscale smoothing over time (0.0-1.0) 1172 1173 /** 1174 * minimum quantizer 1175 * - encoding: Set by user. 1176 * - decoding: unused 1177 */ 1178 int qmin; 1179 1180 /** 1181 * maximum quantizer 1182 * - encoding: Set by user. 1183 * - decoding: unused 1184 */ 1185 int qmax; 1186 1187 /** 1188 * maximum quantizer difference between frames 1189 * - encoding: Set by user. 1190 * - decoding: unused 1191 */ 1192 int max_qdiff; 1193 1194 /** 1195 * decoder bitstream buffer size 1196 * - encoding: Set by user. 1197 * - decoding: unused 1198 */ 1199 int rc_buffer_size; 1200 1201 /** 1202 * ratecontrol override, see RcOverride 1203 * - encoding: Allocated/set/freed by user. 1204 * - decoding: unused 1205 */ 1206 int rc_override_count; 1207 RcOverride *rc_override; 1208 1209 /** 1210 * maximum bitrate 1211 * - encoding: Set by user. 1212 * - decoding: Set by user, may be overwritten by libavcodec. 1213 */ 1214 int64_t rc_max_rate; 1215 1216 /** 1217 * minimum bitrate 1218 * - encoding: Set by user. 1219 * - decoding: unused 1220 */ 1221 int64_t rc_min_rate; 1222 1223 /** 1224 * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow. 1225 * - encoding: Set by user. 1226 * - decoding: unused. 1227 */ 1228 float rc_max_available_vbv_use; 1229 1230 /** 1231 * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow. 1232 * - encoding: Set by user. 1233 * - decoding: unused. 1234 */ 1235 float rc_min_vbv_overflow_use; 1236 1237 /** 1238 * Number of bits which should be loaded into the rc buffer before decoding starts. 1239 * - encoding: Set by user. 1240 * - decoding: unused 1241 */ 1242 int rc_initial_buffer_occupancy; 1243 1244 /** 1245 * trellis RD quantization 1246 * - encoding: Set by user. 1247 * - decoding: unused 1248 */ 1249 int trellis; 1250 1251 /** 1252 * pass1 encoding statistics output buffer 1253 * - encoding: Set by libavcodec. 1254 * - decoding: unused 1255 */ 1256 char *stats_out; 1257 1258 /** 1259 * pass2 encoding statistics input buffer 1260 * Concatenated stuff from stats_out of pass1 should be placed here. 1261 * - encoding: Allocated/set/freed by user. 1262 * - decoding: unused 1263 */ 1264 char *stats_in; 1265 1266 /** 1267 * Work around bugs in encoders which sometimes cannot be detected automatically. 1268 * - encoding: Set by user 1269 * - decoding: Set by user 1270 */ 1271 int workaround_bugs; 1272 #define FF_BUG_AUTODETECT 1 ///< autodetection 1273 #define FF_BUG_XVID_ILACE 4 1274 #define FF_BUG_UMP4 8 1275 #define FF_BUG_NO_PADDING 16 1276 #define FF_BUG_AMV 32 1277 #define FF_BUG_QPEL_CHROMA 64 1278 #define FF_BUG_STD_QPEL 128 1279 #define FF_BUG_QPEL_CHROMA2 256 1280 #define FF_BUG_DIRECT_BLOCKSIZE 512 1281 #define FF_BUG_EDGE 1024 1282 #define FF_BUG_HPEL_CHROMA 2048 1283 #define FF_BUG_DC_CLIP 4096 1284 #define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders. 1285 #define FF_BUG_TRUNCATED 16384 1286 #define FF_BUG_IEDGE 32768 1287 1288 /** 1289 * strictly follow the standard (MPEG-4, ...). 1290 * - encoding: Set by user. 1291 * - decoding: Set by user. 1292 * Setting this to STRICT or higher means the encoder and decoder will 1293 * generally do stupid things, whereas setting it to unofficial or lower 1294 * will mean the encoder might produce output that is not supported by all 1295 * spec-compliant decoders. Decoders don't differentiate between normal, 1296 * unofficial and experimental (that is, they always try to decode things 1297 * when they can) unless they are explicitly asked to behave stupidly 1298 * (=strictly conform to the specs) 1299 */ 1300 int strict_std_compliance; 1301 #define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software. 1302 #define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences. 1303 #define FF_COMPLIANCE_NORMAL 0 1304 #define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions 1305 #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things. 1306 1307 /** 1308 * error concealment flags 1309 * - encoding: unused 1310 * - decoding: Set by user. 1311 */ 1312 int error_concealment; 1313 #define FF_EC_GUESS_MVS 1 1314 #define FF_EC_DEBLOCK 2 1315 #define FF_EC_FAVOR_INTER 256 1316 1317 /** 1318 * debug 1319 * - encoding: Set by user. 1320 * - decoding: Set by user. 1321 */ 1322 int debug; 1323 #define FF_DEBUG_PICT_INFO 1 1324 #define FF_DEBUG_RC 2 1325 #define FF_DEBUG_BITSTREAM 4 1326 #define FF_DEBUG_MB_TYPE 8 1327 #define FF_DEBUG_QP 16 1328 #define FF_DEBUG_DCT_COEFF 0x00000040 1329 #define FF_DEBUG_SKIP 0x00000080 1330 #define FF_DEBUG_STARTCODE 0x00000100 1331 #define FF_DEBUG_ER 0x00000400 1332 #define FF_DEBUG_MMCO 0x00000800 1333 #define FF_DEBUG_BUGS 0x00001000 1334 #define FF_DEBUG_BUFFERS 0x00008000 1335 #define FF_DEBUG_THREADS 0x00010000 1336 #define FF_DEBUG_GREEN_MD 0x00800000 1337 #define FF_DEBUG_NOMC 0x01000000 1338 1339 /** 1340 * Error recognition; may misdetect some more or less valid parts as errors. 1341 * - encoding: Set by user. 1342 * - decoding: Set by user. 1343 */ 1344 int err_recognition; 1345 1346 /** 1347 * Verify checksums embedded in the bitstream (could be of either encoded or 1348 * decoded data, depending on the codec) and print an error message on mismatch. 1349 * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the 1350 * decoder returning an error. 1351 */ 1352 #define AV_EF_CRCCHECK (1<<0) 1353 #define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations 1354 #define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length 1355 #define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection 1356 1357 #define AV_EF_IGNORE_ERR (1<<15) ///< ignore errors and continue 1358 #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 1359 #define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliances as errors 1360 #define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder should not do as an error 1361 1362 1363 /** 1364 * opaque 64-bit number (generally a PTS) that will be reordered and 1365 * output in AVFrame.reordered_opaque 1366 * - encoding: Set by libavcodec to the reordered_opaque of the input 1367 * frame corresponding to the last returned packet. Only 1368 * supported by encoders with the 1369 * AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE capability. 1370 * - decoding: Set by user. 1371 */ 1372 int64_t reordered_opaque; 1373 1374 /** 1375 * Hardware accelerator in use 1376 * - encoding: unused. 1377 * - decoding: Set by libavcodec 1378 */ 1379 const struct AVHWAccel *hwaccel; 1380 1381 /** 1382 * Hardware accelerator context. 1383 * For some hardware accelerators, a global context needs to be 1384 * provided by the user. In that case, this holds display-dependent 1385 * data FFmpeg cannot instantiate itself. Please refer to the 1386 * FFmpeg HW accelerator documentation to know how to fill this. 1387 * - encoding: unused 1388 * - decoding: Set by user 1389 */ 1390 void *hwaccel_context; 1391 1392 /** 1393 * error 1394 * - encoding: Set by libavcodec if flags & AV_CODEC_FLAG_PSNR. 1395 * - decoding: unused 1396 */ 1397 uint64_t error[AV_NUM_DATA_POINTERS]; 1398 1399 /** 1400 * DCT algorithm, see FF_DCT_* below 1401 * - encoding: Set by user. 1402 * - decoding: unused 1403 */ 1404 int dct_algo; 1405 #define FF_DCT_AUTO 0 1406 #define FF_DCT_FASTINT 1 1407 #define FF_DCT_INT 2 1408 #define FF_DCT_MMX 3 1409 #define FF_DCT_ALTIVEC 5 1410 #define FF_DCT_FAAN 6 1411 1412 /** 1413 * IDCT algorithm, see FF_IDCT_* below. 1414 * - encoding: Set by user. 1415 * - decoding: Set by user. 1416 */ 1417 int idct_algo; 1418 #define FF_IDCT_AUTO 0 1419 #define FF_IDCT_INT 1 1420 #define FF_IDCT_SIMPLE 2 1421 #define FF_IDCT_SIMPLEMMX 3 1422 #define FF_IDCT_ARM 7 1423 #define FF_IDCT_ALTIVEC 8 1424 #define FF_IDCT_SIMPLEARM 10 1425 #define FF_IDCT_XVID 14 1426 #define FF_IDCT_SIMPLEARMV5TE 16 1427 #define FF_IDCT_SIMPLEARMV6 17 1428 #define FF_IDCT_FAAN 20 1429 #define FF_IDCT_SIMPLENEON 22 1430 #if FF_API_IDCT_NONE 1431 // formerly used by xvmc 1432 #define FF_IDCT_NONE 24 1433 #endif 1434 #define FF_IDCT_SIMPLEAUTO 128 1435 1436 /** 1437 * bits per sample/pixel from the demuxer (needed for huffyuv). 1438 * - encoding: Set by libavcodec. 1439 * - decoding: Set by user. 1440 */ 1441 int bits_per_coded_sample; 1442 1443 /** 1444 * Bits per sample/pixel of internal libavcodec pixel/sample format. 1445 * - encoding: set by user. 1446 * - decoding: set by libavcodec. 1447 */ 1448 int bits_per_raw_sample; 1449 1450 /** 1451 * low resolution decoding, 1-> 1/2 size, 2->1/4 size 1452 * - encoding: unused 1453 * - decoding: Set by user. 1454 */ 1455 int lowres; 1456 1457 /** 1458 * thread count 1459 * is used to decide how many independent tasks should be passed to execute() 1460 * - encoding: Set by user. 1461 * - decoding: Set by user. 1462 */ 1463 int thread_count; 1464 1465 /** 1466 * Which multithreading methods to use. 1467 * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread, 1468 * so clients which cannot provide future frames should not use it. 1469 * 1470 * - encoding: Set by user, otherwise the default is used. 1471 * - decoding: Set by user, otherwise the default is used. 1472 */ 1473 int thread_type; 1474 #define FF_THREAD_FRAME 1 ///< Decode more than one frame at once 1475 #define FF_THREAD_SLICE 2 ///< Decode more than one part of a single frame at once 1476 1477 /** 1478 * Which multithreading methods are in use by the codec. 1479 * - encoding: Set by libavcodec. 1480 * - decoding: Set by libavcodec. 1481 */ 1482 int active_thread_type; 1483 1484 #if FF_API_THREAD_SAFE_CALLBACKS 1485 /** 1486 * Set by the client if its custom get_buffer() callback can be called 1487 * synchronously from another thread, which allows faster multithreaded decoding. 1488 * draw_horiz_band() will be called from other threads regardless of this setting. 1489 * Ignored if the default get_buffer() is used. 1490 * - encoding: Set by user. 1491 * - decoding: Set by user. 1492 * 1493 * @deprecated the custom get_buffer2() callback should always be 1494 * thread-safe. Thread-unsafe get_buffer2() implementations will be 1495 * invalid starting with LIBAVCODEC_VERSION_MAJOR=60; in other words, 1496 * libavcodec will behave as if this field was always set to 1. 1497 * Callers that want to be forward compatible with future libavcodec 1498 * versions should wrap access to this field in 1499 * #if LIBAVCODEC_VERSION_MAJOR < 60 1500 */ 1501 attribute_deprecated 1502 int thread_safe_callbacks; 1503 #endif 1504 1505 /** 1506 * The codec may call this to execute several independent things. 1507 * It will return only after finishing all tasks. 1508 * The user may replace this with some multithreaded implementation, 1509 * the default implementation will execute the parts serially. 1510 * @param count the number of things to execute 1511 * - encoding: Set by libavcodec, user can override. 1512 * - decoding: Set by libavcodec, user can override. 1513 */ 1514 int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size); 1515 1516 /** 1517 * The codec may call this to execute several independent things. 1518 * It will return only after finishing all tasks. 1519 * The user may replace this with some multithreaded implementation, 1520 * the default implementation will execute the parts serially. 1521 * @param c context passed also to func 1522 * @param count the number of things to execute 1523 * @param arg2 argument passed unchanged to func 1524 * @param ret return values of executed functions, must have space for "count" values. May be NULL. 1525 * @param func function that will be called count times, with jobnr from 0 to count-1. 1526 * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no 1527 * two instances of func executing at the same time will have the same threadnr. 1528 * @return always 0 currently, but code should handle a future improvement where when any call to func 1529 * returns < 0 no further calls to func may be done and < 0 is returned. 1530 * - encoding: Set by libavcodec, user can override. 1531 * - decoding: Set by libavcodec, user can override. 1532 */ 1533 int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count); 1534 1535 /** 1536 * noise vs. sse weight for the nsse comparison function 1537 * - encoding: Set by user. 1538 * - decoding: unused 1539 */ 1540 int nsse_weight; 1541 1542 /** 1543 * profile 1544 * - encoding: Set by user. 1545 * - decoding: Set by libavcodec. 1546 */ 1547 int profile; 1548 #define FF_PROFILE_UNKNOWN -99 1549 #define FF_PROFILE_RESERVED -100 1550 1551 #define FF_PROFILE_AAC_MAIN 0 1552 #define FF_PROFILE_AAC_LOW 1 1553 #define FF_PROFILE_AAC_SSR 2 1554 #define FF_PROFILE_AAC_LTP 3 1555 #define FF_PROFILE_AAC_HE 4 1556 #define FF_PROFILE_AAC_HE_V2 28 1557 #define FF_PROFILE_AAC_LD 22 1558 #define FF_PROFILE_AAC_ELD 38 1559 #define FF_PROFILE_MPEG2_AAC_LOW 128 1560 #define FF_PROFILE_MPEG2_AAC_HE 131 1561 1562 #define FF_PROFILE_DNXHD 0 1563 #define FF_PROFILE_DNXHR_LB 1 1564 #define FF_PROFILE_DNXHR_SQ 2 1565 #define FF_PROFILE_DNXHR_HQ 3 1566 #define FF_PROFILE_DNXHR_HQX 4 1567 #define FF_PROFILE_DNXHR_444 5 1568 1569 #define FF_PROFILE_DTS 20 1570 #define FF_PROFILE_DTS_ES 30 1571 #define FF_PROFILE_DTS_96_24 40 1572 #define FF_PROFILE_DTS_HD_HRA 50 1573 #define FF_PROFILE_DTS_HD_MA 60 1574 #define FF_PROFILE_DTS_EXPRESS 70 1575 1576 #define FF_PROFILE_MPEG2_422 0 1577 #define FF_PROFILE_MPEG2_HIGH 1 1578 #define FF_PROFILE_MPEG2_SS 2 1579 #define FF_PROFILE_MPEG2_SNR_SCALABLE 3 1580 #define FF_PROFILE_MPEG2_MAIN 4 1581 #define FF_PROFILE_MPEG2_SIMPLE 5 1582 1583 #define FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag 1584 #define FF_PROFILE_H264_INTRA (1<<11) // 8+3; constraint_set3_flag 1585 1586 #define FF_PROFILE_H264_BASELINE 66 1587 #define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED) 1588 #define FF_PROFILE_H264_MAIN 77 1589 #define FF_PROFILE_H264_EXTENDED 88 1590 #define FF_PROFILE_H264_HIGH 100 1591 #define FF_PROFILE_H264_HIGH_10 110 1592 #define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA) 1593 #define FF_PROFILE_H264_MULTIVIEW_HIGH 118 1594 #define FF_PROFILE_H264_HIGH_422 122 1595 #define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA) 1596 #define FF_PROFILE_H264_STEREO_HIGH 128 1597 #define FF_PROFILE_H264_HIGH_444 144 1598 #define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244 1599 #define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA) 1600 #define FF_PROFILE_H264_CAVLC_444 44 1601 1602 #define FF_PROFILE_VC1_SIMPLE 0 1603 #define FF_PROFILE_VC1_MAIN 1 1604 #define FF_PROFILE_VC1_COMPLEX 2 1605 #define FF_PROFILE_VC1_ADVANCED 3 1606 1607 #define FF_PROFILE_MPEG4_SIMPLE 0 1608 #define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1 1609 #define FF_PROFILE_MPEG4_CORE 2 1610 #define FF_PROFILE_MPEG4_MAIN 3 1611 #define FF_PROFILE_MPEG4_N_BIT 4 1612 #define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5 1613 #define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6 1614 #define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7 1615 #define FF_PROFILE_MPEG4_HYBRID 8 1616 #define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9 1617 #define FF_PROFILE_MPEG4_CORE_SCALABLE 10 1618 #define FF_PROFILE_MPEG4_ADVANCED_CODING 11 1619 #define FF_PROFILE_MPEG4_ADVANCED_CORE 12 1620 #define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13 1621 #define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14 1622 #define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15 1623 1624 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 1 1625 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 2 1626 #define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 32768 1627 #define FF_PROFILE_JPEG2000_DCINEMA_2K 3 1628 #define FF_PROFILE_JPEG2000_DCINEMA_4K 4 1629 1630 #define FF_PROFILE_VP9_0 0 1631 #define FF_PROFILE_VP9_1 1 1632 #define FF_PROFILE_VP9_2 2 1633 #define FF_PROFILE_VP9_3 3 1634 1635 #define FF_PROFILE_HEVC_MAIN 1 1636 #define FF_PROFILE_HEVC_MAIN_10 2 1637 #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3 1638 #define FF_PROFILE_HEVC_REXT 4 1639 1640 #define FF_PROFILE_VVC_MAIN_10 1 1641 #define FF_PROFILE_VVC_MAIN_10_444 33 1642 1643 #define FF_PROFILE_AV1_MAIN 0 1644 #define FF_PROFILE_AV1_HIGH 1 1645 #define FF_PROFILE_AV1_PROFESSIONAL 2 1646 1647 #define FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT 0xc0 1648 #define FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT 0xc1 1649 #define FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT 0xc2 1650 #define FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS 0xc3 1651 #define FF_PROFILE_MJPEG_JPEG_LS 0xf7 1652 1653 #define FF_PROFILE_SBC_MSBC 1 1654 1655 #define FF_PROFILE_PRORES_PROXY 0 1656 #define FF_PROFILE_PRORES_LT 1 1657 #define FF_PROFILE_PRORES_STANDARD 2 1658 #define FF_PROFILE_PRORES_HQ 3 1659 #define FF_PROFILE_PRORES_4444 4 1660 #define FF_PROFILE_PRORES_XQ 5 1661 1662 #define FF_PROFILE_ARIB_PROFILE_A 0 1663 #define FF_PROFILE_ARIB_PROFILE_C 1 1664 1665 #define FF_PROFILE_KLVA_SYNC 0 1666 #define FF_PROFILE_KLVA_ASYNC 1 1667 1668 /** 1669 * level 1670 * - encoding: Set by user. 1671 * - decoding: Set by libavcodec. 1672 */ 1673 int level; 1674 #define FF_LEVEL_UNKNOWN -99 1675 1676 /** 1677 * Skip loop filtering for selected frames. 1678 * - encoding: unused 1679 * - decoding: Set by user. 1680 */ 1681 enum AVDiscard skip_loop_filter; 1682 1683 /** 1684 * Skip IDCT/dequantization for selected frames. 1685 * - encoding: unused 1686 * - decoding: Set by user. 1687 */ 1688 enum AVDiscard skip_idct; 1689 1690 /** 1691 * Skip decoding for selected frames. 1692 * - encoding: unused 1693 * - decoding: Set by user. 1694 */ 1695 enum AVDiscard skip_frame; 1696 1697 /** 1698 * Header containing style information for text subtitles. 1699 * For SUBTITLE_ASS subtitle type, it should contain the whole ASS 1700 * [Script Info] and [V4+ Styles] section, plus the [Events] line and 1701 * the Format line following. It shouldn't include any Dialogue line. 1702 * - encoding: Set/allocated/freed by user (before avcodec_open2()) 1703 * - decoding: Set/allocated/freed by libavcodec (by avcodec_open2()) 1704 */ 1705 uint8_t *subtitle_header; 1706 int subtitle_header_size; 1707 1708 /** 1709 * Audio only. The number of "priming" samples (padding) inserted by the 1710 * encoder at the beginning of the audio. I.e. this number of leading 1711 * decoded samples must be discarded by the caller to get the original audio 1712 * without leading padding. 1713 * 1714 * - decoding: unused 1715 * - encoding: Set by libavcodec. The timestamps on the output packets are 1716 * adjusted by the encoder so that they always refer to the 1717 * first sample of the data actually contained in the packet, 1718 * including any added padding. E.g. if the timebase is 1719 * 1/samplerate and the timestamp of the first input sample is 1720 * 0, the timestamp of the first output packet will be 1721 * -initial_padding. 1722 */ 1723 int initial_padding; 1724 1725 /** 1726 * - decoding: For codecs that store a framerate value in the compressed 1727 * bitstream, the decoder may export it here. { 0, 1} when 1728 * unknown. 1729 * - encoding: May be used to signal the framerate of CFR content to an 1730 * encoder. 1731 */ 1732 AVRational framerate; 1733 1734 /** 1735 * Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx. 1736 * - encoding: unused. 1737 * - decoding: Set by libavcodec before calling get_format() 1738 */ 1739 enum AVPixelFormat sw_pix_fmt; 1740 1741 /** 1742 * Timebase in which pkt_dts/pts and AVPacket.dts/pts are. 1743 * - encoding unused. 1744 * - decoding set by user. 1745 */ 1746 AVRational pkt_timebase; 1747 1748 /** 1749 * AVCodecDescriptor 1750 * - encoding: unused. 1751 * - decoding: set by libavcodec. 1752 */ 1753 const AVCodecDescriptor *codec_descriptor; 1754 1755 /** 1756 * Current statistics for PTS correction. 1757 * - decoding: maintained and used by libavcodec, not intended to be used by user apps 1758 * - encoding: unused 1759 */ 1760 int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far 1761 int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far 1762 int64_t pts_correction_last_pts; /// PTS of the last frame 1763 int64_t pts_correction_last_dts; /// DTS of the last frame 1764 1765 /** 1766 * Character encoding of the input subtitles file. 1767 * - decoding: set by user 1768 * - encoding: unused 1769 */ 1770 char *sub_charenc; 1771 1772 /** 1773 * Subtitles character encoding mode. Formats or codecs might be adjusting 1774 * this setting (if they are doing the conversion themselves for instance). 1775 * - decoding: set by libavcodec 1776 * - encoding: unused 1777 */ 1778 int sub_charenc_mode; 1779 #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) 1780 #define FF_SUB_CHARENC_MODE_AUTOMATIC 0 ///< libavcodec will select the mode itself 1781 #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 1782 #define FF_SUB_CHARENC_MODE_IGNORE 2 ///< neither convert the subtitles, nor check them for valid UTF-8 1783 1784 /** 1785 * Skip processing alpha if supported by codec. 1786 * Note that if the format uses pre-multiplied alpha (common with VP6, 1787 * and recommended due to better video quality/compression) 1788 * the image will look as if alpha-blended onto a black background. 1789 * However for formats that do not use pre-multiplied alpha 1790 * there might be serious artefacts (though e.g. libswscale currently 1791 * assumes pre-multiplied alpha anyway). 1792 * 1793 * - decoding: set by user 1794 * - encoding: unused 1795 */ 1796 int skip_alpha; 1797 1798 /** 1799 * Number of samples to skip after a discontinuity 1800 * - decoding: unused 1801 * - encoding: set by libavcodec 1802 */ 1803 int seek_preroll; 1804 1805 #if FF_API_DEBUG_MV 1806 /** 1807 * @deprecated unused 1808 */ 1809 attribute_deprecated 1810 int debug_mv; 1811 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames 1812 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames 1813 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames 1814 #endif 1815 1816 /** 1817 * custom intra quantization matrix 1818 * - encoding: Set by user, can be NULL. 1819 * - decoding: unused. 1820 */ 1821 uint16_t *chroma_intra_matrix; 1822 1823 /** 1824 * dump format separator. 1825 * can be ", " or "\n " or anything else 1826 * - encoding: Set by user. 1827 * - decoding: Set by user. 1828 */ 1829 uint8_t *dump_separator; 1830 1831 /** 1832 * ',' separated list of allowed decoders. 1833 * If NULL then all are allowed 1834 * - encoding: unused 1835 * - decoding: set by user 1836 */ 1837 char *codec_whitelist; 1838 1839 /** 1840 * Properties of the stream that gets decoded 1841 * - encoding: unused 1842 * - decoding: set by libavcodec 1843 */ 1844 unsigned properties; 1845 #define FF_CODEC_PROPERTY_LOSSLESS 0x00000001 1846 #define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002 1847 #define FF_CODEC_PROPERTY_FILM_GRAIN 0x00000004 1848 1849 /** 1850 * Additional data associated with the entire coded stream. 1851 * 1852 * - decoding: unused 1853 * - encoding: may be set by libavcodec after avcodec_open2(). 1854 */ 1855 AVPacketSideData *coded_side_data; 1856 int nb_coded_side_data; 1857 1858 /** 1859 * A reference to the AVHWFramesContext describing the input (for encoding) 1860 * or output (decoding) frames. The reference is set by the caller and 1861 * afterwards owned (and freed) by libavcodec - it should never be read by 1862 * the caller after being set. 1863 * 1864 * - decoding: This field should be set by the caller from the get_format() 1865 * callback. The previous reference (if any) will always be 1866 * unreffed by libavcodec before the get_format() call. 1867 * 1868 * If the default get_buffer2() is used with a hwaccel pixel 1869 * format, then this AVHWFramesContext will be used for 1870 * allocating the frame buffers. 1871 * 1872 * - encoding: For hardware encoders configured to use a hwaccel pixel 1873 * format, this field should be set by the caller to a reference 1874 * to the AVHWFramesContext describing input frames. 1875 * AVHWFramesContext.format must be equal to 1876 * AVCodecContext.pix_fmt. 1877 * 1878 * This field should be set before avcodec_open2() is called. 1879 */ 1880 AVBufferRef *hw_frames_ctx; 1881 1882 #if FF_API_SUB_TEXT_FORMAT 1883 /** 1884 * @deprecated unused 1885 */ 1886 attribute_deprecated 1887 int sub_text_format; 1888 #define FF_SUB_TEXT_FMT_ASS 0 1889 #endif 1890 1891 /** 1892 * Audio only. The amount of padding (in samples) appended by the encoder to 1893 * the end of the audio. I.e. this number of decoded samples must be 1894 * discarded by the caller from the end of the stream to get the original 1895 * audio without any trailing padding. 1896 * 1897 * - decoding: unused 1898 * - encoding: unused 1899 */ 1900 int trailing_padding; 1901 1902 /** 1903 * The number of pixels per image to maximally accept. 1904 * 1905 * - decoding: set by user 1906 * - encoding: set by user 1907 */ 1908 int64_t max_pixels; 1909 1910 /** 1911 * A reference to the AVHWDeviceContext describing the device which will 1912 * be used by a hardware encoder/decoder. The reference is set by the 1913 * caller and afterwards owned (and freed) by libavcodec. 1914 * 1915 * This should be used if either the codec device does not require 1916 * hardware frames or any that are used are to be allocated internally by 1917 * libavcodec. If the user wishes to supply any of the frames used as 1918 * encoder input or decoder output then hw_frames_ctx should be used 1919 * instead. When hw_frames_ctx is set in get_format() for a decoder, this 1920 * field will be ignored while decoding the associated stream segment, but 1921 * may again be used on a following one after another get_format() call. 1922 * 1923 * For both encoders and decoders this field should be set before 1924 * avcodec_open2() is called and must not be written to thereafter. 1925 * 1926 * Note that some decoders may require this field to be set initially in 1927 * order to support hw_frames_ctx at all - in that case, all frames 1928 * contexts used must be created on the same device. 1929 */ 1930 AVBufferRef *hw_device_ctx; 1931 1932 /** 1933 * Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated 1934 * decoding (if active). 1935 * - encoding: unused 1936 * - decoding: Set by user (either before avcodec_open2(), or in the 1937 * AVCodecContext.get_format callback) 1938 */ 1939 int hwaccel_flags; 1940 1941 /** 1942 * Video decoding only. Certain video codecs support cropping, meaning that 1943 * only a sub-rectangle of the decoded frame is intended for display. This 1944 * option controls how cropping is handled by libavcodec. 1945 * 1946 * When set to 1 (the default), libavcodec will apply cropping internally. 1947 * I.e. it will modify the output frame width/height fields and offset the 1948 * data pointers (only by as much as possible while preserving alignment, or 1949 * by the full amount if the AV_CODEC_FLAG_UNALIGNED flag is set) so that 1950 * the frames output by the decoder refer only to the cropped area. The 1951 * crop_* fields of the output frames will be zero. 1952 * 1953 * When set to 0, the width/height fields of the output frames will be set 1954 * to the coded dimensions and the crop_* fields will describe the cropping 1955 * rectangle. Applying the cropping is left to the caller. 1956 * 1957 * @warning When hardware acceleration with opaque output frames is used, 1958 * libavcodec is unable to apply cropping from the top/left border. 1959 * 1960 * @note when this option is set to zero, the width/height fields of the 1961 * AVCodecContext and output AVFrames have different meanings. The codec 1962 * context fields store display dimensions (with the coded dimensions in 1963 * coded_width/height), while the frame fields store the coded dimensions 1964 * (with the display dimensions being determined by the crop_* fields). 1965 */ 1966 int apply_cropping; 1967 1968 /* 1969 * Video decoding only. Sets the number of extra hardware frames which 1970 * the decoder will allocate for use by the caller. This must be set 1971 * before avcodec_open2() is called. 1972 * 1973 * Some hardware decoders require all frames that they will use for 1974 * output to be defined in advance before decoding starts. For such 1975 * decoders, the hardware frame pool must therefore be of a fixed size. 1976 * The extra frames set here are on top of any number that the decoder 1977 * needs internally in order to operate normally (for example, frames 1978 * used as reference pictures). 1979 */ 1980 int extra_hw_frames; 1981 1982 /** 1983 * The percentage of damaged samples to discard a frame. 1984 * 1985 * - decoding: set by user 1986 * - encoding: unused 1987 */ 1988 int discard_damaged_percentage; 1989 1990 /** 1991 * The number of samples per frame to maximally accept. 1992 * 1993 * - decoding: set by user 1994 * - encoding: set by user 1995 */ 1996 int64_t max_samples; 1997 1998 /** 1999 * Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of 2000 * metadata exported in frame, packet, or coded stream side data by 2001 * decoders and encoders. 2002 * 2003 * - decoding: set by user 2004 * - encoding: set by user 2005 */ 2006 int export_side_data; 2007 2008 /** 2009 * This callback is called at the beginning of each packet to get a data 2010 * buffer for it. 2011 * 2012 * The following field will be set in the packet before this callback is 2013 * called: 2014 * - size 2015 * This callback must use the above value to calculate the required buffer size, 2016 * which must padded by at least AV_INPUT_BUFFER_PADDING_SIZE bytes. 2017 * 2018 * In some specific cases, the encoder may not use the entire buffer allocated by this 2019 * callback. This will be reflected in the size value in the packet once returned by 2020 * avcodec_receive_packet(). 2021 * 2022 * This callback must fill the following fields in the packet: 2023 * - data: alignment requirements for AVPacket apply, if any. Some architectures and 2024 * encoders may benefit from having aligned data. 2025 * - buf: must contain a pointer to an AVBufferRef structure. The packet's 2026 * data pointer must be contained in it. See: av_buffer_create(), av_buffer_alloc(), 2027 * and av_buffer_ref(). 2028 * 2029 * If AV_CODEC_CAP_DR1 is not set then get_encode_buffer() must call 2030 * avcodec_default_get_encode_buffer() instead of providing a buffer allocated by 2031 * some other means. 2032 * 2033 * The flags field may contain a combination of AV_GET_ENCODE_BUFFER_FLAG_ flags. 2034 * They may be used for example to hint what use the buffer may get after being 2035 * created. 2036 * Implementations of this callback may ignore flags they don't understand. 2037 * If AV_GET_ENCODE_BUFFER_FLAG_REF is set in flags then the packet may be reused 2038 * (read and/or written to if it is writable) later by libavcodec. 2039 * 2040 * This callback must be thread-safe, as when frame threading is used, it may 2041 * be called from multiple threads simultaneously. 2042 * 2043 * @see avcodec_default_get_encode_buffer() 2044 * 2045 * - encoding: Set by libavcodec, user can override. 2046 * - decoding: unused 2047 */ 2048 int (*get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags); 2049 2050 /** 2051 * Audio channel layout. 2052 * - encoding: must be set by the caller, to one of AVCodec.ch_layouts. 2053 * - decoding: may be set by the caller if known e.g. from the container. 2054 * The decoder can then override during decoding as needed. 2055 */ 2056 AVChannelLayout ch_layout; 2057 } AVCodecContext; 2058 2059 /** 2060 * @defgroup lavc_hwaccel AVHWAccel 2061 * 2062 * @note Nothing in this structure should be accessed by the user. At some 2063 * point in future it will not be externally visible at all. 2064 * 2065 * @{ 2066 */ 2067 typedef struct AVHWAccel { 2068 /** 2069 * Name of the hardware accelerated codec. 2070 * The name is globally unique among encoders and among decoders (but an 2071 * encoder and a decoder can share the same name). 2072 */ 2073 const char *name; 2074 2075 /** 2076 * Type of codec implemented by the hardware accelerator. 2077 * 2078 * See AVMEDIA_TYPE_xxx 2079 */ 2080 enum AVMediaType type; 2081 2082 /** 2083 * Codec implemented by the hardware accelerator. 2084 * 2085 * See AV_CODEC_ID_xxx 2086 */ 2087 enum AVCodecID id; 2088 2089 /** 2090 * Supported pixel format. 2091 * 2092 * Only hardware accelerated formats are supported here. 2093 */ 2094 enum AVPixelFormat pix_fmt; 2095 2096 /** 2097 * Hardware accelerated codec capabilities. 2098 * see AV_HWACCEL_CODEC_CAP_* 2099 */ 2100 int capabilities; 2101 2102 /***************************************************************** 2103 * No fields below this line are part of the public API. They 2104 * may not be used outside of libavcodec and can be changed and 2105 * removed at will. 2106 * New public fields should be added right above. 2107 ***************************************************************** 2108 */ 2109 2110 /** 2111 * Allocate a custom buffer 2112 */ 2113 int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame); 2114 2115 /** 2116 * Called at the beginning of each frame or field picture. 2117 * 2118 * Meaningful frame information (codec specific) is guaranteed to 2119 * be parsed at this point. This function is mandatory. 2120 * 2121 * Note that buf can be NULL along with buf_size set to 0. 2122 * Otherwise, this means the whole frame is available at this point. 2123 * 2124 * @param avctx the codec context 2125 * @param buf the frame data buffer base 2126 * @param buf_size the size of the frame in bytes 2127 * @return zero if successful, a negative value otherwise 2128 */ 2129 int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); 2130 2131 /** 2132 * Callback for parameter data (SPS/PPS/VPS etc). 2133 * 2134 * Useful for hardware decoders which keep persistent state about the 2135 * video parameters, and need to receive any changes to update that state. 2136 * 2137 * @param avctx the codec context 2138 * @param type the nal unit type 2139 * @param buf the nal unit data buffer 2140 * @param buf_size the size of the nal unit in bytes 2141 * @return zero if successful, a negative value otherwise 2142 */ 2143 int (*decode_params)(AVCodecContext *avctx, int type, const uint8_t *buf, uint32_t buf_size); 2144 2145 /** 2146 * Callback for each slice. 2147 * 2148 * Meaningful slice information (codec specific) is guaranteed to 2149 * be parsed at this point. This function is mandatory. 2150 * 2151 * @param avctx the codec context 2152 * @param buf the slice data buffer base 2153 * @param buf_size the size of the slice in bytes 2154 * @return zero if successful, a negative value otherwise 2155 */ 2156 int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); 2157 2158 /** 2159 * Called at the end of each frame or field picture. 2160 * 2161 * The whole picture is parsed at this point and can now be sent 2162 * to the hardware accelerator. This function is mandatory. 2163 * 2164 * @param avctx the codec context 2165 * @return zero if successful, a negative value otherwise 2166 */ 2167 int (*end_frame)(AVCodecContext *avctx); 2168 2169 /** 2170 * Size of per-frame hardware accelerator private data. 2171 * 2172 * Private data is allocated with av_mallocz() before 2173 * AVCodecContext.get_buffer() and deallocated after 2174 * AVCodecContext.release_buffer(). 2175 */ 2176 int frame_priv_data_size; 2177 2178 /** 2179 * Initialize the hwaccel private data. 2180 * 2181 * This will be called from ff_get_format(), after hwaccel and 2182 * hwaccel_context are set and the hwaccel private data in AVCodecInternal 2183 * is allocated. 2184 */ 2185 int (*init)(AVCodecContext *avctx); 2186 2187 /** 2188 * Uninitialize the hwaccel private data. 2189 * 2190 * This will be called from get_format() or avcodec_close(), after hwaccel 2191 * and hwaccel_context are already uninitialized. 2192 */ 2193 int (*uninit)(AVCodecContext *avctx); 2194 2195 /** 2196 * Size of the private data to allocate in 2197 * AVCodecInternal.hwaccel_priv_data. 2198 */ 2199 int priv_data_size; 2200 2201 /** 2202 * Internal hwaccel capabilities. 2203 */ 2204 int caps_internal; 2205 2206 /** 2207 * Fill the given hw_frames context with current codec parameters. Called 2208 * from get_format. Refer to avcodec_get_hw_frames_parameters() for 2209 * details. 2210 * 2211 * This CAN be called before AVHWAccel.init is called, and you must assume 2212 * that avctx->hwaccel_priv_data is invalid. 2213 */ 2214 int (*frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx); 2215 } AVHWAccel; 2216 2217 /** 2218 * HWAccel is experimental and is thus avoided in favor of non experimental 2219 * codecs 2220 */ 2221 #define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200 2222 2223 /** 2224 * Hardware acceleration should be used for decoding even if the codec level 2225 * used is unknown or higher than the maximum supported level reported by the 2226 * hardware driver. 2227 * 2228 * It's generally a good idea to pass this flag unless you have a specific 2229 * reason not to, as hardware tends to under-report supported levels. 2230 */ 2231 #define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0) 2232 2233 /** 2234 * Hardware acceleration can output YUV pixel formats with a different chroma 2235 * sampling than 4:2:0 and/or other than 8 bits per component. 2236 */ 2237 #define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1) 2238 2239 /** 2240 * Hardware acceleration should still be attempted for decoding when the 2241 * codec profile does not match the reported capabilities of the hardware. 2242 * 2243 * For example, this can be used to try to decode baseline profile H.264 2244 * streams in hardware - it will often succeed, because many streams marked 2245 * as baseline profile actually conform to constrained baseline profile. 2246 * 2247 * @warning If the stream is actually not supported then the behaviour is 2248 * undefined, and may include returning entirely incorrect output 2249 * while indicating success. 2250 */ 2251 #define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2) 2252 2253 /** 2254 * @} 2255 */ 2256 2257 enum AVSubtitleType { 2258 SUBTITLE_NONE, 2259 2260 SUBTITLE_BITMAP, ///< A bitmap, pict will be set 2261 2262 /** 2263 * Plain text, the text field must be set by the decoder and is 2264 * authoritative. ass and pict fields may contain approximations. 2265 */ 2266 SUBTITLE_TEXT, 2267 2268 /** 2269 * Formatted text, the ass field must be set by the decoder and is 2270 * authoritative. pict and text fields may contain approximations. 2271 */ 2272 SUBTITLE_ASS, 2273 }; 2274 2275 #define AV_SUBTITLE_FLAG_FORCED 0x00000001 2276 2277 typedef struct AVSubtitleRect { 2278 int x; ///< top left corner of pict, undefined when pict is not set 2279 int y; ///< top left corner of pict, undefined when pict is not set 2280 int w; ///< width of pict, undefined when pict is not set 2281 int h; ///< height of pict, undefined when pict is not set 2282 int nb_colors; ///< number of colors in pict, undefined when pict is not set 2283 2284 /** 2285 * data+linesize for the bitmap of this subtitle. 2286 * Can be set for text/ass as well once they are rendered. 2287 */ 2288 uint8_t *data[4]; 2289 int linesize[4]; 2290 2291 enum AVSubtitleType type; 2292 2293 char *text; ///< 0 terminated plain UTF-8 text 2294 2295 /** 2296 * 0 terminated ASS/SSA compatible event line. 2297 * The presentation of this is unaffected by the other values in this 2298 * struct. 2299 */ 2300 char *ass; 2301 2302 int flags; 2303 } AVSubtitleRect; 2304 2305 typedef struct AVSubtitle { 2306 uint16_t format; /* 0 = graphics */ 2307 uint32_t start_display_time; /* relative to packet pts, in ms */ 2308 uint32_t end_display_time; /* relative to packet pts, in ms */ 2309 unsigned num_rects; 2310 AVSubtitleRect **rects; 2311 int64_t pts; ///< Same as packet pts, in AV_TIME_BASE 2312 } AVSubtitle; 2313 2314 /** 2315 * Return the LIBAVCODEC_VERSION_INT constant. 2316 */ 2317 unsigned avcodec_version(void); 2318 2319 /** 2320 * Return the libavcodec build-time configuration. 2321 */ 2322 const char *avcodec_configuration(void); 2323 2324 /** 2325 * Return the libavcodec license. 2326 */ 2327 const char *avcodec_license(void); 2328 2329 /** 2330 * Allocate an AVCodecContext and set its fields to default values. The 2331 * resulting struct should be freed with avcodec_free_context(). 2332 * 2333 * @param codec if non-NULL, allocate private data and initialize defaults 2334 * for the given codec. It is illegal to then call avcodec_open2() 2335 * with a different codec. 2336 * If NULL, then the codec-specific defaults won't be initialized, 2337 * which may result in suboptimal default settings (this is 2338 * important mainly for encoders, e.g. libx264). 2339 * 2340 * @return An AVCodecContext filled with default values or NULL on failure. 2341 */ 2342 AVCodecContext *avcodec_alloc_context3(const AVCodec *codec); 2343 2344 /** 2345 * Free the codec context and everything associated with it and write NULL to 2346 * the provided pointer. 2347 */ 2348 void avcodec_free_context(AVCodecContext **avctx); 2349 2350 /** 2351 * Get the AVClass for AVCodecContext. It can be used in combination with 2352 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 2353 * 2354 * @see av_opt_find(). 2355 */ 2356 const AVClass *avcodec_get_class(void); 2357 2358 #if FF_API_GET_FRAME_CLASS 2359 /** 2360 * @deprecated This function should not be used. 2361 */ 2362 attribute_deprecated 2363 const AVClass *avcodec_get_frame_class(void); 2364 #endif 2365 2366 /** 2367 * Get the AVClass for AVSubtitleRect. It can be used in combination with 2368 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 2369 * 2370 * @see av_opt_find(). 2371 */ 2372 const AVClass *avcodec_get_subtitle_rect_class(void); 2373 2374 /** 2375 * Fill the parameters struct based on the values from the supplied codec 2376 * context. Any allocated fields in par are freed and replaced with duplicates 2377 * of the corresponding fields in codec. 2378 * 2379 * @return >= 0 on success, a negative AVERROR code on failure 2380 */ 2381 int avcodec_parameters_from_context(AVCodecParameters *par, 2382 const AVCodecContext *codec); 2383 2384 /** 2385 * Fill the codec context based on the values from the supplied codec 2386 * parameters. Any allocated fields in codec that have a corresponding field in 2387 * par are freed and replaced with duplicates of the corresponding field in par. 2388 * Fields in codec that do not have a counterpart in par are not touched. 2389 * 2390 * @return >= 0 on success, a negative AVERROR code on failure. 2391 */ 2392 int avcodec_parameters_to_context(AVCodecContext *codec, 2393 const AVCodecParameters *par); 2394 2395 /** 2396 * Initialize the AVCodecContext to use the given AVCodec. Prior to using this 2397 * function the context has to be allocated with avcodec_alloc_context3(). 2398 * 2399 * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(), 2400 * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for 2401 * retrieving a codec. 2402 * 2403 * @note Always call this function before using decoding routines (such as 2404 * @ref avcodec_receive_frame()). 2405 * 2406 * @code 2407 * av_dict_set(&opts, "b", "2.5M", 0); 2408 * codec = avcodec_find_decoder(AV_CODEC_ID_H264); 2409 * if (!codec) 2410 * exit(1); 2411 * 2412 * context = avcodec_alloc_context3(codec); 2413 * 2414 * if (avcodec_open2(context, codec, opts) < 0) 2415 * exit(1); 2416 * @endcode 2417 * 2418 * @param avctx The context to initialize. 2419 * @param codec The codec to open this context for. If a non-NULL codec has been 2420 * previously passed to avcodec_alloc_context3() or 2421 * for this context, then this parameter MUST be either NULL or 2422 * equal to the previously passed codec. 2423 * @param options A dictionary filled with AVCodecContext and codec-private options. 2424 * On return this object will be filled with options that were not found. 2425 * 2426 * @return zero on success, a negative value on error 2427 * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(), 2428 * av_dict_set(), av_opt_find(). 2429 */ 2430 int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options); 2431 2432 /** 2433 * Close a given AVCodecContext and free all the data associated with it 2434 * (but not the AVCodecContext itself). 2435 * 2436 * Calling this function on an AVCodecContext that hasn't been opened will free 2437 * the codec-specific data allocated in avcodec_alloc_context3() with a non-NULL 2438 * codec. Subsequent calls will do nothing. 2439 * 2440 * @note Do not use this function. Use avcodec_free_context() to destroy a 2441 * codec context (either open or closed). Opening and closing a codec context 2442 * multiple times is not supported anymore -- use multiple codec contexts 2443 * instead. 2444 */ 2445 int avcodec_close(AVCodecContext *avctx); 2446 2447 /** 2448 * Free all allocated data in the given subtitle struct. 2449 * 2450 * @param sub AVSubtitle to free. 2451 */ 2452 void avsubtitle_free(AVSubtitle *sub); 2453 2454 /** 2455 * @} 2456 */ 2457 2458 /** 2459 * @addtogroup lavc_decoding 2460 * @{ 2461 */ 2462 2463 /** 2464 * The default callback for AVCodecContext.get_buffer2(). It is made public so 2465 * it can be called by custom get_buffer2() implementations for decoders without 2466 * AV_CODEC_CAP_DR1 set. 2467 */ 2468 int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags); 2469 2470 /** 2471 * The default callback for AVCodecContext.get_encode_buffer(). It is made public so 2472 * it can be called by custom get_encode_buffer() implementations for encoders without 2473 * AV_CODEC_CAP_DR1 set. 2474 */ 2475 int avcodec_default_get_encode_buffer(AVCodecContext *s, AVPacket *pkt, int flags); 2476 2477 /** 2478 * Modify width and height values so that they will result in a memory 2479 * buffer that is acceptable for the codec if you do not use any horizontal 2480 * padding. 2481 * 2482 * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened. 2483 */ 2484 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height); 2485 2486 /** 2487 * Modify width and height values so that they will result in a memory 2488 * buffer that is acceptable for the codec if you also ensure that all 2489 * line sizes are a multiple of the respective linesize_align[i]. 2490 * 2491 * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened. 2492 */ 2493 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, 2494 int linesize_align[AV_NUM_DATA_POINTERS]); 2495 2496 /** 2497 * Converts AVChromaLocation to swscale x/y chroma position. 2498 * 2499 * The positions represent the chroma (0,0) position in a coordinates system 2500 * with luma (0,0) representing the origin and luma(1,1) representing 256,256 2501 * 2502 * @param xpos horizontal chroma sample position 2503 * @param ypos vertical chroma sample position 2504 */ 2505 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos); 2506 2507 /** 2508 * Converts swscale x/y chroma position to AVChromaLocation. 2509 * 2510 * The positions represent the chroma (0,0) position in a coordinates system 2511 * with luma (0,0) representing the origin and luma(1,1) representing 256,256 2512 * 2513 * @param xpos horizontal chroma sample position 2514 * @param ypos vertical chroma sample position 2515 */ 2516 enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos); 2517 2518 /** 2519 * Decode a subtitle message. 2520 * Return a negative value on error, otherwise return the number of bytes used. 2521 * If no subtitle could be decompressed, got_sub_ptr is zero. 2522 * Otherwise, the subtitle is stored in *sub. 2523 * Note that AV_CODEC_CAP_DR1 is not available for subtitle codecs. This is for 2524 * simplicity, because the performance difference is expected to be negligible 2525 * and reusing a get_buffer written for video codecs would probably perform badly 2526 * due to a potentially very different allocation pattern. 2527 * 2528 * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input 2529 * and output. This means that for some packets they will not immediately 2530 * produce decoded output and need to be flushed at the end of decoding to get 2531 * all the decoded data. Flushing is done by calling this function with packets 2532 * with avpkt->data set to NULL and avpkt->size set to 0 until it stops 2533 * returning subtitles. It is safe to flush even those decoders that are not 2534 * marked with AV_CODEC_CAP_DELAY, then no subtitles will be returned. 2535 * 2536 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 2537 * before packets may be fed to the decoder. 2538 * 2539 * @param avctx the codec context 2540 * @param[out] sub The preallocated AVSubtitle in which the decoded subtitle will be stored, 2541 * must be freed with avsubtitle_free if *got_sub_ptr is set. 2542 * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero. 2543 * @param[in] avpkt The input AVPacket containing the input buffer. 2544 */ 2545 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, 2546 int *got_sub_ptr, 2547 AVPacket *avpkt); 2548 2549 /** 2550 * Supply raw packet data as input to a decoder. 2551 * 2552 * Internally, this call will copy relevant AVCodecContext fields, which can 2553 * influence decoding per-packet, and apply them when the packet is actually 2554 * decoded. (For example AVCodecContext.skip_frame, which might direct the 2555 * decoder to drop the frame contained by the packet sent with this function.) 2556 * 2557 * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE 2558 * larger than the actual read bytes because some optimized bitstream 2559 * readers read 32 or 64 bits at once and could read over the end. 2560 * 2561 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2() 2562 * before packets may be fed to the decoder. 2563 * 2564 * @param avctx codec context 2565 * @param[in] avpkt The input AVPacket. Usually, this will be a single video 2566 * frame, or several complete audio frames. 2567 * Ownership of the packet remains with the caller, and the 2568 * decoder will not write to the packet. The decoder may create 2569 * a reference to the packet data (or copy it if the packet is 2570 * not reference-counted). 2571 * Unlike with older APIs, the packet is always fully consumed, 2572 * and if it contains multiple frames (e.g. some audio codecs), 2573 * will require you to call avcodec_receive_frame() multiple 2574 * times afterwards before you can send a new packet. 2575 * It can be NULL (or an AVPacket with data set to NULL and 2576 * size set to 0); in this case, it is considered a flush 2577 * packet, which signals the end of the stream. Sending the 2578 * first flush packet will return success. Subsequent ones are 2579 * unnecessary and will return AVERROR_EOF. If the decoder 2580 * still has frames buffered, it will return them after sending 2581 * a flush packet. 2582 * 2583 * @return 0 on success, otherwise negative error code: 2584 * AVERROR(EAGAIN): input is not accepted in the current state - user 2585 * must read output with avcodec_receive_frame() (once 2586 * all output is read, the packet should be resent, and 2587 * the call will not fail with EAGAIN). 2588 * AVERROR_EOF: the decoder has been flushed, and no new packets can 2589 * be sent to it (also returned if more than 1 flush 2590 * packet is sent) 2591 * AVERROR(EINVAL): codec not opened, it is an encoder, or requires flush 2592 * AVERROR(ENOMEM): failed to add packet to internal queue, or similar 2593 * other errors: legitimate decoding errors 2594 */ 2595 int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt); 2596 2597 /** 2598 * Return decoded output data from a decoder. 2599 * 2600 * @param avctx codec context 2601 * @param frame This will be set to a reference-counted video or audio 2602 * frame (depending on the decoder type) allocated by the 2603 * decoder. Note that the function will always call 2604 * av_frame_unref(frame) before doing anything else. 2605 * 2606 * @return 2607 * 0: success, a frame was returned 2608 * AVERROR(EAGAIN): output is not available in this state - user must try 2609 * to send new input 2610 * AVERROR_EOF: the decoder has been fully flushed, and there will be 2611 * no more output frames 2612 * AVERROR(EINVAL): codec not opened, or it is an encoder 2613 * AVERROR_INPUT_CHANGED: current decoded frame has changed parameters 2614 * with respect to first decoded frame. Applicable 2615 * when flag AV_CODEC_FLAG_DROPCHANGED is set. 2616 * other negative values: legitimate decoding errors 2617 */ 2618 int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame); 2619 2620 /** 2621 * Supply a raw video or audio frame to the encoder. Use avcodec_receive_packet() 2622 * to retrieve buffered output packets. 2623 * 2624 * @param avctx codec context 2625 * @param[in] frame AVFrame containing the raw audio or video frame to be encoded. 2626 * Ownership of the frame remains with the caller, and the 2627 * encoder will not write to the frame. The encoder may create 2628 * a reference to the frame data (or copy it if the frame is 2629 * not reference-counted). 2630 * It can be NULL, in which case it is considered a flush 2631 * packet. This signals the end of the stream. If the encoder 2632 * still has packets buffered, it will return them after this 2633 * call. Once flushing mode has been entered, additional flush 2634 * packets are ignored, and sending frames will return 2635 * AVERROR_EOF. 2636 * 2637 * For audio: 2638 * If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame 2639 * can have any number of samples. 2640 * If it is not set, frame->nb_samples must be equal to 2641 * avctx->frame_size for all frames except the last. 2642 * The final frame may be smaller than avctx->frame_size. 2643 * @return 0 on success, otherwise negative error code: 2644 * AVERROR(EAGAIN): input is not accepted in the current state - user 2645 * must read output with avcodec_receive_packet() (once 2646 * all output is read, the packet should be resent, and 2647 * the call will not fail with EAGAIN). 2648 * AVERROR_EOF: the encoder has been flushed, and no new frames can 2649 * be sent to it 2650 * AVERROR(EINVAL): codec not opened, it is a decoder, or requires flush 2651 * AVERROR(ENOMEM): failed to add packet to internal queue, or similar 2652 * other errors: legitimate encoding errors 2653 */ 2654 int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame); 2655 2656 /** 2657 * Read encoded data from the encoder. 2658 * 2659 * @param avctx codec context 2660 * @param avpkt This will be set to a reference-counted packet allocated by the 2661 * encoder. Note that the function will always call 2662 * av_packet_unref(avpkt) before doing anything else. 2663 * @return 0 on success, otherwise negative error code: 2664 * AVERROR(EAGAIN): output is not available in the current state - user 2665 * must try to send input 2666 * AVERROR_EOF: the encoder has been fully flushed, and there will be 2667 * no more output packets 2668 * AVERROR(EINVAL): codec not opened, or it is a decoder 2669 * other errors: legitimate encoding errors 2670 */ 2671 int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt); 2672 2673 /** 2674 * Create and return a AVHWFramesContext with values adequate for hardware 2675 * decoding. This is meant to get called from the get_format callback, and is 2676 * a helper for preparing a AVHWFramesContext for AVCodecContext.hw_frames_ctx. 2677 * This API is for decoding with certain hardware acceleration modes/APIs only. 2678 * 2679 * The returned AVHWFramesContext is not initialized. The caller must do this 2680 * with av_hwframe_ctx_init(). 2681 * 2682 * Calling this function is not a requirement, but makes it simpler to avoid 2683 * codec or hardware API specific details when manually allocating frames. 2684 * 2685 * Alternatively to this, an API user can set AVCodecContext.hw_device_ctx, 2686 * which sets up AVCodecContext.hw_frames_ctx fully automatically, and makes 2687 * it unnecessary to call this function or having to care about 2688 * AVHWFramesContext initialization at all. 2689 * 2690 * There are a number of requirements for calling this function: 2691 * 2692 * - It must be called from get_format with the same avctx parameter that was 2693 * passed to get_format. Calling it outside of get_format is not allowed, and 2694 * can trigger undefined behavior. 2695 * - The function is not always supported (see description of return values). 2696 * Even if this function returns successfully, hwaccel initialization could 2697 * fail later. (The degree to which implementations check whether the stream 2698 * is actually supported varies. Some do this check only after the user's 2699 * get_format callback returns.) 2700 * - The hw_pix_fmt must be one of the choices suggested by get_format. If the 2701 * user decides to use a AVHWFramesContext prepared with this API function, 2702 * the user must return the same hw_pix_fmt from get_format. 2703 * - The device_ref passed to this function must support the given hw_pix_fmt. 2704 * - After calling this API function, it is the user's responsibility to 2705 * initialize the AVHWFramesContext (returned by the out_frames_ref parameter), 2706 * and to set AVCodecContext.hw_frames_ctx to it. If done, this must be done 2707 * before returning from get_format (this is implied by the normal 2708 * AVCodecContext.hw_frames_ctx API rules). 2709 * - The AVHWFramesContext parameters may change every time time get_format is 2710 * called. Also, AVCodecContext.hw_frames_ctx is reset before get_format. So 2711 * you are inherently required to go through this process again on every 2712 * get_format call. 2713 * - It is perfectly possible to call this function without actually using 2714 * the resulting AVHWFramesContext. One use-case might be trying to reuse a 2715 * previously initialized AVHWFramesContext, and calling this API function 2716 * only to test whether the required frame parameters have changed. 2717 * - Fields that use dynamically allocated values of any kind must not be set 2718 * by the user unless setting them is explicitly allowed by the documentation. 2719 * If the user sets AVHWFramesContext.free and AVHWFramesContext.user_opaque, 2720 * the new free callback must call the potentially set previous free callback. 2721 * This API call may set any dynamically allocated fields, including the free 2722 * callback. 2723 * 2724 * The function will set at least the following fields on AVHWFramesContext 2725 * (potentially more, depending on hwaccel API): 2726 * 2727 * - All fields set by av_hwframe_ctx_alloc(). 2728 * - Set the format field to hw_pix_fmt. 2729 * - Set the sw_format field to the most suited and most versatile format. (An 2730 * implication is that this will prefer generic formats over opaque formats 2731 * with arbitrary restrictions, if possible.) 2732 * - Set the width/height fields to the coded frame size, rounded up to the 2733 * API-specific minimum alignment. 2734 * - Only _if_ the hwaccel requires a pre-allocated pool: set the initial_pool_size 2735 * field to the number of maximum reference surfaces possible with the codec, 2736 * plus 1 surface for the user to work (meaning the user can safely reference 2737 * at most 1 decoded surface at a time), plus additional buffering introduced 2738 * by frame threading. If the hwaccel does not require pre-allocation, the 2739 * field is left to 0, and the decoder will allocate new surfaces on demand 2740 * during decoding. 2741 * - Possibly AVHWFramesContext.hwctx fields, depending on the underlying 2742 * hardware API. 2743 * 2744 * Essentially, out_frames_ref returns the same as av_hwframe_ctx_alloc(), but 2745 * with basic frame parameters set. 2746 * 2747 * The function is stateless, and does not change the AVCodecContext or the 2748 * device_ref AVHWDeviceContext. 2749 * 2750 * @param avctx The context which is currently calling get_format, and which 2751 * implicitly contains all state needed for filling the returned 2752 * AVHWFramesContext properly. 2753 * @param device_ref A reference to the AVHWDeviceContext describing the device 2754 * which will be used by the hardware decoder. 2755 * @param hw_pix_fmt The hwaccel format you are going to return from get_format. 2756 * @param out_frames_ref On success, set to a reference to an _uninitialized_ 2757 * AVHWFramesContext, created from the given device_ref. 2758 * Fields will be set to values required for decoding. 2759 * Not changed if an error is returned. 2760 * @return zero on success, a negative value on error. The following error codes 2761 * have special semantics: 2762 * AVERROR(ENOENT): the decoder does not support this functionality. Setup 2763 * is always manual, or it is a decoder which does not 2764 * support setting AVCodecContext.hw_frames_ctx at all, 2765 * or it is a software format. 2766 * AVERROR(EINVAL): it is known that hardware decoding is not supported for 2767 * this configuration, or the device_ref is not supported 2768 * for the hwaccel referenced by hw_pix_fmt. 2769 */ 2770 int avcodec_get_hw_frames_parameters(AVCodecContext *avctx, 2771 AVBufferRef *device_ref, 2772 enum AVPixelFormat hw_pix_fmt, 2773 AVBufferRef **out_frames_ref); 2774 2775 2776 2777 /** 2778 * @defgroup lavc_parsing Frame parsing 2779 * @{ 2780 */ 2781 2782 enum AVPictureStructure { 2783 AV_PICTURE_STRUCTURE_UNKNOWN, //< unknown 2784 AV_PICTURE_STRUCTURE_TOP_FIELD, //< coded as top field 2785 AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field 2786 AV_PICTURE_STRUCTURE_FRAME, //< coded as frame 2787 }; 2788 2789 typedef struct AVCodecParserContext { 2790 void *priv_data; 2791 const struct AVCodecParser *parser; 2792 int64_t frame_offset; /* offset of the current frame */ 2793 int64_t cur_offset; /* current offset 2794 (incremented by each av_parser_parse()) */ 2795 int64_t next_frame_offset; /* offset of the next frame */ 2796 /* video info */ 2797 int pict_type; /* XXX: Put it back in AVCodecContext. */ 2798 /** 2799 * This field is used for proper frame duration computation in lavf. 2800 * It signals, how much longer the frame duration of the current frame 2801 * is compared to normal frame duration. 2802 * 2803 * frame_duration = (1 + repeat_pict) * time_base 2804 * 2805 * It is used by codecs like H.264 to display telecined material. 2806 */ 2807 int repeat_pict; /* XXX: Put it back in AVCodecContext. */ 2808 int64_t pts; /* pts of the current frame */ 2809 int64_t dts; /* dts of the current frame */ 2810 2811 /* private data */ 2812 int64_t last_pts; 2813 int64_t last_dts; 2814 int fetch_timestamp; 2815 2816 #define AV_PARSER_PTS_NB 4 2817 int cur_frame_start_index; 2818 int64_t cur_frame_offset[AV_PARSER_PTS_NB]; 2819 int64_t cur_frame_pts[AV_PARSER_PTS_NB]; 2820 int64_t cur_frame_dts[AV_PARSER_PTS_NB]; 2821 2822 int flags; 2823 #define PARSER_FLAG_COMPLETE_FRAMES 0x0001 2824 #define PARSER_FLAG_ONCE 0x0002 2825 /// Set if the parser has a valid file offset 2826 #define PARSER_FLAG_FETCHED_OFFSET 0x0004 2827 #define PARSER_FLAG_USE_CODEC_TS 0x1000 2828 2829 int64_t offset; ///< byte offset from starting packet start 2830 int64_t cur_frame_end[AV_PARSER_PTS_NB]; 2831 2832 /** 2833 * Set by parser to 1 for key frames and 0 for non-key frames. 2834 * It is initialized to -1, so if the parser doesn't set this flag, 2835 * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames 2836 * will be used. 2837 */ 2838 int key_frame; 2839 2840 // Timestamp generation support: 2841 /** 2842 * Synchronization point for start of timestamp generation. 2843 * 2844 * Set to >0 for sync point, 0 for no sync point and <0 for undefined 2845 * (default). 2846 * 2847 * For example, this corresponds to presence of H.264 buffering period 2848 * SEI message. 2849 */ 2850 int dts_sync_point; 2851 2852 /** 2853 * Offset of the current timestamp against last timestamp sync point in 2854 * units of AVCodecContext.time_base. 2855 * 2856 * Set to INT_MIN when dts_sync_point unused. Otherwise, it must 2857 * contain a valid timestamp offset. 2858 * 2859 * Note that the timestamp of sync point has usually a nonzero 2860 * dts_ref_dts_delta, which refers to the previous sync point. Offset of 2861 * the next frame after timestamp sync point will be usually 1. 2862 * 2863 * For example, this corresponds to H.264 cpb_removal_delay. 2864 */ 2865 int dts_ref_dts_delta; 2866 2867 /** 2868 * Presentation delay of current frame in units of AVCodecContext.time_base. 2869 * 2870 * Set to INT_MIN when dts_sync_point unused. Otherwise, it must 2871 * contain valid non-negative timestamp delta (presentation time of a frame 2872 * must not lie in the past). 2873 * 2874 * This delay represents the difference between decoding and presentation 2875 * time of the frame. 2876 * 2877 * For example, this corresponds to H.264 dpb_output_delay. 2878 */ 2879 int pts_dts_delta; 2880 2881 /** 2882 * Position of the packet in file. 2883 * 2884 * Analogous to cur_frame_pts/dts 2885 */ 2886 int64_t cur_frame_pos[AV_PARSER_PTS_NB]; 2887 2888 /** 2889 * Byte position of currently parsed frame in stream. 2890 */ 2891 int64_t pos; 2892 2893 /** 2894 * Previous frame byte position. 2895 */ 2896 int64_t last_pos; 2897 2898 /** 2899 * Duration of the current frame. 2900 * For audio, this is in units of 1 / AVCodecContext.sample_rate. 2901 * For all other types, this is in units of AVCodecContext.time_base. 2902 */ 2903 int duration; 2904 2905 enum AVFieldOrder field_order; 2906 2907 /** 2908 * Indicate whether a picture is coded as a frame, top field or bottom field. 2909 * 2910 * For example, H.264 field_pic_flag equal to 0 corresponds to 2911 * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag 2912 * equal to 1 and bottom_field_flag equal to 0 corresponds to 2913 * AV_PICTURE_STRUCTURE_TOP_FIELD. 2914 */ 2915 enum AVPictureStructure picture_structure; 2916 2917 /** 2918 * Picture number incremented in presentation or output order. 2919 * This field may be reinitialized at the first picture of a new sequence. 2920 * 2921 * For example, this corresponds to H.264 PicOrderCnt. 2922 */ 2923 int output_picture_number; 2924 2925 /** 2926 * Dimensions of the decoded video intended for presentation. 2927 */ 2928 int width; 2929 int height; 2930 2931 /** 2932 * Dimensions of the coded video. 2933 */ 2934 int coded_width; 2935 int coded_height; 2936 2937 /** 2938 * The format of the coded data, corresponds to enum AVPixelFormat for video 2939 * and for enum AVSampleFormat for audio. 2940 * 2941 * Note that a decoder can have considerable freedom in how exactly it 2942 * decodes the data, so the format reported here might be different from the 2943 * one returned by a decoder. 2944 */ 2945 int format; 2946 } AVCodecParserContext; 2947 2948 typedef struct AVCodecParser { 2949 int codec_ids[7]; /* several codec IDs are permitted */ 2950 int priv_data_size; 2951 int (*parser_init)(AVCodecParserContext *s); 2952 /* This callback never returns an error, a negative value means that 2953 * the frame start was in a previous packet. */ 2954 int (*parser_parse)(AVCodecParserContext *s, 2955 AVCodecContext *avctx, 2956 const uint8_t **poutbuf, int *poutbuf_size, 2957 const uint8_t *buf, int buf_size); 2958 void (*parser_close)(AVCodecParserContext *s); 2959 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size); 2960 } AVCodecParser; 2961 2962 /** 2963 * Iterate over all registered codec parsers. 2964 * 2965 * @param opaque a pointer where libavcodec will store the iteration state. Must 2966 * point to NULL to start the iteration. 2967 * 2968 * @return the next registered codec parser or NULL when the iteration is 2969 * finished 2970 */ 2971 const AVCodecParser *av_parser_iterate(void **opaque); 2972 2973 AVCodecParserContext *av_parser_init(int codec_id); 2974 2975 /** 2976 * Parse a packet. 2977 * 2978 * @param s parser context. 2979 * @param avctx codec context. 2980 * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished. 2981 * @param poutbuf_size set to size of parsed buffer or zero if not yet finished. 2982 * @param buf input buffer. 2983 * @param buf_size buffer size in bytes without the padding. I.e. the full buffer 2984 size is assumed to be buf_size + AV_INPUT_BUFFER_PADDING_SIZE. 2985 To signal EOF, this should be 0 (so that the last frame 2986 can be output). 2987 * @param pts input presentation timestamp. 2988 * @param dts input decoding timestamp. 2989 * @param pos input byte position in stream. 2990 * @return the number of bytes of the input bitstream used. 2991 * 2992 * Example: 2993 * @code 2994 * while(in_len){ 2995 * len = av_parser_parse2(myparser, AVCodecContext, &data, &size, 2996 * in_data, in_len, 2997 * pts, dts, pos); 2998 * in_data += len; 2999 * in_len -= len; 3000 * 3001 * if(size) 3002 * decode_frame(data, size); 3003 * } 3004 * @endcode 3005 */ 3006 int av_parser_parse2(AVCodecParserContext *s, 3007 AVCodecContext *avctx, 3008 uint8_t **poutbuf, int *poutbuf_size, 3009 const uint8_t *buf, int buf_size, 3010 int64_t pts, int64_t dts, 3011 int64_t pos); 3012 3013 void av_parser_close(AVCodecParserContext *s); 3014 3015 /** 3016 * @} 3017 * @} 3018 */ 3019 3020 /** 3021 * @addtogroup lavc_encoding 3022 * @{ 3023 */ 3024 3025 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, 3026 const AVSubtitle *sub); 3027 3028 3029 /** 3030 * @} 3031 */ 3032 3033 /** 3034 * @defgroup lavc_misc Utility functions 3035 * @ingroup libavc 3036 * 3037 * Miscellaneous utility functions related to both encoding and decoding 3038 * (or neither). 3039 * @{ 3040 */ 3041 3042 /** 3043 * @defgroup lavc_misc_pixfmt Pixel formats 3044 * 3045 * Functions for working with pixel formats. 3046 * @{ 3047 */ 3048 3049 /** 3050 * Return a value representing the fourCC code associated to the 3051 * pixel format pix_fmt, or 0 if no associated fourCC code can be 3052 * found. 3053 */ 3054 unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt); 3055 3056 /** 3057 * Find the best pixel format to convert to given a certain source pixel 3058 * format. When converting from one pixel format to another, information loss 3059 * may occur. For example, when converting from RGB24 to GRAY, the color 3060 * information will be lost. Similarly, other losses occur when converting from 3061 * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of 3062 * the given pixel formats should be used to suffer the least amount of loss. 3063 * The pixel formats from which it chooses one, are determined by the 3064 * pix_fmt_list parameter. 3065 * 3066 * 3067 * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from 3068 * @param[in] src_pix_fmt source pixel format 3069 * @param[in] has_alpha Whether the source pixel format alpha channel is used. 3070 * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur. 3071 * @return The best pixel format to convert to or -1 if none was found. 3072 */ 3073 enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list, 3074 enum AVPixelFormat src_pix_fmt, 3075 int has_alpha, int *loss_ptr); 3076 3077 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt); 3078 3079 /** 3080 * @} 3081 */ 3082 3083 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode); 3084 3085 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size); 3086 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count); 3087 //FIXME func typedef 3088 3089 /** 3090 * Fill AVFrame audio data and linesize pointers. 3091 * 3092 * The buffer buf must be a preallocated buffer with a size big enough 3093 * to contain the specified samples amount. The filled AVFrame data 3094 * pointers will point to this buffer. 3095 * 3096 * AVFrame extended_data channel pointers are allocated if necessary for 3097 * planar audio. 3098 * 3099 * @param frame the AVFrame 3100 * frame->nb_samples must be set prior to calling the 3101 * function. This function fills in frame->data, 3102 * frame->extended_data, frame->linesize[0]. 3103 * @param nb_channels channel count 3104 * @param sample_fmt sample format 3105 * @param buf buffer to use for frame data 3106 * @param buf_size size of buffer 3107 * @param align plane size sample alignment (0 = default) 3108 * @return >=0 on success, negative error code on failure 3109 * @todo return the size in bytes required to store the samples in 3110 * case of success, at the next libavutil bump 3111 */ 3112 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, 3113 enum AVSampleFormat sample_fmt, const uint8_t *buf, 3114 int buf_size, int align); 3115 3116 /** 3117 * Reset the internal codec state / flush internal buffers. Should be called 3118 * e.g. when seeking or when switching to a different stream. 3119 * 3120 * @note for decoders, this function just releases any references the decoder 3121 * might keep internally, but the caller's references remain valid. 3122 * 3123 * @note for encoders, this function will only do something if the encoder 3124 * declares support for AV_CODEC_CAP_ENCODER_FLUSH. When called, the encoder 3125 * will drain any remaining packets, and can then be re-used for a different 3126 * stream (as opposed to sending a null frame which will leave the encoder 3127 * in a permanent EOF state after draining). This can be desirable if the 3128 * cost of tearing down and replacing the encoder instance is high. 3129 */ 3130 void avcodec_flush_buffers(AVCodecContext *avctx); 3131 3132 /** 3133 * Return audio frame duration. 3134 * 3135 * @param avctx codec context 3136 * @param frame_bytes size of the frame, or 0 if unknown 3137 * @return frame duration, in samples, if known. 0 if not able to 3138 * determine. 3139 */ 3140 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes); 3141 3142 /* memory */ 3143 3144 /** 3145 * Same behaviour av_fast_malloc but the buffer has additional 3146 * AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0. 3147 * 3148 * In addition the whole buffer will initially and after resizes 3149 * be 0-initialized so that no uninitialized data will ever appear. 3150 */ 3151 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size); 3152 3153 /** 3154 * Same behaviour av_fast_padded_malloc except that buffer will always 3155 * be 0-initialized after call. 3156 */ 3157 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size); 3158 3159 /** 3160 * @return a positive value if s is open (i.e. avcodec_open2() was called on it 3161 * with no corresponding avcodec_close()), 0 otherwise. 3162 */ 3163 int avcodec_is_open(AVCodecContext *s); 3164 3165 /** 3166 * @} 3167 */ 3168 3169 #endif /* AVCODEC_AVCODEC_H */ 3170