FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
avcodec.h
Go to the documentation of this file.
1 /*
2  * copyright (c) 2001 Fabrice Bellard
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #ifndef AVCODEC_AVCODEC_H
22 #define AVCODEC_AVCODEC_H
23 
24 /**
25  * @file
26  * @ingroup libavc
27  * Libavcodec external API header
28  */
29 
30 #include <errno.h>
31 #include "libavutil/samplefmt.h"
32 #include "libavutil/attributes.h"
33 #include "libavutil/avutil.h"
34 #include "libavutil/buffer.h"
35 #include "libavutil/cpu.h"
37 #include "libavutil/dict.h"
38 #include "libavutil/frame.h"
39 #include "libavutil/log.h"
40 #include "libavutil/pixfmt.h"
41 #include "libavutil/rational.h"
42 
43 #include "version.h"
44 
45 #if FF_API_FAST_MALLOC
46 // to provide fast_*alloc
47 #include "libavutil/mem.h"
48 #endif
49 
50 /**
51  * @defgroup libavc Encoding/Decoding Library
52  * @{
53  *
54  * @defgroup lavc_decoding Decoding
55  * @{
56  * @}
57  *
58  * @defgroup lavc_encoding Encoding
59  * @{
60  * @}
61  *
62  * @defgroup lavc_codec Codecs
63  * @{
64  * @defgroup lavc_codec_native Native Codecs
65  * @{
66  * @}
67  * @defgroup lavc_codec_wrappers External library wrappers
68  * @{
69  * @}
70  * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge
71  * @{
72  * @}
73  * @}
74  * @defgroup lavc_internal Internal
75  * @{
76  * @}
77  * @}
78  *
79  */
80 
81 /**
82  * @defgroup lavc_core Core functions/structures.
83  * @ingroup libavc
84  *
85  * Basic definitions, functions for querying libavcodec capabilities,
86  * allocating core structures, etc.
87  * @{
88  */
89 
90 
91 /**
92  * Identify the syntax and semantics of the bitstream.
93  * The principle is roughly:
94  * Two decoders with the same ID can decode the same streams.
95  * Two encoders with the same ID can encode compatible streams.
96  * There may be slight deviations from the principle due to implementation
97  * details.
98  *
99  * If you add a codec ID to this list, add it so that
100  * 1. no value of a existing codec ID changes (that would break ABI),
101  * 2. Give it a value which when taken as ASCII is recognized uniquely by a human as this specific codec.
102  * This ensures that 2 forks can independently add AVCodecIDs without producing conflicts.
103  *
104  * After adding new codec IDs, do not forget to add an entry to the codec
105  * descriptor list and bump libavcodec minor version.
106  */
107 enum AVCodecID {
109 
110  /* video codecs */
112  AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
113 #if FF_API_XVMC
114  AV_CODEC_ID_MPEG2VIDEO_XVMC,
115 #endif /* FF_API_XVMC */
289 
290  AV_CODEC_ID_BRENDER_PIX= MKBETAG('B','P','I','X'),
291  AV_CODEC_ID_Y41P = MKBETAG('Y','4','1','P'),
292  AV_CODEC_ID_ESCAPE130 = MKBETAG('E','1','3','0'),
293  AV_CODEC_ID_EXR = MKBETAG('0','E','X','R'),
294  AV_CODEC_ID_AVRP = MKBETAG('A','V','R','P'),
295 
296  AV_CODEC_ID_012V = MKBETAG('0','1','2','V'),
297  AV_CODEC_ID_G2M = MKBETAG( 0 ,'G','2','M'),
298  AV_CODEC_ID_AVUI = MKBETAG('A','V','U','I'),
299  AV_CODEC_ID_AYUV = MKBETAG('A','Y','U','V'),
300  AV_CODEC_ID_TARGA_Y216 = MKBETAG('T','2','1','6'),
301  AV_CODEC_ID_V308 = MKBETAG('V','3','0','8'),
302  AV_CODEC_ID_V408 = MKBETAG('V','4','0','8'),
303  AV_CODEC_ID_YUV4 = MKBETAG('Y','U','V','4'),
304  AV_CODEC_ID_SANM = MKBETAG('S','A','N','M'),
305  AV_CODEC_ID_PAF_VIDEO = MKBETAG('P','A','F','V'),
306  AV_CODEC_ID_AVRN = MKBETAG('A','V','R','n'),
307  AV_CODEC_ID_CPIA = MKBETAG('C','P','I','A'),
308  AV_CODEC_ID_XFACE = MKBETAG('X','F','A','C'),
309  AV_CODEC_ID_SGIRLE = MKBETAG('S','G','I','R'),
310  AV_CODEC_ID_MVC1 = MKBETAG('M','V','C','1'),
311  AV_CODEC_ID_MVC2 = MKBETAG('M','V','C','2'),
312  AV_CODEC_ID_SNOW = MKBETAG('S','N','O','W'),
313  AV_CODEC_ID_WEBP = MKBETAG('W','E','B','P'),
314  AV_CODEC_ID_SMVJPEG = MKBETAG('S','M','V','J'),
315  AV_CODEC_ID_HEVC = MKBETAG('H','2','6','5'),
316 #define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
317 
318  /* various PCM "codecs" */
319  AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
353 
354  /* various ADPCM codecs */
385  AV_CODEC_ID_VIMA = MKBETAG('V','I','M','A'),
386  AV_CODEC_ID_ADPCM_AFC = MKBETAG('A','F','C',' '),
387  AV_CODEC_ID_ADPCM_IMA_OKI = MKBETAG('O','K','I',' '),
388  AV_CODEC_ID_ADPCM_DTK = MKBETAG('D','T','K',' '),
389  AV_CODEC_ID_ADPCM_IMA_RAD = MKBETAG('R','A','D',' '),
390  AV_CODEC_ID_ADPCM_G726LE = MKBETAG('6','2','7','G'),
391 
392  /* AMR */
395 
396  /* RealAudio codecs*/
399 
400  /* various DPCM codecs */
405 
406  /* audio codecs */
407  AV_CODEC_ID_MP2 = 0x15000,
408  AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
425  AV_CODEC_ID_GSM, ///< as in Berlin toast format
437  AV_CODEC_ID_GSM_MS, /* as found in WAV */
439 #if FF_API_VOXWARE
441 #endif
474  AV_CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
475  AV_CODEC_ID_SONIC = MKBETAG('S','O','N','C'),
476  AV_CODEC_ID_SONIC_LS = MKBETAG('S','O','N','L'),
477  AV_CODEC_ID_PAF_AUDIO = MKBETAG('P','A','F','A'),
478  AV_CODEC_ID_OPUS = MKBETAG('O','P','U','S'),
479  AV_CODEC_ID_TAK = MKBETAG('t','B','a','K'),
480  AV_CODEC_ID_EVRC = MKBETAG('s','e','v','c'),
481  AV_CODEC_ID_SMV = MKBETAG('s','s','m','v'),
482 
483  /* subtitle codecs */
484  AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs.
487  AV_CODEC_ID_TEXT, ///< raw UTF-8 text
494  AV_CODEC_ID_MICRODVD = MKBETAG('m','D','V','D'),
495  AV_CODEC_ID_EIA_608 = MKBETAG('c','6','0','8'),
496  AV_CODEC_ID_JACOSUB = MKBETAG('J','S','U','B'),
497  AV_CODEC_ID_SAMI = MKBETAG('S','A','M','I'),
498  AV_CODEC_ID_REALTEXT = MKBETAG('R','T','X','T'),
499  AV_CODEC_ID_SUBVIEWER1 = MKBETAG('S','b','V','1'),
500  AV_CODEC_ID_SUBVIEWER = MKBETAG('S','u','b','V'),
501  AV_CODEC_ID_SUBRIP = MKBETAG('S','R','i','p'),
502  AV_CODEC_ID_WEBVTT = MKBETAG('W','V','T','T'),
503  AV_CODEC_ID_MPL2 = MKBETAG('M','P','L','2'),
504  AV_CODEC_ID_VPLAYER = MKBETAG('V','P','l','r'),
505  AV_CODEC_ID_PJS = MKBETAG('P','h','J','S'),
506  AV_CODEC_ID_ASS = MKBETAG('A','S','S',' '), ///< ASS as defined in Matroska
507 
508  /* other specific kind of codecs (generally used for attachments) */
509  AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs.
510  AV_CODEC_ID_TTF = 0x18000,
511  AV_CODEC_ID_BINTEXT = MKBETAG('B','T','X','T'),
512  AV_CODEC_ID_XBIN = MKBETAG('X','B','I','N'),
513  AV_CODEC_ID_IDF = MKBETAG( 0 ,'I','D','F'),
514  AV_CODEC_ID_OTF = MKBETAG( 0 ,'O','T','F'),
515  AV_CODEC_ID_SMPTE_KLV = MKBETAG('K','L','V','A'),
516  AV_CODEC_ID_DVD_NAV = MKBETAG('D','N','A','V'),
517  AV_CODEC_ID_TIMED_ID3 = MKBETAG('T','I','D','3'),
518 
519 
520  AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
521 
522  AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
523  * stream (only used by libavformat) */
524  AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
525  * stream (only used by libavformat) */
526  AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information.
527 
528 #if FF_API_CODEC_ID
529 #include "old_codec_ids.h"
530 #endif
531 };
532 
533 /**
534  * This struct describes the properties of a single codec described by an
535  * AVCodecID.
536  * @see avcodec_get_descriptor()
537  */
538 typedef struct AVCodecDescriptor {
539  enum AVCodecID id;
541  /**
542  * Name of the codec described by this descriptor. It is non-empty and
543  * unique for each codec descriptor. It should contain alphanumeric
544  * characters and '_' only.
545  */
546  const char *name;
547  /**
548  * A more descriptive name for this codec. May be NULL.
549  */
550  const char *long_name;
551  /**
552  * Codec properties, a combination of AV_CODEC_PROP_* flags.
553  */
554  int props;
556 
557 /**
558  * Codec uses only intra compression.
559  * Video codecs only.
560  */
561 #define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
562 /**
563  * Codec supports lossy compression. Audio and video codecs only.
564  * @note a codec may support both lossy and lossless
565  * compression modes
566  */
567 #define AV_CODEC_PROP_LOSSY (1 << 1)
568 /**
569  * Codec supports lossless compression. Audio and video codecs only.
570  */
571 #define AV_CODEC_PROP_LOSSLESS (1 << 2)
572 /**
573  * Subtitle codec is bitmap based
574  * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
575  */
576 #define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
577 /**
578  * Subtitle codec is text based.
579  * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
580  */
581 #define AV_CODEC_PROP_TEXT_SUB (1 << 17)
582 
583 /**
584  * @ingroup lavc_decoding
585  * Required number of additionally allocated bytes at the end of the input bitstream for decoding.
586  * This is mainly needed because some optimized bitstream readers read
587  * 32 or 64 bit at once and could read over the end.<br>
588  * Note: If the first 23 bits of the additional bytes are not 0, then damaged
589  * MPEG bitstreams could cause overread and segfault.
590  */
591 #define FF_INPUT_BUFFER_PADDING_SIZE 16
592 
593 /**
594  * @ingroup lavc_encoding
595  * minimum encoding buffer size
596  * Used to avoid some checks during header writing.
597  */
598 #define FF_MIN_BUFFER_SIZE 16384
599 
600 
601 /**
602  * @ingroup lavc_encoding
603  * motion estimation type.
604  */
606  ME_ZERO = 1, ///< no search, that is use 0,0 vector whenever one is needed
610  ME_EPZS, ///< enhanced predictive zonal search
611  ME_X1, ///< reserved for experiments
612  ME_HEX, ///< hexagon based search
613  ME_UMH, ///< uneven multi-hexagon search
614  ME_TESA, ///< transformed exhaustive search algorithm
615  ME_ITER=50, ///< iterative search
616 };
617 
618 /**
619  * @ingroup lavc_decoding
620  */
622  /* We leave some space between them for extensions (drop some
623  * keyframes for intra-only or drop just some bidir frames). */
624  AVDISCARD_NONE =-16, ///< discard nothing
625  AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi
626  AVDISCARD_NONREF = 8, ///< discard all non reference
627  AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames
628  AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
629  AVDISCARD_ALL = 48, ///< discard all
630 };
631 
633  AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
636  AVCOL_PRI_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
637  AVCOL_PRI_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
638  AVCOL_PRI_SMPTE240M = 7, ///< functionally identical to above
640  AVCOL_PRI_BT2020 = 9, ///< ITU-R BT2020
641  AVCOL_PRI_NB , ///< Not part of ABI
642 };
643 
645  AVCOL_TRC_BT709 = 1, ///< also ITU-R BT1361
647  AVCOL_TRC_GAMMA22 = 4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
648  AVCOL_TRC_GAMMA28 = 5, ///< also ITU-R BT470BG
649  AVCOL_TRC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
651  AVCOL_TRC_LINEAR = 8, ///< "Linear transfer characteristics"
652  AVCOL_TRC_LOG = 9, ///< "Logarithmic transfer characteristic (100:1 range)"
653  AVCOL_TRC_LOG_SQRT = 10, ///< "Logarithmic transfer characteristic (100 * Sqrt( 10 ) : 1 range)"
654  AVCOL_TRC_IEC61966_2_4 = 11, ///< IEC 61966-2-4
655  AVCOL_TRC_BT1361_ECG = 12, ///< ITU-R BT1361 Extended Colour Gamut
656  AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC)
657  AVCOL_TRC_BT2020_10 = 14, ///< ITU-R BT2020 for 10 bit system
658  AVCOL_TRC_BT2020_12 = 15, ///< ITU-R BT2020 for 12 bit system
659  AVCOL_TRC_NB , ///< Not part of ABI
660 };
661 
662 /**
663  * X X 3 4 X X are luma samples,
664  * 1 2 1-6 are possible chroma positions
665  * X X 5 6 X 0 is undefined/unknown position
666  */
669  AVCHROMA_LOC_LEFT = 1, ///< mpeg2/4, h264 default
670  AVCHROMA_LOC_CENTER = 2, ///< mpeg1, jpeg, h263
671  AVCHROMA_LOC_TOPLEFT = 3, ///< DV
675  AVCHROMA_LOC_NB , ///< Not part of ABI
676 };
677 
688  AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI
689 };
690 
691 /**
692  * @ingroup lavc_encoding
693  */
694 typedef struct RcOverride{
697  int qscale; // If this is 0 then quality_factor will be used instead.
699 } RcOverride;
700 
701 #if FF_API_MAX_BFRAMES
702 /**
703  * @deprecated there is no libavcodec-wide limit on the number of B-frames
704  */
705 #define FF_MAX_B_FRAMES 16
706 #endif
707 
708 /* encoding support
709  These flags can be passed in AVCodecContext.flags before initialization.
710  Note: Not everything is supported yet.
711 */
712 
713 /**
714  * Allow decoders to produce frames with data planes that are not aligned
715  * to CPU requirements (e.g. due to cropping).
716  */
717 #define CODEC_FLAG_UNALIGNED 0x0001
718 #define CODEC_FLAG_QSCALE 0x0002 ///< Use fixed qscale.
719 #define CODEC_FLAG_4MV 0x0004 ///< 4 MV per MB allowed / advanced prediction for H.263.
720 #define CODEC_FLAG_OUTPUT_CORRUPT 0x0008 ///< Output even those frames that might be corrupted
721 #define CODEC_FLAG_QPEL 0x0010 ///< Use qpel MC.
722 #define CODEC_FLAG_GMC 0x0020 ///< Use GMC.
723 #define CODEC_FLAG_MV0 0x0040 ///< Always try a MB with MV=<0,0>.
724 /**
725  * The parent program guarantees that the input for B-frames containing
726  * streams is not written to for at least s->max_b_frames+1 frames, if
727  * this is not set the input will be copied.
728  */
729 #define CODEC_FLAG_INPUT_PRESERVED 0x0100
730 #define CODEC_FLAG_PASS1 0x0200 ///< Use internal 2pass ratecontrol in first pass mode.
731 #define CODEC_FLAG_PASS2 0x0400 ///< Use internal 2pass ratecontrol in second pass mode.
732 #define CODEC_FLAG_GRAY 0x2000 ///< Only decode/encode grayscale.
733 #if FF_API_EMU_EDGE
734 /**
735  * @deprecated edges are not used/required anymore. I.e. this flag is now always
736  * set.
737  */
738 #define CODEC_FLAG_EMU_EDGE 0x4000
739 #endif
740 #define CODEC_FLAG_PSNR 0x8000 ///< error[?] variables will be set during encoding.
741 #define CODEC_FLAG_TRUNCATED 0x00010000 /** Input bitstream might be truncated at a random
742  location instead of only at frame boundaries. */
743 #define CODEC_FLAG_NORMALIZE_AQP 0x00020000 ///< Normalize adaptive quantization.
744 #define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< Use interlaced DCT.
745 #define CODEC_FLAG_LOW_DELAY 0x00080000 ///< Force low delay.
746 #define CODEC_FLAG_GLOBAL_HEADER 0x00400000 ///< Place global headers in extradata instead of every keyframe.
747 #define CODEC_FLAG_BITEXACT 0x00800000 ///< Use only bitexact stuff (except (I)DCT).
748 /* Fx : Flag for h263+ extra options */
749 #define CODEC_FLAG_AC_PRED 0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction
750 #define CODEC_FLAG_LOOP_FILTER 0x00000800 ///< loop filter
751 #define CODEC_FLAG_INTERLACED_ME 0x20000000 ///< interlaced motion estimation
752 #define CODEC_FLAG_CLOSED_GOP 0x80000000
753 #define CODEC_FLAG2_FAST 0x00000001 ///< Allow non spec compliant speedup tricks.
754 #define CODEC_FLAG2_NO_OUTPUT 0x00000004 ///< Skip bitstream encoding.
755 #define CODEC_FLAG2_LOCAL_HEADER 0x00000008 ///< Place global headers at every keyframe instead of in extradata.
756 #define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!
757 #define CODEC_FLAG2_IGNORE_CROP 0x00010000 ///< Discard cropping information from SPS.
759 #define CODEC_FLAG2_CHUNKS 0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
760 #define CODEC_FLAG2_SHOW_ALL 0x00400000 ///< Show all frames before the first keyframe
761 
762 /* Unsupported options :
763  * Syntax Arithmetic coding (SAC)
764  * Reference Picture Selection
765  * Independent Segment Decoding */
766 /* /Fx */
767 /* codec capabilities */
769 #define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< Decoder can use draw_horiz_band callback.
770 /**
771  * Codec uses get_buffer() for allocating buffers and supports custom allocators.
772  * If not set, it might not use get_buffer() at all or use operations that
773  * assume the buffer was allocated by avcodec_default_get_buffer.
774  */
775 #define CODEC_CAP_DR1 0x0002
776 #define CODEC_CAP_TRUNCATED 0x0008
777 #if FF_API_XVMC
778 /* Codec can export data for HW decoding. This flag indicates that
779  * the codec would call get_format() with list that might contain HW accelerated
780  * pixel formats (XvMC, VDPAU, VAAPI, etc). The application can pick any of them
781  * including raw image format.
782  * The application can use the passed context to determine bitstream version,
783  * chroma format, resolution etc.
784  */
785 #define CODEC_CAP_HWACCEL 0x0010
786 #endif /* FF_API_XVMC */
787 /**
788  * Encoder or decoder requires flushing with NULL input at the end in order to
789  * give the complete and correct output.
790  *
791  * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
792  * with NULL data. The user can still send NULL data to the public encode
793  * or decode function, but libavcodec will not pass it along to the codec
794  * unless this flag is set.
795  *
796  * Decoders:
797  * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
798  * avpkt->size=0 at the end to get the delayed data until the decoder no longer
799  * returns frames.
800  *
801  * Encoders:
802  * The encoder needs to be fed with NULL data at the end of encoding until the
803  * encoder no longer returns data.
804  *
805  * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
806  * flag also means that the encoder must set the pts and duration for
807  * each output packet. If this flag is not set, the pts and duration will
808  * be determined by libavcodec from the input frame.
809  */
810 #define CODEC_CAP_DELAY 0x0020
811 /**
812  * Codec can be fed a final frame with a smaller size.
813  * This can be used to prevent truncation of the last audio samples.
814  */
815 #define CODEC_CAP_SMALL_LAST_FRAME 0x0040
816 #if FF_API_CAP_VDPAU
817 /**
818  * Codec can export data for HW decoding (VDPAU).
819  */
820 #define CODEC_CAP_HWACCEL_VDPAU 0x0080
821 #endif
822 /**
823  * Codec can output multiple frames per AVPacket
824  * Normally demuxers return one frame at a time, demuxers which do not do
825  * are connected to a parser to split what they return into proper frames.
826  * This flag is reserved to the very rare category of codecs which have a
827  * bitstream that cannot be split into frames without timeconsuming
828  * operations like full decoding. Demuxers carring such bitstreams thus
829  * may return multiple frames in a packet. This has many disadvantages like
830  * prohibiting stream copy in many cases thus it should only be considered
831  * as a last resort.
832  */
833 #define CODEC_CAP_SUBFRAMES 0x0100
834 /**
835  * Codec is experimental and is thus avoided in favor of non experimental
836  * encoders
837  */
838 #define CODEC_CAP_EXPERIMENTAL 0x0200
839 /**
840  * Codec should fill in channel configuration and samplerate instead of container
841  */
842 #define CODEC_CAP_CHANNEL_CONF 0x0400
843 #if FF_API_NEG_LINESIZES
844 /**
845  * @deprecated no codecs use this capability
846  */
847 #define CODEC_CAP_NEG_LINESIZES 0x0800
848 #endif
849 /**
850  * Codec supports frame-level multithreading.
851  */
852 #define CODEC_CAP_FRAME_THREADS 0x1000
853 /**
854  * Codec supports slice-based (or partition-based) multithreading.
855  */
856 #define CODEC_CAP_SLICE_THREADS 0x2000
857 /**
858  * Codec supports changed parameters at any point.
859  */
860 #define CODEC_CAP_PARAM_CHANGE 0x4000
861 /**
862  * Codec supports avctx->thread_count == 0 (auto).
863  */
864 #define CODEC_CAP_AUTO_THREADS 0x8000
865 /**
866  * Audio encoder supports receiving a different number of samples in each call.
867  */
868 #define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
869 /**
870  * Codec is intra only.
871  */
872 #define CODEC_CAP_INTRA_ONLY 0x40000000
873 /**
874  * Codec is lossless.
875  */
876 #define CODEC_CAP_LOSSLESS 0x80000000
877 
878 #if FF_API_MB_TYPE
879 //The following defines may change, don't expect compatibility if you use them.
880 #define MB_TYPE_INTRA4x4 0x0001
881 #define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific
882 #define MB_TYPE_INTRA_PCM 0x0004 //FIXME H.264-specific
883 #define MB_TYPE_16x16 0x0008
884 #define MB_TYPE_16x8 0x0010
885 #define MB_TYPE_8x16 0x0020
886 #define MB_TYPE_8x8 0x0040
887 #define MB_TYPE_INTERLACED 0x0080
888 #define MB_TYPE_DIRECT2 0x0100 //FIXME
889 #define MB_TYPE_ACPRED 0x0200
890 #define MB_TYPE_GMC 0x0400
891 #define MB_TYPE_SKIP 0x0800
892 #define MB_TYPE_P0L0 0x1000
893 #define MB_TYPE_P1L0 0x2000
894 #define MB_TYPE_P0L1 0x4000
895 #define MB_TYPE_P1L1 0x8000
896 #define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0)
897 #define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1)
898 #define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1)
899 #define MB_TYPE_QUANT 0x00010000
900 #define MB_TYPE_CBP 0x00020000
901 //Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...)
902 #endif
903 
904 /**
905  * Pan Scan area.
906  * This specifies the area which should be displayed.
907  * Note there may be multiple such areas for one frame.
908  */
909 typedef struct AVPanScan{
910  /**
911  * id
912  * - encoding: Set by user.
913  * - decoding: Set by libavcodec.
914  */
915  int id;
916 
917  /**
918  * width and height in 1/16 pel
919  * - encoding: Set by user.
920  * - decoding: Set by libavcodec.
921  */
922  int width;
923  int height;
924 
925  /**
926  * position of the top left corner in 1/16 pel for up to 3 fields/frames
927  * - encoding: Set by user.
928  * - decoding: Set by libavcodec.
929  */
930  int16_t position[3][2];
931 }AVPanScan;
932 
933 #if FF_API_QSCALE_TYPE
934 #define FF_QSCALE_TYPE_MPEG1 0
935 #define FF_QSCALE_TYPE_MPEG2 1
936 #define FF_QSCALE_TYPE_H264 2
937 #define FF_QSCALE_TYPE_VP56 3
938 #endif
939 
940 #if FF_API_GET_BUFFER
941 #define FF_BUFFER_TYPE_INTERNAL 1
942 #define FF_BUFFER_TYPE_USER 2 ///< direct rendering buffers (image is (de)allocated by user)
943 #define FF_BUFFER_TYPE_SHARED 4 ///< Buffer from somewhere else; don't deallocate image (data/base), all other tables are not shared.
944 #define FF_BUFFER_TYPE_COPY 8 ///< Just a (modified) copy of some other buffer, don't deallocate anything.
946 #define FF_BUFFER_HINTS_VALID 0x01 // Buffer hints value is meaningful (if 0 ignore).
947 #define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer.
948 #define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content.
949 #define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update).
950 #endif
951 
952 /**
953  * The decoder will keep a reference to the frame and may reuse it later.
954  */
955 #define AV_GET_BUFFER_FLAG_REF (1 << 0)
956 
957 /**
958  * @defgroup lavc_packet AVPacket
959  *
960  * Types and functions for working with AVPacket.
961  * @{
962  */
966 
967  /**
968  * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
969  * @code
970  * u32le param_flags
971  * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
972  * s32le channel_count
973  * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
974  * u64le channel_layout
975  * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
976  * s32le sample_rate
977  * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
978  * s32le width
979  * s32le height
980  * @endcode
981  */
983 
984  /**
985  * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
986  * structures with info about macroblocks relevant to splitting the
987  * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
988  * That is, it does not necessarily contain info about all macroblocks,
989  * as long as the distance between macroblocks in the info is smaller
990  * than the target payload size.
991  * Each MB info structure is 12 bytes, and is laid out as follows:
992  * @code
993  * u32le bit offset from the start of the packet
994  * u8 current quantizer at the start of the macroblock
995  * u8 GOB number
996  * u16le macroblock address within the GOB
997  * u8 horizontal MV predictor
998  * u8 vertical MV predictor
999  * u8 horizontal MV predictor for block number 3
1000  * u8 vertical MV predictor for block number 3
1001  * @endcode
1002  */
1004 
1005  /**
1006  * Recommmends skipping the specified number of samples
1007  * @code
1008  * u32le number of samples to skip from start of this packet
1009  * u32le number of samples to skip from end of this packet
1010  * u8 reason for start skip
1011  * u8 reason for end skip (0=padding silence, 1=convergence)
1012  * @endcode
1013  */
1015 
1016  /**
1017  * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
1018  * the packet may contain "dual mono" audio specific to Japanese DTV
1019  * and if it is true, recommends only the selected channel to be used.
1020  * @code
1021  * u8 selected channels (0=mail/left, 1=sub/right, 2=both)
1022  * @endcode
1023  */
1025 
1026  /**
1027  * A list of zero terminated key/value strings. There is no end marker for
1028  * the list, so it is required to rely on the side data size to stop.
1029  */
1031 
1032  /**
1033  * Subtitle event position
1034  * @code
1035  * u32le x1
1036  * u32le y1
1037  * u32le x2
1038  * u32le y2
1039  * @endcode
1040  */
1042 
1043  /**
1044  * Data found in BlockAdditional element of matroska container. There is
1045  * no end marker for the data, so it is required to rely on the side data
1046  * size to recognize the end. 8 byte id (as found in BlockAddId) followed
1047  * by data.
1048  */
1050 
1051  /**
1052  * The optional first identifier line of a WebVTT cue.
1053  */
1055 
1056  /**
1057  * The optional settings (rendering instructions) that immediately
1058  * follow the timestamp specifier of a WebVTT cue.
1059  */
1061 
1062  /**
1063  * A list of zero terminated key/value strings. There is no end marker for
1064  * the list, so it is required to rely on the side data size to stop. This
1065  * side data includes updated metadata which appeared in the stream.
1066  */
1068 };
1069 
1070 /**
1071  * This structure stores compressed data. It is typically exported by demuxers
1072  * and then passed as input to decoders, or received as output from encoders and
1073  * then passed to muxers.
1074  *
1075  * For video, it should typically contain one compressed frame. For audio it may
1076  * contain several compressed frames.
1077  *
1078  * AVPacket is one of the few structs in FFmpeg, whose size is a part of public
1079  * ABI. Thus it may be allocated on stack and no new fields can be added to it
1080  * without libavcodec and libavformat major bump.
1081  *
1082  * The semantics of data ownership depends on the buf or destruct (deprecated)
1083  * fields. If either is set, the packet data is dynamically allocated and is
1084  * valid indefinitely until av_free_packet() is called (which in turn calls
1085  * av_buffer_unref()/the destruct callback to free the data). If neither is set,
1086  * the packet data is typically backed by some static buffer somewhere and is
1087  * only valid for a limited time (e.g. until the next read call when demuxing).
1088  *
1089  * The side data is always allocated with av_malloc() and is freed in
1090  * av_free_packet().
1091  */
1092 typedef struct AVPacket {
1093  /**
1094  * A reference to the reference-counted buffer where the packet data is
1095  * stored.
1096  * May be NULL, then the packet data is not reference-counted.
1097  */
1098  AVBufferRef *buf;
1099  /**
1100  * Presentation timestamp in AVStream->time_base units; the time at which
1101  * the decompressed packet will be presented to the user.
1102  * Can be AV_NOPTS_VALUE if it is not stored in the file.
1103  * pts MUST be larger or equal to dts as presentation cannot happen before
1104  * decompression, unless one wants to view hex dumps. Some formats misuse
1105  * the terms dts and pts/cts to mean something different. Such timestamps
1106  * must be converted to true pts/dts before they are stored in AVPacket.
1107  */
1108  int64_t pts;
1109  /**
1110  * Decompression timestamp in AVStream->time_base units; the time at which
1111  * the packet is decompressed.
1112  * Can be AV_NOPTS_VALUE if it is not stored in the file.
1113  */
1114  int64_t dts;
1116  int size;
1117  int stream_index;
1118  /**
1119  * A combination of AV_PKT_FLAG values
1120  */
1121  int flags;
1122  /**
1123  * Additional packet data that can be provided by the container.
1124  * Packet can contain several types of side information.
1125  */
1126  struct {
1127  uint8_t *data;
1128  int size;
1131  int side_data_elems;
1132 
1133  /**
1134  * Duration of this packet in AVStream->time_base units, 0 if unknown.
1135  * Equals next_pts - this_pts in presentation order.
1136  */
1137  int duration;
1138 #if FF_API_DESTRUCT_PACKET
1140  void (*destruct)(struct AVPacket *);
1142  void *priv;
1143 #endif
1144  int64_t pos; ///< byte position in stream, -1 if unknown
1145 
1146  /**
1147  * Time difference in AVStream->time_base units from the pts of this
1148  * packet to the point at which the output from the decoder has converged
1149  * independent from the availability of previous frames. That is, the
1150  * frames are virtually identical no matter if decoding started from
1151  * the very first frame or from this keyframe.
1152  * Is AV_NOPTS_VALUE if unknown.
1153  * This field is not the display duration of the current packet.
1154  * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY
1155  * set.
1156  *
1157  * The purpose of this field is to allow seeking in streams that have no
1158  * keyframes in the conventional sense. It corresponds to the
1159  * recovery point SEI in H.264 and match_time_delta in NUT. It is also
1160  * essential for some types of subtitle streams to ensure that all
1161  * subtitles are correctly displayed after seeking.
1162  */
1163  int64_t convergence_duration;
1165 #define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe
1166 #define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
1173 };
1174 /**
1175  * @}
1176  */
1177 
1178 struct AVCodecInternal;
1183  AV_FIELD_TT, //< Top coded_first, top displayed first
1184  AV_FIELD_BB, //< Bottom coded first, bottom displayed first
1185  AV_FIELD_TB, //< Top coded first, bottom displayed first
1186  AV_FIELD_BT, //< Bottom coded first, top displayed first
1187 };
1188 
1189 /**
1190  * main external API structure.
1191  * New fields can be added to the end with minor version bumps.
1192  * Removal, reordering and changes to existing fields require a major
1193  * version bump.
1194  * Please use AVOptions (av_opt* / av_set/get*()) to access these fields from user
1195  * applications.
1196  * sizeof(AVCodecContext) must not be used outside libav*.
1197  */
1198 typedef struct AVCodecContext {
1199  /**
1200  * information on struct for av_log
1201  * - set by avcodec_alloc_context3
1202  */
1204  int log_level_offset;
1206  enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
1207  const struct AVCodec *codec;
1208  char codec_name[32];
1209  enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */
1210 
1211  /**
1212  * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
1213  * This is used to work around some encoder bugs.
1214  * A demuxer should set this to what is stored in the field used to identify the codec.
1215  * If there are multiple such fields in a container then the demuxer should choose the one
1216  * which maximizes the information about the used codec.
1217  * If the codec tag field in a container is larger than 32 bits then the demuxer should
1218  * remap the longer ID to 32 bits with a table or other structure. Alternatively a new
1219  * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated
1220  * first.
1221  * - encoding: Set by user, if not then the default based on codec_id will be used.
1222  * - decoding: Set by user, will be converted to uppercase by libavcodec during init.
1223  */
1224  unsigned int codec_tag;
1225 
1226  /**
1227  * fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
1228  * This is used to work around some encoder bugs.
1229  * - encoding: unused
1230  * - decoding: Set by user, will be converted to uppercase by libavcodec during init.
1231  */
1232  unsigned int stream_codec_tag;
1234  void *priv_data;
1235 
1236  /**
1237  * Private context used for internal data.
1238  *
1239  * Unlike priv_data, this is not codec-specific. It is used in general
1240  * libavcodec functions.
1241  */
1242  struct AVCodecInternal *internal;
1243 
1244  /**
1245  * Private data of the user, can be used to carry app specific stuff.
1246  * - encoding: Set by user.
1247  * - decoding: Set by user.
1248  */
1249  void *opaque;
1250 
1251  /**
1252  * the average bitrate
1253  * - encoding: Set by user; unused for constant quantizer encoding.
1254  * - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream.
1255  */
1256  int bit_rate;
1257 
1258  /**
1259  * number of bits the bitstream is allowed to diverge from the reference.
1260  * the reference can be CBR (for CBR pass1) or VBR (for pass2)
1261  * - encoding: Set by user; unused for constant quantizer encoding.
1262  * - decoding: unused
1263  */
1264  int bit_rate_tolerance;
1265 
1266  /**
1267  * Global quality for codecs which cannot change it per frame.
1268  * This should be proportional to MPEG-1/2/4 qscale.
1269  * - encoding: Set by user.
1270  * - decoding: unused
1271  */
1272  int global_quality;
1273 
1274  /**
1275  * - encoding: Set by user.
1276  * - decoding: unused
1277  */
1279 #define FF_COMPRESSION_DEFAULT -1
1280 
1281  /**
1282  * CODEC_FLAG_*.
1283  * - encoding: Set by user.
1284  * - decoding: Set by user.
1285  */
1286  int flags;
1287 
1288  /**
1289  * CODEC_FLAG2_*
1290  * - encoding: Set by user.
1291  * - decoding: Set by user.
1292  */
1293  int flags2;
1294 
1295  /**
1296  * some codecs need / can use extradata like Huffman tables.
1297  * mjpeg: Huffman tables
1298  * rv10: additional flags
1299  * mpeg4: global headers (they can be in the bitstream or here)
1300  * The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger
1301  * than extradata_size to avoid problems if it is read with the bitstream reader.
1302  * The bytewise contents of extradata must not depend on the architecture or CPU endianness.
1303  * - encoding: Set/allocated/freed by libavcodec.
1304  * - decoding: Set/allocated/freed by user.
1305  */
1307  int extradata_size;
1308 
1309  /**
1310  * This is the fundamental unit of time (in seconds) in terms
1311  * of which frame timestamps are represented. For fixed-fps content,
1312  * timebase should be 1/framerate and timestamp increments should be
1313  * identically 1.
1314  * - encoding: MUST be set by user.
1315  * - decoding: Set by libavcodec.
1316  */
1318 
1319  /**
1320  * For some codecs, the time base is closer to the field rate than the frame rate.
1321  * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration
1322  * if no telecine is used ...
1323  *
1324  * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.
1325  */
1326  int ticks_per_frame;
1327 
1328  /**
1329  * Codec delay.
1330  *
1331  * Encoding: Number of frames delay there will be from the encoder input to
1332  * the decoder output. (we assume the decoder matches the spec)
1333  * Decoding: Number of frames delay in addition to what a standard decoder
1334  * as specified in the spec would produce.
1335  *
1336  * Video:
1337  * Number of frames the decoded output will be delayed relative to the
1338  * encoded input.
1339  *
1340  * Audio:
1341  * For encoding, this is the number of "priming" samples added to the
1342  * beginning of the stream. The decoded output will be delayed by this
1343  * many samples relative to the input to the encoder. Note that this
1344  * field is purely informational and does not directly affect the pts
1345  * output by the encoder, which should always be based on the actual
1346  * presentation time, including any delay.
1347  * For decoding, this is the number of samples the decoder needs to
1348  * output before the decoder's output is valid. When seeking, you should
1349  * start decoding this many samples prior to your desired seek point.
1350  *
1351  * - encoding: Set by libavcodec.
1352  * - decoding: Set by libavcodec.
1353  */
1354  int delay;
1355 
1356 
1357  /* video only */
1358  /**
1359  * picture width / height.
1360  * - encoding: MUST be set by user.
1361  * - decoding: May be set by the user before opening the decoder if known e.g.
1362  * from the container. Some decoders will require the dimensions
1363  * to be set by the caller. During decoding, the decoder may
1364  * overwrite those values as required.
1365  */
1366  int width, height;
1367 
1368  /**
1369  * Bitstream width / height, may be different from width/height e.g. when
1370  * the decoded frame is cropped before being output or lowres is enabled.
1371  * - encoding: unused
1372  * - decoding: May be set by the user before opening the decoder if known
1373  * e.g. from the container. During decoding, the decoder may
1374  * overwrite those values as required.
1375  */
1377 
1378 #if FF_API_ASPECT_EXTENDED
1379 #define FF_ASPECT_EXTENDED 15
1380 #endif
1381 
1382  /**
1383  * the number of pictures in a group of pictures, or 0 for intra_only
1384  * - encoding: Set by user.
1385  * - decoding: unused
1386  */
1387  int gop_size;
1388 
1389  /**
1390  * Pixel format, see AV_PIX_FMT_xxx.
1391  * May be set by the demuxer if known from headers.
1392  * May be overridden by the decoder if it knows better.
1393  * - encoding: Set by user.
1394  * - decoding: Set by user if known, overridden by libavcodec if known
1395  */
1396  enum AVPixelFormat pix_fmt;
1397 
1398  /**
1399  * Motion estimation algorithm used for video coding.
1400  * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex),
1401  * 8 (umh), 9 (iter), 10 (tesa) [7, 8, 10 are x264 specific, 9 is snow specific]
1402  * - encoding: MUST be set by user.
1403  * - decoding: unused
1404  */
1405  int me_method;
1406 
1407  /**
1408  * If non NULL, 'draw_horiz_band' is called by the libavcodec
1409  * decoder to draw a horizontal band. It improves cache usage. Not
1410  * all codecs can do that. You must check the codec capabilities
1411  * beforehand.
1412  * When multithreading is used, it may be called from multiple threads
1413  * at the same time; threads might draw different parts of the same AVFrame,
1414  * or multiple AVFrames, and there is no guarantee that slices will be drawn
1415  * in order.
1416  * The function is also used by hardware acceleration APIs.
1417  * It is called at least once during frame decoding to pass
1418  * the data needed for hardware render.
1419  * In that mode instead of pixel data, AVFrame points to
1420  * a structure specific to the acceleration API. The application
1421  * reads the structure and can change some fields to indicate progress
1422  * or mark state.
1423  * - encoding: unused
1424  * - decoding: Set by user.
1425  * @param height the height of the slice
1426  * @param y the y position of the slice
1427  * @param type 1->top field, 2->bottom field, 3->frame
1428  * @param offset offset into the AVFrame.data from which the slice should be read
1429  */
1430  void (*draw_horiz_band)(struct AVCodecContext *s,
1431  const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
1432  int y, int type, int height);
1433 
1434  /**
1435  * callback to negotiate the pixelFormat
1436  * @param fmt is the list of formats which are supported by the codec,
1437  * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality.
1438  * The first is always the native one.
1439  * @return the chosen format
1440  * - encoding: unused
1441  * - decoding: Set by user, if not set the native format will be chosen.
1442  */
1443  enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
1444 
1445  /**
1446  * maximum number of B-frames between non-B-frames
1447  * Note: The output will be delayed by max_b_frames+1 relative to the input.
1448  * - encoding: Set by user.
1449  * - decoding: unused
1450  */
1451  int max_b_frames;
1452 
1453  /**
1454  * qscale factor between IP and B-frames
1455  * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset).
1456  * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
1457  * - encoding: Set by user.
1458  * - decoding: unused
1459  */
1460  float b_quant_factor;
1461 
1462  /** obsolete FIXME remove */
1464 #define FF_RC_STRATEGY_XVID 1
1466  int b_frame_strategy;
1467 
1468  /**
1469  * qscale offset between IP and B-frames
1470  * - encoding: Set by user.
1471  * - decoding: unused
1472  */
1473  float b_quant_offset;
1474 
1475  /**
1476  * Size of the frame reordering buffer in the decoder.
1477  * For MPEG-2 it is 1 IPB or 0 low delay IP.
1478  * - encoding: Set by libavcodec.
1479  * - decoding: Set by libavcodec.
1480  */
1481  int has_b_frames;
1482 
1483  /**
1484  * 0-> h263 quant 1-> mpeg quant
1485  * - encoding: Set by user.
1486  * - decoding: unused
1487  */
1488  int mpeg_quant;
1489 
1490  /**
1491  * qscale factor between P and I-frames
1492  * If > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset).
1493  * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
1494  * - encoding: Set by user.
1495  * - decoding: unused
1496  */
1497  float i_quant_factor;
1498 
1499  /**
1500  * qscale offset between P and I-frames
1501  * - encoding: Set by user.
1502  * - decoding: unused
1503  */
1504  float i_quant_offset;
1505 
1506  /**
1507  * luminance masking (0-> disabled)
1508  * - encoding: Set by user.
1509  * - decoding: unused
1510  */
1511  float lumi_masking;
1512 
1513  /**
1514  * temporary complexity masking (0-> disabled)
1515  * - encoding: Set by user.
1516  * - decoding: unused
1517  */
1518  float temporal_cplx_masking;
1519 
1520  /**
1521  * spatial complexity masking (0-> disabled)
1522  * - encoding: Set by user.
1523  * - decoding: unused
1524  */
1525  float spatial_cplx_masking;
1526 
1527  /**
1528  * p block masking (0-> disabled)
1529  * - encoding: Set by user.
1530  * - decoding: unused
1531  */
1532  float p_masking;
1533 
1534  /**
1535  * darkness masking (0-> disabled)
1536  * - encoding: Set by user.
1537  * - decoding: unused
1538  */
1539  float dark_masking;
1540 
1541  /**
1542  * slice count
1543  * - encoding: Set by libavcodec.
1544  * - decoding: Set by user (or 0).
1545  */
1546  int slice_count;
1547  /**
1548  * prediction method (needed for huffyuv)
1549  * - encoding: Set by user.
1550  * - decoding: unused
1551  */
1553 #define FF_PRED_LEFT 0
1554 #define FF_PRED_PLANE 1
1555 #define FF_PRED_MEDIAN 2
1556 
1557  /**
1558  * slice offsets in the frame in bytes
1559  * - encoding: Set/allocated by libavcodec.
1560  * - decoding: Set/allocated by user (or NULL).
1561  */
1562  int *slice_offset;
1563 
1564  /**
1565  * sample aspect ratio (0 if unknown)
1566  * That is the width of a pixel divided by the height of the pixel.
1567  * Numerator and denominator must be relatively prime and smaller than 256 for some video standards.
1568  * - encoding: Set by user.
1569  * - decoding: Set by libavcodec.
1570  */
1572 
1573  /**
1574  * motion estimation comparison function
1575  * - encoding: Set by user.
1576  * - decoding: unused
1577  */
1578  int me_cmp;
1579  /**
1580  * subpixel motion estimation comparison function
1581  * - encoding: Set by user.
1582  * - decoding: unused
1583  */
1584  int me_sub_cmp;
1585  /**
1586  * macroblock comparison function (not supported yet)
1587  * - encoding: Set by user.
1588  * - decoding: unused
1589  */
1590  int mb_cmp;
1591  /**
1592  * interlaced DCT comparison function
1593  * - encoding: Set by user.
1594  * - decoding: unused
1595  */
1597 #define FF_CMP_SAD 0
1598 #define FF_CMP_SSE 1
1599 #define FF_CMP_SATD 2
1600 #define FF_CMP_DCT 3
1601 #define FF_CMP_PSNR 4
1602 #define FF_CMP_BIT 5
1603 #define FF_CMP_RD 6
1604 #define FF_CMP_ZERO 7
1605 #define FF_CMP_VSAD 8
1606 #define FF_CMP_VSSE 9
1607 #define FF_CMP_NSSE 10
1608 #define FF_CMP_W53 11
1609 #define FF_CMP_W97 12
1610 #define FF_CMP_DCTMAX 13
1611 #define FF_CMP_DCT264 14
1612 #define FF_CMP_CHROMA 256
1613 
1614  /**
1615  * ME diamond size & shape
1616  * - encoding: Set by user.
1617  * - decoding: unused
1618  */
1619  int dia_size;
1620 
1621  /**
1622  * amount of previous MV predictors (2a+1 x 2a+1 square)
1623  * - encoding: Set by user.
1624  * - decoding: unused
1625  */
1627 
1628  /**
1629  * prepass for motion estimation
1630  * - encoding: Set by user.
1631  * - decoding: unused
1632  */
1633  int pre_me;
1634 
1635  /**
1636  * motion estimation prepass comparison function
1637  * - encoding: Set by user.
1638  * - decoding: unused
1639  */
1640  int me_pre_cmp;
1641 
1642  /**
1643  * ME prepass diamond size & shape
1644  * - encoding: Set by user.
1645  * - decoding: unused
1646  */
1647  int pre_dia_size;
1648 
1649  /**
1650  * subpel ME quality
1651  * - encoding: Set by user.
1652  * - decoding: unused
1653  */
1654  int me_subpel_quality;
1655 
1656  /**
1657  * DTG active format information (additional aspect ratio
1658  * information only used in DVB MPEG-2 transport streams)
1659  * 0 if not set.
1660  *
1661  * - encoding: unused
1662  * - decoding: Set by decoder.
1663  */
1665 #define FF_DTG_AFD_SAME 8
1666 #define FF_DTG_AFD_4_3 9
1667 #define FF_DTG_AFD_16_9 10
1668 #define FF_DTG_AFD_14_9 11
1669 #define FF_DTG_AFD_4_3_SP_14_9 13
1670 #define FF_DTG_AFD_16_9_SP_14_9 14
1671 #define FF_DTG_AFD_SP_4_3 15
1672 
1673  /**
1674  * maximum motion estimation search range in subpel units
1675  * If 0 then no limit.
1676  *
1677  * - encoding: Set by user.
1678  * - decoding: unused
1679  */
1680  int me_range;
1681 
1682  /**
1683  * intra quantizer bias
1684  * - encoding: Set by user.
1685  * - decoding: unused
1686  */
1688 #define FF_DEFAULT_QUANT_BIAS 999999
1689 
1690  /**
1691  * inter quantizer bias
1692  * - encoding: Set by user.
1693  * - decoding: unused
1694  */
1695  int inter_quant_bias;
1696 
1697  /**
1698  * slice flags
1699  * - encoding: unused
1700  * - decoding: Set by user.
1701  */
1703 #define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display
1704 #define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG2 field pics)
1705 #define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1)
1706 
1707 #if FF_API_XVMC
1708  /**
1709  * XVideo Motion Acceleration
1710  * - encoding: forbidden
1711  * - decoding: set by decoder
1712  * @deprecated XvMC doesn't need it anymore.
1713  */
1715 #endif /* FF_API_XVMC */
1716 
1717  /**
1718  * macroblock decision mode
1719  * - encoding: Set by user.
1720  * - decoding: unused
1721  */
1723 #define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp
1724 #define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits
1725 #define FF_MB_DECISION_RD 2 ///< rate distortion
1727  /**
1728  * custom intra quantization matrix
1729  * - encoding: Set by user, can be NULL.
1730  * - decoding: Set by libavcodec.
1731  */
1732  uint16_t *intra_matrix;
1734  /**
1735  * custom inter quantization matrix
1736  * - encoding: Set by user, can be NULL.
1737  * - decoding: Set by libavcodec.
1738  */
1739  uint16_t *inter_matrix;
1741  /**
1742  * scene change detection threshold
1743  * 0 is default, larger means fewer detected scene changes.
1744  * - encoding: Set by user.
1745  * - decoding: unused
1746  */
1748 
1749  /**
1750  * noise reduction strength
1751  * - encoding: Set by user.
1752  * - decoding: unused
1753  */
1754  int noise_reduction;
1755 
1756  /**
1757  * Motion estimation threshold below which no motion estimation is
1758  * performed, but instead the user specified motion vectors are used.
1759  *
1760  * - encoding: Set by user.
1761  * - decoding: unused
1762  */
1763  int me_threshold;
1764 
1765  /**
1766  * Macroblock threshold below which the user specified macroblock types will be used.
1767  * - encoding: Set by user.
1768  * - decoding: unused
1769  */
1770  int mb_threshold;
1771 
1772  /**
1773  * precision of the intra DC coefficient - 8
1774  * - encoding: Set by user.
1775  * - decoding: unused
1776  */
1777  int intra_dc_precision;
1778 
1779  /**
1780  * Number of macroblock rows at the top which are skipped.
1781  * - encoding: unused
1782  * - decoding: Set by user.
1783  */
1784  int skip_top;
1785 
1786  /**
1787  * Number of macroblock rows at the bottom which are skipped.
1788  * - encoding: unused
1789  * - decoding: Set by user.
1790  */
1791  int skip_bottom;
1792 
1793  /**
1794  * Border processing masking, raises the quantizer for mbs on the borders
1795  * of the picture.
1796  * - encoding: Set by user.
1797  * - decoding: unused
1798  */
1799  float border_masking;
1800 
1801  /**
1802  * minimum MB lagrange multipler
1803  * - encoding: Set by user.
1804  * - decoding: unused
1805  */
1806  int mb_lmin;
1807 
1808  /**
1809  * maximum MB lagrange multipler
1810  * - encoding: Set by user.
1811  * - decoding: unused
1812  */
1813  int mb_lmax;
1814 
1815  /**
1816  *
1817  * - encoding: Set by user.
1818  * - decoding: unused
1819  */
1821 
1822  /**
1823  *
1824  * - encoding: Set by user.
1825  * - decoding: unused
1826  */
1827  int bidir_refine;
1828 
1829  /**
1830  *
1831  * - encoding: Set by user.
1832  * - decoding: unused
1833  */
1834  int brd_scale;
1835 
1836  /**
1837  * minimum GOP size
1838  * - encoding: Set by user.
1839  * - decoding: unused
1840  */
1841  int keyint_min;
1842 
1843  /**
1844  * number of reference frames
1845  * - encoding: Set by user.
1846  * - decoding: Set by lavc.
1847  */
1848  int refs;
1849 
1850  /**
1851  * chroma qp offset from luma
1852  * - encoding: Set by user.
1853  * - decoding: unused
1854  */
1855  int chromaoffset;
1856 
1857  /**
1858  * Multiplied by qscale for each frame and added to scene_change_score.
1859  * - encoding: Set by user.
1860  * - decoding: unused
1861  */
1862  int scenechange_factor;
1863 
1864  /**
1865  *
1866  * Note: Value depends upon the compare function used for fullpel ME.
1867  * - encoding: Set by user.
1868  * - decoding: unused
1869  */
1870  int mv0_threshold;
1871 
1872  /**
1873  * Adjust sensitivity of b_frame_strategy 1.
1874  * - encoding: Set by user.
1875  * - decoding: unused
1876  */
1877  int b_sensitivity;
1878 
1879  /**
1880  * Chromaticity coordinates of the source primaries.
1881  * - encoding: Set by user
1882  * - decoding: Set by libavcodec
1883  */
1885 
1886  /**
1887  * Color Transfer Characteristic.
1888  * - encoding: Set by user
1889  * - decoding: Set by libavcodec
1890  */
1892 
1893  /**
1894  * YUV colorspace type.
1895  * - encoding: Set by user
1896  * - decoding: Set by libavcodec
1897  */
1898  enum AVColorSpace colorspace;
1899 
1900  /**
1901  * MPEG vs JPEG YUV range.
1902  * - encoding: Set by user
1903  * - decoding: Set by libavcodec
1904  */
1906 
1907  /**
1908  * This defines the location of chroma samples.
1909  * - encoding: Set by user
1910  * - decoding: Set by libavcodec
1911  */
1913 
1914  /**
1915  * Number of slices.
1916  * Indicates number of picture subdivisions. Used for parallelized
1917  * decoding.
1918  * - encoding: Set by user
1919  * - decoding: unused
1920  */
1921  int slices;
1922 
1923  /** Field order
1924  * - encoding: set by libavcodec
1925  * - decoding: Set by user.
1926  */
1928 
1929  /* audio only */
1930  int sample_rate; ///< samples per second
1931  int channels; ///< number of audio channels
1932 
1933  /**
1934  * audio sample format
1935  * - encoding: Set by user.
1936  * - decoding: Set by libavcodec.
1937  */
1938  enum AVSampleFormat sample_fmt; ///< sample format
1939 
1940  /* The following data should not be initialized. */
1941  /**
1942  * Number of samples per channel in an audio frame.
1943  *
1944  * - encoding: set by libavcodec in avcodec_open2(). Each submitted frame
1945  * except the last must contain exactly frame_size samples per channel.
1946  * May be 0 when the codec has CODEC_CAP_VARIABLE_FRAME_SIZE set, then the
1947  * frame size is not restricted.
1948  * - decoding: may be set by some decoders to indicate constant frame size
1949  */
1950  int frame_size;
1951 
1952  /**
1953  * Frame counter, set by libavcodec.
1954  *
1955  * - decoding: total number of frames returned from the decoder so far.
1956  * - encoding: total number of frames passed to the encoder so far.
1957  *
1958  * @note the counter is not incremented if encoding/decoding resulted in
1959  * an error.
1960  */
1961  int frame_number;
1962 
1963  /**
1964  * number of bytes per packet if constant and known or 0
1965  * Used by some WAV based audio codecs.
1966  */
1967  int block_align;
1968 
1969  /**
1970  * Audio cutoff bandwidth (0 means "automatic")
1971  * - encoding: Set by user.
1972  * - decoding: unused
1973  */
1974  int cutoff;
1975 
1976 #if FF_API_REQUEST_CHANNELS
1977  /**
1978  * Decoder should decode to this many channels if it can (0 for default)
1979  * - encoding: unused
1980  * - decoding: Set by user.
1981  * @deprecated Deprecated in favor of request_channel_layout.
1982  */
1984 #endif
1985 
1986  /**
1987  * Audio channel layout.
1988  * - encoding: set by user.
1989  * - decoding: set by user, may be overwritten by libavcodec.
1990  */
1991  uint64_t channel_layout;
1992 
1993  /**
1994  * Request decoder to use this channel layout if it can (0 for default)
1995  * - encoding: unused
1996  * - decoding: Set by user.
1997  */
1998  uint64_t request_channel_layout;
1999 
2000  /**
2001  * Type of service that the audio stream conveys.
2002  * - encoding: Set by user.
2003  * - decoding: Set by libavcodec.
2004  */
2006 
2007  /**
2008  * desired sample format
2009  * - encoding: Not used.
2010  * - decoding: Set by user.
2011  * Decoder will decode to this format if it can.
2012  */
2014 
2015 #if FF_API_GET_BUFFER
2016  /**
2017  * Called at the beginning of each frame to get a buffer for it.
2018  *
2019  * The function will set AVFrame.data[], AVFrame.linesize[].
2020  * AVFrame.extended_data[] must also be set, but it should be the same as
2021  * AVFrame.data[] except for planar audio with more channels than can fit
2022  * in AVFrame.data[]. In that case, AVFrame.data[] shall still contain as
2023  * many data pointers as it can hold.
2024  *
2025  * if CODEC_CAP_DR1 is not set then get_buffer() must call
2026  * avcodec_default_get_buffer() instead of providing buffers allocated by
2027  * some other means.
2028  *
2029  * AVFrame.data[] should be 32- or 16-byte-aligned unless the CPU doesn't
2030  * need it. avcodec_default_get_buffer() aligns the output buffer properly,
2031  * but if get_buffer() is overridden then alignment considerations should
2032  * be taken into account.
2033  *
2034  * @see avcodec_default_get_buffer()
2035  *
2036  * Video:
2037  *
2038  * If pic.reference is set then the frame will be read later by libavcodec.
2039  * avcodec_align_dimensions2() should be used to find the required width and
2040  * height, as they normally need to be rounded up to the next multiple of 16.
2041  *
2042  * If frame multithreading is used and thread_safe_callbacks is set,
2043  * it may be called from a different thread, but not from more than one at
2044  * once. Does not need to be reentrant.
2045  *
2046  * @see release_buffer(), reget_buffer()
2047  * @see avcodec_align_dimensions2()
2048  *
2049  * Audio:
2050  *
2051  * Decoders request a buffer of a particular size by setting
2052  * AVFrame.nb_samples prior to calling get_buffer(). The decoder may,
2053  * however, utilize only part of the buffer by setting AVFrame.nb_samples
2054  * to a smaller value in the output frame.
2055  *
2056  * Decoders cannot use the buffer after returning from
2057  * avcodec_decode_audio4(), so they will not call release_buffer(), as it
2058  * is assumed to be released immediately upon return. In some rare cases,
2059  * a decoder may need to call get_buffer() more than once in a single
2060  * call to avcodec_decode_audio4(). In that case, when get_buffer() is
2061  * called again after it has already been called once, the previously
2062  * acquired buffer is assumed to be released at that time and may not be
2063  * reused by the decoder.
2064  *
2065  * As a convenience, av_samples_get_buffer_size() and
2066  * av_samples_fill_arrays() in libavutil may be used by custom get_buffer()
2067  * functions to find the required data size and to fill data pointers and
2068  * linesize. In AVFrame.linesize, only linesize[0] may be set for audio
2069  * since all planes must be the same size.
2070  *
2071  * @see av_samples_get_buffer_size(), av_samples_fill_arrays()
2072  *
2073  * - encoding: unused
2074  * - decoding: Set by libavcodec, user can override.
2075  *
2076  * @deprecated use get_buffer2()
2077  */
2079  int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic);
2080 
2081  /**
2082  * Called to release buffers which were allocated with get_buffer.
2083  * A released buffer can be reused in get_buffer().
2084  * pic.data[*] must be set to NULL.
2085  * May be called from a different thread if frame multithreading is used,
2086  * but not by more than one thread at once, so does not need to be reentrant.
2087  * - encoding: unused
2088  * - decoding: Set by libavcodec, user can override.
2089  *
2090  * @deprecated custom freeing callbacks should be set from get_buffer2()
2091  */
2093  void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic);
2094 
2095  /**
2096  * Called at the beginning of a frame to get cr buffer for it.
2097  * Buffer type (size, hints) must be the same. libavcodec won't check it.
2098  * libavcodec will pass previous buffer in pic, function should return
2099  * same buffer or new buffer with old frame "painted" into it.
2100  * If pic.data[0] == NULL must behave like get_buffer().
2101  * if CODEC_CAP_DR1 is not set then reget_buffer() must call
2102  * avcodec_default_reget_buffer() instead of providing buffers allocated by
2103  * some other means.
2104  * - encoding: unused
2105  * - decoding: Set by libavcodec, user can override.
2106  */
2108  int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic);
2109 #endif
2110 
2111  /**
2112  * This callback is called at the beginning of each frame to get data
2113  * buffer(s) for it. There may be one contiguous buffer for all the data or
2114  * there may be a buffer per each data plane or anything in between. What
2115  * this means is, you may set however many entries in buf[] you feel necessary.
2116  * Each buffer must be reference-counted using the AVBuffer API (see description
2117  * of buf[] below).
2118  *
2119  * The following fields will be set in the frame before this callback is
2120  * called:
2121  * - format
2122  * - width, height (video only)
2123  * - sample_rate, channel_layout, nb_samples (audio only)
2124  * Their values may differ from the corresponding values in
2125  * AVCodecContext. This callback must use the frame values, not the codec
2126  * context values, to calculate the required buffer size.
2127  *
2128  * This callback must fill the following fields in the frame:
2129  * - data[]
2130  * - linesize[]
2131  * - extended_data:
2132  * * if the data is planar audio with more than 8 channels, then this
2133  * callback must allocate and fill extended_data to contain all pointers
2134  * to all data planes. data[] must hold as many pointers as it can.
2135  * extended_data must be allocated with av_malloc() and will be freed in
2136  * av_frame_unref().
2137  * * otherwise exended_data must point to data
2138  * - buf[] must contain one or more pointers to AVBufferRef structures. Each of
2139  * the frame's data and extended_data pointers must be contained in these. That
2140  * is, one AVBufferRef for each allocated chunk of memory, not necessarily one
2141  * AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(),
2142  * and av_buffer_ref().
2143  * - extended_buf and nb_extended_buf must be allocated with av_malloc() by
2144  * this callback and filled with the extra buffers if there are more
2145  * buffers than buf[] can hold. extended_buf will be freed in
2146  * av_frame_unref().
2147  *
2148  * If CODEC_CAP_DR1 is not set then get_buffer2() must call
2149  * avcodec_default_get_buffer2() instead of providing buffers allocated by
2150  * some other means.
2151  *
2152  * Each data plane must be aligned to the maximum required by the target
2153  * CPU.
2154  *
2155  * @see avcodec_default_get_buffer2()
2156  *
2157  * Video:
2158  *
2159  * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused
2160  * (read and/or written to if it is writable) later by libavcodec.
2161  *
2162  * avcodec_align_dimensions2() should be used to find the required width and
2163  * height, as they normally need to be rounded up to the next multiple of 16.
2164  *
2165  * Some decoders do not support linesizes changing between frames.
2166  *
2167  * If frame multithreading is used and thread_safe_callbacks is set,
2168  * this callback may be called from a different thread, but not from more
2169  * than one at once. Does not need to be reentrant.
2170  *
2171  * @see avcodec_align_dimensions2()
2172  *
2173  * Audio:
2174  *
2175  * Decoders request a buffer of a particular size by setting
2176  * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may,
2177  * however, utilize only part of the buffer by setting AVFrame.nb_samples
2178  * to a smaller value in the output frame.
2179  *
2180  * As a convenience, av_samples_get_buffer_size() and
2181  * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2()
2182  * functions to find the required data size and to fill data pointers and
2183  * linesize. In AVFrame.linesize, only linesize[0] may be set for audio
2184  * since all planes must be the same size.
2185  *
2186  * @see av_samples_get_buffer_size(), av_samples_fill_arrays()
2187  *
2188  * - encoding: unused
2189  * - decoding: Set by libavcodec, user can override.
2190  */
2191  int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);
2192 
2193  /**
2194  * If non-zero, the decoded audio and video frames returned from
2195  * avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted
2196  * and are valid indefinitely. The caller must free them with
2197  * av_frame_unref() when they are not needed anymore.
2198  * Otherwise, the decoded frames must not be freed by the caller and are
2199  * only valid until the next decode call.
2200  *
2201  * - encoding: unused
2202  * - decoding: set by the caller before avcodec_open2().
2203  */
2204  int refcounted_frames;
2205 
2206  /* - encoding parameters */
2207  float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0)
2208  float qblur; ///< amount of qscale smoothing over time (0.0-1.0)
2209 
2210  /**
2211  * minimum quantizer
2212  * - encoding: Set by user.
2213  * - decoding: unused
2214  */
2215  int qmin;
2216 
2217  /**
2218  * maximum quantizer
2219  * - encoding: Set by user.
2220  * - decoding: unused
2221  */
2222  int qmax;
2223 
2224  /**
2225  * maximum quantizer difference between frames
2226  * - encoding: Set by user.
2227  * - decoding: unused
2228  */
2229  int max_qdiff;
2230 
2231  /**
2232  * ratecontrol qmin qmax limiting method
2233  * 0-> clipping, 1-> use a nice continuous function to limit qscale wthin qmin/qmax.
2234  * - encoding: Set by user.
2235  * - decoding: unused
2236  */
2237  float rc_qsquish;
2240  int rc_qmod_freq;
2241 
2242  /**
2243  * decoder bitstream buffer size
2244  * - encoding: Set by user.
2245  * - decoding: unused
2246  */
2247  int rc_buffer_size;
2248 
2249  /**
2250  * ratecontrol override, see RcOverride
2251  * - encoding: Allocated/set/freed by user.
2252  * - decoding: unused
2253  */
2256 
2257  /**
2258  * rate control equation
2259  * - encoding: Set by user
2260  * - decoding: unused
2261  */
2262  const char *rc_eq;
2263 
2264  /**
2265  * maximum bitrate
2266  * - encoding: Set by user.
2267  * - decoding: unused
2268  */
2269  int rc_max_rate;
2270 
2271  /**
2272  * minimum bitrate
2273  * - encoding: Set by user.
2274  * - decoding: unused
2275  */
2276  int rc_min_rate;
2278  float rc_buffer_aggressivity;
2279 
2280  /**
2281  * initial complexity for pass1 ratecontrol
2282  * - encoding: Set by user.
2283  * - decoding: unused
2284  */
2285  float rc_initial_cplx;
2286 
2287  /**
2288  * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow.
2289  * - encoding: Set by user.
2290  * - decoding: unused.
2291  */
2293 
2294  /**
2295  * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow.
2296  * - encoding: Set by user.
2297  * - decoding: unused.
2298  */
2300 
2301  /**
2302  * Number of bits which should be loaded into the rc buffer before decoding starts.
2303  * - encoding: Set by user.
2304  * - decoding: unused
2305  */
2308 #define FF_CODER_TYPE_VLC 0
2309 #define FF_CODER_TYPE_AC 1
2310 #define FF_CODER_TYPE_RAW 2
2311 #define FF_CODER_TYPE_RLE 3
2312 #define FF_CODER_TYPE_DEFLATE 4
2313  /**
2314  * coder type
2315  * - encoding: Set by user.
2316  * - decoding: unused
2317  */
2318  int coder_type;
2319 
2320  /**
2321  * context model
2322  * - encoding: Set by user.
2323  * - decoding: unused
2324  */
2325  int context_model;
2326 
2327  /**
2328  * minimum Lagrange multipler
2329  * - encoding: Set by user.
2330  * - decoding: unused
2331  */
2332  int lmin;
2333 
2334  /**
2335  * maximum Lagrange multipler
2336  * - encoding: Set by user.
2337  * - decoding: unused
2338  */
2339  int lmax;
2340 
2341  /**
2342  * frame skip threshold
2343  * - encoding: Set by user.
2344  * - decoding: unused
2345  */
2347 
2348  /**
2349  * frame skip factor
2350  * - encoding: Set by user.
2351  * - decoding: unused
2352  */
2353  int frame_skip_factor;
2354 
2355  /**
2356  * frame skip exponent
2357  * - encoding: Set by user.
2358  * - decoding: unused
2359  */
2360  int frame_skip_exp;
2361 
2362  /**
2363  * frame skip comparison function
2364  * - encoding: Set by user.
2365  * - decoding: unused
2366  */
2367  int frame_skip_cmp;
2368 
2369  /**
2370  * trellis RD quantization
2371  * - encoding: Set by user.
2372  * - decoding: unused
2373  */
2374  int trellis;
2375 
2376  /**
2377  * - encoding: Set by user.
2378  * - decoding: unused
2379  */
2381 
2382  /**
2383  * - encoding: Set by user.
2384  * - decoding: unused
2385  */
2387 
2388  /**
2389  * GOP timecode frame start number
2390  * - encoding: Set by user, in non drop frame format
2391  * - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
2392  */
2393  int64_t timecode_frame_start;
2394 
2395  /* The RTP callback: This function is called */
2396  /* every time the encoder has a packet to send. */
2397  /* It depends on the encoder if the data starts */
2398  /* with a Start Code (it should). H.263 does. */
2399  /* mb_nb contains the number of macroblocks */
2400  /* encoded in the RTP payload. */
2401  void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
2403  int rtp_payload_size; /* The size of the RTP payload: the coder will */
2404  /* do its best to deliver a chunk with size */
2405  /* below rtp_payload_size, the chunk will start */
2406  /* with a start code on some codecs like H.263. */
2407  /* This doesn't take account of any particular */
2408  /* headers inside the transmitted RTP payload. */
2409 
2410  /* statistics, used for 2-pass encoding */
2411  int mv_bits;
2415  int i_count;
2416  int p_count;
2418  int misc_bits;
2419 
2420  /**
2421  * number of bits used for the previously encoded frame
2422  * - encoding: Set by libavcodec.
2423  * - decoding: unused
2424  */
2425  int frame_bits;
2426 
2427  /**
2428  * pass1 encoding statistics output buffer
2429  * - encoding: Set by libavcodec.
2430  * - decoding: unused
2431  */
2432  char *stats_out;
2433 
2434  /**
2435  * pass2 encoding statistics input buffer
2436  * Concatenated stuff from stats_out of pass1 should be placed here.
2437  * - encoding: Allocated/set/freed by user.
2438  * - decoding: unused
2439  */
2440  char *stats_in;
2441 
2442  /**
2443  * Work around bugs in encoders which sometimes cannot be detected automatically.
2444  * - encoding: Set by user
2445  * - decoding: Set by user
2446  */
2448 #define FF_BUG_AUTODETECT 1 ///< autodetection
2449 #if FF_API_OLD_MSMPEG4
2450 #define FF_BUG_OLD_MSMPEG4 2
2451 #endif
2452 #define FF_BUG_XVID_ILACE 4
2453 #define FF_BUG_UMP4 8
2454 #define FF_BUG_NO_PADDING 16
2455 #define FF_BUG_AMV 32
2456 #if FF_API_AC_VLC
2457 #define FF_BUG_AC_VLC 0 ///< Will be removed, libavcodec can now handle these non-compliant files by default.
2458 #endif
2459 #define FF_BUG_QPEL_CHROMA 64
2460 #define FF_BUG_STD_QPEL 128
2461 #define FF_BUG_QPEL_CHROMA2 256
2462 #define FF_BUG_DIRECT_BLOCKSIZE 512
2463 #define FF_BUG_EDGE 1024
2464 #define FF_BUG_HPEL_CHROMA 2048
2465 #define FF_BUG_DC_CLIP 4096
2466 #define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders.
2467 #define FF_BUG_TRUNCATED 16384
2468 
2469  /**
2470  * strictly follow the standard (MPEG4, ...).
2471  * - encoding: Set by user.
2472  * - decoding: Set by user.
2473  * Setting this to STRICT or higher means the encoder and decoder will
2474  * generally do stupid things, whereas setting it to unofficial or lower
2475  * will mean the encoder might produce output that is not supported by all
2476  * spec-compliant decoders. Decoders don't differentiate between normal,
2477  * unofficial and experimental (that is, they always try to decode things
2478  * when they can) unless they are explicitly asked to behave stupidly
2479  * (=strictly conform to the specs)
2480  */
2482 #define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software.
2483 #define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences.
2484 #define FF_COMPLIANCE_NORMAL 0
2485 #define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions
2486 #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
2487 
2488  /**
2489  * error concealment flags
2490  * - encoding: unused
2491  * - decoding: Set by user.
2492  */
2494 #define FF_EC_GUESS_MVS 1
2495 #define FF_EC_DEBLOCK 2
2496 
2497  /**
2498  * debug
2499  * - encoding: Set by user.
2500  * - decoding: Set by user.
2501  */
2502  int debug;
2503 #define FF_DEBUG_PICT_INFO 1
2504 #define FF_DEBUG_RC 2
2505 #define FF_DEBUG_BITSTREAM 4
2506 #define FF_DEBUG_MB_TYPE 8
2507 #define FF_DEBUG_QP 16
2508 #if FF_API_DEBUG_MV
2509 /**
2510  * @deprecated this option does nothing
2511  */
2512 #define FF_DEBUG_MV 32
2513 #endif
2514 #define FF_DEBUG_DCT_COEFF 0x00000040
2515 #define FF_DEBUG_SKIP 0x00000080
2516 #define FF_DEBUG_STARTCODE 0x00000100
2517 #define FF_DEBUG_PTS 0x00000200
2518 #define FF_DEBUG_ER 0x00000400
2519 #define FF_DEBUG_MMCO 0x00000800
2520 #define FF_DEBUG_BUGS 0x00001000
2521 #if FF_API_DEBUG_MV
2522 #define FF_DEBUG_VIS_QP 0x00002000 ///< only access through AVOptions from outside libavcodec
2523 #define FF_DEBUG_VIS_MB_TYPE 0x00004000 ///< only access through AVOptions from outside libavcodec
2524 #endif
2525 #define FF_DEBUG_BUFFERS 0x00008000
2526 #define FF_DEBUG_THREADS 0x00010000
2527 
2528 #if FF_API_DEBUG_MV
2529  /**
2530  * debug
2531  * Code outside libavcodec should access this field using AVOptions
2532  * - encoding: Set by user.
2533  * - decoding: Set by user.
2534  */
2536 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames
2537 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames
2538 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
2539 #endif
2540 
2541  /**
2542  * Error recognition; may misdetect some more or less valid parts as errors.
2543  * - encoding: unused
2544  * - decoding: Set by user.
2545  */
2546  int err_recognition;
2547 
2548 /**
2549  * Verify checksums embedded in the bitstream (could be of either encoded or
2550  * decoded data, depending on the codec) and print an error message on mismatch.
2551  * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the
2552  * decoder returning an error.
2553  */
2554 #define AV_EF_CRCCHECK (1<<0)
2555 #define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations
2556 #define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length
2557 #define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection
2559 #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
2560 #define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliancies as errors
2561 #define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder should not do as an error
2562 
2563 
2564  /**
2565  * opaque 64bit number (generally a PTS) that will be reordered and
2566  * output in AVFrame.reordered_opaque
2567  * @deprecated in favor of pkt_pts
2568  * - encoding: unused
2569  * - decoding: Set by user.
2570  */
2571  int64_t reordered_opaque;
2572 
2573  /**
2574  * Hardware accelerator in use
2575  * - encoding: unused.
2576  * - decoding: Set by libavcodec
2577  */
2578  struct AVHWAccel *hwaccel;
2579 
2580  /**
2581  * Hardware accelerator context.
2582  * For some hardware accelerators, a global context needs to be
2583  * provided by the user. In that case, this holds display-dependent
2584  * data FFmpeg cannot instantiate itself. Please refer to the
2585  * FFmpeg HW accelerator documentation to know how to fill this
2586  * is. e.g. for VA API, this is a struct vaapi_context.
2587  * - encoding: unused
2588  * - decoding: Set by user
2589  */
2590  void *hwaccel_context;
2591 
2592  /**
2593  * error
2594  * - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR.
2595  * - decoding: unused
2596  */
2597  uint64_t error[AV_NUM_DATA_POINTERS];
2598 
2599  /**
2600  * DCT algorithm, see FF_DCT_* below
2601  * - encoding: Set by user.
2602  * - decoding: unused
2603  */
2605 #define FF_DCT_AUTO 0
2606 #define FF_DCT_FASTINT 1
2607 #define FF_DCT_INT 2
2608 #define FF_DCT_MMX 3
2609 #define FF_DCT_ALTIVEC 5
2610 #define FF_DCT_FAAN 6
2611 
2612  /**
2613  * IDCT algorithm, see FF_IDCT_* below.
2614  * - encoding: Set by user.
2615  * - decoding: Set by user.
2616  */
2618 #define FF_IDCT_AUTO 0
2619 #define FF_IDCT_INT 1
2620 #define FF_IDCT_SIMPLE 2
2621 #define FF_IDCT_SIMPLEMMX 3
2622 #define FF_IDCT_ARM 7
2623 #define FF_IDCT_ALTIVEC 8
2624 #define FF_IDCT_SH4 9
2625 #define FF_IDCT_SIMPLEARM 10
2626 #define FF_IDCT_IPP 13
2627 #define FF_IDCT_XVIDMMX 14
2628 #define FF_IDCT_SIMPLEARMV5TE 16
2629 #define FF_IDCT_SIMPLEARMV6 17
2630 #define FF_IDCT_SIMPLEVIS 18
2631 #define FF_IDCT_FAAN 20
2632 #define FF_IDCT_SIMPLENEON 22
2633 #if FF_API_ARCH_ALPHA
2634 #define FF_IDCT_SIMPLEALPHA 23
2635 #endif
2636 
2637  /**
2638  * bits per sample/pixel from the demuxer (needed for huffyuv).
2639  * - encoding: Set by libavcodec.
2640  * - decoding: Set by user.
2641  */
2643 
2644  /**
2645  * Bits per sample/pixel of internal libavcodec pixel/sample format.
2646  * - encoding: set by user.
2647  * - decoding: set by libavcodec.
2648  */
2649  int bits_per_raw_sample;
2650 
2651 #if FF_API_LOWRES
2652  /**
2653  * low resolution decoding, 1-> 1/2 size, 2->1/4 size
2654  * - encoding: unused
2655  * - decoding: Set by user.
2656  * Code outside libavcodec should access this field using:
2657  * av_codec_{get,set}_lowres(avctx)
2658  */
2659  int lowres;
2660 #endif
2661 
2662  /**
2663  * the picture in the bitstream
2664  * - encoding: Set by libavcodec.
2665  * - decoding: unused
2666  */
2668 
2669  /**
2670  * thread count
2671  * is used to decide how many independent tasks should be passed to execute()
2672  * - encoding: Set by user.
2673  * - decoding: Set by user.
2674  */
2675  int thread_count;
2676 
2677  /**
2678  * Which multithreading methods to use.
2679  * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread,
2680  * so clients which cannot provide future frames should not use it.
2681  *
2682  * - encoding: Set by user, otherwise the default is used.
2683  * - decoding: Set by user, otherwise the default is used.
2684  */
2686 #define FF_THREAD_FRAME 1 ///< Decode more than one frame at once
2687 #define FF_THREAD_SLICE 2 ///< Decode more than one part of a single frame at once
2688 
2689  /**
2690  * Which multithreading methods are in use by the codec.
2691  * - encoding: Set by libavcodec.
2692  * - decoding: Set by libavcodec.
2693  */
2694  int active_thread_type;
2695 
2696  /**
2697  * Set by the client if its custom get_buffer() callback can be called
2698  * synchronously from another thread, which allows faster multithreaded decoding.
2699  * draw_horiz_band() will be called from other threads regardless of this setting.
2700  * Ignored if the default get_buffer() is used.
2701  * - encoding: Set by user.
2702  * - decoding: Set by user.
2703  */
2705 
2706  /**
2707  * The codec may call this to execute several independent things.
2708  * It will return only after finishing all tasks.
2709  * The user may replace this with some multithreaded implementation,
2710  * the default implementation will execute the parts serially.
2711  * @param count the number of things to execute
2712  * - encoding: Set by libavcodec, user can override.
2713  * - decoding: Set by libavcodec, user can override.
2714  */
2715  int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
2716 
2717  /**
2718  * The codec may call this to execute several independent things.
2719  * It will return only after finishing all tasks.
2720  * The user may replace this with some multithreaded implementation,
2721  * the default implementation will execute the parts serially.
2722  * Also see avcodec_thread_init and e.g. the --enable-pthread configure option.
2723  * @param c context passed also to func
2724  * @param count the number of things to execute
2725  * @param arg2 argument passed unchanged to func
2726  * @param ret return values of executed functions, must have space for "count" values. May be NULL.
2727  * @param func function that will be called count times, with jobnr from 0 to count-1.
2728  * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no
2729  * two instances of func executing at the same time will have the same threadnr.
2730  * @return always 0 currently, but code should handle a future improvement where when any call to func
2731  * returns < 0 no further calls to func may be done and < 0 is returned.
2732  * - encoding: Set by libavcodec, user can override.
2733  * - decoding: Set by libavcodec, user can override.
2734  */
2735  int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count);
2736 
2737 #if FF_API_THREAD_OPAQUE
2738  /**
2739  * @deprecated this field should not be used from outside of lavc
2740  */
2742  void *thread_opaque;
2743 #endif
2744 
2745  /**
2746  * noise vs. sse weight for the nsse comparsion function
2747  * - encoding: Set by user.
2748  * - decoding: unused
2749  */
2750  int nsse_weight;
2751 
2752  /**
2753  * profile
2754  * - encoding: Set by user.
2755  * - decoding: Set by libavcodec.
2756  */
2757  int profile;
2758 #define FF_PROFILE_UNKNOWN -99
2759 #define FF_PROFILE_RESERVED -100
2761 #define FF_PROFILE_AAC_MAIN 0
2762 #define FF_PROFILE_AAC_LOW 1
2763 #define FF_PROFILE_AAC_SSR 2
2764 #define FF_PROFILE_AAC_LTP 3
2765 #define FF_PROFILE_AAC_HE 4
2766 #define FF_PROFILE_AAC_HE_V2 28
2767 #define FF_PROFILE_AAC_LD 22
2768 #define FF_PROFILE_AAC_ELD 38
2769 #define FF_PROFILE_MPEG2_AAC_LOW 128
2770 #define FF_PROFILE_MPEG2_AAC_HE 131
2772 #define FF_PROFILE_DTS 20
2773 #define FF_PROFILE_DTS_ES 30
2774 #define FF_PROFILE_DTS_96_24 40
2775 #define FF_PROFILE_DTS_HD_HRA 50
2776 #define FF_PROFILE_DTS_HD_MA 60
2778 #define FF_PROFILE_MPEG2_422 0
2779 #define FF_PROFILE_MPEG2_HIGH 1
2780 #define FF_PROFILE_MPEG2_SS 2
2781 #define FF_PROFILE_MPEG2_SNR_SCALABLE 3
2782 #define FF_PROFILE_MPEG2_MAIN 4
2783 #define FF_PROFILE_MPEG2_SIMPLE 5
2785 #define FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag
2786 #define FF_PROFILE_H264_INTRA (1<<11) // 8+3; constraint_set3_flag
2788 #define FF_PROFILE_H264_BASELINE 66
2789 #define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
2790 #define FF_PROFILE_H264_MAIN 77
2791 #define FF_PROFILE_H264_EXTENDED 88
2792 #define FF_PROFILE_H264_HIGH 100
2793 #define FF_PROFILE_H264_HIGH_10 110
2794 #define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA)
2795 #define FF_PROFILE_H264_HIGH_422 122
2796 #define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA)
2797 #define FF_PROFILE_H264_HIGH_444 144
2798 #define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244
2799 #define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA)
2800 #define FF_PROFILE_H264_CAVLC_444 44
2802 #define FF_PROFILE_VC1_SIMPLE 0
2803 #define FF_PROFILE_VC1_MAIN 1
2804 #define FF_PROFILE_VC1_COMPLEX 2
2805 #define FF_PROFILE_VC1_ADVANCED 3
2807 #define FF_PROFILE_MPEG4_SIMPLE 0
2808 #define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1
2809 #define FF_PROFILE_MPEG4_CORE 2
2810 #define FF_PROFILE_MPEG4_MAIN 3
2811 #define FF_PROFILE_MPEG4_N_BIT 4
2812 #define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5
2813 #define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6
2814 #define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7
2815 #define FF_PROFILE_MPEG4_HYBRID 8
2816 #define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9
2817 #define FF_PROFILE_MPEG4_CORE_SCALABLE 10
2818 #define FF_PROFILE_MPEG4_ADVANCED_CODING 11
2819 #define FF_PROFILE_MPEG4_ADVANCED_CORE 12
2820 #define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
2821 #define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14
2822 #define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15
2824 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 0
2825 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 1
2826 #define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 2
2827 #define FF_PROFILE_JPEG2000_DCINEMA_2K 3
2828 #define FF_PROFILE_JPEG2000_DCINEMA_4K 4
2829 
2831 #define FF_PROFILE_HEVC_MAIN 1
2832 #define FF_PROFILE_HEVC_MAIN_10 2
2833 #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3
2834 
2835  /**
2836  * level
2837  * - encoding: Set by user.
2838  * - decoding: Set by libavcodec.
2839  */
2840  int level;
2841 #define FF_LEVEL_UNKNOWN -99
2842 
2843  /**
2844  * Skip loop filtering for selected frames.
2845  * - encoding: unused
2846  * - decoding: Set by user.
2847  */
2849 
2850  /**
2851  * Skip IDCT/dequantization for selected frames.
2852  * - encoding: unused
2853  * - decoding: Set by user.
2854  */
2855  enum AVDiscard skip_idct;
2856 
2857  /**
2858  * Skip decoding for selected frames.
2859  * - encoding: unused
2860  * - decoding: Set by user.
2861  */
2862  enum AVDiscard skip_frame;
2863 
2864  /**
2865  * Header containing style information for text subtitles.
2866  * For SUBTITLE_ASS subtitle type, it should contain the whole ASS
2867  * [Script Info] and [V4+ Styles] section, plus the [Events] line and
2868  * the Format line following. It shouldn't include any Dialogue line.
2869  * - encoding: Set/allocated/freed by user (before avcodec_open2())
2870  * - decoding: Set/allocated/freed by libavcodec (by avcodec_open2())
2871  */
2874 
2875 #if FF_API_ERROR_RATE
2876  /**
2877  * @deprecated use the 'error_rate' private AVOption of the mpegvideo
2878  * encoders
2879  */
2881  int error_rate;
2882 #endif
2883 
2884 #if FF_API_CODEC_PKT
2885  /**
2886  * @deprecated this field is not supposed to be accessed from outside lavc
2887  */
2889  AVPacket *pkt;
2890 #endif
2891 
2892  /**
2893  * VBV delay coded in the last frame (in periods of a 27 MHz clock).
2894  * Used for compliant TS muxing.
2895  * - encoding: Set by libavcodec.
2896  * - decoding: unused.
2897  */
2898  uint64_t vbv_delay;
2899 
2900  /**
2901  * Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
2902  * Code outside libavcodec should access this field using:
2903  * av_codec_{get,set}_pkt_timebase(avctx)
2904  * - encoding unused.
2905  * - decoding set by user.
2906  */
2908 
2909  /**
2910  * AVCodecDescriptor
2911  * Code outside libavcodec should access this field using:
2912  * av_codec_{get,set}_codec_descriptor(avctx)
2913  * - encoding: unused.
2914  * - decoding: set by libavcodec.
2915  */
2917 
2918 #if !FF_API_LOWRES
2919  /**
2920  * low resolution decoding, 1-> 1/2 size, 2->1/4 size
2921  * - encoding: unused
2922  * - decoding: Set by user.
2923  * Code outside libavcodec should access this field using:
2924  * av_codec_{get,set}_lowres(avctx)
2925  */
2926  int lowres;
2927 #endif
2928 
2929  /**
2930  * Current statistics for PTS correction.
2931  * - decoding: maintained and used by libavcodec, not intended to be used by user apps
2932  * - encoding: unused
2933  */
2934  int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
2935  int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
2936  int64_t pts_correction_last_pts; /// PTS of the last frame
2937  int64_t pts_correction_last_dts; /// DTS of the last frame
2938 
2939  /**
2940  * Character encoding of the input subtitles file.
2941  * - decoding: set by user
2942  * - encoding: unused
2943  */
2944  char *sub_charenc;
2945 
2946  /**
2947  * Subtitles character encoding mode. Formats or codecs might be adjusting
2948  * this setting (if they are doing the conversion themselves for instance).
2949  * - decoding: set by libavcodec
2950  * - encoding: unused
2951  */
2953 #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)
2954 #define FF_SUB_CHARENC_MODE_AUTOMATIC 0 ///< libavcodec will select the mode itself
2955 #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
2956 
2957  /**
2958  * Skip processing alpha if supported by codec.
2959  * Note that if the format uses pre-multiplied alpha (common with VP6,
2960  * and recommended due to better video quality/compression)
2961  * the image will look as if alpha-blended onto a black background.
2962  * However for formats that do not use pre-multiplied alpha
2963  * there might be serious artefacts (though e.g. libswscale currently
2964  * assumes pre-multiplied alpha anyway).
2965  * Code outside libavcodec should access this field using AVOptions
2966  *
2967  * - decoding: set by user
2968  * - encoding: unused
2969  */
2970  int skip_alpha;
2971 
2972  /**
2973  * Number of samples to skip after a discontinuity
2974  * - decoding: unused
2975  * - encoding: set by libavcodec
2976  */
2979 #if !FF_API_DEBUG_MV
2980  /**
2981  * debug motion vectors
2982  * Code outside libavcodec should access this field using AVOptions
2983  * - encoding: Set by user.
2984  * - decoding: Set by user.
2985  */
2986  int debug_mv;
2987 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames
2988 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames
2989 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
2990 #endif
2991 
2992  /**
2993  * custom intra quantization matrix
2994  * Code outside libavcodec should access this field using av_codec_g/set_chroma_intra_matrix()
2995  * - encoding: Set by user, can be NULL.
2996  * - decoding: unused.
2997  */
2998  uint16_t *chroma_intra_matrix;
2999 } AVCodecContext;
3000 
3003 
3006 
3007 int av_codec_get_lowres(const AVCodecContext *avctx);
3008 void av_codec_set_lowres(AVCodecContext *avctx, int val);
3009 
3010 int av_codec_get_seek_preroll(const AVCodecContext *avctx);
3011 void av_codec_set_seek_preroll(AVCodecContext *avctx, int val);
3012 
3013 uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx);
3014 void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val);
3015 
3016 /**
3017  * AVProfile.
3018  */
3019 typedef struct AVProfile {
3020  int profile;
3021  const char *name; ///< short name for the profile
3022 } AVProfile;
3023 
3024 typedef struct AVCodecDefault AVCodecDefault;
3025 
3026 struct AVSubtitle;
3027 
3028 /**
3029  * AVCodec.
3030  */
3031 typedef struct AVCodec {
3032  /**
3033  * Name of the codec implementation.
3034  * The name is globally unique among encoders and among decoders (but an
3035  * encoder and a decoder can share the same name).
3036  * This is the primary way to find a codec from the user perspective.
3037  */
3038  const char *name;
3039  /**
3040  * Descriptive name for the codec, meant to be more human readable than name.
3041  * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
3042  */
3043  const char *long_name;
3045  enum AVCodecID id;
3046  /**
3047  * Codec capabilities.
3048  * see CODEC_CAP_*
3049  */
3051  const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
3052  const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
3053  const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
3054  const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
3055  const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
3056 #if FF_API_LOWRES
3057  uint8_t max_lowres; ///< maximum value for lowres supported by the decoder, no direct access, use av_codec_get_max_lowres()
3058 #endif
3059  const AVClass *priv_class; ///< AVClass for the private context
3060  const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
3061 
3062  /*****************************************************************
3063  * No fields below this line are part of the public API. They
3064  * may not be used outside of libavcodec and can be changed and
3065  * removed at will.
3066  * New public fields should be added right above.
3067  *****************************************************************
3068  */
3070  struct AVCodec *next;
3071  /**
3072  * @name Frame-level threading support functions
3073  * @{
3074  */
3075  /**
3076  * If defined, called on thread contexts when they are created.
3077  * If the codec allocates writable tables in init(), re-allocate them here.
3078  * priv_data will be set to a copy of the original.
3079  */
3080  int (*init_thread_copy)(AVCodecContext *);
3081  /**
3082  * Copy necessary context variables from a previous thread context to the current one.
3083  * If not defined, the next thread will start automatically; otherwise, the codec
3084  * must call ff_thread_finish_setup().
3085  *
3086  * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
3087  */
3089  /** @} */
3090 
3091  /**
3092  * Private codec-specific defaults.
3093  */
3094  const AVCodecDefault *defaults;
3095 
3096  /**
3097  * Initialize codec static data, called from avcodec_register().
3098  */
3099  void (*init_static_data)(struct AVCodec *codec);
3102  int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
3103  const struct AVSubtitle *sub);
3104  /**
3105  * Encode data to an AVPacket.
3106  *
3107  * @param avctx codec context
3108  * @param avpkt output AVPacket (may contain a user-provided buffer)
3109  * @param[in] frame AVFrame containing the raw data to be encoded
3110  * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
3111  * non-empty packet was returned in avpkt.
3112  * @return 0 on success, negative error code on failure
3113  */
3114  int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
3115  int *got_packet_ptr);
3116  int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
3117  int (*close)(AVCodecContext *);
3118  /**
3119  * Flush buffers.
3120  * Will be called when seeking
3121  */
3122  void (*flush)(AVCodecContext *);
3123 } AVCodec;
3124 
3125 int av_codec_get_max_lowres(const AVCodec *codec);
3126 
3127 struct MpegEncContext;
3128 
3129 /**
3130  * AVHWAccel.
3131  */
3132 typedef struct AVHWAccel {
3133  /**
3134  * Name of the hardware accelerated codec.
3135  * The name is globally unique among encoders and among decoders (but an
3136  * encoder and a decoder can share the same name).
3137  */
3138  const char *name;
3139 
3140  /**
3141  * Type of codec implemented by the hardware accelerator.
3142  *
3143  * See AVMEDIA_TYPE_xxx
3144  */
3145  enum AVMediaType type;
3146 
3147  /**
3148  * Codec implemented by the hardware accelerator.
3149  *
3150  * See AV_CODEC_ID_xxx
3151  */
3152  enum AVCodecID id;
3153 
3154  /**
3155  * Supported pixel format.
3156  *
3157  * Only hardware accelerated formats are supported here.
3158  */
3159  enum AVPixelFormat pix_fmt;
3160 
3161  /**
3162  * Hardware accelerated codec capabilities.
3163  * see FF_HWACCEL_CODEC_CAP_*
3164  */
3165  int capabilities;
3167  struct AVHWAccel *next;
3168 
3169  /**
3170  * Called at the beginning of each frame or field picture.
3171  *
3172  * Meaningful frame information (codec specific) is guaranteed to
3173  * be parsed at this point. This function is mandatory.
3174  *
3175  * Note that buf can be NULL along with buf_size set to 0.
3176  * Otherwise, this means the whole frame is available at this point.
3177  *
3178  * @param avctx the codec context
3179  * @param buf the frame data buffer base
3180  * @param buf_size the size of the frame in bytes
3181  * @return zero if successful, a negative value otherwise
3182  */
3183  int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
3184 
3185  /**
3186  * Callback for each slice.
3187  *
3188  * Meaningful slice information (codec specific) is guaranteed to
3189  * be parsed at this point. This function is mandatory.
3190  * The only exception is XvMC, that works on MB level.
3191  *
3192  * @param avctx the codec context
3193  * @param buf the slice data buffer base
3194  * @param buf_size the size of the slice in bytes
3195  * @return zero if successful, a negative value otherwise
3196  */
3197  int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
3198 
3199  /**
3200  * Called at the end of each frame or field picture.
3201  *
3202  * The whole picture is parsed at this point and can now be sent
3203  * to the hardware accelerator. This function is mandatory.
3204  *
3205  * @param avctx the codec context
3206  * @return zero if successful, a negative value otherwise
3207  */
3208  int (*end_frame)(AVCodecContext *avctx);
3209 
3210  /**
3211  * Size of HW accelerator private data.
3212  *
3213  * Private data is allocated with av_mallocz() before
3214  * AVCodecContext.get_buffer() and deallocated after
3215  * AVCodecContext.release_buffer().
3216  */
3217  int priv_data_size;
3218 
3219  /**
3220  * Called for every Macroblock in a slice.
3221  *
3222  * XvMC uses it to replace the ff_MPV_decode_mb().
3223  * Instead of decoding to raw picture, MB parameters are
3224  * stored in an array provided by the video driver.
3225  *
3226  * @param s the mpeg context
3227  */
3228  void (*decode_mb)(struct MpegEncContext *s);
3229 } AVHWAccel;
3230 
3231 /**
3232  * @defgroup lavc_picture AVPicture
3233  *
3234  * Functions for working with AVPicture
3235  * @{
3236  */
3237 
3238 /**
3239  * Picture data structure.
3240  *
3241  * Up to four components can be stored into it, the last component is
3242  * alpha.
3243  */
3244 typedef struct AVPicture {
3245  uint8_t *data[AV_NUM_DATA_POINTERS]; ///< pointers to the image data planes
3246  int linesize[AV_NUM_DATA_POINTERS]; ///< number of bytes per line
3247 } AVPicture;
3248 
3249 /**
3250  * @}
3251  */
3254  SUBTITLE_NONE,
3256  SUBTITLE_BITMAP, ///< A bitmap, pict will be set
3257 
3258  /**
3259  * Plain text, the text field must be set by the decoder and is
3260  * authoritative. ass and pict fields may contain approximations.
3261  */
3262  SUBTITLE_TEXT,
3263 
3264  /**
3265  * Formatted text, the ass field must be set by the decoder and is
3266  * authoritative. pict and text fields may contain approximations.
3267  */
3268  SUBTITLE_ASS,
3269 };
3271 #define AV_SUBTITLE_FLAG_FORCED 0x00000001
3273 typedef struct AVSubtitleRect {
3274  int x; ///< top left corner of pict, undefined when pict is not set
3275  int y; ///< top left corner of pict, undefined when pict is not set
3276  int w; ///< width of pict, undefined when pict is not set
3277  int h; ///< height of pict, undefined when pict is not set
3278  int nb_colors; ///< number of colors in pict, undefined when pict is not set
3279 
3280  /**
3281  * data+linesize for the bitmap of this subtitle.
3282  * can be set for text/ass as well once they where rendered
3283  */
3285  enum AVSubtitleType type;
3287  char *text; ///< 0 terminated plain UTF-8 text
3288 
3289  /**
3290  * 0 terminated ASS/SSA compatible event line.
3291  * The presentation of this is unaffected by the other values in this
3292  * struct.
3293  */
3294  char *ass;
3296  int flags;
3297 } AVSubtitleRect;
3299 typedef struct AVSubtitle {
3300  uint16_t format; /* 0 = graphics */
3301  uint32_t start_display_time; /* relative to packet pts, in ms */
3302  uint32_t end_display_time; /* relative to packet pts, in ms */
3303  unsigned num_rects;
3305  int64_t pts; ///< Same as packet pts, in AV_TIME_BASE
3306 } AVSubtitle;
3307 
3308 /**
3309  * If c is NULL, returns the first registered codec,
3310  * if c is non-NULL, returns the next registered codec after c,
3311  * or NULL if c is the last one.
3312  */
3313 AVCodec *av_codec_next(const AVCodec *c);
3314 
3315 /**
3316  * Return the LIBAVCODEC_VERSION_INT constant.
3317  */
3318 unsigned avcodec_version(void);
3319 
3320 /**
3321  * Return the libavcodec build-time configuration.
3322  */
3323 const char *avcodec_configuration(void);
3324 
3325 /**
3326  * Return the libavcodec license.
3327  */
3328 const char *avcodec_license(void);
3329 
3330 /**
3331  * Register the codec codec and initialize libavcodec.
3332  *
3333  * @warning either this function or avcodec_register_all() must be called
3334  * before any other libavcodec functions.
3335  *
3336  * @see avcodec_register_all()
3337  */
3338 void avcodec_register(AVCodec *codec);
3339 
3340 /**
3341  * Register all the codecs, parsers and bitstream filters which were enabled at
3342  * configuration time. If you do not call this function you can select exactly
3343  * which formats you want to support, by using the individual registration
3344  * functions.
3345  *
3346  * @see avcodec_register
3347  * @see av_register_codec_parser
3348  * @see av_register_bitstream_filter
3349  */
3350 void avcodec_register_all(void);
3351 
3352 /**
3353  * Allocate an AVCodecContext and set its fields to default values. The
3354  * resulting struct can be deallocated by calling avcodec_close() on it followed
3355  * by av_free().
3356  *
3357  * @param codec if non-NULL, allocate private data and initialize defaults
3358  * for the given codec. It is illegal to then call avcodec_open2()
3359  * with a different codec.
3360  * If NULL, then the codec-specific defaults won't be initialized,
3361  * which may result in suboptimal default settings (this is
3362  * important mainly for encoders, e.g. libx264).
3363  *
3364  * @return An AVCodecContext filled with default values or NULL on failure.
3365  * @see avcodec_get_context_defaults
3366  */
3368 
3369 /**
3370  * Set the fields of the given AVCodecContext to default values corresponding
3371  * to the given codec (defaults may be codec-dependent).
3372  *
3373  * Do not call this function if a non-NULL codec has been passed
3374  * to avcodec_alloc_context3() that allocated this AVCodecContext.
3375  * If codec is non-NULL, it is illegal to call avcodec_open2() with a
3376  * different codec on this AVCodecContext.
3377  */
3379 
3380 /**
3381  * Get the AVClass for AVCodecContext. It can be used in combination with
3382  * AV_OPT_SEARCH_FAKE_OBJ for examining options.
3383  *
3384  * @see av_opt_find().
3385  */
3386 const AVClass *avcodec_get_class(void);
3387 
3388 /**
3389  * Get the AVClass for AVFrame. It can be used in combination with
3390  * AV_OPT_SEARCH_FAKE_OBJ for examining options.
3391  *
3392  * @see av_opt_find().
3393  */
3394 const AVClass *avcodec_get_frame_class(void);
3395 
3396 /**
3397  * Get the AVClass for AVSubtitleRect. It can be used in combination with
3398  * AV_OPT_SEARCH_FAKE_OBJ for examining options.
3399  *
3400  * @see av_opt_find().
3401  */
3403 
3404 /**
3405  * Copy the settings of the source AVCodecContext into the destination
3406  * AVCodecContext. The resulting destination codec context will be
3407  * unopened, i.e. you are required to call avcodec_open2() before you
3408  * can use this AVCodecContext to decode/encode video/audio data.
3409  *
3410  * @param dest target codec context, should be initialized with
3411  * avcodec_alloc_context3(NULL), but otherwise uninitialized
3412  * @param src source codec context
3413  * @return AVERROR() on error (e.g. memory allocation error), 0 on success
3414  */
3416 
3417 #if FF_API_AVFRAME_LAVC
3418 /**
3419  * @deprecated use av_frame_alloc()
3420  */
3423 
3424 /**
3425  * Set the fields of the given AVFrame to default values.
3426  *
3427  * @param frame The AVFrame of which the fields should be set to default values.
3428  *
3429  * @deprecated use av_frame_unref()
3430  */
3433 
3434 /**
3435  * Free the frame and any dynamically allocated objects in it,
3436  * e.g. extended_data.
3437  *
3438  * @param frame frame to be freed. The pointer will be set to NULL.
3439  *
3440  * @warning this function does NOT free the data buffers themselves
3441  * (it does not know how, since they might have been allocated with
3442  * a custom get_buffer()).
3443  *
3444  * @deprecated use av_frame_free()
3445  */
3448 #endif
3449 
3450 /**
3451  * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
3452  * function the context has to be allocated with avcodec_alloc_context3().
3453  *
3454  * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),
3455  * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for
3456  * retrieving a codec.
3457  *
3458  * @warning This function is not thread safe!
3459  *
3460  * @code
3461  * avcodec_register_all();
3462  * av_dict_set(&opts, "b", "2.5M", 0);
3463  * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
3464  * if (!codec)
3465  * exit(1);
3466  *
3467  * context = avcodec_alloc_context3(codec);
3468  *
3469  * if (avcodec_open2(context, codec, opts) < 0)
3470  * exit(1);
3471  * @endcode
3472  *
3473  * @param avctx The context to initialize.
3474  * @param codec The codec to open this context for. If a non-NULL codec has been
3475  * previously passed to avcodec_alloc_context3() or
3476  * avcodec_get_context_defaults3() for this context, then this
3477  * parameter MUST be either NULL or equal to the previously passed
3478  * codec.
3479  * @param options A dictionary filled with AVCodecContext and codec-private options.
3480  * On return this object will be filled with options that were not found.
3481  *
3482  * @return zero on success, a negative value on error
3483  * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(),
3484  * av_dict_set(), av_opt_find().
3485  */
3486 int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
3487 
3488 /**
3489  * Close a given AVCodecContext and free all the data associated with it
3490  * (but not the AVCodecContext itself).
3491  *
3492  * Calling this function on an AVCodecContext that hasn't been opened will free
3493  * the codec-specific data allocated in avcodec_alloc_context3() /
3494  * avcodec_get_context_defaults3() with a non-NULL codec. Subsequent calls will
3495  * do nothing.
3496  */
3497 int avcodec_close(AVCodecContext *avctx);
3498 
3499 /**
3500  * Free all allocated data in the given subtitle struct.
3501  *
3502  * @param sub AVSubtitle to free.
3503  */
3504 void avsubtitle_free(AVSubtitle *sub);
3505 
3506 /**
3507  * @}
3508  */
3509 
3510 /**
3511  * @addtogroup lavc_packet
3512  * @{
3513  */
3514 
3515 #if FF_API_DESTRUCT_PACKET
3516 /**
3517  * Default packet destructor.
3518  * @deprecated use the AVBuffer API instead
3519  */
3522 #endif
3523 
3524 /**
3525  * Initialize optional fields of a packet with default values.
3526  *
3527  * Note, this does not touch the data and size members, which have to be
3528  * initialized separately.
3529  *
3530  * @param pkt packet
3531  */
3532 void av_init_packet(AVPacket *pkt);
3533 
3534 /**
3535  * Allocate the payload of a packet and initialize its fields with
3536  * default values.
3537  *
3538  * @param pkt packet
3539  * @param size wanted payload size
3540  * @return 0 if OK, AVERROR_xxx otherwise
3541  */
3542 int av_new_packet(AVPacket *pkt, int size);
3543 
3544 /**
3545  * Reduce packet size, correctly zeroing padding
3546  *
3547  * @param pkt packet
3548  * @param size new size
3549  */
3550 void av_shrink_packet(AVPacket *pkt, int size);
3551 
3552 /**
3553  * Increase packet size, correctly zeroing padding
3554  *
3555  * @param pkt packet
3556  * @param grow_by number of bytes by which to increase the size of the packet
3557  */
3558 int av_grow_packet(AVPacket *pkt, int grow_by);
3559 
3560 /**
3561  * Initialize a reference-counted packet from av_malloc()ed data.
3562  *
3563  * @param pkt packet to be initialized. This function will set the data, size,
3564  * buf and destruct fields, all others are left untouched.
3565  * @param data Data allocated by av_malloc() to be used as packet data. If this
3566  * function returns successfully, the data is owned by the underlying AVBuffer.
3567  * The caller may not access the data through other means.
3568  * @param size size of data in bytes, without the padding. I.e. the full buffer
3569  * size is assumed to be size + FF_INPUT_BUFFER_PADDING_SIZE.
3570  *
3571  * @return 0 on success, a negative AVERROR on error
3572  */
3574 
3575 /**
3576  * @warning This is a hack - the packet memory allocation stuff is broken. The
3577  * packet is allocated if it was not really allocated.
3578  */
3579 int av_dup_packet(AVPacket *pkt);
3580 
3581 /**
3582  * Copy packet, including contents
3583  *
3584  * @return 0 on success, negative AVERROR on fail
3585  */
3586 int av_copy_packet(AVPacket *dst, AVPacket *src);
3587 
3588 /**
3589  * Copy packet side data
3590  *
3591  * @return 0 on success, negative AVERROR on fail
3592  */
3594 
3595 /**
3596  * Free a packet.
3597  *
3598  * @param pkt packet to free
3599  */
3600 void av_free_packet(AVPacket *pkt);
3601 
3602 /**
3603  * Allocate new information of a packet.
3604  *
3605  * @param pkt packet
3606  * @param type side information type
3607  * @param size side information size
3608  * @return pointer to fresh allocated data or NULL otherwise
3609  */
3611  int size);
3612 
3613 /**
3614  * Shrink the already allocated side data buffer
3615  *
3616  * @param pkt packet
3617  * @param type side information type
3618  * @param size new side information size
3619  * @return 0 on success, < 0 on failure
3620  */
3622  int size);
3623 
3624 /**
3625  * Get side information from packet.
3626  *
3627  * @param pkt packet
3628  * @param type desired side information type
3629  * @param size pointer for side information size to store (optional)
3630  * @return pointer to data if present or NULL otherwise
3631  */
3633  int *size);
3634 
3636 
3638 
3639 /**
3640  * Pack a dictionary for use in side_data.
3641  *
3642  * @param dict The dictionary to pack.
3643  * @param size pointer to store the size of the returned data
3644  * @return pointer to data if successful, NULL otherwise
3645  */
3647 /**
3648  * Unpack a dictionary from side_data.
3649  *
3650  * @param data data from side_data
3651  * @param size size of the data
3652  * @param dict the metadata storage dictionary
3653  * @return 0 on success, < 0 on failure
3654  */
3655 int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
3656 
3657 
3658 /**
3659  * Convenience function to free all the side data stored.
3660  * All the other fields stay untouched.
3661  *
3662  * @param pkt packet
3663  */
3665 
3666 /**
3667  * Setup a new reference to the data described by a given packet
3668  *
3669  * If src is reference-counted, setup dst as a new reference to the
3670  * buffer in src. Otherwise allocate a new buffer in dst and copy the
3671  * data from src into it.
3672  *
3673  * All the other fields are copied from src.
3674  *
3675  * @see av_packet_unref
3676  *
3677  * @param dst Destination packet
3678  * @param src Source packet
3679  *
3680  * @return 0 on success, a negative AVERROR on error.
3681  */
3682 int av_packet_ref(AVPacket *dst, AVPacket *src);
3683 
3684 /**
3685  * Wipe the packet.
3686  *
3687  * Unreference the buffer referenced by the packet and reset the
3688  * remaining packet fields to their default values.
3689  *
3690  * @param pkt The packet to be unreferenced.
3691  */
3693 
3694 /**
3695  * Move every field in src to dst and reset src.
3696  *
3697  * @see av_packet_unref
3698  *
3699  * @param src Source packet, will be reset
3700  * @param dst Destination packet
3701  */
3703 
3704 /**
3705  * Copy only "properties" fields from src to dst.
3706  *
3707  * Properties for the purpose of this function are all the fields
3708  * beside those related to the packet data (buf, data, size)
3709  *
3710  * @param dst Destination packet
3711  * @param src Source packet
3712  *
3713  * @return 0 on success AVERROR on failure.
3714  *
3715  */
3716 int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
3717 
3718 /**
3719  * @}
3720  */
3721 
3722 /**
3723  * @addtogroup lavc_decoding
3724  * @{
3725  */
3726 
3727 /**
3728  * Find a registered decoder with a matching codec ID.
3729  *
3730  * @param id AVCodecID of the requested decoder
3731  * @return A decoder if one was found, NULL otherwise.
3732  */
3734 
3735 /**
3736  * Find a registered decoder with the specified name.
3737  *
3738  * @param name name of the requested decoder
3739  * @return A decoder if one was found, NULL otherwise.
3740  */
3742 
3743 #if FF_API_GET_BUFFER
3747 #endif
3748 
3749 /**
3750  * The default callback for AVCodecContext.get_buffer2(). It is made public so
3751  * it can be called by custom get_buffer2() implementations for decoders without
3752  * CODEC_CAP_DR1 set.
3753  */
3755 
3756 #if FF_API_EMU_EDGE
3757 /**
3758  * Return the amount of padding in pixels which the get_buffer callback must
3759  * provide around the edge of the image for codecs which do not have the
3760  * CODEC_FLAG_EMU_EDGE flag.
3761  *
3762  * @return Required padding in pixels.
3763  *
3764  * @deprecated CODEC_FLAG_EMU_EDGE is deprecated, so this function is no longer
3765  * needed
3766  */
3768 unsigned avcodec_get_edge_width(void);
3769 #endif
3770 
3771 /**
3772  * Modify width and height values so that they will result in a memory
3773  * buffer that is acceptable for the codec if you do not use any horizontal
3774  * padding.
3775  *
3776  * May only be used if a codec with CODEC_CAP_DR1 has been opened.
3777  */
3779 
3780 /**
3781  * Modify width and height values so that they will result in a memory
3782  * buffer that is acceptable for the codec if you also ensure that all
3783  * line sizes are a multiple of the respective linesize_align[i].
3784  *
3785  * May only be used if a codec with CODEC_CAP_DR1 has been opened.
3786  */
3788  int linesize_align[AV_NUM_DATA_POINTERS]);
3789 
3790 /**
3791  * Converts AVChromaLocation to swscale x/y chroma position.
3792  *
3793  * The positions represent the chroma (0,0) position in a coordinates system
3794  * with luma (0,0) representing the origin and luma(1,1) representing 256,256
3795  *
3796  * @param xpos horizontal chroma sample position
3797  * @param ypos vertical chroma sample position
3798  */
3799 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
3800 
3801 /**
3802  * Converts swscale x/y chroma position to AVChromaLocation.
3803  *
3804  * The positions represent the chroma (0,0) position in a coordinates system
3805  * with luma (0,0) representing the origin and luma(1,1) representing 256,256
3806  *
3807  * @param xpos horizontal chroma sample position
3808  * @param ypos vertical chroma sample position
3809  */
3810 enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);
3811 
3812 #if FF_API_OLD_DECODE_AUDIO
3813 /**
3814  * Wrapper function which calls avcodec_decode_audio4.
3815  *
3816  * @deprecated Use avcodec_decode_audio4 instead.
3817  *
3818  * Decode the audio frame of size avpkt->size from avpkt->data into samples.
3819  * Some decoders may support multiple frames in a single AVPacket, such
3820  * decoders would then just decode the first frame. In this case,
3821  * avcodec_decode_audio3 has to be called again with an AVPacket that contains
3822  * the remaining data in order to decode the second frame etc.
3823  * If no frame
3824  * could be outputted, frame_size_ptr is zero. Otherwise, it is the
3825  * decompressed frame size in bytes.
3826  *
3827  * @warning You must set frame_size_ptr to the allocated size of the
3828  * output buffer before calling avcodec_decode_audio3().
3829  *
3830  * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
3831  * the actual read bytes because some optimized bitstream readers read 32 or 64
3832  * bits at once and could read over the end.
3833  *
3834  * @warning The end of the input buffer avpkt->data should be set to 0 to ensure that
3835  * no overreading happens for damaged MPEG streams.
3836  *
3837  * @warning You must not provide a custom get_buffer() when using
3838  * avcodec_decode_audio3(). Doing so will override it with
3839  * avcodec_default_get_buffer. Use avcodec_decode_audio4() instead,
3840  * which does allow the application to provide a custom get_buffer().
3841  *
3842  * @note You might have to align the input buffer avpkt->data and output buffer
3843  * samples. The alignment requirements depend on the CPU: On some CPUs it isn't
3844  * necessary at all, on others it won't work at all if not aligned and on others
3845  * it will work but it will have an impact on performance.
3846  *
3847  * In practice, avpkt->data should have 4 byte alignment at minimum and
3848  * samples should be 16 byte aligned unless the CPU doesn't need it
3849  * (AltiVec and SSE do).
3850  *
3851  * @note Codecs which have the CODEC_CAP_DELAY capability set have a delay
3852  * between input and output, these need to be fed with avpkt->data=NULL,
3853  * avpkt->size=0 at the end to return the remaining frames.
3854  *
3855  * @param avctx the codec context
3856  * @param[out] samples the output buffer, sample type in avctx->sample_fmt
3857  * If the sample format is planar, each channel plane will
3858  * be the same size, with no padding between channels.
3859  * @param[in,out] frame_size_ptr the output buffer size in bytes
3860  * @param[in] avpkt The input AVPacket containing the input buffer.
3861  * You can create such packet with av_init_packet() and by then setting
3862  * data and size, some decoders might in addition need other fields.
3863  * All decoders are designed to use the least fields possible though.
3864  * @return On error a negative value is returned, otherwise the number of bytes
3865  * used or zero if no frame data was decompressed (used) from the input AVPacket.
3866  */
3867 attribute_deprecated int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
3868  int *frame_size_ptr,
3869  AVPacket *avpkt);
3870 #endif
3871 
3872 /**
3873  * Decode the audio frame of size avpkt->size from avpkt->data into frame.
3874  *
3875  * Some decoders may support multiple frames in a single AVPacket. Such
3876  * decoders would then just decode the first frame and the return value would be
3877  * less than the packet size. In this case, avcodec_decode_audio4 has to be
3878  * called again with an AVPacket containing the remaining data in order to
3879  * decode the second frame, etc... Even if no frames are returned, the packet
3880  * needs to be fed to the decoder with remaining data until it is completely
3881  * consumed or an error occurs.
3882  *
3883  * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input
3884  * and output. This means that for some packets they will not immediately
3885  * produce decoded output and need to be flushed at the end of decoding to get
3886  * all the decoded data. Flushing is done by calling this function with packets
3887  * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
3888  * returning samples. It is safe to flush even those decoders that are not
3889  * marked with CODEC_CAP_DELAY, then no samples will be returned.
3890  *
3891  * @warning The input buffer, avpkt->data must be FF_INPUT_BUFFER_PADDING_SIZE
3892  * larger than the actual read bytes because some optimized bitstream
3893  * readers read 32 or 64 bits at once and could read over the end.
3894  *
3895  * @param avctx the codec context
3896  * @param[out] frame The AVFrame in which to store decoded audio samples.
3897  * The decoder will allocate a buffer for the decoded frame by
3898  * calling the AVCodecContext.get_buffer2() callback.
3899  * When AVCodecContext.refcounted_frames is set to 1, the frame is
3900  * reference counted and the returned reference belongs to the
3901  * caller. The caller must release the frame using av_frame_unref()
3902  * when the frame is no longer needed. The caller may safely write
3903  * to the frame if av_frame_is_writable() returns 1.
3904  * When AVCodecContext.refcounted_frames is set to 0, the returned
3905  * reference belongs to the decoder and is valid only until the
3906  * next call to this function or until closing or flushing the
3907  * decoder. The caller may not write to it.
3908  * @param[out] got_frame_ptr Zero if no frame could be decoded, otherwise it is
3909  * non-zero. Note that this field being set to zero
3910  * does not mean that an error has occurred. For
3911  * decoders with CODEC_CAP_DELAY set, no given decode
3912  * call is guaranteed to produce a frame.
3913  * @param[in] avpkt The input AVPacket containing the input buffer.
3914  * At least avpkt->data and avpkt->size should be set. Some
3915  * decoders might also require additional fields to be set.
3916  * @return A negative error code is returned if an error occurred during
3917  * decoding, otherwise the number of bytes consumed from the input
3918  * AVPacket is returned.
3919  */
3921  int *got_frame_ptr, const AVPacket *avpkt);
3922 
3923 /**
3924  * Decode the video frame of size avpkt->size from avpkt->data into picture.
3925  * Some decoders may support multiple frames in a single AVPacket, such
3926  * decoders would then just decode the first frame.
3927  *
3928  * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
3929  * the actual read bytes because some optimized bitstream readers read 32 or 64
3930  * bits at once and could read over the end.
3931  *
3932  * @warning The end of the input buffer buf should be set to 0 to ensure that
3933  * no overreading happens for damaged MPEG streams.
3934  *
3935  * @note Codecs which have the CODEC_CAP_DELAY capability set have a delay
3936  * between input and output, these need to be fed with avpkt->data=NULL,
3937  * avpkt->size=0 at the end to return the remaining frames.
3938  *
3939  * @param avctx the codec context
3940  * @param[out] picture The AVFrame in which the decoded video frame will be stored.
3941  * Use av_frame_alloc() to get an AVFrame. The codec will
3942  * allocate memory for the actual bitmap by calling the
3943  * AVCodecContext.get_buffer2() callback.
3944  * When AVCodecContext.refcounted_frames is set to 1, the frame is
3945  * reference counted and the returned reference belongs to the
3946  * caller. The caller must release the frame using av_frame_unref()
3947  * when the frame is no longer needed. The caller may safely write
3948  * to the frame if av_frame_is_writable() returns 1.
3949  * When AVCodecContext.refcounted_frames is set to 0, the returned
3950  * reference belongs to the decoder and is valid only until the
3951  * next call to this function or until closing or flushing the
3952  * decoder. The caller may not write to it.
3953  *
3954  * @param[in] avpkt The input AVPacket containing the input buffer.
3955  * You can create such packet with av_init_packet() and by then setting
3956  * data and size, some decoders might in addition need other fields like
3957  * flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least
3958  * fields possible.
3959  * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
3960  * @return On error a negative value is returned, otherwise the number of bytes
3961  * used or zero if no frame could be decompressed.
3962  */
3963 int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
3964  int *got_picture_ptr,
3965  const AVPacket *avpkt);
3966 
3967 /**
3968  * Decode a subtitle message.
3969  * Return a negative value on error, otherwise return the number of bytes used.
3970  * If no subtitle could be decompressed, got_sub_ptr is zero.
3971  * Otherwise, the subtitle is stored in *sub.
3972  * Note that CODEC_CAP_DR1 is not available for subtitle codecs. This is for
3973  * simplicity, because the performance difference is expect to be negligible
3974  * and reusing a get_buffer written for video codecs would probably perform badly
3975  * due to a potentially very different allocation pattern.
3976  *
3977  * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input
3978  * and output. This means that for some packets they will not immediately
3979  * produce decoded output and need to be flushed at the end of decoding to get
3980  * all the decoded data. Flushing is done by calling this function with packets
3981  * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
3982  * returning subtitles. It is safe to flush even those decoders that are not
3983  * marked with CODEC_CAP_DELAY, then no subtitles will be returned.
3984  *
3985  * @param avctx the codec context
3986  * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored, must be
3987  freed with avsubtitle_free if *got_sub_ptr is set.
3988  * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
3989  * @param[in] avpkt The input AVPacket containing the input buffer.
3990  */
3992  int *got_sub_ptr,
3993  AVPacket *avpkt);
3994 
3995 /**
3996  * @defgroup lavc_parsing Frame parsing
3997  * @{
3998  */
4002  AV_PICTURE_STRUCTURE_TOP_FIELD, //< coded as top field
4003  AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field
4004  AV_PICTURE_STRUCTURE_FRAME, //< coded as frame
4005 };
4007 typedef struct AVCodecParserContext {
4008  void *priv_data;
4010  int64_t frame_offset; /* offset of the current frame */
4011  int64_t cur_offset; /* current offset
4012  (incremented by each av_parser_parse()) */
4013  int64_t next_frame_offset; /* offset of the next frame */
4014  /* video info */
4015  int pict_type; /* XXX: Put it back in AVCodecContext. */
4016  /**
4017  * This field is used for proper frame duration computation in lavf.
4018  * It signals, how much longer the frame duration of the current frame
4019  * is compared to normal frame duration.
4020  *
4021  * frame_duration = (1 + repeat_pict) * time_base
4022  *
4023  * It is used by codecs like H.264 to display telecined material.
4024  */
4025  int repeat_pict; /* XXX: Put it back in AVCodecContext. */
4026  int64_t pts; /* pts of the current frame */
4027  int64_t dts; /* dts of the current frame */
4028 
4029  /* private data */
4030  int64_t last_pts;
4031  int64_t last_dts;
4032  int fetch_timestamp;
4034 #define AV_PARSER_PTS_NB 4
4040  int flags;
4041 #define PARSER_FLAG_COMPLETE_FRAMES 0x0001
4042 #define PARSER_FLAG_ONCE 0x0002
4043 /// Set if the parser has a valid file offset
4044 #define PARSER_FLAG_FETCHED_OFFSET 0x0004
4045 #define PARSER_FLAG_USE_CODEC_TS 0x1000
4047  int64_t offset; ///< byte offset from starting packet start
4049 
4050  /**
4051  * Set by parser to 1 for key frames and 0 for non-key frames.
4052  * It is initialized to -1, so if the parser doesn't set this flag,
4053  * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames
4054  * will be used.
4055  */
4056  int key_frame;
4057 
4058  /**
4059  * Time difference in stream time base units from the pts of this
4060  * packet to the point at which the output from the decoder has converged
4061  * independent from the availability of previous frames. That is, the
4062  * frames are virtually identical no matter if decoding started from
4063  * the very first frame or from this keyframe.
4064  * Is AV_NOPTS_VALUE if unknown.
4065  * This field is not the display duration of the current frame.
4066  * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY
4067  * set.
4068  *
4069  * The purpose of this field is to allow seeking in streams that have no
4070  * keyframes in the conventional sense. It corresponds to the
4071  * recovery point SEI in H.264 and match_time_delta in NUT. It is also
4072  * essential for some types of subtitle streams to ensure that all
4073  * subtitles are correctly displayed after seeking.
4074  */
4075  int64_t convergence_duration;
4076 
4077  // Timestamp generation support:
4078  /**
4079  * Synchronization point for start of timestamp generation.
4080  *
4081  * Set to >0 for sync point, 0 for no sync point and <0 for undefined
4082  * (default).
4083  *
4084  * For example, this corresponds to presence of H.264 buffering period
4085  * SEI message.
4086  */
4087  int dts_sync_point;
4088 
4089  /**
4090  * Offset of the current timestamp against last timestamp sync point in
4091  * units of AVCodecContext.time_base.
4092  *
4093  * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
4094  * contain a valid timestamp offset.
4095  *
4096  * Note that the timestamp of sync point has usually a nonzero
4097  * dts_ref_dts_delta, which refers to the previous sync point. Offset of
4098  * the next frame after timestamp sync point will be usually 1.
4099  *
4100  * For example, this corresponds to H.264 cpb_removal_delay.
4101  */
4102  int dts_ref_dts_delta;
4103 
4104  /**
4105  * Presentation delay of current frame in units of AVCodecContext.time_base.
4106  *
4107  * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
4108  * contain valid non-negative timestamp delta (presentation time of a frame
4109  * must not lie in the past).
4110  *
4111  * This delay represents the difference between decoding and presentation
4112  * time of the frame.
4113  *
4114  * For example, this corresponds to H.264 dpb_output_delay.
4115  */
4116  int pts_dts_delta;
4117 
4118  /**
4119  * Position of the packet in file.
4120  *
4121  * Analogous to cur_frame_pts/dts
4122  */
4124 
4125  /**
4126  * Byte position of currently parsed frame in stream.
4127  */
4128  int64_t pos;
4129 
4130  /**
4131  * Previous frame byte position.
4132  */
4133  int64_t last_pos;
4134 
4135  /**
4136  * Duration of the current frame.
4137  * For audio, this is in units of 1 / AVCodecContext.sample_rate.
4138  * For all other types, this is in units of AVCodecContext.time_base.
4139  */
4140  int duration;
4143 
4144  /**
4145  * Indicate whether a picture is coded as a frame, top field or bottom field.
4146  *
4147  * For example, H.264 field_pic_flag equal to 0 corresponds to
4148  * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag
4149  * equal to 1 and bottom_field_flag equal to 0 corresponds to
4150  * AV_PICTURE_STRUCTURE_TOP_FIELD.
4151  */
4153 
4154  /**
4155  * Picture number incremented in presentation or output order.
4156  * This field may be reinitialized at the first picture of a new sequence.
4157  *
4158  * For example, this corresponds to H.264 PicOrderCnt.
4159  */
4163 typedef struct AVCodecParser {
4164  int codec_ids[5]; /* several codec IDs are permitted */
4168  AVCodecContext *avctx,
4169  const uint8_t **poutbuf, int *poutbuf_size,
4170  const uint8_t *buf, int buf_size);
4172  int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
4173  struct AVCodecParser *next;
4174 } AVCodecParser;
4175 
4177 
4180 
4181 /**
4182  * Parse a packet.
4183  *
4184  * @param s parser context.
4185  * @param avctx codec context.
4186  * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished.
4187  * @param poutbuf_size set to size of parsed buffer or zero if not yet finished.
4188  * @param buf input buffer.
4189  * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output).
4190  * @param pts input presentation timestamp.
4191  * @param dts input decoding timestamp.
4192  * @param pos input byte position in stream.
4193  * @return the number of bytes of the input bitstream used.
4194  *
4195  * Example:
4196  * @code
4197  * while(in_len){
4198  * len = av_parser_parse2(myparser, AVCodecContext, &data, &size,
4199  * in_data, in_len,
4200  * pts, dts, pos);
4201  * in_data += len;
4202  * in_len -= len;
4203  *
4204  * if(size)
4205  * decode_frame(data, size);
4206  * }
4207  * @endcode
4208  */
4210  AVCodecContext *avctx,
4211  uint8_t **poutbuf, int *poutbuf_size,
4212  const uint8_t *buf, int buf_size,
4213  int64_t pts, int64_t dts,
4214  int64_t pos);
4215 
4216 /**
4217  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
4218  * @deprecated use AVBitStreamFilter
4219  */
4221  AVCodecContext *avctx,
4222  uint8_t **poutbuf, int *poutbuf_size,
4223  const uint8_t *buf, int buf_size, int keyframe);
4225 
4226 /**
4227  * @}
4228  * @}
4229  */
4230 
4231 /**
4232  * @addtogroup lavc_encoding
4233  * @{
4234  */
4235 
4236 /**
4237  * Find a registered encoder with a matching codec ID.
4238  *
4239  * @param id AVCodecID of the requested encoder
4240  * @return An encoder if one was found, NULL otherwise.
4241  */
4243 
4244 /**
4245  * Find a registered encoder with the specified name.
4246  *
4247  * @param name name of the requested encoder
4248  * @return An encoder if one was found, NULL otherwise.
4249  */
4251 
4252 #if FF_API_OLD_ENCODE_AUDIO
4253 /**
4254  * Encode an audio frame from samples into buf.
4255  *
4256  * @deprecated Use avcodec_encode_audio2 instead.
4257  *
4258  * @note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large.
4259  * However, for codecs with avctx->frame_size equal to 0 (e.g. PCM) the user
4260  * will know how much space is needed because it depends on the value passed
4261  * in buf_size as described below. In that case a lower value can be used.
4262  *
4263  * @param avctx the codec context
4264  * @param[out] buf the output buffer
4265  * @param[in] buf_size the output buffer size
4266  * @param[in] samples the input buffer containing the samples
4267  * The number of samples read from this buffer is frame_size*channels,
4268  * both of which are defined in avctx.
4269  * For codecs which have avctx->frame_size equal to 0 (e.g. PCM) the number of
4270  * samples read from samples is equal to:
4271  * buf_size * 8 / (avctx->channels * av_get_bits_per_sample(avctx->codec_id))
4272  * This also implies that av_get_bits_per_sample() must not return 0 for these
4273  * codecs.
4274  * @return On error a negative value is returned, on success zero or the number
4275  * of bytes used to encode the data read from the input buffer.
4276  */
4278  uint8_t *buf, int buf_size,
4279  const short *samples);
4280 #endif
4281 
4282 /**
4283  * Encode a frame of audio.
4284  *
4285  * Takes input samples from frame and writes the next output packet, if
4286  * available, to avpkt. The output packet does not necessarily contain data for
4287  * the most recent frame, as encoders can delay, split, and combine input frames
4288  * internally as needed.
4289  *
4290  * @param avctx codec context
4291  * @param avpkt output AVPacket.
4292  * The user can supply an output buffer by setting
4293  * avpkt->data and avpkt->size prior to calling the
4294  * function, but if the size of the user-provided data is not
4295  * large enough, encoding will fail. If avpkt->data and
4296  * avpkt->size are set, avpkt->destruct must also be set. All
4297  * other AVPacket fields will be reset by the encoder using
4298  * av_init_packet(). If avpkt->data is NULL, the encoder will
4299  * allocate it. The encoder will set avpkt->size to the size
4300  * of the output packet.
4301  *
4302  * If this function fails or produces no output, avpkt will be
4303  * freed using av_free_packet() (i.e. avpkt->destruct will be
4304  * called to free the user supplied buffer).
4305  * @param[in] frame AVFrame containing the raw audio data to be encoded.
4306  * May be NULL when flushing an encoder that has the
4307  * CODEC_CAP_DELAY capability set.
4308  * If CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
4309  * can have any number of samples.
4310  * If it is not set, frame->nb_samples must be equal to
4311  * avctx->frame_size for all frames except the last.
4312  * The final frame may be smaller than avctx->frame_size.
4313  * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the
4314  * output packet is non-empty, and to 0 if it is
4315  * empty. If the function returns an error, the
4316  * packet can be assumed to be invalid, and the
4317  * value of got_packet_ptr is undefined and should
4318  * not be used.
4319  * @return 0 on success, negative error code on failure
4320  */
4321 int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
4322  const AVFrame *frame, int *got_packet_ptr);
4323 
4324 #if FF_API_OLD_ENCODE_VIDEO
4325 /**
4326  * @deprecated use avcodec_encode_video2() instead.
4327  *
4328  * Encode a video frame from pict into buf.
4329  * The input picture should be
4330  * stored using a specific format, namely avctx.pix_fmt.
4331  *
4332  * @param avctx the codec context
4333  * @param[out] buf the output buffer for the bitstream of encoded frame
4334  * @param[in] buf_size the size of the output buffer in bytes
4335  * @param[in] pict the input picture to encode
4336  * @return On error a negative value is returned, on success zero or the number
4337  * of bytes used from the output buffer.
4338  */
4340 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
4341  const AVFrame *pict);
4342 #endif
4343 
4344 /**
4345  * Encode a frame of video.
4346  *
4347  * Takes input raw video data from frame and writes the next output packet, if
4348  * available, to avpkt. The output packet does not necessarily contain data for
4349  * the most recent frame, as encoders can delay and reorder input frames
4350  * internally as needed.
4351  *
4352  * @param avctx codec context
4353  * @param avpkt output AVPacket.
4354  * The user can supply an output buffer by setting
4355  * avpkt->data and avpkt->size prior to calling the
4356  * function, but if the size of the user-provided data is not
4357  * large enough, encoding will fail. All other AVPacket fields
4358  * will be reset by the encoder using av_init_packet(). If
4359  * avpkt->data is NULL, the encoder will allocate it.
4360  * The encoder will set avpkt->size to the size of the
4361  * output packet. The returned data (if any) belongs to the
4362  * caller, he is responsible for freeing it.
4363  *
4364  * If this function fails or produces no output, avpkt will be
4365  * freed using av_free_packet() (i.e. avpkt->destruct will be
4366  * called to free the user supplied buffer).
4367  * @param[in] frame AVFrame containing the raw video data to be encoded.
4368  * May be NULL when flushing an encoder that has the
4369  * CODEC_CAP_DELAY capability set.
4370  * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the
4371  * output packet is non-empty, and to 0 if it is
4372  * empty. If the function returns an error, the
4373  * packet can be assumed to be invalid, and the
4374  * value of got_packet_ptr is undefined and should
4375  * not be used.
4376  * @return 0 on success, negative error code on failure
4377  */
4378 int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,
4379  const AVFrame *frame, int *got_packet_ptr);
4380 
4381 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
4382  const AVSubtitle *sub);
4383 
4384 
4385 /**
4386  * @}
4387  */
4388 
4389 #if FF_API_AVCODEC_RESAMPLE
4390 /**
4391  * @defgroup lavc_resample Audio resampling
4392  * @ingroup libavc
4393  * @deprecated use libswresample instead
4394  *
4395  * @{
4396  */
4397 struct ReSampleContext;
4398 struct AVResampleContext;
4399 
4400 typedef struct ReSampleContext ReSampleContext;
4401 
4402 /**
4403  * Initialize audio resampling context.
4404  *
4405  * @param output_channels number of output channels
4406  * @param input_channels number of input channels
4407  * @param output_rate output sample rate
4408  * @param input_rate input sample rate
4409  * @param sample_fmt_out requested output sample format
4410  * @param sample_fmt_in input sample format
4411  * @param filter_length length of each FIR filter in the filterbank relative to the cutoff frequency
4412  * @param log2_phase_count log2 of the number of entries in the polyphase filterbank
4413  * @param linear if 1 then the used FIR filter will be linearly interpolated
4414  between the 2 closest, if 0 the closest will be used
4415  * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate
4416  * @return allocated ReSampleContext, NULL if error occurred
4417  */
4420  int output_rate, int input_rate,
4421  enum AVSampleFormat sample_fmt_out,
4422  enum AVSampleFormat sample_fmt_in,
4423  int filter_length, int log2_phase_count,
4424  int linear, double cutoff);
4425 
4427 int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
4428 
4429 /**
4430  * Free resample context.
4431  *
4432  * @param s a non-NULL pointer to a resample context previously
4433  * created with av_audio_resample_init()
4434  */
4437 
4438 
4439 /**
4440  * Initialize an audio resampler.
4441  * Note, if either rate is not an integer then simply scale both rates up so they are.
4442  * @param filter_length length of each FIR filter in the filterbank relative to the cutoff freq
4443  * @param log2_phase_count log2 of the number of entries in the polyphase filterbank
4444  * @param linear If 1 then the used FIR filter will be linearly interpolated
4445  between the 2 closest, if 0 the closest will be used
4446  * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate
4447  */
4449 struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff);
4450 
4451 /**
4452  * Resample an array of samples using a previously configured context.
4453  * @param src an array of unconsumed samples
4454  * @param consumed the number of samples of src which have been consumed are returned here
4455  * @param src_size the number of unconsumed samples available
4456  * @param dst_size the amount of space in samples available in dst
4457  * @param update_ctx If this is 0 then the context will not be modified, that way several channels can be resampled with the same context.
4458  * @return the number of samples written in dst or -1 if an error occurred
4459  */
4461 int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx);
4462 
4463 
4464 /**
4465  * Compensate samplerate/timestamp drift. The compensation is done by changing
4466  * the resampler parameters, so no audible clicks or similar distortions occur
4467  * @param compensation_distance distance in output samples over which the compensation should be performed
4468  * @param sample_delta number of output samples which should be output less
4469  *
4470  * example: av_resample_compensate(c, 10, 500)
4471  * here instead of 510 samples only 500 samples would be output
4472  *
4473  * note, due to rounding the actual compensation might be slightly different,
4474  * especially if the compensation_distance is large and the in_rate used during init is small
4475  */
4477 void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance);
4479 void av_resample_close(struct AVResampleContext *c);
4480 
4481 /**
4482  * @}
4483  */
4484 #endif
4485 
4486 /**
4487  * @addtogroup lavc_picture
4488  * @{
4489  */
4490 
4491 /**
4492  * Allocate memory for the pixels of a picture and setup the AVPicture
4493  * fields for it.
4494  *
4495  * Call avpicture_free() to free it.
4496  *
4497  * @param picture the picture structure to be filled in
4498  * @param pix_fmt the pixel format of the picture
4499  * @param width the width of the picture
4500  * @param height the height of the picture
4501  * @return zero if successful, a negative error code otherwise
4502  *
4503  * @see av_image_alloc(), avpicture_fill()
4504  */
4505 int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height);
4506 
4507 /**
4508  * Free a picture previously allocated by avpicture_alloc().
4509  * The data buffer used by the AVPicture is freed, but the AVPicture structure
4510  * itself is not.
4511  *
4512  * @param picture the AVPicture to be freed
4513  */
4514 void avpicture_free(AVPicture *picture);
4515 
4516 /**
4517  * Setup the picture fields based on the specified image parameters
4518  * and the provided image data buffer.
4519  *
4520  * The picture fields are filled in by using the image data buffer
4521  * pointed to by ptr.
4522  *
4523  * If ptr is NULL, the function will fill only the picture linesize
4524  * array and return the required size for the image buffer.
4525  *
4526  * To allocate an image buffer and fill the picture data in one call,
4527  * use avpicture_alloc().
4528  *
4529  * @param picture the picture to be filled in
4530  * @param ptr buffer where the image data is stored, or NULL
4531  * @param pix_fmt the pixel format of the image
4532  * @param width the width of the image in pixels
4533  * @param height the height of the image in pixels
4534  * @return the size in bytes required for src, a negative error code
4535  * in case of failure
4536  *
4537  * @see av_image_fill_arrays()
4538  */
4539 int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
4540  enum AVPixelFormat pix_fmt, int width, int height);
4541 
4542 /**
4543  * Copy pixel data from an AVPicture into a buffer.
4544  *
4545  * avpicture_get_size() can be used to compute the required size for
4546  * the buffer to fill.
4547  *
4548  * @param src source picture with filled data
4549  * @param pix_fmt picture pixel format
4550  * @param width picture width
4551  * @param height picture height
4552  * @param dest destination buffer
4553  * @param dest_size destination buffer size in bytes
4554  * @return the number of bytes written to dest, or a negative value
4555  * (error code) on error, for example if the destination buffer is not
4556  * big enough
4557  *
4558  * @see av_image_copy_to_buffer()
4559  */
4561  int width, int height,
4562  unsigned char *dest, int dest_size);
4563 
4564 /**
4565  * Calculate the size in bytes that a picture of the given width and height
4566  * would occupy if stored in the given picture format.
4567  *
4568  * @param pix_fmt picture pixel format
4569  * @param width picture width
4570  * @param height picture height
4571  * @return the computed picture buffer size or a negative error code
4572  * in case of error
4573  *
4574  * @see av_image_get_buffer_size().
4575  */
4577 
4578 #if FF_API_DEINTERLACE
4579 /**
4580  * deinterlace - if not supported return -1
4581  *
4582  * @deprecated - use yadif (in libavfilter) instead
4583  */
4585 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
4586  enum AVPixelFormat pix_fmt, int width, int height);
4587 #endif
4588 /**
4589  * Copy image src to dst. Wraps av_image_copy().
4590  */
4591 void av_picture_copy(AVPicture *dst, const AVPicture *src,
4592  enum AVPixelFormat pix_fmt, int width, int height);
4593 
4594 /**
4595  * Crop image top and left side.
4596  */
4597 int av_picture_crop(AVPicture *dst, const AVPicture *src,
4598  enum AVPixelFormat pix_fmt, int top_band, int left_band);
4599 
4600 /**
4601  * Pad image.
4602  */
4603 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt,
4604  int padtop, int padbottom, int padleft, int padright, int *color);
4605 
4606 /**
4607  * @}
4608  */
4609 
4610 /**
4611  * @defgroup lavc_misc Utility functions
4612  * @ingroup libavc
4613  *
4614  * Miscellaneous utility functions related to both encoding and decoding
4615  * (or neither).
4616  * @{
4617  */
4618 
4619 /**
4620  * @defgroup lavc_misc_pixfmt Pixel formats
4621  *
4622  * Functions for working with pixel formats.
4623  * @{
4624  */
4625 
4626 /**
4627  * Utility function to access log2_chroma_w log2_chroma_h from
4628  * the pixel format AVPixFmtDescriptor.
4629  *
4630  * This function asserts that pix_fmt is valid. See av_pix_fmt_get_chroma_sub_sample
4631  * for one that returns a failure code and continues in case of invalid
4632  * pix_fmts.
4633  *
4634  * @param[in] pix_fmt the pixel format
4635  * @param[out] h_shift store log2_chroma_w
4636  * @param[out] v_shift store log2_chroma_h
4637  *
4638  * @see av_pix_fmt_get_chroma_sub_sample
4639  */
4640 
4641 void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
4642 
4643 /**
4644  * Return a value representing the fourCC code associated to the
4645  * pixel format pix_fmt, or 0 if no associated fourCC code can be
4646  * found.
4647  */
4650 #define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */
4651 #define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */
4652 #define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */
4653 #define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */
4654 #define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */
4655 #define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */
4656 
4657 /**
4658  * Compute what kind of losses will occur when converting from one specific
4659  * pixel format to another.
4660  * When converting from one pixel format to another, information loss may occur.
4661  * For example, when converting from RGB24 to GRAY, the color information will
4662  * be lost. Similarly, other losses occur when converting from some formats to
4663  * other formats. These losses can involve loss of chroma, but also loss of
4664  * resolution, loss of color depth, loss due to the color space conversion, loss
4665  * of the alpha bits or loss due to color quantization.
4666  * avcodec_get_fix_fmt_loss() informs you about the various types of losses
4667  * which will occur when converting from one pixel format to another.
4668  *
4669  * @param[in] dst_pix_fmt destination pixel format
4670  * @param[in] src_pix_fmt source pixel format
4671  * @param[in] has_alpha Whether the source pixel format alpha channel is used.
4672  * @return Combination of flags informing you what kind of losses will occur
4673  * (maximum loss for an invalid dst_pix_fmt).
4674  */
4675 int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
4676  int has_alpha);
4677 
4678 /**
4679  * Find the best pixel format to convert to given a certain source pixel
4680  * format. When converting from one pixel format to another, information loss
4681  * may occur. For example, when converting from RGB24 to GRAY, the color
4682  * information will be lost. Similarly, other losses occur when converting from
4683  * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of
4684  * the given pixel formats should be used to suffer the least amount of loss.
4685  * The pixel formats from which it chooses one, are determined by the
4686  * pix_fmt_list parameter.
4687  *
4688  *
4689  * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from
4690  * @param[in] src_pix_fmt source pixel format
4691  * @param[in] has_alpha Whether the source pixel format alpha channel is used.
4692  * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur.
4693  * @return The best pixel format to convert to or -1 if none was found.
4694  */
4695 enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list,
4696  enum AVPixelFormat src_pix_fmt,
4697  int has_alpha, int *loss_ptr);
4698 
4699 /**
4700  * Find the best pixel format to convert to given a certain source pixel
4701  * format and a selection of two destination pixel formats. When converting from
4702  * one pixel format to another, information loss may occur. For example, when converting
4703  * from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when
4704  * converting from some formats to other formats. avcodec_find_best_pix_fmt_of_2() selects which of
4705  * the given pixel formats should be used to suffer the least amount of loss.
4706  *
4707  * If one of the destination formats is AV_PIX_FMT_NONE the other pixel format (if valid) will be
4708  * returned.
4709  *
4710  * @code
4711  * src_pix_fmt = AV_PIX_FMT_YUV420P;
4712  * dst_pix_fmt1= AV_PIX_FMT_RGB24;
4713  * dst_pix_fmt2= AV_PIX_FMT_GRAY8;
4714  * dst_pix_fmt3= AV_PIX_FMT_RGB8;
4715  * loss= FF_LOSS_CHROMA; // don't care about chroma loss, so chroma loss will be ignored.
4716  * dst_pix_fmt = avcodec_find_best_pix_fmt_of_2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, alpha, &loss);
4717  * dst_pix_fmt = avcodec_find_best_pix_fmt_of_2(dst_pix_fmt, dst_pix_fmt3, src_pix_fmt, alpha, &loss);
4718  * @endcode
4719  *
4720  * @param[in] dst_pix_fmt1 One of the two destination pixel formats to choose from
4721  * @param[in] dst_pix_fmt2 The other of the two destination pixel formats to choose from
4722  * @param[in] src_pix_fmt Source pixel format
4723  * @param[in] has_alpha Whether the source pixel format alpha channel is used.
4724  * @param[in, out] loss_ptr Combination of loss flags. In: selects which of the losses to ignore, i.e.
4725  * NULL or value of zero means we care about all losses. Out: the loss
4726  * that occurs when converting from src to selected dst pixel format.
4727  * @return The best pixel format to convert to or -1 if none was found.
4728  */
4729 enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
4730  enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
4731 
4733 #if AV_HAVE_INCOMPATIBLE_LIBAV_ABI
4734 enum AVPixelFormat avcodec_find_best_pix_fmt2(const enum AVPixelFormat *pix_fmt_list,
4735  enum AVPixelFormat src_pix_fmt,
4736  int has_alpha, int *loss_ptr);
4737 #else
4738 enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
4739  enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
4740 #endif
4741 
4742 
4744 
4745 /**
4746  * @}
4747  */
4748 
4749 #if FF_API_SET_DIMENSIONS
4750 /**
4751  * @deprecated this function is not supposed to be used from outside of lavc
4752  */
4755 #endif
4756 
4757 /**
4758  * Put a string representing the codec tag codec_tag in buf.
4759  *
4760  * @param buf buffer to place codec tag in
4761  * @param buf_size size in bytes of buf
4762  * @param codec_tag codec tag to assign
4763  * @return the length of the string that would have been generated if
4764  * enough space had been available, excluding the trailing null
4765  */
4766 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag);
4767 
4768 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
4769 
4770 /**
4771  * Return a name for the specified profile, if available.
4772  *
4773  * @param codec the codec that is searched for the given profile
4774  * @param profile the profile value for which a name is requested
4775  * @return A name for the profile if found, NULL otherwise.
4776  */
4777 const char *av_get_profile_name(const AVCodec *codec, int profile);
4778 
4779 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size);
4780 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count);
4781 //FIXME func typedef
4782 
4783 /**
4784  * Fill AVFrame audio data and linesize pointers.
4785  *
4786  * The buffer buf must be a preallocated buffer with a size big enough
4787  * to contain the specified samples amount. The filled AVFrame data
4788  * pointers will point to this buffer.
4789  *
4790  * AVFrame extended_data channel pointers are allocated if necessary for
4791  * planar audio.
4792  *
4793  * @param frame the AVFrame
4794  * frame->nb_samples must be set prior to calling the
4795  * function. This function fills in frame->data,
4796  * frame->extended_data, frame->linesize[0].
4797  * @param nb_channels channel count
4798  * @param sample_fmt sample format
4799  * @param buf buffer to use for frame data
4800  * @param buf_size size of buffer
4801  * @param align plane size sample alignment (0 = default)
4802  * @return >=0 on success, negative error code on failure
4803  * @todo return the size in bytes required to store the samples in
4804  * case of success, at the next libavutil bump
4805  */
4807  enum AVSampleFormat sample_fmt, const uint8_t *buf,
4808  int buf_size, int align);
4809 
4810 /**
4811  * Reset the internal decoder state / flush internal buffers. Should be called
4812  * e.g. when seeking or when switching to a different stream.
4813  *
4814  * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0),
4815  * this invalidates the frames previously returned from the decoder. When
4816  * refcounted frames are used, the decoder just releases any references it might
4817  * keep internally, but the caller's reference remains valid.
4818  */
4820 
4821 /**
4822  * Return codec bits per sample.
4823  *
4824  * @param[in] codec_id the codec
4825  * @return Number of bits per sample or zero if unknown for the given codec.
4826  */
4828 
4829 /**
4830  * Return the PCM codec associated with a sample format.
4831  * @param be endianness, 0 for little, 1 for big,
4832  * -1 (or anything else) for native
4833  * @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
4834  */
4835 enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
4836 
4837 /**
4838  * Return codec bits per sample.
4839  * Only return non-zero if the bits per sample is exactly correct, not an
4840  * approximation.
4841  *
4842  * @param[in] codec_id the codec
4843  * @return Number of bits per sample or zero if unknown for the given codec.
4844  */
4846 
4847 /**
4848  * Return audio frame duration.
4849  *
4850  * @param avctx codec context
4851  * @param frame_bytes size of the frame, or 0 if unknown
4852  * @return frame duration, in samples, if known. 0 if not able to
4853  * determine.
4854  */
4855 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes);
4856 
4859  void *priv_data;
4864 
4866 typedef struct AVBitStreamFilter {
4867  const char *name;
4869  int (*filter)(AVBitStreamFilterContext *bsfc,
4870  AVCodecContext *avctx, const char *args,
4871  uint8_t **poutbuf, int *poutbuf_size,
4872  const uint8_t *buf, int buf_size, int keyframe);
4874  struct AVBitStreamFilter *next;
4876 
4877 /**
4878  * Register a bitstream filter.
4879  *
4880  * The filter will be accessible to the application code through
4881  * av_bitstream_filter_next() or can be directly initialized with
4882  * av_bitstream_filter_init().
4883  *
4884  * @see avcodec_register_all()
4885  */
4887 
4888 /**
4889  * Create and initialize a bitstream filter context given a bitstream
4890  * filter name.
4891  *
4892  * The returned context must be freed with av_bitstream_filter_close().
4893  *
4894  * @param name the name of the bitstream filter
4895  * @return a bitstream filter context if a matching filter was found
4896  * and successfully initialized, NULL otherwise
4897  */
4899 
4900 /**
4901  * Filter bitstream.
4902  *
4903  * This function filters the buffer buf with size buf_size, and places the
4904  * filtered buffer in the buffer pointed to by poutbuf.
4905  *
4906  * The output buffer must be freed by the caller.
4907  *
4908  * @param bsfc bitstream filter context created by av_bitstream_filter_init()
4909  * @param avctx AVCodecContext accessed by the filter, may be NULL.
4910  * If specified, this must point to the encoder context of the
4911  * output stream the packet is sent to.
4912  * @param args arguments which specify the filter configuration, may be NULL
4913  * @param poutbuf pointer which is updated to point to the filtered buffer
4914  * @param poutbuf_size pointer which is updated to the filtered buffer size in bytes
4915  * @param buf buffer containing the data to filter
4916  * @param buf_size size in bytes of buf
4917  * @param keyframe set to non-zero if the buffer to filter corresponds to a key-frame packet data
4918  * @return >= 0 in case of success, or a negative error code in case of failure
4919  *
4920  * If the return value is positive, an output buffer is allocated and
4921  * is availble in *poutbuf, and is distinct from the input buffer.
4922  *
4923  * If the return value is 0, the output buffer is not allocated and
4924  * should be considered identical to the input buffer, or in case
4925  * *poutbuf was set it points to the input buffer (not necessarily to
4926  * its starting address).
4927  */
4929  AVCodecContext *avctx, const char *args,
4930  uint8_t **poutbuf, int *poutbuf_size,
4931  const uint8_t *buf, int buf_size, int keyframe);
4932 
4933 /**
4934  * Release bitstream filter context.
4935  *
4936  * @param bsf the bitstream filter context created with
4937  * av_bitstream_filter_init(), can be NULL
4938  */
4940 
4941 /**
4942  * If f is NULL, return the first registered bitstream filter,
4943  * if f is non-NULL, return the next registered bitstream filter
4944  * after f, or NULL if f is the last one.
4945  *
4946  * This function can be used to iterate over all registered bitstream
4947  * filters.
4948  */