FFmpeg: libavformat/apngdec.c Source File

FFmpeg

[フレーム]

libavformat

apngdec.c

Go to the documentation of this file.

1 /*

2 * APNG demuxer

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 */

22 /**

23 * @file

24 * APNG demuxer.

25 * @see https://wiki.mozilla.org/APNG_Specification

26 * @see http://www.w3.org/TR/PNG

27 */

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"

41 #define DEFAULT_APNG_FPS 15

43 typedef struct APNGDemuxContext {

44 const AVClass *class;

46 int max_fps;

47 int default_fps;

49 int pkt_duration;

51 int is_key_frame;

53 /*

54 * loop options

55 */

56 int ignore_loop;

57 uint32_t num_frames;

58 uint32_t num_play;

59 uint32_t cur_loop;

60 } APNGDemuxContext;

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;

77 bytestream2_init(&gb, p->buf, p->buf_size);

79 if (bytestream2_get_be64(&gb) != PNGSIG)

80 return 0;

82 for (;;) {

83 len = bytestream2_get_be32(&gb);

84 if (len > 0x7fffffff)

85 return 0;

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') &&

91 len + 4 > bytestream2_get_bytes_left(&gb))

92 return 0;

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

126 static int append_extradata(AVCodecParameters *par, AVIOContext *pb, int len)

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

149 static int apng_read_header(AVFormatContext *s)

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);

175 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

176 st->codecpar->codec_id = AV_CODEC_ID_APNG;

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

241 static int decode_fctl_chunk(AVFormatContext *s, APNGDemuxContext *ctx, AVPacket *pkt)

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

311 static int apng_read_packet(AVFormatContext *s, AVPacket *pkt)

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)

385 pkt->flags |= AV_PKT_FLAG_KEY;

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),

414 AV_OPT_TYPE_INT, { .i64 = DEFAULT_APNG_FPS }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },

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

426 const FFInputFormat ff_apng_demuxer = {

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),

432 .read_probe = apng_probe,

433 .read_header = apng_read_header,

434 .read_packet = apng_read_packet,

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:422

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

int64_t

long long int64_t

Definition: coverity.c:34

apng_read_header

static int apng_read_header(AVFormatContext *s)

Definition: apngdec.c:149

AVOption

AVOption.

Definition: opt.h:429

AVPacket::duration

int64_t duration

Duration of this packet in AVStream->time_base units, 0 if unknown.

Definition: packet.h:557

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

APNG_DISPOSE_OP_BACKGROUND

@ APNG_DISPOSE_OP_BACKGROUND

Definition: apng.h:32

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:594

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:860

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

intreadwrite.h

#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

APNG_BLEND_OP_SOURCE

@ APNG_BLEND_OP_SOURCE

Definition: apng.h:37

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:1287

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:771

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:535

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

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

APNG_DISPOSE_OP_PREVIOUS

@ APNG_DISPOSE_OP_PREVIOUS

Definition: apng.h:33

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:415

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

height

#define height

Definition: dsp.h:85

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:538

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:603

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:545

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:532

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

APNGDemuxContext::pkt_duration

int pkt_duration

Definition: apngdec.c:49

demux.h

len

int len

Definition: vorbis_enc_data.h:426

tag

uint32_t tag

Definition: movenc.c:1879

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:748

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:107

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

Underlying C type is int.

Definition: opt.h:259

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:318

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:356

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

state

static struct @454 state

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:516

png.h

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Underlying C type is int.

Definition: opt.h:327

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

width

#define width

Definition: dsp.h:85

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:227

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

Generated on Fri Aug 22 2025 13:59:24 for FFmpeg by doxygen 1.8.17