FFmpeg: libavformat/swfdec.c Source File

FFmpeg

[フレーム]

libavformat

swfdec.c

Go to the documentation of this file.

1 /*

2 * Flash Compatible Streaming Format demuxer

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #include "config.h"

25 #if CONFIG_ZLIB

26 #include <zlib.h>

27 #endif

29 #include "libavutil/avassert.h"

30 #include "libavutil/channel_layout.h"

31 #include "libavutil/imgutils.h"

32 #include "libavutil/internal.h"

33 #include "libavutil/intreadwrite.h"

34 #include "libavutil/mem.h"

35 #include "libavcodec/get_bits.h"

36 #include "demux.h"

37 #include "swf.h"

38 #include "flv.h"

40 typedef struct SWFDecContext {

41 int samples_per_frame;

42 int frame_rate;

43 #if CONFIG_ZLIB

44 #define ZBUF_SIZE 4096

45 AVIOContext *zpb;

46 uint8_t *zbuf_in;

47 uint8_t *zbuf_out;

48 z_stream zstream;

49 #endif

50 } SWFDecContext;

52 static const AVCodecTag swf_audio_codec_tags[] = {

53 { AV_CODEC_ID_PCM_S16LE, 0x00 },

54 { AV_CODEC_ID_ADPCM_SWF, 0x01 },

55 { AV_CODEC_ID_MP3, 0x02 },

56 { AV_CODEC_ID_PCM_S16LE, 0x03 },

57 { AV_CODEC_ID_NELLYMOSER, 0x06 },

58 { AV_CODEC_ID_NONE, 0 },

59 };

61 static int get_swf_tag(AVIOContext *pb, int *len_ptr)

62 {

63 int tag, len;

65 if (avio_feof(pb))

66 return AVERROR_EOF;

68 tag = avio_rl16(pb);

69 len = tag & 0x3f;

70 tag = tag >> 6;

71 if (len == 0x3f) {

72 len = avio_rl32(pb);

73 }

74 *len_ptr = len;

75 return tag;

76 }

79 static int swf_probe(const AVProbeData *p)

80 {

81 GetBitContext gb;

82 int len, xmin, xmax, ymin, ymax;

84 if(p->buf_size < 15)

85 return 0;

87 /* check file header */

88 if ( AV_RB24(p->buf) != AV_RB24("CWS")

89 && AV_RB24(p->buf) != AV_RB24("FWS"))

90 return 0;

92 if ( AV_RB24(p->buf) == AV_RB24("CWS")

93 && p->buf[3] <= 20)

94 return AVPROBE_SCORE_MAX / 4 + 1;

96 if (init_get_bits8(&gb, p->buf + 8, p->buf_size - 8) < 0)

97 return 0;

99 len = get_bits(&gb, 5);

100 if (!len)

101 return 0;

102 xmin = get_bits_long(&gb, len);

103 xmax = get_bits_long(&gb, len);

104 ymin = get_bits_long(&gb, len);

105 ymax = get_bits_long(&gb, len);

106 if (xmin || ymin || !xmax || !ymax)

107 return 0;

108

109 if (p->buf[3] >= 20 || xmax < 16 || ymax < 16)

110 return AVPROBE_SCORE_MAX / 4;

111

112 return AVPROBE_SCORE_EXTENSION + 1;

113 }

114

115 #if CONFIG_ZLIB

116 static int zlib_refill(void *opaque, uint8_t *buf, int buf_size)

117 {

118 AVFormatContext *s = opaque;

119 SWFDecContext *swf = s->priv_data;

120 z_stream *z = &swf->zstream;

121 int ret;

122

123 retry:

124 if (!z->avail_in) {

125 int n = avio_read(s->pb, swf->zbuf_in, ZBUF_SIZE);

126 if (n < 0)

127 return n;

128 z->next_in = swf->zbuf_in;

129 z->avail_in = n;

130 }

131

132 z->next_out = buf;

133 z->avail_out = buf_size;

134

135 ret = inflate(z, Z_NO_FLUSH);

136 if (ret == Z_STREAM_END)

137 return AVERROR_EOF;

138 if (ret != Z_OK)

139 return AVERROR(EINVAL);

140

141 if (buf_size - z->avail_out == 0)

142 goto retry;

143

144 return buf_size - z->avail_out;

145 }

