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 "libavcodec/get_bits.h"

35 #include "demux.h"

36 #include "swf.h"

37 #include "flv.h"

39 typedef struct SWFDecContext {

40 int samples_per_frame;

41 int frame_rate;

42 #if CONFIG_ZLIB

43 #define ZBUF_SIZE 4096

44 AVIOContext *zpb;

45 uint8_t *zbuf_in;

46 uint8_t *zbuf_out;

47 z_stream zstream;

48 #endif

49 } SWFDecContext;

51 static const AVCodecTag swf_audio_codec_tags[] = {

52 { AV_CODEC_ID_PCM_S16LE, 0x00 },

53 { AV_CODEC_ID_ADPCM_SWF, 0x01 },

54 { AV_CODEC_ID_MP3, 0x02 },

55 { AV_CODEC_ID_PCM_S16LE, 0x03 },

56 { AV_CODEC_ID_NELLYMOSER, 0x06 },

57 { AV_CODEC_ID_NONE, 0 },

58 };

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

61 {

62 int tag, len;

64 if (avio_feof(pb))

65 return AVERROR_EOF;

67 tag = avio_rl16(pb);

68 len = tag & 0x3f;

69 tag = tag >> 6;

70 if (len == 0x3f) {

71 len = avio_rl32(pb);

72 }

73 *len_ptr = len;

74 return tag;

75 }

78 static int swf_probe(const AVProbeData *p)

79 {

80 GetBitContext gb;

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

83 if(p->buf_size < 15)

84 return 0;

86 /* check file header */

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

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

89 return 0;

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

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

93 return AVPROBE_SCORE_MAX / 4 + 1;

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

96 return 0;

98 len = get_bits(&gb, 5);

99 if (!len)

100 return 0;

101 xmin = get_bits_long(&gb, len);

102 xmax = get_bits_long(&gb, len);

103 ymin = get_bits_long(&gb, len);

104 ymax = get_bits_long(&gb, len);

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

106 return 0;

107

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

109 return AVPROBE_SCORE_MAX / 4;

110

111 return AVPROBE_SCORE_EXTENSION + 1;

112 }

113

114 #if CONFIG_ZLIB

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

116 {

117 AVFormatContext *s = opaque;

118 SWFDecContext *swf = s->priv_data;

119 z_stream *z = &swf->zstream;

120 int ret;

121

122 retry:

123 if (!z->avail_in) {

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

125 if (n < 0)

126 return n;

127 z->next_in = swf->zbuf_in;

128 z->avail_in = n;

129 }

130

131 z->next_out = buf;

132 z->avail_out = buf_size;

133

134 ret = inflate(z, Z_NO_FLUSH);

135 if (ret == Z_STREAM_END)

136 return AVERROR_EOF;

137 if (ret != Z_OK)

138 return AVERROR(EINVAL);

139

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

141 goto retry;

142

143 return buf_size - z->avail_out;

144 }

145

146 static av_cold int swf_read_close(AVFormatContext *avctx);

147 #endif

148

149 static int swf_read_header(AVFormatContext *s)

150 {

151 SWFDecContext *swf = s->priv_data;

152 AVIOContext *pb = s->pb;

153 int nbits, len, tag;

154

155 tag = avio_rb32(pb) & 0xffffff00;

156 avio_rl32(pb);

157

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

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

160 #if CONFIG_ZLIB

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

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

163 return AVERROR(EINVAL);

164 }

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

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

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

168 s, zlib_refill, NULL, NULL))) {

169 swf_read_close(s);

170 return AVERROR(ENOMEM);

171 }

172 swf->zpb->seekable = 0;

173 pb = swf->zpb;

174 #else

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

176 return AVERROR(EIO);

177 #endif

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

179 return AVERROR(EIO);

180 /* skip rectangle size */

181 nbits = avio_r8(pb) >> 3;

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

183 avio_skip(pb, len);

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

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

186

187 swf->samples_per_frame = 0;

