FFmpeg
target_dec_fuzzer.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 /* Targeted fuzzer that targets specific codecs depending on two
20  compile-time flags.
21  INSTRUCTIONS:
22 
23  * Get the very fresh clang, e.g. see http://libfuzzer.info#versions
24  * Get and build libFuzzer:
25  svn co http://llvm.org/svn/llvm-project/llvm/trunk/lib/Fuzzer
26  ./Fuzzer/build.sh
27  * build ffmpeg for fuzzing:
28  FLAGS="-fsanitize=address -fsanitize-coverage=trace-pc-guard,trace-cmp -g" CC="clang $FLAGS" CXX="clang++ $FLAGS" ./configure --disable-x86asm
29  make clean && make -j
30  * build the fuzz target.
31  Choose the value of FFMPEG_CODEC (e.g. AV_CODEC_ID_DVD_SUBTITLE) and
32  choose one of FUZZ_FFMPEG_VIDEO, FUZZ_FFMPEG_AUDIO, FUZZ_FFMPEG_SUBTITLE.
33  clang -fsanitize=address -fsanitize-coverage=trace-pc-guard,trace-cmp tools/target_dec_fuzzer.c -o target_dec_fuzzer -I. -DFFMPEG_CODEC=AV_CODEC_ID_MPEG1VIDEO -DFUZZ_FFMPEG_VIDEO ../../libfuzzer/libFuzzer.a -Llibavcodec -Llibavdevice -Llibavfilter -Llibavformat -Llibavresample -Llibavutil -Llibpostproc -Llibswscale -Llibswresample -Wl,--as-needed -Wl,-z,noexecstack -Wl,--warn-common -Wl,-rpath-link=:libpostproc:libswresample:libswscale:libavfilter:libavdevice:libavformat:libavcodec:libavutil:libavresample -lavdevice -lavfilter -lavformat -lavcodec -lswresample -lswscale -lavutil -ldl -lxcb -lxcb-shm -lxcb -lxcb-xfixes -lxcb -lxcb-shape -lxcb -lX11 -lasound -lm -lbz2 -lz -pthread
34  * create a corpus directory and put some samples there (empty dir is ok too):
35  mkdir CORPUS && cp some-files CORPUS
36 
37  * Run fuzzing:
38  ./target_dec_fuzzer -max_len=100000 CORPUS
39 
40  More info:
41  http://libfuzzer.info
42  http://tutorial.libfuzzer.info
43  https://github.com/google/oss-fuzz
44  http://lcamtuf.coredump.cx/afl/
45  https://security.googleblog.com/2016/08/guided-in-process-fuzzing-of-chrome.html
46 */
47 
48 #include "config.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/imgutils.h"
51 #include "libavutil/intreadwrite.h"
52 
53 #include "libavcodec/avcodec.h"
54 #include "libavcodec/bytestream.h"
55 #include "libavformat/avformat.h"
56 
57 //For FF_SANE_NB_CHANNELS, so we dont waste energy testing things that will get instantly rejected
58 #include "libavcodec/internal.h"
59 
60 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
61 
62 extern AVCodec * codec_list[];
63 
64 static void error(const char *err)
65 {
66  fprintf(stderr, "%s", err);
67  exit(1);
68 }
69 
70 static AVCodec *c = NULL;
72 {
73  AVCodec *res;
74 
75  res = avcodec_find_decoder(codec_id);
76  if (!res)
77  error("Failed to find decoder");
78  return res;
79 }
80 
81 static int subtitle_handler(AVCodecContext *avctx, void *frame,
82  int *got_sub_ptr, AVPacket *avpkt)
83 {
85  int ret = avcodec_decode_subtitle2(avctx, &sub, got_sub_ptr, avpkt);
86  if (ret >= 0 && *got_sub_ptr)
87  avsubtitle_free(&sub);
88  return ret;
89 }
90 
91 // Ensure we don't loop forever
92 const uint32_t maxiteration = 8096;
93 const uint64_t maxpixels_per_frame = 4096 * 4096;
94 uint64_t maxpixels;
95 
96 uint64_t maxsamples_per_frame = 256*1024*32;
97 uint64_t maxsamples;
98 
99 static const uint64_t FUZZ_TAG = 0x4741542D5A5A5546ULL;
100 
102  const uint64_t fuzz_tag = FUZZ_TAG;
103  const uint8_t *last = data;
104  const uint8_t *end = data + size;
105  uint32_t it = 0;
106  uint64_t ec_pixels = 0;
107  uint64_t nb_samples = 0;
108  int (*decode_handler)(AVCodecContext *avctx, AVFrame *picture,
109  int *got_picture_ptr,
110  const AVPacket *avpkt) = NULL;
111  AVCodecParserContext *parser = NULL;
112  uint64_t keyframes = 0;
113  uint64_t flushpattern = -1;
115 
116  if (!c) {
117 #ifdef FFMPEG_DECODER
118 #define DECODER_SYMBOL0(CODEC) ff_##CODEC##_decoder
119 #define DECODER_SYMBOL(CODEC) DECODER_SYMBOL0(CODEC)
120  extern AVCodec DECODER_SYMBOL(FFMPEG_DECODER);
121  codec_list[0] = &DECODER_SYMBOL(FFMPEG_DECODER);
122 
123 #if FFMPEG_DECODER == tiff || FFMPEG_DECODER == tdsc
124  extern AVCodec DECODER_SYMBOL(mjpeg);
125  codec_list[1] = &DECODER_SYMBOL(mjpeg);
126 #endif
127 
128  c = &DECODER_SYMBOL(FFMPEG_DECODER);
129 #else
130  c = AVCodecInitialize(FFMPEG_CODEC); // Done once.
131 #endif
133  }
134 
135  switch (c->type) {
136  case AVMEDIA_TYPE_AUDIO : decode_handler = avcodec_decode_audio4; break;
137  case AVMEDIA_TYPE_VIDEO : decode_handler = avcodec_decode_video2; break;
138  case AVMEDIA_TYPE_SUBTITLE: decode_handler = subtitle_handler ; break;
139  }
140  switch (c->id) {
141  case AV_CODEC_ID_APE: maxsamples_per_frame /= 256; break;
142  }
145  switch (c->id) {
146  case AV_CODEC_ID_AGM: maxpixels /= 1024; break;
147  case AV_CODEC_ID_BINKVIDEO: maxpixels /= 32; break;
148  case AV_CODEC_ID_CFHD: maxpixels /= 128; break;
149  case AV_CODEC_ID_DIRAC: maxpixels /= 8192; break;
150  case AV_CODEC_ID_DST: maxsamples /= 1<<20; break;
151  case AV_CODEC_ID_DXV: maxpixels /= 32; break;
152  case AV_CODEC_ID_FFWAVESYNTH: maxsamples /= 16384; break;
153  case AV_CODEC_ID_G2M: maxpixels /= 64; break;
154  case AV_CODEC_ID_GDV: maxpixels /= 512; break;
155  case AV_CODEC_ID_GIF: maxpixels /= 16; break;
156  case AV_CODEC_ID_HAP: maxpixels /= 128; break;
157  case AV_CODEC_ID_HEVC: maxpixels /= 16384; break;
158  case AV_CODEC_ID_HNM4_VIDEO: maxpixels /= 128; break;
159  case AV_CODEC_ID_IFF_ILBM: maxpixels /= 128; break;
160  case AV_CODEC_ID_INDEO4: maxpixels /= 128; break;
161  case AV_CODEC_ID_LAGARITH: maxpixels /= 1024; break;
162  case AV_CODEC_ID_LSCR: maxpixels /= 16; break;
163  case AV_CODEC_ID_MOTIONPIXELS:maxpixels /= 256; break;
164  case AV_CODEC_ID_MP4ALS: maxsamples /= 65536; break;
165  case AV_CODEC_ID_MSRLE: maxpixels /= 16; break;
166  case AV_CODEC_ID_MSS2: maxpixels /= 16384; break;
167  case AV_CODEC_ID_MSZH: maxpixels /= 128; break;
168  case AV_CODEC_ID_OPUS: maxsamples /= 16384; break;
169  case AV_CODEC_ID_PNG: maxpixels /= 128; break;
170  case AV_CODEC_ID_APNG: maxpixels /= 128; break;
171  case AV_CODEC_ID_QTRLE: maxpixels /= 16; break;
172  case AV_CODEC_ID_RASC: maxpixels /= 16; break;
173  case AV_CODEC_ID_SANM: maxpixels /= 16; break;
174  case AV_CODEC_ID_SCPR: maxpixels /= 32; break;
175  case AV_CODEC_ID_SCREENPRESSO:maxpixels /= 64; break;
176  case AV_CODEC_ID_SMACKVIDEO: maxpixels /= 64; break;
177  case AV_CODEC_ID_SNOW: maxpixels /= 128; break;
178  case AV_CODEC_ID_TGV: maxpixels /= 32; break;
179  case AV_CODEC_ID_TRUEMOTION2: maxpixels /= 1024; break;
180  case AV_CODEC_ID_VP7: maxpixels /= 256; break;
181  case AV_CODEC_ID_VP9: maxpixels /= 4096; break;
182  case AV_CODEC_ID_WMV3IMAGE: maxpixels /= 8192; break;
183  case AV_CODEC_ID_WS_VQA: maxpixels /= 16384; break;
184  case AV_CODEC_ID_WMALOSSLESS: maxsamples /= 1024; break;
185  case AV_CODEC_ID_ZEROCODEC: maxpixels /= 128; break;
186  }
187 
189 
191  AVCodecContext* parser_avctx = avcodec_alloc_context3(NULL);
192  if (!ctx || !parser_avctx)
193  error("Failed memory allocation");
194 
195  if (ctx->max_pixels == 0 || ctx->max_pixels > maxpixels_per_frame)
196  ctx->max_pixels = maxpixels_per_frame; //To reduce false positive OOM and hangs
197  ctx->refcounted_frames = 1; //To reduce false positive timeouts and focus testing on the refcounted API
198 
200 
201  if (size > 1024) {
202  GetByteContext gbc;
203  int extradata_size;
204  int flags;
205  size -= 1024;
206  bytestream2_init(&gbc, data + size, 1024);
207  ctx->width = bytestream2_get_le32(&gbc);
208  ctx->height = bytestream2_get_le32(&gbc);
209  ctx->bit_rate = bytestream2_get_le64(&gbc);
210  ctx->bits_per_coded_sample = bytestream2_get_le32(&gbc);
211  // Try to initialize a parser for this codec, note, this may fail which just means we test without one
212  flags = bytestream2_get_byte(&gbc);
213  if (flags & 1)
214  parser = av_parser_init(c->id);
215  if (flags & 2)
217  if (flags & 4) {
219  if (flags & 8)
221  }
222  if ((flags & 0x10) && c->id != AV_CODEC_ID_H264)
223  ctx->flags2 |= AV_CODEC_FLAG2_FAST;
224 
225  if (flags & 0x40)
227 
228  extradata_size = bytestream2_get_le32(&gbc);
229 
230  ctx->sample_rate = bytestream2_get_le32(&gbc) & 0x7FFFFFFF;
231  ctx->channels = (unsigned)bytestream2_get_le32(&gbc) % FF_SANE_NB_CHANNELS;
232  ctx->block_align = bytestream2_get_le32(&gbc) & 0x7FFFFFFF;
233  ctx->codec_tag = bytestream2_get_le32(&gbc);
234  if (c->codec_tags) {
235  int n;
236  for (n = 0; c->codec_tags[n] != FF_CODEC_TAGS_END; n++);
237  ctx->codec_tag = c->codec_tags[ctx->codec_tag % n];
238  }
239  keyframes = bytestream2_get_le64(&gbc);
240  ctx->request_channel_layout = bytestream2_get_le64(&gbc);
241 
242  ctx->idct_algo = bytestream2_get_byte(&gbc) % 25;
243  flushpattern = bytestream2_get_le64(&gbc);
244 
245  if (flags & 0x20) {
246  switch (ctx->codec_id) {
247  case AV_CODEC_ID_AC3:
248  case AV_CODEC_ID_EAC3:
249  av_dict_set_int(&opts, "cons_noisegen", bytestream2_get_byte(&gbc) & 1, 0);
250  av_dict_set_int(&opts, "heavy_compr", bytestream2_get_byte(&gbc) & 1, 0);
251  av_dict_set_int(&opts, "target_level", (int)(bytestream2_get_byte(&gbc) % 32) - 31, 0);
252  av_dict_set_int(&opts, "dmix_mode", (int)(bytestream2_get_byte(&gbc) % 4) - 1, 0);
253  break;
254  }
255  }
256 
257 
258  if (extradata_size < size) {
259  ctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
260  if (ctx->extradata) {
261  ctx->extradata_size = extradata_size;
262  size -= ctx->extradata_size;
263  memcpy(ctx->extradata, data + size, ctx->extradata_size);
264  }
265  }
266  if (av_image_check_size(ctx->width, ctx->height, 0, ctx))
267  ctx->width = ctx->height = 0;
268  }
269 
270  int res = avcodec_open2(ctx, c, &opts);
271  if (res < 0) {
272  avcodec_free_context(&ctx);
273  av_free(parser_avctx);
274  av_parser_close(parser);
275  av_dict_free(&opts);
276  return 0; // Failure of avcodec_open2() does not imply that a issue was found
277  }
278  parser_avctx->codec_id = ctx->codec_id;
279 
280  int got_frame;
282  if (!frame)
283  error("Failed memory allocation");
284 
285  // Read very simple container
286  AVPacket avpkt, parsepkt;
287  av_init_packet(&avpkt);
288  av_init_packet(&parsepkt);
289  while (data < end && it < maxiteration) {
290  // Search for the TAG
291  while (data + sizeof(fuzz_tag) < end) {
292  if (data[0] == (fuzz_tag & 0xFF) && AV_RN64(data) == fuzz_tag)
293  break;
294  data++;
295  }
296  if (data + sizeof(fuzz_tag) > end)
297  data = end;
298 
299  res = av_new_packet(&parsepkt, data - last);
300  if (res < 0)
301  error("Failed memory allocation");
302  memcpy(parsepkt.data, last, data - last);
303  parsepkt.flags = (keyframes & 1) * AV_PKT_FLAG_DISCARD + (!!(keyframes & 2)) * AV_PKT_FLAG_KEY;
304  keyframes = (keyframes >> 2) + (keyframes<<62);
305  data += sizeof(fuzz_tag);
306  last = data;
307 
308  while (parsepkt.size > 0) {
309 
310  if (parser) {
311  av_init_packet(&avpkt);
312  int ret = av_parser_parse2(parser, parser_avctx, &avpkt.data, &avpkt.size,
313  parsepkt.data, parsepkt.size,
314  parsepkt.pts, parsepkt.dts, parsepkt.pos);
315  if (avpkt.data == parsepkt.data) {
316  avpkt.buf = av_buffer_ref(parsepkt.buf);
317  if (!avpkt.buf)
318  error("Failed memory allocation");
319  } else {
320  if (av_packet_make_refcounted(&avpkt) < 0)
321  error("Failed memory allocation");
322  }
323  parsepkt.data += ret;
324  parsepkt.size -= ret;
325  parsepkt.pos += ret;
326  avpkt.pts = parser->pts;
327  avpkt.dts = parser->dts;
328  avpkt.pos = parser->pos;
329  if ( parser->key_frame == 1 ||
330  (parser->key_frame == -1 && parser->pict_type == AV_PICTURE_TYPE_I))
331  avpkt.flags |= AV_PKT_FLAG_KEY;
332  avpkt.flags |= parsepkt.flags & AV_PKT_FLAG_DISCARD;
333  } else {
334  av_packet_move_ref(&avpkt, &parsepkt);
335  }
336 
337  if (!(flushpattern & 7))
339  flushpattern = (flushpattern >> 3) + (flushpattern << 61);
340 
341  // Iterate through all data
342  while (avpkt.size > 0 && it++ < maxiteration) {
343  av_frame_unref(frame);
344  int ret = decode_handler(ctx, frame, &got_frame, &avpkt);
345 
346  ec_pixels += (ctx->width + 32LL) * (ctx->height + 32LL);
347  if (it > 20 || ec_pixels > 4 * ctx->max_pixels)
348  ctx->error_concealment = 0;
349  if (ec_pixels > maxpixels)
350  goto maximums_reached;
351 
352  if (ctx->codec_type == AVMEDIA_TYPE_AUDIO &&
353  frame->nb_samples == 0 && !got_frame &&
354  (avpkt.flags & AV_PKT_FLAG_DISCARD))
355  nb_samples += ctx->max_samples;
356 
357  nb_samples += frame->nb_samples;
358  if (nb_samples > maxsamples)
359  goto maximums_reached;
360 
361  if (ret <= 0 || ret > avpkt.size)
362  break;
363  if (ctx->codec_type != AVMEDIA_TYPE_AUDIO)
364  ret = avpkt.size;
365  avpkt.data += ret;
366  avpkt.size -= ret;
367  }
368  av_packet_unref(&avpkt);
369  }
370  av_packet_unref(&parsepkt);
371  }
372 maximums_reached:
373 
374  av_packet_unref(&avpkt);
375 
376  do {
377  got_frame = 0;
378  av_frame_unref(frame);
379  decode_handler(ctx, frame, &got_frame, &avpkt);
380  } while (got_frame == 1 && it++ < maxiteration);
381 
382  fprintf(stderr, "pixels decoded: %"PRId64", samples decoded: %"PRId64", iterations: %d\n", ec_pixels, nb_samples, it);
383 
384  av_frame_free(&frame);
385  avcodec_free_context(&ctx);
386  avcodec_free_context(&parser_avctx);
387  av_parser_close(parser);
388  av_packet_unref(&parsepkt);
389  av_dict_free(&opts);
390  return 0;
391 }
#define FF_SANE_NB_CHANNELS
Definition: internal.h:97
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1599
const uint32_t maxiteration
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
Definition: avcodec.h:1676
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
uint64_t maxsamples
misc image utilities
int64_t bit_rate
the average bitrate
Definition: avcodec.h:581
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
void av_log_set_level(int level)
Set the log level.
Definition: log.c:440
int size
Definition: packet.h:364
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1675
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
attribute_deprecated int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: decode.c:833
enum AVMediaType type
Definition: codec.h:203
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:998
AVCodec.
Definition: codec.h:190
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:1228
uint8_t
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define AV_LOG_PANIC
Something went really wrong and we will crash now.
Definition: log.h:181
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
uint8_t * data
Definition: packet.h:363
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s it
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:664
ptrdiff_t size
Definition: opengl_enc.c:100
const uint32_t * codec_tags
List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
Definition: codec.h:328
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1755
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static AVCodec * c
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
enum AVCodecID id
Definition: codec.h:204
static const uint64_t FUZZ_TAG
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:3468
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int error_concealment
error concealment flags
Definition: avcodec.h:1606
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:346
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2261
const uint64_t maxpixels_per_frame
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
AVDictionary * opts
Definition: movenc.c:50
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1660
#define FFMIN(a, b)
Definition: common.h:96
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:172
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.
Definition: parser.c:120
static AVCodec * AVCodecInitialize(enum AVCodecID codec_id)
int width
picture width / height.
Definition: avcodec.h:704
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1734
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:672
AVFormatContext * ctx
Definition: movenc.c:48
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:224
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1671
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
static void error(const char *err)
static int subtitle_handler(AVCodecContext *avctx, void *frame, int *got_sub_ptr, AVPacket *avpkt)
if(ret)
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: utils.c:1069
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:539
attribute_deprecated int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: decode.c:826
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
Definition: options.c:187
enum AVCodecID codec_id
Definition: avcodec.h:541
int sample_rate
samples per second
Definition: avcodec.h:1191
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:348
main external API structure.
Definition: avcodec.h:531
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1118
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:556
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:2349
int extradata_size
Definition: avcodec.h:633
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
Definition: avcodec.h:1674
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:550
attribute_deprecated int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
Definition: avcodec.h:1362
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:939
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
#define flags(name, subs,...)
Definition: cbs_av1.c:560
Main libavformat public API header.
int
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:408
common internal api header.
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
Definition: dict.c:147
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
#define av_free(p)
uint64_t maxpixels
int channels
number of audio channels
Definition: avcodec.h:1192
#define AV_RN64(p)
Definition: intreadwrite.h:368
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:618
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
static float sub(float src0, float src1)
#define FF_CODEC_TAGS_END
AVCodec.codec_tags termination value.
Definition: internal.h:80
void av_force_cpu_flags(int arg)
Disables cpu detection and forces the specified flags.
Definition: cpu.c:67
uint64_t maxsamples_per_frame
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:1249
This structure stores compressed data.
Definition: packet.h:340
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:3407
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1594
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
AVCodec * codec_list[]