146

147 static av_cold int swf_read_close(AVFormatContext *avctx);

148 #endif

149

150 static int swf_read_header(AVFormatContext *s)

151 {

152 SWFDecContext *swf = s->priv_data;

153 AVIOContext *pb = s->pb;

154 int nbits, len, tag;

155

156 tag = avio_rb32(pb) & 0xffffff00;

157 avio_rl32(pb);

158

159 if (tag == MKBETAG('C', 'W', 'S', 0)) {

160 av_log(s, AV_LOG_INFO, "SWF compressed file detected\n");

161 #if CONFIG_ZLIB

162 if (inflateInit(&swf->zstream) != Z_OK) {

163 av_log(s, AV_LOG_ERROR, "Unable to init zlib context\n");

164 return AVERROR(EINVAL);

165 }

166 if (!(swf->zbuf_in = av_malloc(ZBUF_SIZE)) ||

167 !(swf->zbuf_out = av_malloc(ZBUF_SIZE)) ||

168 !(swf->zpb = avio_alloc_context(swf->zbuf_out, ZBUF_SIZE, 0,

169 s, zlib_refill, NULL, NULL))) {

170 swf_read_close(s);

171 return AVERROR(ENOMEM);

172 }

173 swf->zpb->seekable = 0;

174 pb = swf->zpb;

175 #else

176 av_log(s, AV_LOG_ERROR, "zlib support is required to read SWF compressed files\n");

177 return AVERROR(EIO);

178 #endif

179 } else if (tag != MKBETAG('F', 'W', 'S', 0))

180 return AVERROR(EIO);

181 /* skip rectangle size */

182 nbits = avio_r8(pb) >> 3;

183 len = (4 * nbits - 3 + 7) / 8;

184 avio_skip(pb, len);

185 swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */

186 avio_rl16(pb); /* frame count */

187

188 swf->samples_per_frame = 0;

189 s->ctx_flags |= AVFMTCTX_NOHEADER;

190 return 0;

191 }

192

193 static AVStream *create_new_audio_stream(AVFormatContext *s, int id, int info)

194 {

195 int sample_rate_code, sample_size_code;

196 AVStream *ast = avformat_new_stream(s, NULL);

197 if (!ast)

198 return NULL;

199 ast->id = id;

200 av_channel_layout_default(&ast->codecpar->ch_layout, 1 + (info & 1));

201 ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

202 ast->codecpar->codec_id = ff_codec_get_id(swf_audio_codec_tags, info>>4 & 15);

203 ffstream(ast)->need_parsing = AVSTREAM_PARSE_FULL;

204 sample_rate_code = info>>2 & 3;

205 sample_size_code = info>>1 & 1;

206 if (!sample_size_code && ast->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE)

207 ast->codecpar->codec_id = AV_CODEC_ID_PCM_U8;

208 ast->codecpar->sample_rate = 44100 >> (3 - sample_rate_code);

209 avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);

210 return ast;

211 }

212

213 static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)

214 {

215 SWFDecContext *swf = s->priv_data;

216 AVIOContext *pb = s->pb;

217 AVStream *vst = NULL, *ast = NULL, *st = 0;

218 int tag, len, i, frame, v, res;

219

220 #if CONFIG_ZLIB

221 if (swf->zpb)

222 pb = swf->zpb;

223 #endif

224

225 for(;;) {

226 uint64_t pos = avio_tell(pb);

227 tag = get_swf_tag(pb, &len);

228 if (tag < 0)

229 return tag;

230 if (len < 0) {

231 av_log(s, AV_LOG_ERROR, "invalid tag length: %d\n", len);

232 return AVERROR_INVALIDDATA;

233 }

234 if (tag == TAG_VIDEOSTREAM) {

235 int ch_id = avio_rl16(pb);

236 len -= 2;

237

238 for (i=0; i<s->nb_streams; i++) {

239 st = s->streams[i];

240 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)

241 goto skip;

242 }

243

244 avio_rl16(pb);

245 avio_rl16(pb);

246 avio_rl16(pb);

247 avio_r8(pb);

248 /* Check for FLV1 */

249 vst = avformat_new_stream(s, NULL);

250 if (!vst)

251 return AVERROR(ENOMEM);

252 vst->id = ch_id;

253 vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

254 vst->codecpar->codec_id = ff_codec_get_id(ff_swf_codec_tags, avio_r8(pb));

255 avpriv_set_pts_info(vst, 16, 256, swf->frame_rate);

256 len -= 8;

257 } else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {

258 /* streaming found */

259

260 for (i=0; i<s->nb_streams; i++) {

261 st = s->streams[i];

262 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)

263 goto skip;

264 }

265

266 avio_r8(pb);

267 v = avio_r8(pb);

268 swf->samples_per_frame = avio_rl16(pb);

269 ast = create_new_audio_stream(s, -1, v); /* -1 to avoid clash with video stream ch_id */

270 if (!ast)

271 return AVERROR(ENOMEM);

272 len -= 4;

273 } else if (tag == TAG_DEFINESOUND) {

274 /* audio stream */

275 int ch_id = avio_rl16(pb);

276

277 for (i=0; i<s->nb_streams; i++) {

278 st = s->streams[i];

279 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == ch_id)

280 goto skip;

281 }