188 s->ctx_flags |= AVFMTCTX_NOHEADER;

189 return 0;

190 }

191

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

193 {

194 int sample_rate_code, sample_size_code;

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

196 if (!ast)

197 return NULL;

198 ast->id = id;

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

200 ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

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

202 ffstream(ast)->need_parsing = AVSTREAM_PARSE_FULL;

203 sample_rate_code = info>>2 & 3;

204 sample_size_code = info>>1 & 1;

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

206 ast->codecpar->codec_id = AV_CODEC_ID_PCM_U8;

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

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

209 return ast;

210 }

211

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

213 {

214 SWFDecContext *swf = s->priv_data;

215 AVIOContext *pb = s->pb;

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

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

218

219 #if CONFIG_ZLIB

220 if (swf->zpb)

221 pb = swf->zpb;

222 #endif

223

224 for(;;) {

225 uint64_t pos = avio_tell(pb);

226 tag = get_swf_tag(pb, &len);

227 if (tag < 0)

228 return tag;

229 if (len < 0) {

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

231 return AVERROR_INVALIDDATA;

232 }

233 if (tag == TAG_VIDEOSTREAM) {

234 int ch_id = avio_rl16(pb);

235 len -= 2;

236

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

238 st = s->streams[i];

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

240 goto skip;

241 }

242

243 avio_rl16(pb);

244 avio_rl16(pb);

245 avio_rl16(pb);

246 avio_r8(pb);

247 /* Check for FLV1 */

248 vst = avformat_new_stream(s, NULL);

249 if (!vst)

250 return AVERROR(ENOMEM);

251 vst->id = ch_id;

252 vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

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

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

255 len -= 8;

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

257 /* streaming found */

258

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

260 st = s->streams[i];

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

262 goto skip;

263 }

264

265 avio_r8(pb);

266 v = avio_r8(pb);

267 swf->samples_per_frame = avio_rl16(pb);

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

269 if (!ast)

270 return AVERROR(ENOMEM);

271 len -= 4;

272 } else if (tag == TAG_DEFINESOUND) {

273 /* audio stream */

274 int ch_id = avio_rl16(pb);

275

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

277 st = s->streams[i];

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

279 goto skip;

280 }

281

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

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

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

285 v = avio_r8(pb);

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

287 if (!ast)

288 return AVERROR(ENOMEM);

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

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

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

292 len -= 2;

293 }

294 len -= 7;

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

296 return res;

297 pkt->pos = pos;

298 pkt->stream_index = ast->index;

299 return pkt->size;

300 } else if (tag == TAG_VIDEOFRAME) {

301 int ch_id = avio_rl16(pb);

302 len -= 2;

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

304 st = s->streams[i];

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

306 int pkt_flags = 0;

307 frame = avio_rl16(pb);

308 len -= 2;

309 if (len <= 0)

310 goto skip;

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

312 unsigned flags = avio_r8(pb);

313 len--;

314 if (len <= 0)

315 goto skip;

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

317 }

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

319 return res;

320 pkt->pos = pos;

321 pkt->pts = frame;

322 pkt->stream_index = st->index;

323 pkt->flags |= pkt_flags;

324 return pkt->size;

325 }

326 }

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

328 #if CONFIG_ZLIB

329 long out_len;

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

331 uint32_t colormap[AVPALETTE_COUNT] = {0};

332 const int alpha_bmp = tag == TAG_DEFINEBITSLOSSLESS2;

333 const int colormapbpp = 3 + alpha_bmp;

334 int linesize, colormapsize = 0;

335

336 const int ch_id = avio_rl16(pb);

337 const int bmp_fmt = avio_r8(pb);

338 const int width = avio_rl16(pb);

339 const int height = avio_rl16(pb);

340 int pix_fmt;

341

342 len -= 2+1+2+2;

343

344 switch (bmp_fmt) {

345 case 3: // PAL-8

346 linesize = width;

347 colormapsize = avio_r8(pb) + 1;

348 len--;

349 break;

350 case 4: // RGB15

351 linesize = width * 2;

352 break;

353 case 5: // RGB24 (0RGB)

354 linesize = width * 4;

355 break;

356 default:

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

358 goto bitmap_end_skip;

359 }

