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 "demux.h"
32 #include "internal.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/intreadwrite.h"
35 #include "libavutil/mem.h"
36 #include "libavutil/opt.h"
37 #include "libavcodec/apng.h"
38 #include "libavcodec/png.h"
39 #include "libavcodec/bytestream.h"
40 
41 #define DEFAULT_APNG_FPS 15
42 
43 typedef struct APNGDemuxContext {
44  const AVClass *class;
45 
46  int max_fps;
48 
50 
52 
53  /*
54  * loop options
55  */
57  uint32_t num_frames;
58  uint32_t num_play;
59  uint32_t cur_loop;
61 
62 /*
63  * To be a valid APNG file, we mandate, in this order:
64  * PNGSIG
65  * IHDR
66  * ...
67  * acTL
68  * ...
69  * IDAT
70  */
71 static int apng_probe(const AVProbeData *p)
72 {
73  GetByteContext gb;
74  int state = 0;
75  uint32_t len, tag;
76 
77  bytestream2_init(&gb, p->buf, p->buf_size);
78 
79  if (bytestream2_get_be64(&gb) != PNGSIG)
80  return 0;
81 
82  for (;;) {
83  len = bytestream2_get_be32(&gb);
84  if (len > 0x7fffffff)
85  return 0;
86 
87  tag = bytestream2_get_le32(&gb);
88  /* we don't check IDAT size, as this is the last tag
89  * we check, and it may be larger than the probe buffer */
90  if (tag != MKTAG('I', 'D', 'A', 'T') &&
92  return 0;
93 
94  switch (tag) {
95  case MKTAG('I', 'H', 'D', 'R'):
96  if (len != 13)
97  return 0;
98  if (av_image_check_size(bytestream2_get_be32(&gb), bytestream2_get_be32(&gb), 0, NULL))
99  return 0;
100  bytestream2_skip(&gb, 9);
101  state++;
102  break;
103  case MKTAG('a', 'c', 'T', 'L'):
104  if (state != 1 ||
105  len != 8 ||
106  bytestream2_get_be32(&gb) == 0) /* 0 is not a valid value for number of frames */
107  return 0;
108  bytestream2_skip(&gb, 8);
109  state++;
110  break;
111  case MKTAG('I', 'D', 'A', 'T'):
112  if (state != 2)
113  return 0;
114  goto end;
115  default:
116  /* skip other tags */
117  bytestream2_skip(&gb, len + 4);
118  break;
119  }
120  }
121 
122 end:
123  return AVPROBE_SCORE_MAX;
124 }
125 
127 {
128  int previous_size = par->extradata_size;
129  int new_size, ret;
130  uint8_t *new_extradata;
131 
132  if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - previous_size)
133  return AVERROR_INVALIDDATA;
134 
135  new_size = previous_size + len;
136  new_extradata = av_realloc(par->extradata, new_size + AV_INPUT_BUFFER_PADDING_SIZE);
137  if (!new_extradata)
138  return AVERROR(ENOMEM);
139  memset(new_extradata + new_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
140  par->extradata = new_extradata;
141  par->extradata_size = new_size;
142 
143  if ((ret = ffio_read_size(pb, par->extradata + previous_size, len)) < 0)
144  return ret;
145 
146  return previous_size;
147 }
148 
150 {
151  APNGDemuxContext *ctx = s->priv_data;
152  AVIOContext *pb = s->pb;
153  uint32_t len, tag;
154  AVStream *st;
155  int acTL_found = 0;
156  int64_t ret;
157 
158  /* verify PNGSIG */
159  if (avio_rb64(pb) != PNGSIG)
160  return AVERROR_INVALIDDATA;
161 
162  /* parse IHDR (must be first chunk) */
163  len = avio_rb32(pb);
164  tag = avio_rl32(pb);
165  if (len != 13 || tag != MKTAG('I', 'H', 'D', 'R'))
166  return AVERROR_INVALIDDATA;
167 
168  st = avformat_new_stream(s, NULL);
169  if (!st)
170  return AVERROR(ENOMEM);
171 
172  /* set the timebase to something large enough (1/100,000 of second)
173  * to hopefully cope with all sane frame durations */
174  avpriv_set_pts_info(st, 64, 1, 100000);
177  st->codecpar->width = avio_rb32(pb);
178  st->codecpar->height = avio_rb32(pb);
179  if ((ret = av_image_check_size(st->codecpar->width, st->codecpar->height, 0, s)) < 0)
180  return ret;
181 
182  /* extradata will contain every chunk up to the first fcTL (excluded) */
183  ret = ff_alloc_extradata(st->codecpar, len + 12);
184  if (ret < 0)
185  return ret;
186  AV_WB32(st->codecpar->extradata, len);
187  AV_WL32(st->codecpar->extradata+4, tag);
188  AV_WB32(st->codecpar->extradata+8, st->codecpar->width);
189  AV_WB32(st->codecpar->extradata+12, st->codecpar->height);
190  if ((ret = ffio_read_size(pb, st->codecpar->extradata + 16, 9)) < 0)
191  return ret;
192 
193  while (1) {
194  if (acTL_found && ctx->num_play != 1) {
195  int64_t size = avio_size(pb);
196  int64_t offset = avio_tell(pb);
197  if (size < 0) {
198  return size;
199  } else if (offset < 0) {
200  return offset;
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  return ret;
209 
210  len = avio_rb32(pb);
211  if (len > INT_MAX - 12)
212  return AVERROR_INVALIDDATA;
213 
214  tag = avio_rl32(pb);
215  switch (tag) {
216  case MKTAG('a', 'c', 'T', 'L'):
217  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 ||
218  (ret = append_extradata(st->codecpar, pb, len + 12)) < 0)
219  return ret;
220  acTL_found = 1;
221  ctx->num_frames = AV_RB32(st->codecpar->extradata + ret + 8);
222  ctx->num_play = AV_RB32(st->codecpar->extradata + ret + 12);
223  av_log(s, AV_LOG_DEBUG, "num_frames: %"PRIu32", num_play: %"PRIu32"\n",
224  ctx->num_frames, ctx->num_play);
225  break;
226  case MKTAG('f', 'c', 'T', 'L'):
227  if (!acTL_found || len != APNG_FCTL_CHUNK_SIZE) {
228  return AVERROR_INVALIDDATA;
229  }
230  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0)
231  return ret;
232  return 0;
233  default:
234  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 ||
235  (ret = append_extradata(st->codecpar, pb, len + 12)) < 0)
236  return ret;
237  }
238  }
239 }
240 
242 {
243  uint32_t sequence_number, width, height, x_offset, y_offset;
244  uint16_t delay_num, delay_den;
245  uint8_t dispose_op, blend_op;
246 
247  sequence_number = avio_rb32(s->pb);
248  width = avio_rb32(s->pb);
249  height = avio_rb32(s->pb);
250  x_offset = avio_rb32(s->pb);
251  y_offset = avio_rb32(s->pb);
252  delay_num = avio_rb16(s->pb);
253  delay_den = avio_rb16(s->pb);
254  dispose_op = avio_r8(s->pb);
255  blend_op = avio_r8(s->pb);
256  avio_skip(s->pb, 4); /* crc */
257 
258  /* default is hundredths of seconds */
259  if (!delay_den)
260  delay_den = 100;
261  if (!delay_num || (ctx->max_fps && delay_den / delay_num > ctx->max_fps)) {
262  delay_num = 1;
263  delay_den = ctx->default_fps;
264  }
265  ctx->pkt_duration = av_rescale_q(delay_num,
266  (AVRational){ 1, delay_den },
267  s->streams[0]->time_base);
268 
269  av_log(s, AV_LOG_DEBUG, "%s: "
270  "sequence_number: %"PRId32", "
271  "width: %"PRIu32", "
272  "height: %"PRIu32", "
273  "x_offset: %"PRIu32", "
274  "y_offset: %"PRIu32", "
275  "delay_num: %"PRIu16", "
276  "delay_den: %"PRIu16", "
277  "dispose_op: %d, "
278  "blend_op: %d\n",
279  __func__,
280  sequence_number,
281  width,
282  height,
283  x_offset,
284  y_offset,
285  delay_num,
286  delay_den,
287  dispose_op,
288  blend_op);
289 
290  if (width != s->streams[0]->codecpar->width ||
291  height != s->streams[0]->codecpar->height ||
292  x_offset != 0 ||
293  y_offset != 0) {
294  if (sequence_number == 0 ||
295  x_offset >= s->streams[0]->codecpar->width ||
296  width > s->streams[0]->codecpar->width - x_offset ||
297  y_offset >= s->streams[0]->codecpar->height ||
298  height > s->streams[0]->codecpar->height - y_offset)
299  return AVERROR_INVALIDDATA;
300  ctx->is_key_frame = 0;
301  } else {
302  if (sequence_number == 0 && dispose_op == APNG_DISPOSE_OP_PREVIOUS)
303  dispose_op = APNG_DISPOSE_OP_BACKGROUND;
304  ctx->is_key_frame = dispose_op == APNG_DISPOSE_OP_BACKGROUND ||
305  blend_op == APNG_BLEND_OP_SOURCE;
306  }
307 
308  return 0;
309 }
310 
312 {
313  APNGDemuxContext *ctx = s->priv_data;
314  int64_t ret;
315  int64_t size;
316  AVIOContext *pb = s->pb;
317  uint32_t len, tag;
318 
319  /*
320  * fcTL chunk length, in bytes:
321  * 4 (length)
322  * 4 (tag)
323  * 26 (actual chunk)
324  * 4 (crc) bytes
325  * and needed next:
326  * 4 (length)
327  * 4 (tag (must be fdAT or IDAT))
328  */
329  /* if num_play is not 1, then the seekback is already guaranteed */
330  if (ctx->num_play == 1 && (ret = ffio_ensure_seekback(pb, 46)) < 0)
331  return ret;
332 
333  len = avio_rb32(pb);
334  tag = avio_rl32(pb);
335 
336  if (avio_feof(pb))
337  return AVERROR_EOF;
338 
339  switch (tag) {
340  case MKTAG('f', 'c', 'T', 'L'):
341  if (len != APNG_FCTL_CHUNK_SIZE)
342  return AVERROR_INVALIDDATA;
343 
344  if ((ret = decode_fctl_chunk(s, ctx, pkt)) < 0)
345  return ret;
346 
347  /* fcTL must precede fdAT or IDAT */
348  len = avio_rb32(pb);
349  tag = avio_rl32(pb);
350  if (len > 0x7fffffff ||
351  tag != MKTAG('f', 'd', 'A', 'T') &&
352  tag != MKTAG('I', 'D', 'A', 'T'))
353  return AVERROR_INVALIDDATA;
354 
355  size = 38 /* fcTL */ + 8 /* len, tag */ + len + 4 /* crc */;
356  if (size > INT_MAX)
357  return AVERROR(EINVAL);
358 
359  if ((ret = avio_seek(pb, -46, SEEK_CUR)) < 0 ||
360  (ret = av_append_packet(pb, pkt, size)) < 0)
361  return ret;
362 
363  if (ctx->num_play == 1 && (ret = ffio_ensure_seekback(pb, 8)) < 0)
364  return ret;
365 
366  len = avio_rb32(pb);
367  tag = avio_rl32(pb);
368  while (tag &&
369  tag != MKTAG('f', 'c', 'T', 'L') &&
370  tag != MKTAG('I', 'E', 'N', 'D')) {
371  if (len > 0x7fffffff)
372  return AVERROR_INVALIDDATA;
373  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 ||
374  (ret = av_append_packet(pb, pkt, len + 12)) < 0)
375  return ret;
376  if (ctx->num_play == 1 && (ret = ffio_ensure_seekback(pb, 8)) < 0)
377  return ret;
378  len = avio_rb32(pb);
379  tag = avio_rl32(pb);
380  }
381  if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0)
382  return ret;
383 
384  if (ctx->is_key_frame)
386  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
387  pkt->duration = ctx->pkt_duration;
388  return ret;
389  case MKTAG('I', 'E', 'N', 'D'):
390  ctx->cur_loop++;
391  if (ctx->ignore_loop || ctx->num_play >= 1 && ctx->cur_loop == ctx->num_play) {
392  avio_seek(pb, -8, SEEK_CUR);
393  return AVERROR_EOF;
394  }
395  if ((ret = avio_seek(pb, s->streams[0]->codecpar->extradata_size + 8, SEEK_SET)) < 0)
396  return ret;
397  return 0;
398  default:
399  avpriv_request_sample(s, "In-stream tag=%s (0x%08"PRIX32") len=%"PRIu32,
400  av_fourcc2str(tag), tag, len);
401  avio_skip(pb, len + 4);
402  }
403 
404  /* Handle the unsupported yet cases */
405  return AVERROR_PATCHWELCOME;
406 }
407 
408 static const AVOption options[] = {
409  { "ignore_loop", "ignore loop setting" , offsetof(APNGDemuxContext, ignore_loop),
410  AV_OPT_TYPE_BOOL, { .i64 = 1 } , 0, 1 , AV_OPT_FLAG_DECODING_PARAM },
411  { "max_fps" , "maximum framerate (0 is no limit)" , offsetof(APNGDemuxContext, max_fps),
412  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
413  { "default_fps", "default framerate (0 is as fast as possible)", offsetof(APNGDemuxContext, default_fps),
415  { NULL },
416 };
417 
418 static const AVClass demuxer_class = {
419  .class_name = "APNG demuxer",
420  .item_name = av_default_item_name,
421  .option = options,
422  .version = LIBAVUTIL_VERSION_INT,
423  .category = AV_CLASS_CATEGORY_DEMUXER,
424 };
425 
427  .p.name = "apng",
428  .p.long_name = NULL_IF_CONFIG_SMALL("Animated Portable Network Graphics"),
429  .p.flags = AVFMT_GENERIC_INDEX,
430  .p.priv_class = &demuxer_class,
431  .priv_data_size = sizeof(APNGDemuxContext),
435 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
AVERROR
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
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
GetByteContext
Definition: bytestream.h:33
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
APNG_FCTL_CHUNK_SIZE
#define APNG_FCTL_CHUNK_SIZE
Definition: apng.h:42
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
apng_read_header
static int apng_read_header(AVFormatContext *s)
Definition: apngdec.c:149
AVOption
AVOption.
Definition: opt.h:357
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
AV_CODEC_ID_APNG
@ AV_CODEC_ID_APNG
Definition: codec_id.h:265
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
APNGDemuxContext::ignore_loop
int ignore_loop
Definition: apngdec.c:56
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:853
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:480
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
pkt
AVPacket * pkt
Definition: movenc.c:60
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_rescale_q
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
AV_CLASS_CATEGORY_DEMUXER
@ AV_CLASS_CATEGORY_DEMUXER
Definition: log.h:33
apng_read_packet
static int apng_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: apngdec.c:311
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
apng.h
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
APNG_DISPOSE_OP_PREVIOUS
@ APNG_DISPOSE_OP_PREVIOUS
Definition: apng.h:33
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:908
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
APNGDemuxContext::num_play
uint32_t num_play
Definition: apngdec.c:58
DEFAULT_APNG_FPS
#define DEFAULT_APNG_FPS
Definition: apngdec.c:41
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:417
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:730
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
decode_fctl_chunk
static int decode_fctl_chunk(AVFormatContext *s, APNGDemuxContext *ctx, AVPacket *pkt)
Definition: apngdec.c:241
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_RB32
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:96
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:523
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
height
#define height
append_extradata
static int append_extradata(AVCodecParameters *par, AVIOContext *pb, int len)
Definition: apngdec.c:126
ffio_ensure_seekback
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1023
offset
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
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
PNGSIG
#define PNGSIG
Definition: png.h:49
options
static const AVOption options[]
Definition: apngdec.c:408
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
avio_internal.h
APNGDemuxContext::max_fps
int max_fps
Definition: apngdec.c:46
AVCodecParameters::height
int height
Definition: codec_par.h:135
APNGDemuxContext::is_key_frame
int is_key_frame
Definition: apngdec.c:51
state
static struct @416 state
APNGDemuxContext::pkt_duration
int pkt_duration
Definition: apngdec.c:49
demux.h
APNG_BLEND_OP_SOURCE
@ APNG_BLEND_OP_SOURCE
Definition: apng.h:37
len
int len
Definition: vorbis_enc_data.h:426
tag
uint32_t tag
Definition: movenc.c:1788
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
AVClass::class_name
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:71
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:746
av_append_packet
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:120
avformat.h
apng_probe
static int apng_probe(const AVProbeData *p)
Definition: apngdec.c:71
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
APNGDemuxContext
Definition: apngdec.c:43
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
APNG_DISPOSE_OP_BACKGROUND
@ APNG_DISPOSE_OP_BACKGROUND
Definition: apng.h:32
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:284
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
mem.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
APNGDemuxContext::cur_loop
uint32_t cur_loop
Definition: apngdec.c:59
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:501
png.h
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
FFInputFormat
Definition: demux.h:37
bytestream.h
demuxer_class
static const AVClass demuxer_class
Definition: apngdec.c:418
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
ffio_read_size
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:662
av_image_check_size
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:318
APNGDemuxContext::default_fps
int default_fps
Definition: apngdec.c:47
APNGDemuxContext::num_frames
uint32_t num_frames
Definition: apngdec.c:57
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:345
ff_alloc_extradata
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:240
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346
ff_apng_demuxer
const FFInputFormat ff_apng_demuxer
Definition: apngdec.c:426