282

283 // FIXME: The entire audio stream is stored in a single chunk/tag. Normally,

284 // these are smaller audio streams in DEFINESOUND tags, but it's technically

285 // possible they could be huge. Break it up into multiple packets if it's big.

286 v = avio_r8(pb);

287 ast = create_new_audio_stream(s, ch_id, v);

288 if (!ast)

289 return AVERROR(ENOMEM);

290 ast->duration = avio_rl32(pb); // number of samples

291 if (((v>>4) & 15) == 2) { // MP3 sound data record

292 ffstream(ast)->skip_samples = avio_rl16(pb);

293 len -= 2;

294 }

295 len -= 7;

296 if ((res = av_get_packet(pb, pkt, len)) < 0)

297 return res;

298 pkt->pos = pos;

299 pkt->stream_index = ast->index;

300 return pkt->size;

301 } else if (tag == TAG_VIDEOFRAME) {

302 int ch_id = avio_rl16(pb);

303 len -= 2;

304 for(i=0; i<s->nb_streams; i++) {

305 st = s->streams[i];

306 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {

307 int pkt_flags = 0;

308 frame = avio_rl16(pb);

309 len -= 2;

310 if (len <= 0)

311 goto skip;

312 if (st->codecpar->codec_id == AV_CODEC_ID_FLASHSV) {

313 unsigned flags = avio_r8(pb);

314 len--;

315 if (len <= 0)

316 goto skip;

317 pkt_flags |= (flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY ? AV_PKT_FLAG_KEY : 0;

318 }

319 if ((res = av_get_packet(pb, pkt, len)) < 0)

320 return res;

321 pkt->pos = pos;

322 pkt->pts = frame;

323 pkt->stream_index = st->index;

324 pkt->flags |= pkt_flags;

325 return pkt->size;

326 }

327 }

328 } else if (tag == TAG_DEFINEBITSLOSSLESS || tag == TAG_DEFINEBITSLOSSLESS2) {

329 #if CONFIG_ZLIB

330 long out_len;

331 uint8_t *buf = NULL, *zbuf = NULL, *pal;

332 uint32_t colormap[AVPALETTE_COUNT] = {0};

333 const int alpha_bmp = tag == TAG_DEFINEBITSLOSSLESS2;

334 const int colormapbpp = 3 + alpha_bmp;

335 int linesize, colormapsize = 0;

336

337 const int ch_id = avio_rl16(pb);

338 const int bmp_fmt = avio_r8(pb);

339 const int width = avio_rl16(pb);

340 const int height = avio_rl16(pb);

341 int pix_fmt;

342

343 len -= 2+1+2+2;

344

345 switch (bmp_fmt) {

346 case 3: // PAL-8

347 linesize = width;

348 colormapsize = avio_r8(pb) + 1;

349 len--;

350 break;

351 case 4: // RGB15

352 linesize = width * 2;

353 break;

354 case 5: // RGB24 (0RGB)

355 linesize = width * 4;

356 break;

357 default:

358 av_log(s, AV_LOG_ERROR, "invalid bitmap format %d, skipped\n", bmp_fmt);

359 goto bitmap_end_skip;

360 }

361

362 linesize = FFALIGN(linesize, 4);

363

364 if (av_image_check_size(width, height, 0, s) < 0 ||

365 linesize >= INT_MAX / height ||

366 linesize * height >= INT_MAX - colormapsize * colormapbpp) {

367 av_log(s, AV_LOG_ERROR, "invalid frame size %dx%d\n", width, height);

368 goto bitmap_end_skip;

369 }

370

371 out_len = colormapsize * colormapbpp + linesize * height;

372

373 ff_dlog(s, "bitmap: ch=%d fmt=%d %dx%d (linesize=%d) len=%d->%ld pal=%d\n",

374 ch_id, bmp_fmt, width, height, linesize, len, out_len, colormapsize);

375

376 if (len * 17373LL < out_len)

377 goto bitmap_end_skip;

378

379 zbuf = av_malloc(len);

380 if (!zbuf) {

381 res = AVERROR(ENOMEM);

382 goto bitmap_end;

383 }

384

385 len = avio_read(pb, zbuf, len);

386 if (len < 0)

387 goto bitmap_end_skip;

388

389 buf = av_malloc(out_len);

390 if (!buf) {

391 res = AVERROR(ENOMEM);

392 goto bitmap_end;

393 }

394 if ((res = uncompress(buf, &out_len, zbuf, len)) != Z_OK) {

395 av_log(s, AV_LOG_WARNING, "Failed to uncompress one bitmap\n");

396 goto bitmap_end_skip;

397 }

398

399 for (i = 0; i < s->nb_streams; i++) {

400 st = s->streams[i];

401 if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO && st->id == -3)

402 break;

403 }

404 if (i == s->nb_streams) {

405 vst = avformat_new_stream(s, NULL);

406 if (!vst) {

407 res = AVERROR(ENOMEM);

408 goto bitmap_end;

409 }

410 vst->id = -3; /* -3 to avoid clash with video stream and audio stream */

411 vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

412 vst->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;

413 avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);

414 st = vst;

415 }

