FFmpeg  4.4.6
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 
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)
88  return ret;
89 }
90 
92  int *got_frame, const AVPacket *dummy)
93 {
94  int ret = avcodec_receive_frame(avctx, frame);
95  *got_frame = ret >= 0;
96  return ret;
97 }
98 
99 // Ensure we don't loop forever
100 const uint32_t maxiteration = 8096;
101 uint64_t maxpixels_per_frame = 4096 * 4096;
102 uint64_t maxpixels;
103 
104 uint64_t maxsamples_per_frame = 256*1024*32;
105 uint64_t maxsamples;
106 
107 static const uint64_t FUZZ_TAG = 0x4741542D5A5A5546ULL;
108 
110  const uint64_t fuzz_tag = FUZZ_TAG;
111  const uint8_t *last = data;
112  const uint8_t *end = data + size;
113  uint32_t it = 0;
114  uint64_t ec_pixels = 0;
115  uint64_t nb_samples = 0;
116  int (*decode_handler)(AVCodecContext *avctx, AVFrame *picture,
117  int *got_picture_ptr,
118  const AVPacket *avpkt) = NULL;
119  AVCodecParserContext *parser = NULL;
120  uint64_t keyframes = 0;
121  uint64_t flushpattern = -1;
123 
124  if (!c) {
125 #ifdef FFMPEG_DECODER
126 #define DECODER_SYMBOL0(CODEC) ff_##CODEC##_decoder
127 #define DECODER_SYMBOL(CODEC) DECODER_SYMBOL0(CODEC)
128  extern AVCodec DECODER_SYMBOL(FFMPEG_DECODER);
129  codec_list[0] = &DECODER_SYMBOL(FFMPEG_DECODER);
130 
131 #if FFMPEG_DECODER == tiff || FFMPEG_DECODER == tdsc
132  extern AVCodec DECODER_SYMBOL(mjpeg);
133  codec_list[1] = &DECODER_SYMBOL(mjpeg);
134 #endif
135 
136  c = &DECODER_SYMBOL(FFMPEG_DECODER);
137 #else
138  c = AVCodecInitialize(FFMPEG_CODEC); // Done once.
139 #endif
141  }
142 
143  switch (c->type) {
144  case AVMEDIA_TYPE_AUDIO :
145  case AVMEDIA_TYPE_VIDEO : decode_handler = audio_video_handler ; break;
146  case AVMEDIA_TYPE_SUBTITLE: decode_handler = subtitle_handler ; break;
147  }
148  switch (c->id) {
149  case AV_CODEC_ID_APE: maxsamples_per_frame /= 256; break;
150  }
153  switch (c->id) {
154  case AV_CODEC_ID_AGM: maxpixels /= 1024; break;
155  case AV_CODEC_ID_BINKVIDEO: maxpixels /= 32; break;
156  case AV_CODEC_ID_CFHD: maxpixels /= 128; break;
157  case AV_CODEC_ID_COOK: maxsamples /= 1<<20; break;
158  case AV_CODEC_ID_DIRAC: maxpixels /= 8192; break;
159  case AV_CODEC_ID_DST: maxsamples /= 1<<20; break;
160  case AV_CODEC_ID_DXV: maxpixels /= 32; break;
161  case AV_CODEC_ID_FFWAVESYNTH: maxsamples /= 16384; break;
162  case AV_CODEC_ID_FLV1: maxpixels /= 1024; break;
163  case AV_CODEC_ID_G2M: maxpixels /= 1024; break;
164  case AV_CODEC_ID_GDV: maxpixels /= 512; break;
165  case AV_CODEC_ID_GIF: maxpixels /= 16; break;
166  case AV_CODEC_ID_H264: maxpixels /= 256; break;
167  case AV_CODEC_ID_HAP: maxpixels /= 128; break;
168  case AV_CODEC_ID_HEVC: maxpixels /= 16384; break;
169  case AV_CODEC_ID_HNM4_VIDEO: maxpixels /= 128; break;
170  case AV_CODEC_ID_IFF_ILBM: maxpixels /= 128; break;
171  case AV_CODEC_ID_INDEO4: maxpixels /= 128; break;
172  case AV_CODEC_ID_INTERPLAY_ACM: maxsamples /= 16384; break;
173  case AV_CODEC_ID_LAGARITH: maxpixels /= 1024; break;
174  case AV_CODEC_ID_LSCR: maxpixels /= 16; break;
175  case AV_CODEC_ID_MMVIDEO: maxpixels /= 256; break;
176  case AV_CODEC_ID_MOTIONPIXELS:maxpixels /= 256; break;
177  case AV_CODEC_ID_MP4ALS: maxsamples /= 65536; break;
178  case AV_CODEC_ID_MSA1: maxpixels /= 16384; break;
179  case AV_CODEC_ID_MSRLE: maxpixels /= 16; break;
180  case AV_CODEC_ID_MSS2: maxpixels /= 16384; break;
181  case AV_CODEC_ID_MSZH: maxpixels /= 128; break;
182  case AV_CODEC_ID_OPUS: maxsamples /= 16384; break;
183  case AV_CODEC_ID_PNG: maxpixels /= 128; break;
184  case AV_CODEC_ID_APNG: maxpixels /= 128; break;
185  case AV_CODEC_ID_QTRLE: maxpixels /= 16; break;
186  case AV_CODEC_ID_RASC: maxpixels /= 16; break;
187  case AV_CODEC_ID_RTV1: maxpixels /= 16; break;
188  case AV_CODEC_ID_SANM: maxpixels /= 16; break;
189  case AV_CODEC_ID_SCPR: maxpixels /= 32; break;
190  case AV_CODEC_ID_SCREENPRESSO:maxpixels /= 64; break;
191  case AV_CODEC_ID_SMACKVIDEO: maxpixels /= 64; break;
192  case AV_CODEC_ID_SNOW: maxpixels /= 128; break;
193  case AV_CODEC_ID_TGV: maxpixels /= 32; break;
194  case AV_CODEC_ID_THEORA: maxpixels /= 1024; break;
195  case AV_CODEC_ID_TRUEMOTION2: maxpixels /= 1024; break;
196  case AV_CODEC_ID_VC1IMAGE: maxpixels /= 8192; break;
197  case AV_CODEC_ID_VMNC: maxpixels /= 8192; break;
198  case AV_CODEC_ID_VP7: maxpixels /= 256; break;
199  case AV_CODEC_ID_VP9: maxpixels /= 4096; break;
200  case AV_CODEC_ID_WAVPACK: maxsamples /= 1024; break;
201  case AV_CODEC_ID_WMV3IMAGE: maxpixels /= 8192; break;
202  case AV_CODEC_ID_WS_VQA: maxpixels /= 16384; break;
203  case AV_CODEC_ID_WMALOSSLESS: maxsamples /= 1024; break;
204  case AV_CODEC_ID_ZEROCODEC: maxpixels /= 128; break;
205  }
206 
209 
211  AVCodecContext* parser_avctx = avcodec_alloc_context3(NULL);
212  if (!ctx || !parser_avctx)
213  error("Failed memory allocation");
214 
215  if (ctx->max_pixels == 0 || ctx->max_pixels > maxpixels_per_frame)
216  ctx->max_pixels = maxpixels_per_frame; //To reduce false positive OOM and hangs
217 
218  ctx->max_samples = maxsamples_per_frame;
219 
220  if (size > 1024) {
221  GetByteContext gbc;
222  int extradata_size;
223  int flags;
224  size -= 1024;
225  bytestream2_init(&gbc, data + size, 1024);
226  ctx->width = bytestream2_get_le32(&gbc);
227  ctx->height = bytestream2_get_le32(&gbc);
228  ctx->bit_rate = bytestream2_get_le64(&gbc);
229  ctx->bits_per_coded_sample = bytestream2_get_le32(&gbc);
230  // Try to initialize a parser for this codec, note, this may fail which just means we test without one
231  flags = bytestream2_get_byte(&gbc);
232  if (flags & 1)
233  parser = av_parser_init(c->id);
234  if (flags & 2)
236  if (flags & 4) {
237  ctx->err_recognition = AV_EF_AGGRESSIVE | AV_EF_COMPLIANT | AV_EF_CAREFUL;
238  if (flags & 8)
239  ctx->err_recognition |= AV_EF_EXPLODE;
240  }
241  if ((flags & 0x10) && c->id != AV_CODEC_ID_H264)
242  ctx->flags2 |= AV_CODEC_FLAG2_FAST;
243 
244  if (flags & 0x40)
246 
247  extradata_size = bytestream2_get_le32(&gbc);
248 
249  ctx->sample_rate = bytestream2_get_le32(&gbc) & 0x7FFFFFFF;
250  ctx->channels = (unsigned)bytestream2_get_le32(&gbc) % FF_SANE_NB_CHANNELS;
251  ctx->block_align = bytestream2_get_le32(&gbc) & 0x7FFFFFFF;
252  ctx->codec_tag = bytestream2_get_le32(&gbc);
253  if (c->codec_tags) {
254  int n;
255  for (n = 0; c->codec_tags[n] != FF_CODEC_TAGS_END; n++);
256  ctx->codec_tag = c->codec_tags[ctx->codec_tag % n];
257  }
258  keyframes = bytestream2_get_le64(&gbc);
259  ctx->request_channel_layout = bytestream2_get_le64(&gbc);
260 
261  ctx->idct_algo = bytestream2_get_byte(&gbc) % 25;
262  flushpattern = bytestream2_get_le64(&gbc);
263 
264  if (flags & 0x20) {
265  switch (ctx->codec_id) {
266  case AV_CODEC_ID_AC3:
267  case AV_CODEC_ID_EAC3:
268  av_dict_set_int(&opts, "cons_noisegen", bytestream2_get_byte(&gbc) & 1, 0);
269  av_dict_set_int(&opts, "heavy_compr", bytestream2_get_byte(&gbc) & 1, 0);
270  av_dict_set_int(&opts, "target_level", (int)(bytestream2_get_byte(&gbc) % 32) - 31, 0);
271  av_dict_set_int(&opts, "dmix_mode", (int)(bytestream2_get_byte(&gbc) % 4) - 1, 0);
272  break;
273  }
274  }
275 
276 
277  if (extradata_size < size) {
278  ctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
279  if (ctx->extradata) {
280  ctx->extradata_size = extradata_size;
281  size -= ctx->extradata_size;
282  memcpy(ctx->extradata, data + size, ctx->extradata_size);
283  }
284  }
285  if (av_image_check_size(ctx->width, ctx->height, 0, ctx))
286  ctx->width = ctx->height = 0;
287  }
288 
289  int res = avcodec_open2(ctx, c, &opts);
290  if (res < 0) {
292  av_free(parser_avctx);
293  av_parser_close(parser);
294  av_dict_free(&opts);
295  return 0; // Failure of avcodec_open2() does not imply that a issue was found
296  }
297  parser_avctx->codec_id = ctx->codec_id;
298 
299  int got_frame;
301  AVPacket *avpkt = av_packet_alloc();
302  AVPacket *parsepkt = av_packet_alloc();
303  if (!frame || !avpkt || !parsepkt)
304  error("Failed memory allocation");
305 
306  // Read very simple container
307  while (data < end && it < maxiteration) {
308  // Search for the TAG
309  while (data + sizeof(fuzz_tag) < end) {
310  if (data[0] == (fuzz_tag & 0xFF) && AV_RN64(data) == fuzz_tag)
311  break;
312  data++;
313  }
314  if (data + sizeof(fuzz_tag) > end)
315  data = end;
316 
317  res = av_new_packet(parsepkt, data - last);
318  if (res < 0)
319  error("Failed memory allocation");
320  memcpy(parsepkt->data, last, data - last);
321  parsepkt->flags = (keyframes & 1) * AV_PKT_FLAG_DISCARD + (!!(keyframes & 2)) * AV_PKT_FLAG_KEY;
322  keyframes = (keyframes >> 2) + (keyframes<<62);
323  data += sizeof(fuzz_tag);
324  last = data;
325 
326  while (parsepkt->size > 0) {
327  int decode_more;
328 
329  if (parser) {
330  int ret = av_parser_parse2(parser, parser_avctx, &avpkt->data, &avpkt->size,
331  parsepkt->data, parsepkt->size,
332  parsepkt->pts, parsepkt->dts, parsepkt->pos);
333  if (avpkt->data == parsepkt->data) {
334  avpkt->buf = av_buffer_ref(parsepkt->buf);
335  if (!avpkt->buf)
336  error("Failed memory allocation");
337  } else {
338  if (av_packet_make_refcounted(avpkt) < 0)
339  error("Failed memory allocation");
340  }
341  parsepkt->data += ret;
342  parsepkt->size -= ret;
343  parsepkt->pos += ret;
344  avpkt->pts = parser->pts;
345  avpkt->dts = parser->dts;
346  avpkt->pos = parser->pos;
347  if ( parser->key_frame == 1 ||
348  (parser->key_frame == -1 && parser->pict_type == AV_PICTURE_TYPE_I))
349  avpkt->flags |= AV_PKT_FLAG_KEY;
350  avpkt->flags |= parsepkt->flags & AV_PKT_FLAG_DISCARD;
351  } else {
352  av_packet_move_ref(avpkt, parsepkt);
353  }
354 
355  if (!(flushpattern & 7))
357  flushpattern = (flushpattern >> 3) + (flushpattern << 61);
358 
359  if (ctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
360  int ret = avcodec_send_packet(ctx, avpkt);
361  decode_more = ret >= 0;
362  if(!decode_more) {
363  ec_pixels += (ctx->width + 32LL) * (ctx->height + 32LL);
364  if (it > 20 || ec_pixels > 4 * ctx->max_pixels)
365  ctx->error_concealment = 0;
366  if (ec_pixels > maxpixels)
367  goto maximums_reached;
368  }
369  } else
370  decode_more = 1;
371 
372  // Iterate through all data
373  while (decode_more && it++ < maxiteration) {
375  int ret = decode_handler(ctx, frame, &got_frame, avpkt);
376 
377  ec_pixels += (ctx->width + 32LL) * (ctx->height + 32LL);
378  if (it > 20 || ec_pixels > 4 * ctx->max_pixels)
379  ctx->error_concealment = 0;
380  if (ec_pixels > maxpixels)
381  goto maximums_reached;
382 
383  if (ctx->codec_type == AVMEDIA_TYPE_AUDIO &&
384  frame->nb_samples == 0 && !got_frame &&
385  (avpkt->flags & AV_PKT_FLAG_DISCARD))
386  nb_samples += ctx->max_samples;
387 
388  nb_samples += frame->nb_samples;
389  if (nb_samples > maxsamples)
390  goto maximums_reached;
391 
392  if (ret <= 0 || ret > avpkt->size)
393  break;
394 
395  if (ctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
396  avpkt->data += ret;
397  avpkt->size -= ret;
398  decode_more = avpkt->size > 0;
399  } else
400  decode_more = ret >= 0;
401  }
402  av_packet_unref(avpkt);
403  }
404  av_packet_unref(parsepkt);
405  }
406 maximums_reached:
407 
408  av_packet_unref(avpkt);
409 
410  if (ctx->codec_type != AVMEDIA_TYPE_SUBTITLE)
412 
413  do {
414  got_frame = 0;
416  decode_handler(ctx, frame, &got_frame, avpkt);
417  } while (got_frame == 1 && it++ < maxiteration);
418 
419  fprintf(stderr, "pixels decoded: %"PRId64", samples decoded: %"PRId64", iterations: %d\n", ec_pixels, nb_samples, it);
420 
423  avcodec_free_context(&parser_avctx);
424  av_parser_close(parser);
425  av_packet_free(&avpkt);
426  av_packet_free(&parsepkt);
427  av_dict_free(&opts);
428  return 0;
429 }
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
Libavcodec external API header.
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1610
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1664
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1660
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
Definition: avcodec.h:1665
#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:1663
Main libavformat public API header.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
#define flags(name, subs,...)
Definition: cbs_av1.c:572
#define FFMIN(a, b)
Definition: common.h:105
#define NULL
Definition: coverity.c:32
void av_force_cpu_flags(int arg)
Disables cpu detection and forces the specified flags.
Definition: cpu.c:67
static AVFrame * frame
static float sub(float src0, float src1)
int
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:144
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:348
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:551
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:173
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:188
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:165
@ AV_CODEC_ID_IFF_ILBM
Definition: codec_id.h:185
@ AV_CODEC_ID_AGM
Definition: codec_id.h:293
@ AV_CODEC_ID_INTERPLAY_ACM
Definition: codec_id.h:503
@ AV_CODEC_ID_LSCR
Definition: codec_id.h:294
@ AV_CODEC_ID_MSA1
Definition: codec_id.h:212
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:70
@ AV_CODEC_ID_PNG
Definition: codec_id.h:110
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:464
@ AV_CODEC_ID_SMACKVIDEO
Definition: codec_id.h:132
@ AV_CODEC_ID_APNG
Definition: codec_id.h:264
@ AV_CODEC_ID_QTRLE
Definition: codec_id.h:104
@ AV_CODEC_ID_INDEO4
Definition: codec_id.h:160
@ AV_CODEC_ID_SNOW
Definition: codec_id.h:262
@ AV_CODEC_ID_MOTIONPIXELS
Definition: codec_id.h:168
@ AV_CODEC_ID_TGV
Definition: codec_id.h:169
@ AV_CODEC_ID_FFWAVESYNTH
Definition: codec_id.h:493
@ AV_CODEC_ID_MP4ALS
Definition: codec_id.h:469
@ AV_CODEC_ID_WS_VQA
Definition: codec_id.h:93
@ AV_CODEC_ID_RASC
Definition: codec_id.h:290
@ AV_CODEC_ID_GIF
Definition: codec_id.h:146
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
@ AV_CODEC_ID_VP7
Definition: codec_id.h:230
@ AV_CODEC_ID_APE
Definition: codec_id.h:456
@ AV_CODEC_ID_CFHD
Definition: codec_id.h:266
@ AV_CODEC_ID_MSRLE
Definition: codec_id.h:94
@ AV_CODEC_ID_VMNC
Definition: codec_id.h:138
@ AV_CODEC_ID_LAGARITH
Definition: codec_id.h:196
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:201
@ AV_CODEC_ID_GDV
Definition: codec_id.h:284
@ AV_CODEC_ID_BINKVIDEO
Definition: codec_id.h:184
@ AV_CODEC_ID_WMV3IMAGE
Definition: codec_id.h:200
@ AV_CODEC_ID_WMALOSSLESS
Definition: codec_id.h:462
@ AV_CODEC_ID_SCPR
Definition: codec_id.h:276
@ AV_CODEC_ID_THEORA
Definition: codec_id.h:79
@ AV_CODEC_ID_SANM
Definition: codec_id.h:231
@ AV_CODEC_ID_DXV
Definition: codec_id.h:240
@ AV_CODEC_ID_MSS2
Definition: codec_id.h:216
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
@ AV_CODEC_ID_COOK
Definition: codec_id.h:444
@ AV_CODEC_ID_MMVIDEO
Definition: codec_id.h:129
@ AV_CODEC_ID_G2M
Definition: codec_id.h:220
@ AV_CODEC_ID_DST
Definition: codec_id.h:506
@ AV_CODEC_ID_TRUEMOTION2
Definition: codec_id.h:126
@ AV_CODEC_ID_HAP
Definition: codec_id.h:238
@ AV_CODEC_ID_HNM4_VIDEO
Definition: codec_id.h:222
@ AV_CODEC_ID_AC3
Definition: codec_id.h:427
@ AV_CODEC_ID_SCREENPRESSO
Definition: codec_id.h:241
@ AV_CODEC_ID_WAVPACK
Definition: codec_id.h:449
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
@ AV_CODEC_ID_ZEROCODEC
Definition: codec_id.h:210
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:484
@ AV_CODEC_ID_MSZH
Definition: codec_id.h:102
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:652
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1034
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:589
#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
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:491
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
#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:417
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:696
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:690
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:228
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
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
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
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
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
void av_log_set_level(int level)
Set the log level.
Definition: log.c:440
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
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
misc image utilities
#define AV_RN64(p)
Definition: intreadwrite.h:368
common internal api header.
#define FF_CODEC_TAGS_END
AVCodec.codec_tags termination value.
Definition: internal.h:90
#define FF_SANE_NB_CHANNELS
Definition: internal.h:107
int dummy
Definition: motion.c:64
const char data[16]
Definition: mxf.c:142
main external API structure.
Definition: avcodec.h:536
enum AVCodecID codec_id
Definition: avcodec.h:546
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:3491
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:3430
AVCodec.
Definition: codec.h:197
enum AVCodecID id
Definition: codec.h:211
const uint32_t * codec_tags
List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
Definition: codec.h:348
enum AVMediaType type
Definition: codec.h:210
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1542
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1354
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
This structure stores compressed data.
Definition: packet.h:346
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:352
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int size
Definition: packet.h:370
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:368
uint8_t * data
Definition: packet.h:369
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
#define av_free(p)
uint64_t maxsamples_per_frame
uint64_t maxpixels_per_frame
AVCodec * codec_list[]
static const uint64_t FUZZ_TAG
const uint32_t maxiteration
static int subtitle_handler(AVCodecContext *avctx, void *frame, int *got_sub_ptr, AVPacket *avpkt)
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
static void error(const char *err)
static AVCodec * AVCodecInitialize(enum AVCodecID codec_id)
static AVCodec * c
uint64_t maxsamples
uint64_t maxpixels
static int audio_video_handler(AVCodecContext *avctx, AVFrame *frame, int *got_frame, const AVPacket *dummy)
AVFormatContext * ctx
Definition: movenc.c:48
AVDictionary * opts
Definition: movenc.c:50
int size
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
if(ret< 0)
Definition: vf_mcdeint.c:282