360

361 linesize = FFALIGN(linesize, 4);

362

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

364 linesize >= INT_MAX / height ||

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

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

367 goto bitmap_end_skip;

368 }

369

370 out_len = colormapsize * colormapbpp + linesize * height;

371

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

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

374

375 if (len * 17373LL < out_len)

376 goto bitmap_end_skip;

377

378 zbuf = av_malloc(len);

379 if (!zbuf) {

380 res = AVERROR(ENOMEM);

381 goto bitmap_end;

382 }

383

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

385 if (len < 0)

386 goto bitmap_end_skip;

387

388 buf = av_malloc(out_len);

389 if (!buf) {

390 res = AVERROR(ENOMEM);

391 goto bitmap_end;

392 }

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

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

395 goto bitmap_end_skip;

396 }

397

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

399 st = s->streams[i];

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

401 break;

402 }

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

404 vst = avformat_new_stream(s, NULL);

405 if (!vst) {

406 res = AVERROR(ENOMEM);

407 goto bitmap_end;

408 }

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

410 vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

411 vst->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;

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

413 st = vst;

414 }

415

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

417 goto bitmap_end;

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

419 st->codecpar->width = width;

420 st->codecpar->height = height;

421 } else {

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

423 }

424 pkt->pos = pos;

425 pkt->stream_index = st->index;

426

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

428 res = AVERROR_INVALIDDATA;

429 goto bitmap_end;

430 }

431

432 switch (bmp_fmt) {

433 case 3:

434 pix_fmt = AV_PIX_FMT_PAL8;

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

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

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

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

439 if (!pal) {

440 res = AVERROR(ENOMEM);

441 goto bitmap_end;

442 }

443 memcpy(pal, colormap, AVPALETTE_SIZE);

444 break;

445 case 4:

446 pix_fmt = AV_PIX_FMT_RGB555;

447 break;

448 case 5:

449 pix_fmt = alpha_bmp ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;

450 break;

451 default:

452 av_assert0(0);

453 }

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

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

456 } else

457 st->codecpar->format = pix_fmt;

458

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

460

461 res = pkt->size;

462

463 bitmap_end:

464 av_freep(&zbuf);

465 av_freep(&buf);

466 return res;

467 bitmap_end_skip:

468 av_freep(&zbuf);

469 av_freep(&buf);

470 #else

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

472 #endif

473 } else if (tag == TAG_STREAMBLOCK) {

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

475 st = s->streams[i];

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

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

478 avio_skip(pb, 4);

479 len -= 4;

480 if (len <= 0)

481 goto skip;

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

483 return res;

484 } else { // ADPCM, PCM

485 if (len <= 0)

486 goto skip;

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

488 return res;

489 }

490 pkt->pos = pos;

491 pkt->stream_index = st->index;

492 return pkt->size;

493 }

494 }

495 } else if (tag == TAG_JPEG2) {

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

497 st = s->streams[i];

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

499 break;

500 }

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

502 vst = avformat_new_stream(s, NULL);

503 if (!vst)

504 return AVERROR(ENOMEM);

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

506 vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

507 vst->codecpar->codec_id = AV_CODEC_ID_MJPEG;

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

509 st = vst;

510 }

511 avio_rl16(pb); /* BITMAP_ID */

512 len -= 2;

513 if (len < 4)

514 goto skip;

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

516 return res;

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

518 return AVERROR_INVALIDDATA;

519 }

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

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

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

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

524 pkt->size -= 4;

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

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

527 } else {

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

529 if (res >= 0)

530 res += 4;

531 }

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

533 if (res < 0) {

534 return res;

535 }

536 av_shrink_packet(pkt, res);

537 }

538

539 pkt->pos = pos;

540 pkt->stream_index = st->index;

541 return pkt->size;