416

417 if ((res = av_new_packet(pkt, out_len - colormapsize * colormapbpp)) < 0)

418 goto bitmap_end;

419 if (!st->codecpar->width && !st->codecpar->height) {

420 st->codecpar->width = width;

421 st->codecpar->height = height;

422 } else {

423 ff_add_param_change(pkt, 0, 0, 0, width, height);

424 }

425 pkt->pos = pos;

426 pkt->stream_index = st->index;

427

428 if (linesize * height > pkt->size) {

429 res = AVERROR_INVALIDDATA;

430 goto bitmap_end;

431 }

432

433 switch (bmp_fmt) {

434 case 3:

435 pix_fmt = AV_PIX_FMT_PAL8;

436 for (i = 0; i < colormapsize; i++)

437 if (alpha_bmp) colormap[i] = buf[3]<<24 | AV_RB24(buf + 4*i);

438 else colormap[i] = 0xffU <<24 | AV_RB24(buf + 3*i);

439 pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);

440 if (!pal) {

441 res = AVERROR(ENOMEM);

442 goto bitmap_end;

443 }

444 memcpy(pal, colormap, AVPALETTE_SIZE);

445 break;

446 case 4:

447 pix_fmt = AV_PIX_FMT_RGB555;

448 break;

449 case 5:

450 pix_fmt = alpha_bmp ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;

451 break;

452 default:

453 av_assert0(0);

454 }

455 if (st->codecpar->format != AV_PIX_FMT_NONE && st->codecpar->format != pix_fmt) {

456 av_log(s, AV_LOG_ERROR, "pixel format change unsupported\n");

457 } else

458 st->codecpar->format = pix_fmt;

459

460 memcpy(pkt->data, buf + colormapsize*colormapbpp, linesize * height);

461

462 res = pkt->size;

463

464 bitmap_end:

465 av_freep(&zbuf);

466 av_freep(&buf);

467 return res;

468 bitmap_end_skip:

469 av_freep(&zbuf);

470 av_freep(&buf);

471 #else

472 av_log(s, AV_LOG_ERROR, "this file requires zlib support compiled in\n");

473 #endif

