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