542 } else {

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

544 }

545 skip:

546 if(len<0)

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

548 len = FFMAX(0, len);

549 avio_skip(pb, len);

550 }

551 }

552

553 #if CONFIG_ZLIB

554 static av_cold int swf_read_close(AVFormatContext *avctx)

555 {

556 SWFDecContext *s = avctx->priv_data;

557 inflateEnd(&s->zstream);

558 av_freep(&s->zbuf_in);

559 av_freep(&s->zbuf_out);

560 avio_context_free(&s->zpb);

561 return 0;

562 }

563 #endif

564

565 const AVInputFormat ff_swf_demuxer = {

566 .name = "swf",

567 .long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),

568 .priv_data_size = sizeof(SWFDecContext),

569 .read_probe = swf_probe,

570 .read_header = swf_read_header,

571 .read_packet = swf_read_packet,

572 #if CONFIG_ZLIB

573 .read_close = swf_read_close,

574 #endif

575 };

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:318

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

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

SWFDecContext

Definition: swfdec.c:39

swf_read_header

static int swf_read_header(AVFormatContext *s)

Definition: swfdec.c:149

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

avformat_new_stream

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

Add a new stream to a media file.

Definition: options.c:237

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:57

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

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:546

AV_CODEC_ID_RAWVIDEO

@ AV_CODEC_ID_RAWVIDEO

Definition: codec_id.h:63

AVPacket::data

uint8_t * data

Definition: packet.h:374

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

FLV_FRAME_KEY

@ FLV_FRAME_KEY

key frame (for AVC, a seekable frame)

Definition: flv.h:116

swf_audio_codec_tags

static const AVCodecTag swf_audio_codec_tags[]

Definition: swfdec.c:51

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:456

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

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:465

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:379

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

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:407

#define U(x)

Definition: vp56_arith.h:37

av_shrink_packet

void av_shrink_packet(AVPacket *pkt, int size)

Reduce packet size, correctly zeroing padding.

Definition: avpacket.c:112

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

GetBitContext

Definition: get_bits.h:61

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

AV_CODEC_ID_MP3

@ AV_CODEC_ID_MP3

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

Definition: codec_id.h:428

avio_rl16

unsigned int avio_rl16(AVIOContext *s)

Definition: aviobuf.c:743

avassert.h

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:790

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

AVInputFormat

Definition: avformat.h:656

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:667

AVCodecTag

Definition: internal.h:50

swf.h

TAG_STREAMHEAD

@ TAG_STREAMHEAD

Definition: swf.h:50

width

#define width

swf_read_packet

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

Definition: swfdec.c:212

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:256

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: avpacket.c:97

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

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:455

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AVCodecParameters::width

int width

Video only.

Definition: codec_par.h:127

info

MIPS optimizations info

Definition: mips.txt:2

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

TAG_VIDEOFRAME

@ TAG_VIDEOFRAME

Definition: swf.h:75

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

get_bits.h

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demuxing_decoding.c:41

FLV_VIDEO_FRAMETYPE_MASK

#define FLV_VIDEO_FRAMETYPE_MASK

Definition: flv.h:45

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:380

AVFormatContext

Format I/O context.

Definition: avformat.h:1213

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1108

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:532

NULL

#define NULL

Definition: coverity.c:32

read_probe

static int read_probe(const AVProbeData *pd)

Definition: jvdec.c:55

AVFMTCTX_NOHEADER

#define AVFMTCTX_NOHEADER

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

Definition: avformat.h:1164

AVPALETTE_SIZE

#define AVPALETTE_SIZE

Definition: pixfmt.h:32

TAG_JPEG2

@ TAG_JPEG2

Definition: swf.h:53

AVProbeData

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

Definition: avformat.h:453

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

flv.h

AV_CODEC_ID_FLASHSV

@ AV_CODEC_ID_FLASHSV

Definition: codec_id.h:136

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:212

AVPALETTE_COUNT

#define AVPALETTE_COUNT

Definition: pixfmt.h:33