474 } else if (tag == TAG_STREAMBLOCK) {

475 for (i = 0; i < s->nb_streams; i++) {

476 st = s->streams[i];

477 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {

478 if (st->codecpar->codec_id == AV_CODEC_ID_MP3) {

479 avio_skip(pb, 4);

480 len -= 4;

481 if (len <= 0)

482 goto skip;

483 if ((res = av_get_packet(pb, pkt, len)) < 0)

484 return res;

485 } else { // ADPCM, PCM

486 if (len <= 0)

487 goto skip;

488 if ((res = av_get_packet(pb, pkt, len)) < 0)

489 return res;

490 }

491 pkt->pos = pos;

492 pkt->stream_index = st->index;

493 return pkt->size;

494 }

495 }

496 } else if (tag == TAG_JPEG2) {

497 for (i=0; i<s->nb_streams; i++) {

498 st = s->streams[i];

499 if (st->codecpar->codec_id == AV_CODEC_ID_MJPEG && st->id == -2)

500 break;

501 }

502 if (i == s->nb_streams) {

503 vst = avformat_new_stream(s, NULL);

504 if (!vst)

505 return AVERROR(ENOMEM);

506 vst->id = -2; /* -2 to avoid clash with video stream and audio stream */

507 vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

508 vst->codecpar->codec_id = AV_CODEC_ID_MJPEG;

509 avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);

510 st = vst;

511 }

512 avio_rl16(pb); /* BITMAP_ID */

513 len -= 2;

514 if (len < 4)

515 goto skip;

516 if ((res = av_new_packet(pkt, len)) < 0)

517 return res;

518 if (avio_read(pb, pkt->data, 4) != 4) {

519 return AVERROR_INVALIDDATA;

520 }

521 if (AV_RB32(pkt->data) == 0xffd8ffd9 ||

522 AV_RB32(pkt->data) == 0xffd9ffd8) {

523 /* old SWF files containing SOI/EOI as data start */

524 /* files created by swink have reversed tag */

525 pkt->size -= 4;

526 memset(pkt->data+pkt->size, 0, 4);

527 res = avio_read(pb, pkt->data, pkt->size);

528 } else {

529 res = avio_read(pb, pkt->data + 4, pkt->size - 4);

530 if (res >= 0)

531 res += 4;

532 }

533 if (res != pkt->size) {

534 if (res < 0) {

535 return res;

536 }

537 av_shrink_packet(pkt, res);

538 }

539

540 pkt->pos = pos;

541 pkt->stream_index = st->index;

542 return pkt->size;

543 } else {

544 av_log(s, AV_LOG_DEBUG, "Unknown tag: %d\n", tag);

545 }

546 skip:

547 if(len<0)

548 av_log(s, AV_LOG_WARNING, "Clipping len %d\n", len);

549 len = FFMAX(0, len);

550 avio_skip(pb, len);

551 }

552 }

553

554 #if CONFIG_ZLIB

555 static av_cold int swf_read_close(AVFormatContext *avctx)

556 {

557 SWFDecContext *s = avctx->priv_data;

558 inflateEnd(&s->zstream);

559 av_freep(&s->zbuf_in);

560 av_freep(&s->zbuf_out);

561 avio_context_free(&s->zpb);

562 return 0;

563 }

564 #endif

565

566 const FFInputFormat ff_swf_demuxer = {

567 .p.name = "swf",

568 .p.long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),

569 .priv_data_size = sizeof(SWFDecContext),

570 .read_probe = swf_probe,

571 .read_header = swf_read_header,

572 .read_packet = swf_read_packet,

573 #if CONFIG_ZLIB

574 .read_close = swf_read_close,

575 #endif

576 };

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:337

flags

const SwsFlags flags[]

Definition: swscale.c:61

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

FFStream::skip_samples

int skip_samples

Number of samples to skip at the start of the frame decoded from the next packet.

Definition: internal.h:208

SWFDecContext

Definition: swfdec.c:40

swf_read_header

static int swf_read_header(AVFormatContext *s)

Definition: swfdec.c:150

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

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

TAG_STREAMHEAD2

@ TAG_STREAMHEAD2

Definition: swf.h:67

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

avio_context_free

void avio_context_free(AVIOContext **s)

