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