AVPROBE_SCORE_EXTENSION

#define AVPROBE_SCORE_EXTENSION

score for file extension

Definition: avformat.h:463

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:177

TAG_STREAMBLOCK

@ TAG_STREAMBLOCK

Definition: swf.h:51

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:759

AVIOContext

Bytestream IO Context.

Definition: avio.h:162

AVPacket::size

int size

Definition: packet.h:375

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

enum AVCodecID id

Definition: extract_extradata_bsf.c:324

ff_codec_get_id

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

Definition: utils.c:144

AV_CODEC_ID_ADPCM_SWF

@ AV_CODEC_ID_ADPCM_SWF

Definition: codec_id.h:370

TAG_STREAMHEAD2

@ TAG_STREAMHEAD2

Definition: swf.h:67

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

get_swf_tag

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

Definition: swfdec.c:60

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

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:632

height

#define height

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:380

TAG_DEFINESOUND

@ TAG_DEFINESOUND

Definition: swf.h:47

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

AV_PIX_FMT_ARGB

@ AV_PIX_FMT_ARGB

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

Definition: pixfmt.h:92

AV_CODEC_ID_MJPEG

@ AV_CODEC_ID_MJPEG

Definition: codec_id.h:57

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:48

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

Definition: cbs_h2645.c:269

AVPacket::pts

int64_t pts

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

Definition: packet.h:367

internal.h

AV_PIX_FMT_RGB555

#define AV_PIX_FMT_RGB555

Definition: pixfmt.h:394

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, 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:135

demux.h

swf_probe

static int swf_probe(const AVProbeData *p)

Definition: swfdec.c:78

len

int len

Definition: vorbis_enc_data.h:426

SWFDecContext::frame_rate

int frame_rate

Definition: swfdec.c:41

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

AV_PIX_FMT_PAL8

@ AV_PIX_FMT_PAL8

8 bits with AV_PIX_FMT_RGB32 palette

Definition: pixfmt.h:77

tag

uint32_t tag

Definition: movenc.c:1646

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:962

ret

Definition: filter_design.txt:187

read_packet

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

Definition: avio_reading.c:42

AVStream

Stream structure.

Definition: avformat.h:948

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

pos

unsigned int pos

Definition: spdifenc.c:412

SWFDecContext::samples_per_frame

int samples_per_frame

Definition: swfdec.c:40

channel_layout.h

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: avpacket.c:230

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:65

avio_read

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

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:641

TAG_VIDEOSTREAM

@ TAG_VIDEOSTREAM

Definition: swf.h:74

create_new_audio_stream

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

Definition: swfdec.c:192

TAG_DEFINEBITSLOSSLESS

@ TAG_DEFINEBITSLOSSLESS

Definition: swf.h:52

AVPacket::stream_index

int stream_index

Definition: packet.h:376

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:347

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AV_CODEC_ID_PCM_U8

@ AV_CODEC_ID_PCM_U8

Definition: codec_id.h:323

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

TAG_DEFINEBITSLOSSLESS2

@ TAG_DEFINEBITSLOSSLESS2

Definition: swf.h:63

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: codec_par.h:61

AVPacket

This structure stores compressed data.

Definition: packet.h:351

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: packet.h:394

ff_swf_demuxer

const AVInputFormat ff_swf_demuxer

Definition: swfdec.c:565

AVSTREAM_PARSE_FULL

@ AVSTREAM_PARSE_FULL

full parsing and repack

Definition: avformat.h:798

imgutils.h

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:561

AV_PIX_FMT_0RGB

@ AV_PIX_FMT_0RGB

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

Definition: pixfmt.h:227

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

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

AV_CODEC_ID_NELLYMOSER

@ AV_CODEC_ID_NELLYMOSER

Definition: codec_id.h:460

avio_feof

int avio_feof(AVIOContext *s)

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

Definition: aviobuf.c:375

Generated on Wed Aug 24 2022 21:42:20 for FFmpeg by doxygen 1.8.17