Free the supplied IO context and everything associated with it.

Definition: aviobuf.c:126

get_bits_long

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:419

AV_CODEC_ID_RAWVIDEO

@ AV_CODEC_ID_RAWVIDEO

Definition: codec_id.h:65

TAG_VIDEOFRAME

@ TAG_VIDEOFRAME

Definition: swf.h:75

AVPacket::data

uint8_t * data

Definition: packet.h:558

avio_alloc_context

AVIOContext * avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, const uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))

Allocate and initialize an AVIOContext for buffered I/O.

Definition: aviobuf.c:109

swf_audio_codec_tags

static const AVCodecTag swf_audio_codec_tags[]

Definition: swfdec.c:52

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:613

TAG_VIDEOSTREAM

@ TAG_VIDEOSTREAM

Definition: swf.h:74

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:463

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:333

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

AV_PKT_DATA_PALETTE

@ AV_PKT_DATA_PALETTE

An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.

Definition: packet.h:47

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:347

av_shrink_packet

void av_shrink_packet(AVPacket *pkt, int size)

Reduce packet size, correctly zeroing padding.

Definition: packet.c:114

inflate

static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)

Definition: vf_neighbor.c:194

GetBitContext

Definition: get_bits.h:109

TAG_JPEG2

@ TAG_JPEG2

Definition: swf.h:53

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:143

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:494

AV_CODEC_ID_MP3

@ AV_CODEC_ID_MP3

preferred ID for decoding MPEG audio layer 1, 2 or 3

Definition: codec_id.h:460

avio_rl16

unsigned int avio_rl16(AVIOContext *s)

Definition: aviobuf.c:717

avassert.h

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:764

TAG_STREAMBLOCK

@ TAG_STREAMBLOCK

Definition: swf.h:51

pkt

AVPacket * pkt

Definition: movenc.c:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:539

AVCodecTag

Definition: internal.h:42

swf.h

read_packet

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

Definition: avio_read_callback.c:42

swf_read_packet

static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)

Definition: swfdec.c:213

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:198

av_new_packet

int av_new_packet(AVPacket *pkt, int size)

Allocate the payload of a packet and initialize its fields with default values.

Definition: packet.c:99

ff_swf_codec_tags

const AVCodecTag ff_swf_codec_tags[]

Definition: swf.c:25

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:549

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demux_decode.c:41

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

AVCodecParameters::width

int width

Video only.

Definition: codec_par.h:134

info

MIPS optimizations info

Definition: mips.txt:2

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

get_bits.h

FLV_VIDEO_FRAMETYPE_MASK

#define FLV_VIDEO_FRAMETYPE_MASK

Definition: flv.h:51

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:314

AVFormatContext

Format I/O context.

Definition: avformat.h:1264

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:767

NULL

#define NULL

Definition: coverity.c:32

AVFMTCTX_NOHEADER

#define AVFMTCTX_NOHEADER

signal that no header is present (streams are added dynamically)

Definition: avformat.h:1215

AVPALETTE_SIZE

#define AVPALETTE_SIZE

Definition: pixfmt.h:32

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:451

flv.h

AV_CODEC_ID_FLASHSV

@ AV_CODEC_ID_FLASHSV

Definition: codec_id.h:138

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:180

TAG_STREAMHEAD

@ TAG_STREAMHEAD

Definition: swf.h:50

AVPALETTE_COUNT

#define AVPALETTE_COUNT

Definition: pixfmt.h:33

AVPROBE_SCORE_EXTENSION

#define AVPROBE_SCORE_EXTENSION

score for file extension

Definition: avformat.h:461

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:184

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:733

AVIOContext

Bytestream IO Context.

Definition: avio.h:160

AVPacket::size

int size

Definition: packet.h:559

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

ff_codec_get_id

enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)

Definition: utils.c:143

height

#define height

Definition: dsp.h:89

AV_CODEC_ID_ADPCM_SWF

@ AV_CODEC_ID_ADPCM_SWF

Definition: codec_id.h:389

ff_add_param_change

int ff_add_param_change(AVPacket *pkt, int32_t channels, uint64_t channel_layout, int32_t sample_rate, int32_t width, int32_t height)

Add side data to a packet for changing parameters to the given values.

