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