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 
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_DVB_SUBTITLE: av_dict_set_int(&opts, "compute_clut", -2, 0); break;
161  case AV_CODEC_ID_DXV: maxpixels /= 32; break;
162  case AV_CODEC_ID_FFWAVESYNTH: maxsamples /= 16384; break;
163  case AV_CODEC_ID_FLAC: maxsamples /= 1024; break;
164  case AV_CODEC_ID_FLV1: maxpixels /= 1024; break;
165  case AV_CODEC_ID_G2M: maxpixels /= 1024; break;
166  case AV_CODEC_ID_GDV: maxpixels /= 512; break;
167  case AV_CODEC_ID_GIF: maxpixels /= 16; break;
168  case AV_CODEC_ID_H264: maxpixels /= 256; break;
169  case AV_CODEC_ID_HAP: maxpixels /= 128; break;
170  case AV_CODEC_ID_HEVC: maxpixels /= 16384; break;
171  case AV_CODEC_ID_HNM4_VIDEO: maxpixels /= 128; break;
172  case AV_CODEC_ID_IFF_ILBM: maxpixels /= 128; break;
173  case AV_CODEC_ID_INDEO4: maxpixels /= 128; break;
174  case AV_CODEC_ID_INTERPLAY_ACM: maxsamples /= 16384; break;
175  case AV_CODEC_ID_LAGARITH: maxpixels /= 1024; break;
176  case AV_CODEC_ID_LSCR: maxpixels /= 16; break;
177  case AV_CODEC_ID_MOTIONPIXELS:maxpixels /= 256; break;
178  case AV_CODEC_ID_MP4ALS: maxsamples /= 65536; break;
179  case AV_CODEC_ID_MSA1: maxpixels /= 16384; break;
180  case AV_CODEC_ID_MSRLE: maxpixels /= 16; break;
181  case AV_CODEC_ID_MSS2: maxpixels /= 16384; break;
182  case AV_CODEC_ID_MSZH: maxpixels /= 128; break;
183  case AV_CODEC_ID_OPUS: maxsamples /= 16384; break;
184  case AV_CODEC_ID_PNG: maxpixels /= 128; break;
185  case AV_CODEC_ID_APNG: maxpixels /= 128; break;
186  case AV_CODEC_ID_QTRLE: maxpixels /= 16; break;
187  case AV_CODEC_ID_RASC: 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_VP4: maxpixels /= 4096; break;
199  case AV_CODEC_ID_VP7: maxpixels /= 256; break;
200  case AV_CODEC_ID_VP9: maxpixels /= 4096; break;
201  case AV_CODEC_ID_WAVPACK: maxsamples /= 1024; break;
202  case AV_CODEC_ID_WMV3IMAGE: maxpixels /= 8192; break;
203  case AV_CODEC_ID_WS_VQA: maxpixels /= 16384; break;
204  case AV_CODEC_ID_WMALOSSLESS: maxsamples /= 1024; break;
205  case AV_CODEC_ID_ZEROCODEC: maxpixels /= 128; break;
206  }
207 
210 
212  AVCodecContext* parser_avctx = avcodec_alloc_context3(NULL);
213  if (!ctx || !parser_avctx)
214  error("Failed memory allocation");
215 
216  if (ctx->max_pixels == 0 || ctx->max_pixels > maxpixels_per_frame)
217  ctx->max_pixels = maxpixels_per_frame; //To reduce false positive OOM and hangs
218 
220 
221  if (size > 1024) {
222  GetByteContext gbc;
223  int extradata_size;
224  int flags;
225  size -= 1024;
226  bytestream2_init(&gbc, data + size, 1024);
227  ctx->width = bytestream2_get_le32(&gbc);
228  ctx->height = bytestream2_get_le32(&gbc);
229  ctx->bit_rate = bytestream2_get_le64(&gbc);
230  ctx->bits_per_coded_sample = bytestream2_get_le32(&gbc);
231  // Try to initialize a parser for this codec, note, this may fail which just means we test without one
232  flags = bytestream2_get_byte(&gbc);
233  if (flags & 1)
234  parser = av_parser_init(c->id);
235  if (flags & 2)
237  if (flags & 4) {
239  if (flags & 8)
241  }
242  if ((flags & 0x10) && c->id != AV_CODEC_ID_H264)
243  ctx->flags2 |= AV_CODEC_FLAG2_FAST;
244 
245  if (flags & 0x40)
247 
248  extradata_size = bytestream2_get_le32(&gbc);
249 
250  ctx->sample_rate = bytestream2_get_le32(&gbc) & 0x7FFFFFFF;
251  ctx->channels = (unsigned)bytestream2_get_le32(&gbc) % FF_SANE_NB_CHANNELS;
252  ctx->block_align = bytestream2_get_le32(&gbc) & 0x7FFFFFFF;
253  ctx->codec_tag = bytestream2_get_le32(&gbc);
254  if (c->codec_tags) {
255  int n;
256  for (n = 0; c->codec_tags[n] != FF_CODEC_TAGS_END; n++);
257  ctx->codec_tag = c->codec_tags[ctx->codec_tag % n];
258  }
259  keyframes = bytestream2_get_le64(&gbc);
260  ctx->request_channel_layout = bytestream2_get_le64(&gbc);
261 
262  ctx->idct_algo = bytestream2_get_byte(&gbc) % 25;
263  flushpattern = bytestream2_get_le64(&gbc);
264 
265  if (flags & 0x20) {
266  switch (ctx->codec_id) {
267  case AV_CODEC_ID_AC3:
268  case AV_CODEC_ID_EAC3:
269  av_dict_set_int(&opts, "cons_noisegen", bytestream2_get_byte(&gbc) & 1, 0);
270  av_dict_set_int(&opts, "heavy_compr", bytestream2_get_byte(&gbc) & 1, 0);
271  av_dict_set_int(&opts, "target_level", (int)(bytestream2_get_byte(&gbc) % 32) - 31, 0);
272  av_dict_set_int(&opts, "dmix_mode", (int)(bytestream2_get_byte(&gbc) % 4) - 1, 0);
273  break;
274  }
275  }
276 
277 
278  if (extradata_size < size) {
279  ctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
280  if (ctx->extradata) {
281  ctx->extradata_size = extradata_size;
282  size -= ctx->extradata_size;
283  memcpy(ctx->extradata, data + size, ctx->extradata_size);
284  }
285  }
286  if (av_image_check_size(ctx->width, ctx->height, 0, ctx))
287  ctx->width = ctx->height = 0;
288  }
289 
290  int res = avcodec_open2(ctx, c, &opts);
291  if (res < 0) {
292  avcodec_free_context(&ctx);
293  av_free(parser_avctx);
294  av_parser_close(parser);
295  av_dict_free(&opts);
296  return 0; // Failure of avcodec_open2() does not imply that a issue was found
297  }
298  parser_avctx->codec_id = ctx->codec_id;
299 
300  int got_frame;
302  AVPacket *avpkt = av_packet_alloc();
303  AVPacket *parsepkt = av_packet_alloc();
304  if (!frame || !avpkt || !parsepkt)
305  error("Failed memory allocation");
306 
307  // Read very simple container
308  while (data < end && it < maxiteration) {
309  // Search for the TAG
310  while (data + sizeof(fuzz_tag) < end) {
311  if (data[0] == (fuzz_tag & 0xFF) && AV_RN64(data) == fuzz_tag)
312  break;
313  data++;
314  }
315  if (data + sizeof(fuzz_tag) > end)
316  data = end;
317 
318  res = av_new_packet(parsepkt, data - last);
319  if (res < 0)
320  error("Failed memory allocation");
321  memcpy(parsepkt->data, last, data - last);
322  parsepkt->flags = (keyframes & 1) * AV_PKT_FLAG_DISCARD + (!!(keyframes & 2)) * AV_PKT_FLAG_KEY;
323  keyframes = (keyframes >> 2) + (keyframes<<62);
324  data += sizeof(fuzz_tag);
325  last = data;
326 
327  while (parsepkt->size > 0) {
328  int decode_more;
329 
330  if (parser) {
331  int ret = av_parser_parse2(parser, parser_avctx, &avpkt->data, &avpkt->size,
332  parsepkt->data, parsepkt->size,
333  parsepkt->pts, parsepkt->dts, parsepkt->pos);
334  if (avpkt->data == parsepkt->data) {
335  avpkt->buf = av_buffer_ref(parsepkt->buf);
336  if (!avpkt->buf)
337  error("Failed memory allocation");
338  } else {
339  if (av_packet_make_refcounted(avpkt) < 0)
340  error("Failed memory allocation");
341  }
342  parsepkt->data += ret;
343  parsepkt->size -= ret;
344  parsepkt->pos += ret;
345  avpkt->pts = parser->pts;
346  avpkt->dts = parser->dts;
347  avpkt->pos = parser->pos;
348  if ( parser->key_frame == 1 ||
349  (parser->key_frame == -1 && parser->pict_type == AV_PICTURE_TYPE_I))
350  avpkt->flags |= AV_PKT_FLAG_KEY;
351  avpkt->flags |= parsepkt->flags & AV_PKT_FLAG_DISCARD;
352  } else {
353  av_packet_move_ref(avpkt, parsepkt);
354  }
355 
356  if (!(flushpattern & 7))
358  flushpattern = (flushpattern >> 3) + (flushpattern << 61);
359 
360  if (ctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
361  int ret = avcodec_send_packet(ctx, avpkt);
362  decode_more = ret >= 0;
363  if(!decode_more) {
364  ec_pixels += (ctx->width + 32LL) * (ctx->height + 32LL);
365  if (it > 20 || ec_pixels > 4 * ctx->max_pixels)
366  ctx->error_concealment = 0;
367  if (ec_pixels > maxpixels)
368  goto maximums_reached;
369  }
370  } else
371  decode_more = 1;
372 
373  // Iterate through all data
374  while (decode_more && it++ < maxiteration) {
375  av_frame_unref(frame);
376  int ret = decode_handler(ctx, frame, &got_frame, avpkt);
377 
378  ec_pixels += (ctx->width + 32LL) * (ctx->height + 32LL);
379  if (it > 20 || ec_pixels > 4 * ctx->max_pixels)
380  ctx->error_concealment = 0;
381  if (ec_pixels > maxpixels)
382  goto maximums_reached;
383 
384  if (ctx->codec_type == AVMEDIA_TYPE_AUDIO &&
385  frame->nb_samples == 0 && !got_frame &&
386  (avpkt->flags & AV_PKT_FLAG_DISCARD))
387  nb_samples += ctx->max_samples;
388 
389  nb_samples += frame->nb_samples;
390  if (nb_samples > maxsamples)
391  goto maximums_reached;
392 
393  if (ret <= 0 || ret > avpkt->size)
394  break;
395 
396  if (ctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
397  avpkt->data += ret;
398  avpkt->size -= ret;
399  decode_more = avpkt->size > 0;
400  } else
401  decode_more = ret >= 0;
402  }
403  av_packet_unref(avpkt);
404  }
405  av_packet_unref(parsepkt);
406  }
407 maximums_reached:
408 
409  av_packet_unref(avpkt);
410 
411  if (ctx->codec_type != AVMEDIA_TYPE_SUBTITLE)
413 
414  do {
415  got_frame = 0;
416  av_frame_unref(frame);
417  decode_handler(ctx, frame, &got_frame, avpkt);
418  } while (got_frame == 1 && it++ < maxiteration);
419 
420  fprintf(stderr, "pixels decoded: %"PRId64", samples decoded: %"PRId64", iterations: %d\n", ec_pixels, nb_samples, it);
421 
422  av_frame_free(&frame);
423  avcodec_free_context(&ctx);
424  avcodec_free_context(&parser_avctx);
425  av_parser_close(parser);
426  av_packet_free(&avpkt);
427  av_packet_free(&parsepkt);
428  av_dict_free(&opts);
429  return 0;
430 }
#define FF_SANE_NB_CHANNELS
Definition: internal.h:102
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1606
const uint32_t maxiteration
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
Definition: avcodec.h:1661
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
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:586
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
void av_log_set_level(int level)
Set the log level.
Definition: log.c:440
int size
Definition: packet.h:370
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1660
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
enum AVMediaType type
Definition: codec.h:210
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:1025
AVCodec.
Definition: codec.h:197
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:1233
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
uint8_t
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:191
#define AV_LOG_PANIC
Something went really wrong and we will crash now.
Definition: log.h:181
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
uint8_t * data
Definition: packet.h:369
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:690
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:348
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1740
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
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:99
enum AVCodecID id
Definition: codec.h:211
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:3487
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
int error_concealment
error concealment flags
Definition: avcodec.h:1613
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:643
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:352
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:2248
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
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:1645
#define FFMIN(a, b)
Definition: common.h:105
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:170
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:709
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1719
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:696
AVFormatContext * ctx
Definition: movenc.c:48
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:228
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:1656
int dummy
Definition: motion.c:64
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: avcodec.c:444
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:580
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:544
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:185
enum AVCodecID codec_id
Definition: avcodec.h:546
int sample_rate
samples per second
Definition: avcodec.h:1196
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:348
main external API structure.
Definition: avcodec.h:536
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:504
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:561
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:2336
uint64_t maxpixels_per_frame
int extradata_size
Definition: avcodec.h:638
#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:1659
static int audio_video_handler(AVCodecContext *avctx, AVFrame *frame, int *got_frame, const AVPacket *dummy)
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:142
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:417
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
#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:1197
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
#define AV_RN64(p)
Definition: intreadwrite.h:368
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:623
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:368
static float sub(float src0, float src1)
#define FF_CODEC_TAGS_END
AVCodec.codec_tags termination value.
Definition: internal.h:85
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:1254
This structure stores compressed data.
Definition: packet.h:346
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:3426
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
AVCodec * codec_list[]