Definition: demux_utils.c:142

get_swf_tag

static int get_swf_tag(AVIOContext *pb, int *len_ptr)

Definition: swfdec.c:61

MKBETAG

#define MKBETAG(a, b, c, d)

Definition: macros.h:56

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

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:606

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:564

read_header

static int read_header(FFV1Context *f, RangeCoder *c)

Definition: ffv1dec.c:498

TAG_DEFINEBITSLOSSLESS2

@ TAG_DEFINEBITSLOSSLESS2

Definition: swf.h:63

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:221

AV_PIX_FMT_ARGB

@ AV_PIX_FMT_ARGB

packed ARGB 8:8:8:8, 32bpp, ARGBARGB...

Definition: pixfmt.h:99

av_channel_layout_default

void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)

Get the default channel layout for a given number of channels.

Definition: channel_layout.c:839

AV_CODEC_ID_MJPEG

@ AV_CODEC_ID_MJPEG

Definition: codec_id.h:59

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:50

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:551

internal.h

AV_PIX_FMT_RGB555

#define AV_PIX_FMT_RGB555

Definition: pixfmt.h:527

demux.h

swf_probe

static int swf_probe(const AVProbeData *p)

Definition: swfdec.c:79

TAG_DEFINESOUND

@ TAG_DEFINESOUND

Definition: swf.h:47

len

int len

Definition: vorbis_enc_data.h:426

SWFDecContext::frame_rate

int frame_rate

Definition: swfdec.c:42

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

Allocate and read the payload of a packet and initialize its fields with default values.

Definition: utils.c:98

AV_PIX_FMT_PAL8

@ AV_PIX_FMT_PAL8

8 bits with AV_PIX_FMT_RGB32 palette

Definition: pixfmt.h:84

tag

uint32_t tag

Definition: movenc.c:1957

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:756

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:744

frame

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

Definition: filter_design.txt:265

pos

unsigned int pos

Definition: spdifenc.c:414

enum AVCodecID id

Definition: dts2pts.c:367

#define U(x)

Definition: vpx_arith.h:37

SWFDecContext::samples_per_frame

int samples_per_frame

Definition: swfdec.c:41

channel_layout.h

FLV_FRAME_KEY

@ FLV_FRAME_KEY

key frame (for AVC, a seekable frame)

Definition: flv.h:160

av_packet_new_side_data

uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)

Allocate new information of a packet.

Definition: packet.c:232

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

TAG_DEFINEBITSLOSSLESS

@ TAG_DEFINEBITSLOSSLESS

Definition: swf.h:52

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:615

create_new_audio_stream

static AVStream * create_new_audio_stream(AVFormatContext *s, int id, int info)

Definition: swfdec.c:193

Windows::Graphics::DirectX::Direct3D11::p

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

AVPacket::stream_index

int stream_index

Definition: packet.h:560

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:321

ff_swf_demuxer

const FFInputFormat ff_swf_demuxer

Definition: swfdec.c:566

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

read_probe

static int read_probe(const AVProbeData *p)

Definition: cdg.c:30

mem.h

AV_CODEC_ID_PCM_U8

@ AV_CODEC_ID_PCM_U8

Definition: codec_id.h:342

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

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

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: packet.h:578

FFInputFormat

Definition: demux.h:47

AVSTREAM_PARSE_FULL

@ AVSTREAM_PARSE_FULL

full parsing and repack

Definition: avformat.h:589

imgutils.h

AV_PIX_FMT_0RGB

@ AV_PIX_FMT_0RGB

packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined

Definition: pixfmt.h:262

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

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

AV_RB24

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_WB32 unsigned int_TMPL AV_RB24

Definition: bytestream.h:97

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1292

skip

static void BS_FUNC() skip(BSCTX *bc, unsigned int n)

Skip n bits in the buffer.

Definition: bitstream_template.h:383

AV_CODEC_ID_NELLYMOSER

@ AV_CODEC_ID_NELLYMOSER

Definition: codec_id.h:492

avio_feof

int avio_feof(AVIOContext *s)

Similar to feof() but also returns nonzero on read errors.

Definition: aviobuf.c:349

Generated on Fri Oct 17 2025 19:23:32 for FFmpeg by doxygen 1.8.17