FFmpeg
apngdec.c
Go to the documentation of this file.
1 /*
2  * APNG demuxer
3  * Copyright (c) 2014 Benoit Fouet
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * APNG demuxer.
25  * @see https://wiki.mozilla.org/APNG_Specification
26  * @see http://www.w3.org/TR/PNG
27  */
28 
29 #include "avformat.h"
30 #include "avio_internal.h"
31 #include "internal.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/apng.h"
36 #include "libavcodec/png.h"
37 #include "libavcodec/bytestream.h"
38 
39 #define DEFAULT_APNG_FPS 15
40 
41 typedef struct APNGDemuxContext {
42  const AVClass *class;
43 
44  int max_fps;
46 
48 
50 
51  /*
52  * loop options
53  */
55  uint32_t num_frames;
56  uint32_t num_play;
57  uint32_t cur_loop;
59 
60 /*
61  * To be a valid APNG file, we mandate, in this order:
62  * PNGSIG
63  * IHDR
64  * ...
65  * acTL
66  * ...
67  * IDAT
68  */
69 static int apng_probe(const AVProbeData *p)
70 {
71  GetByteContext gb;
72  int state = 0;
73  uint32_t len, tag;
74 
75  bytestream2_init(&gb, p->buf, p->buf_size);
76 
77  if (bytestream2_get_be64(&gb) != PNGSIG)
78  return 0;
79 
80  for (;;) {
81  len = bytestream2_get_be32(&gb);
82  if (len > 0x7fffffff)
83  return 0;
84 
85  tag = bytestream2_get_le32(&gb);
86  /* we don't check IDAT size, as this is the last tag
87  * we check, and it may be larger than the probe buffer */
88  if (tag != MKTAG('I', 'D', 'A', 'T') &&
89  len + 4 > bytestream2_get_bytes_left(&gb))
90  return 0;
91 
92  switch (tag) {
93  case MKTAG('I', 'H', 'D', 'R'):
94  if (len != 13)
95  return 0;
96  if (av_image_check_size(bytestream2_get_be32(&gb), bytestream2_get_be32(&gb), 0, NULL))
97  return 0;
98  bytestream2_skip(&gb, 9);
99  state++;
100  break;
101  case MKTAG('a', 'c', 'T', 'L'):
102  if (state != 1 ||
103  len != 8 ||
104  bytestream2_get_be32(&gb) == 0) /* 0 is not a valid value for number of frames */
105  return 0;
106  bytestream2_skip(&gb, 8);
107  state++;
108  break;
109  case MKTAG('I', 'D', 'A', 'T'):
110  if (state != 2)
111  return 0;
112  goto end;
113  default:
114  /* skip other tags */
115  bytestream2_skip(&gb, len + 4);
116  break;
117  }
118  }
119 
120 end:
121  return AVPROBE_SCORE_MAX;
122 }
123 
125 {
126  int previous_size = par->extradata_size;
127  int new_size, ret;
128  uint8_t *new_extradata;
129 
130  if (previous_size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - len)
131  return AVERROR_INVALIDDATA;
132 
133  new_size = previous_size + len;
134  new_extradata = av_realloc(par->extradata, new_size + AV_INPUT_BUFFER_PADDING_SIZE);
135  if (!new_extradata)
136  return AVERROR(ENOMEM);
137  memset(new_extradata + new_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
138  par->extradata = new_extradata;
139  par->extradata_size = new_size;
140 
141  if ((ret = avio_read(pb, par->extradata + previous_size, len)) < 0)
142  return ret;
143 
144  return previous_size;
145 }
146 
148 {
150  AVIOContext *pb = s->pb;
151  uint32_t len, tag;
152  AVStream *st;
153  int acTL_found = 0;
154  int64_t ret = AVERROR_INVALIDDATA;
155 
156  /* verify PNGSIG */
157  if (avio_rb64(pb) != PNGSIG)
158  return ret;
159 
160  /* parse IHDR (must be first chunk) */
161  len = avio_rb32(pb);
162  tag = avio_rl32(pb);
163  if (len != 13 || tag != MKTAG('I', 'H', 'D', 'R'))
164  return ret;
165 
166  st = avformat_new_stream(s, NULL);
167  if (!st)
168  return AVERROR(ENOMEM);
169 
170  /* set the timebase to something large enough (1/100,000 of second)
171  * to hopefully cope with all sane frame durations */
172  avpriv_set_pts_info(st, 64, 1, 100000);
175  st->codecpar->width = avio_rb32(pb);
176  st->codecpar->height = avio_rb32(pb);
177  if ((ret = av_image_check_size(st->codecpar->width, st->codecpar->height, 0, s)) < 0)
178  return ret;
179 
180  /* extradata will contain every chunk up to the first fcTL (excluded) */
181  ret = ff_alloc_extradata(st->codecpar, len + 12);
182  if (ret < 0)
183  return ret;
184  AV_WB32(st->codecpar->extradata, len);
185  AV_WL32(st->codecpar->extradata+4, tag);
186  AV_WB32(st->codecpar->extradata+8, st->codecpar->width);
187  AV_WB32(st->codecpar->extradata+12, st->codecpar->height);
188  if ((ret = avio_read(pb, st->codecpar->extradata+16, 9)) < 0)
189  goto fail;
190 
191  while (!avio_feof(pb)) {
192  if (acTL_found && ctx->num_play != 1) {
193  int64_t size = avio_size(pb);
194  int64_t offset = avio_tell(pb);
195  if (size < 0) {
196  ret = size;
197  goto fail;
198  } else if (offset < 0) {
199  ret = offset;
200  goto fail;
201  } else if ((ret = ffio_ensure_seekback(pb, size - offset)) < 0) {
202  av_log(s, AV_LOG_WARNING, "Could not ensure seekback, will not loop\n");
203  ctx->num_play = 1;
204  }
205  }
206  if ((ctx->num_play == 1 || !acTL_found) &&
207  ((ret = ffio_ensure_seekback(pb, 4 /* len */ + 4 /* tag */)) < 0))
208  goto fail;
209 
210  len = avio_rb32(pb);
211  if (len > 0x7fffffff) {
212  ret = AVERROR_INVALIDDATA;
213  goto fail;
214  }
215 
216  tag = avio_rl32(pb);
217  switch (tag) {
218  case MKTAG('a', 'c', 'T', 'L'):
219  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 ||
220  (ret = append_extradata(st->codecpar, pb, len + 12)) < 0)
221  goto fail;
222  acTL_found = 1;
223  ctx->num_frames = AV_RB32(st->codecpar->extradata + ret + 8);
224  ctx->num_play = AV_RB32(st->codecpar->extradata + ret + 12);
225  av_log(s, AV_LOG_DEBUG, "num_frames: %"PRIu32", num_play: %"PRIu32"\n",
226  ctx->num_frames, ctx->num_play);
227  break;
228  case MKTAG('f', 'c', 'T', 'L'):
229  if (!acTL_found) {
230  ret = AVERROR_INVALIDDATA;
231  goto fail;
232  }
233  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0)
234  goto fail;
235  return 0;
236  default:
237  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 ||
238  (ret = append_extradata(st->codecpar, pb, len + 12)) < 0)
239  goto fail;
240  }
241  }
242 
243 fail:
244  return ret;
245 }
246 
248 {
249  uint32_t sequence_number, width, height, x_offset, y_offset;
250  uint16_t delay_num, delay_den;
251  uint8_t dispose_op, blend_op;
252 
253  sequence_number = avio_rb32(s->pb);
254  width = avio_rb32(s->pb);
255  height = avio_rb32(s->pb);
256  x_offset = avio_rb32(s->pb);
257  y_offset = avio_rb32(s->pb);
258  delay_num = avio_rb16(s->pb);
259  delay_den = avio_rb16(s->pb);
260  dispose_op = avio_r8(s->pb);
261  blend_op = avio_r8(s->pb);
262  avio_skip(s->pb, 4); /* crc */
263 
264  /* default is hundredths of seconds */
265  if (!delay_den)
266  delay_den = 100;
267  if (!delay_num || (ctx->max_fps && delay_den / delay_num > ctx->max_fps)) {
268  delay_num = 1;
269  delay_den = ctx->default_fps;
270  }
271  ctx->pkt_duration = av_rescale_q(delay_num,
272  (AVRational){ 1, delay_den },
273  s->streams[0]->time_base);
274 
275  av_log(s, AV_LOG_DEBUG, "%s: "
276  "sequence_number: %"PRId32", "
277  "width: %"PRIu32", "
278  "height: %"PRIu32", "
279  "x_offset: %"PRIu32", "
280  "y_offset: %"PRIu32", "
281  "delay_num: %"PRIu16", "
282  "delay_den: %"PRIu16", "
283  "dispose_op: %d, "
284  "blend_op: %d\n",
285  __FUNCTION__,
286  sequence_number,
287  width,
288  height,
289  x_offset,
290  y_offset,
291  delay_num,
292  delay_den,
293  dispose_op,
294  blend_op);
295 
296  if (width != s->streams[0]->codecpar->width ||
297  height != s->streams[0]->codecpar->height ||
298  x_offset != 0 ||
299  y_offset != 0) {
300  if (sequence_number == 0 ||
301  x_offset >= s->streams[0]->codecpar->width ||
302  width > s->streams[0]->codecpar->width - x_offset ||
303  y_offset >= s->streams[0]->codecpar->height ||
304  height > s->streams[0]->codecpar->height - y_offset)
305  return AVERROR_INVALIDDATA;
306  ctx->is_key_frame = 0;
307  } else {
308  if (sequence_number == 0 && dispose_op == APNG_DISPOSE_OP_PREVIOUS)
309  dispose_op = APNG_DISPOSE_OP_BACKGROUND;
310  ctx->is_key_frame = dispose_op == APNG_DISPOSE_OP_BACKGROUND ||
311  blend_op == APNG_BLEND_OP_SOURCE;
312  }
313 
314  return 0;
315 }
316 
318 {
320  int64_t ret;
321  int64_t size;
322  AVIOContext *pb = s->pb;
323  uint32_t len, tag;
324 
325  /*
326  * fcTL chunk length, in bytes:
327  * 4 (length)
328  * 4 (tag)
329  * 26 (actual chunk)
330  * 4 (crc) bytes
331  * and needed next:
332  * 4 (length)
333  * 4 (tag (must be fdAT or IDAT))
334  */
335  /* if num_play is not 1, then the seekback is already guaranteed */
336  if (ctx->num_play == 1 && (ret = ffio_ensure_seekback(pb, 46)) < 0)
337  return ret;
338 
339  len = avio_rb32(pb);
340  tag = avio_rl32(pb);
341 
342  if (avio_feof(pb))
343  return AVERROR_EOF;
344 
345  switch (tag) {
346  case MKTAG('f', 'c', 'T', 'L'):
347  if (len != 26)
348  return AVERROR_INVALIDDATA;
349 
350  if ((ret = decode_fctl_chunk(s, ctx, pkt)) < 0)
351  return ret;
352 
353  /* fcTL must precede fdAT or IDAT */
354  len = avio_rb32(pb);
355  tag = avio_rl32(pb);
356  if (len > 0x7fffffff ||
357  tag != MKTAG('f', 'd', 'A', 'T') &&
358  tag != MKTAG('I', 'D', 'A', 'T'))
359  return AVERROR_INVALIDDATA;
360 
361  size = 38 /* fcTL */ + 8 /* len, tag */ + len + 4 /* crc */;
362  if (size > INT_MAX)
363  return AVERROR(EINVAL);
364 
365  if ((ret = avio_seek(pb, -46, SEEK_CUR)) < 0 ||
366  (ret = av_append_packet(pb, pkt, size)) < 0)
367  return ret;
368 
369  if (ctx->num_play == 1 && (ret = ffio_ensure_seekback(pb, 8)) < 0)
370  return ret;
371 
372  len = avio_rb32(pb);
373  tag = avio_rl32(pb);
374  while (tag &&
375  tag != MKTAG('f', 'c', 'T', 'L') &&
376  tag != MKTAG('I', 'E', 'N', 'D')) {
377  if (len > 0x7fffffff)
378  return AVERROR_INVALIDDATA;
379  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 ||
380  (ret = av_append_packet(pb, pkt, len + 12)) < 0)
381  return ret;
382  if (ctx->num_play == 1 && (ret = ffio_ensure_seekback(pb, 8)) < 0)
383  return ret;
384  len = avio_rb32(pb);
385  tag = avio_rl32(pb);
386  }
387  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0)
388  return ret;
389 
390  if (ctx->is_key_frame)
391  pkt->flags |= AV_PKT_FLAG_KEY;
392  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
393  pkt->duration = ctx->pkt_duration;
394  return ret;
395  case MKTAG('I', 'E', 'N', 'D'):
396  ctx->cur_loop++;
397  if (ctx->ignore_loop || ctx->num_play >= 1 && ctx->cur_loop == ctx->num_play) {
398  avio_seek(pb, -8, SEEK_CUR);
399  return AVERROR_EOF;
400  }
401  if ((ret = avio_seek(pb, s->streams[0]->codecpar->extradata_size + 8, SEEK_SET)) < 0)
402  return ret;
403  return 0;
404  default:
405  avpriv_request_sample(s, "In-stream tag=%s (0x%08"PRIX32") len=%"PRIu32,
406  av_fourcc2str(tag), tag, len);
407  avio_skip(pb, len + 4);
408  }
409 
410  /* Handle the unsupported yet cases */
411  return AVERROR_PATCHWELCOME;
412 }
413 
414 static const AVOption options[] = {
415  { "ignore_loop", "ignore loop setting" , offsetof(APNGDemuxContext, ignore_loop),
416  AV_OPT_TYPE_BOOL, { .i64 = 1 } , 0, 1 , AV_OPT_FLAG_DECODING_PARAM },
417  { "max_fps" , "maximum framerate (0 is no limit)" , offsetof(APNGDemuxContext, max_fps),
418  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
419  { "default_fps", "default framerate (0 is as fast as possible)", offsetof(APNGDemuxContext, default_fps),
420  AV_OPT_TYPE_INT, { .i64 = DEFAULT_APNG_FPS }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
421  { NULL },
422 };
423 
424 static const AVClass demuxer_class = {
425  .class_name = "APNG demuxer",
426  .item_name = av_default_item_name,
427  .option = options,
428  .version = LIBAVUTIL_VERSION_INT,
429  .category = AV_CLASS_CATEGORY_DEMUXER,
430 };
431 
433  .name = "apng",
434  .long_name = NULL_IF_CONFIG_SMALL("Animated Portable Network Graphics"),
435  .priv_data_size = sizeof(APNGDemuxContext),
440  .priv_class = &demuxer_class,
441 };
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
AVOption.
Definition: opt.h:246
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4943
#define avpriv_request_sample(...)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4036
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
AVInputFormat ff_apng_demuxer
Definition: apngdec.c:432
static AVPacket pkt
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:783
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4028
Format I/O context.
Definition: avformat.h:1353
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
uint8_t
int width
Video only.
Definition: avcodec.h:4102
AVOptions.
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:798
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1551
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4524
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1421
#define height
uint32_t tag
Definition: movenc.c:1534
#define AVERROR_EOF
End of file.
Definition: error.h:55
ptrdiff_t size
Definition: opengl_enc.c:100
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:919
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:645
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
Read data and append it to the current content of the AVPacket.
Definition: utils.c:318
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1565
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:767
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4032
#define PNGSIG
Definition: png.h:47
uint32_t num_play
Definition: apngdec.c:56
#define fail()
Definition: checkasm.h:122
#define DEFAULT_APNG_FPS
Definition: apngdec.c:39
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:4054
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:636
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
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:282
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3323
#define width
static int decode_fctl_chunk(AVFormatContext *s, APNGDemuxContext *ctx, AVPacket *pkt)
Definition: apngdec.c:247
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int append_extradata(AVCodecParameters *par, AVIOContext *pb, int len)
Definition: apngdec.c:124
static int apng_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: apngdec.c:317
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
Stream structure.
Definition: avformat.h:876
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVIOContext * pb
I/O context.
Definition: avformat.h:1395
int pkt_duration
Definition: apngdec.c:47
int is_key_frame
Definition: apngdec.c:49
static struct @327 state
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:463
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
static const AVOption options[]
Definition: apngdec.c:414
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
static const AVClass demuxer_class
Definition: apngdec.c:424
#define flags(name, subs,...)
Definition: cbs_av1.c:564
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1002
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
Main libavformat public API header.
uint32_t cur_loop
Definition: apngdec.c:57
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:808
int len
void * priv_data
Format private data.
Definition: avformat.h:1381
APNG common header.
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:4050
uint32_t num_frames
Definition: apngdec.c:55
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356
static int apng_probe(const AVProbeData *p)
Definition: apngdec.c:69
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:905
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1510
static int apng_read_header(AVFormatContext *s)
Definition: apngdec.c:147
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1526
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define AV_WL32(p, v)
Definition: intreadwrite.h:426