FFmpeg
swfdec.c
Go to the documentation of this file.
1 /*
2  * Flash Compatible Streaming Format demuxer
3  * Copyright (c) 2000 Fabrice Bellard
4  * Copyright (c) 2003 Tinic Uro
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  */
22 
23 #include "config.h"
24 
25 #if CONFIG_ZLIB
26 #include <zlib.h>
27 #endif
28 
29 #include "libavutil/avassert.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavcodec/get_bits.h"
35 #include "swf.h"
36 #include "flv.h"
37 
38 typedef struct SWFDecContext {
41 #if CONFIG_ZLIB
42 #define ZBUF_SIZE 4096
43  AVIOContext *zpb;
44  uint8_t *zbuf_in;
45  uint8_t *zbuf_out;
46  z_stream zstream;
47 #endif
49 
50 static const AVCodecTag swf_audio_codec_tags[] = {
51  { AV_CODEC_ID_PCM_S16LE, 0x00 },
52  { AV_CODEC_ID_ADPCM_SWF, 0x01 },
53  { AV_CODEC_ID_MP3, 0x02 },
54  { AV_CODEC_ID_PCM_S16LE, 0x03 },
55  { AV_CODEC_ID_NELLYMOSER, 0x06 },
56  { AV_CODEC_ID_NONE, 0 },
57 };
58 
59 static int get_swf_tag(AVIOContext *pb, int *len_ptr)
60 {
61  int tag, len;
62 
63  if (avio_feof(pb))
64  return AVERROR_EOF;
65 
66  tag = avio_rl16(pb);
67  len = tag & 0x3f;
68  tag = tag >> 6;
69  if (len == 0x3f) {
70  len = avio_rl32(pb);
71  }
72  *len_ptr = len;
73  return tag;
74 }
75 
76 
77 static int swf_probe(const AVProbeData *p)
78 {
79  GetBitContext gb;
80  int len, xmin, xmax, ymin, ymax;
81 
82  if(p->buf_size < 15)
83  return 0;
84 
85  /* check file header */
86  if ( AV_RB24(p->buf) != AV_RB24("CWS")
87  && AV_RB24(p->buf) != AV_RB24("FWS"))
88  return 0;
89 
90  if ( AV_RB24(p->buf) == AV_RB24("CWS")
91  && p->buf[3] <= 20)
92  return AVPROBE_SCORE_MAX / 4 + 1;
93 
94  if (init_get_bits8(&gb, p->buf + 8, p->buf_size - 8) < 0)
95  return 0;
96 
97  len = get_bits(&gb, 5);
98  if (!len)
99  return 0;
100  xmin = get_bits_long(&gb, len);
101  xmax = get_bits_long(&gb, len);
102  ymin = get_bits_long(&gb, len);
103  ymax = get_bits_long(&gb, len);
104  if (xmin || ymin || !xmax || !ymax)
105  return 0;
106 
107  if (p->buf[3] >= 20 || xmax < 16 || ymax < 16)
108  return AVPROBE_SCORE_MAX / 4;
109 
110  return AVPROBE_SCORE_EXTENSION + 1;
111 }
112 
113 #if CONFIG_ZLIB
114 static int zlib_refill(void *opaque, uint8_t *buf, int buf_size)
115 {
116  AVFormatContext *s = opaque;
117  SWFDecContext *swf = s->priv_data;
118  z_stream *z = &swf->zstream;
119  int ret;
120 
121 retry:
122  if (!z->avail_in) {
123  int n = avio_read(s->pb, swf->zbuf_in, ZBUF_SIZE);
124  if (n < 0)
125  return n;
126  z->next_in = swf->zbuf_in;
127  z->avail_in = n;
128  }
129 
130  z->next_out = buf;
131  z->avail_out = buf_size;
132 
133  ret = inflate(z, Z_NO_FLUSH);
134  if (ret == Z_STREAM_END)
135  return AVERROR_EOF;
136  if (ret != Z_OK)
137  return AVERROR(EINVAL);
138 
139  if (buf_size - z->avail_out == 0)
140  goto retry;
141 
142  return buf_size - z->avail_out;
143 }
144 
145 static av_cold int swf_read_close(AVFormatContext *avctx);
146 #endif
147 
149 {
150  SWFDecContext *swf = s->priv_data;
151  AVIOContext *pb = s->pb;
152  int nbits, len, tag;
153 
154  tag = avio_rb32(pb) & 0xffffff00;
155  avio_rl32(pb);
156 
157  if (tag == MKBETAG('C', 'W', 'S', 0)) {
158  av_log(s, AV_LOG_INFO, "SWF compressed file detected\n");
159 #if CONFIG_ZLIB
160  if (inflateInit(&swf->zstream) != Z_OK) {
161  av_log(s, AV_LOG_ERROR, "Unable to init zlib context\n");
162  return AVERROR(EINVAL);
163  }
164  if (!(swf->zbuf_in = av_malloc(ZBUF_SIZE)) ||
165  !(swf->zbuf_out = av_malloc(ZBUF_SIZE)) ||
166  !(swf->zpb = avio_alloc_context(swf->zbuf_out, ZBUF_SIZE, 0,
167  s, zlib_refill, NULL, NULL))) {
168  swf_read_close(s);
169  return AVERROR(ENOMEM);
170  }
171  swf->zpb->seekable = 0;
172  pb = swf->zpb;
173 #else
174  av_log(s, AV_LOG_ERROR, "zlib support is required to read SWF compressed files\n");
175  return AVERROR(EIO);
176 #endif
177  } else if (tag != MKBETAG('F', 'W', 'S', 0))
178  return AVERROR(EIO);
179  /* skip rectangle size */
180  nbits = avio_r8(pb) >> 3;
181  len = (4 * nbits - 3 + 7) / 8;
182  avio_skip(pb, len);
183  swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */
184  avio_rl16(pb); /* frame count */
185 
186  swf->samples_per_frame = 0;
187  s->ctx_flags |= AVFMTCTX_NOHEADER;
188  return 0;
189 }
190 
192 {
193  int sample_rate_code, sample_size_code;
195  if (!ast)
196  return NULL;
197  ast->id = id;
198  if (info & 1) {
199  ast->codecpar->channels = 2;
201  } else {
202  ast->codecpar->channels = 1;
204  }
208  sample_rate_code = info>>2 & 3;
209  sample_size_code = info>>1 & 1;
210  if (!sample_size_code && ast->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE)
212  ast->codecpar->sample_rate = 44100 >> (3 - sample_rate_code);
213  avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
214  return ast;
215 }
216 
218 {
219  SWFDecContext *swf = s->priv_data;
220  AVIOContext *pb = s->pb;
221  AVStream *vst = NULL, *ast = NULL, *st = 0;
222  int tag, len, i, frame, v, res;
223 
224 #if CONFIG_ZLIB
225  if (swf->zpb)
226  pb = swf->zpb;
227 #endif
228 
229  for(;;) {
230  uint64_t pos = avio_tell(pb);
231  tag = get_swf_tag(pb, &len);
232  if (tag < 0)
233  return tag;
234  if (len < 0) {
235  av_log(s, AV_LOG_ERROR, "invalid tag length: %d\n", len);
236  return AVERROR_INVALIDDATA;
237  }
238  if (tag == TAG_VIDEOSTREAM) {
239  int ch_id = avio_rl16(pb);
240  len -= 2;
241 
242  for (i=0; i<s->nb_streams; i++) {
243  st = s->streams[i];
244  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)
245  goto skip;
246  }
247 
248  avio_rl16(pb);
249  avio_rl16(pb);
250  avio_rl16(pb);
251  avio_r8(pb);
252  /* Check for FLV1 */
253  vst = avformat_new_stream(s, NULL);
254  if (!vst)
255  return AVERROR(ENOMEM);
256  vst->id = ch_id;
259  avpriv_set_pts_info(vst, 16, 256, swf->frame_rate);
260  len -= 8;
261  } else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
262  /* streaming found */
263 
264  for (i=0; i<s->nb_streams; i++) {
265  st = s->streams[i];
266  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
267  goto skip;
268  }
269 
270  avio_r8(pb);
271  v = avio_r8(pb);
272  swf->samples_per_frame = avio_rl16(pb);
273  ast = create_new_audio_stream(s, -1, v); /* -1 to avoid clash with video stream ch_id */
274  if (!ast)
275  return AVERROR(ENOMEM);
276  len -= 4;
277  } else if (tag == TAG_DEFINESOUND) {
278  /* audio stream */
279  int ch_id = avio_rl16(pb);
280 
281  for (i=0; i<s->nb_streams; i++) {
282  st = s->streams[i];
283  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == ch_id)
284  goto skip;
285  }
286 
287  // FIXME: The entire audio stream is stored in a single chunk/tag. Normally,
288  // these are smaller audio streams in DEFINESOUND tags, but it's technically
289  // possible they could be huge. Break it up into multiple packets if it's big.
290  v = avio_r8(pb);
291  ast = create_new_audio_stream(s, ch_id, v);
292  if (!ast)
293  return AVERROR(ENOMEM);
294  ast->duration = avio_rl32(pb); // number of samples
295  if (((v>>4) & 15) == 2) { // MP3 sound data record
296  ffstream(ast)->skip_samples = avio_rl16(pb);
297  len -= 2;
298  }
299  len -= 7;
300  if ((res = av_get_packet(pb, pkt, len)) < 0)
301  return res;
302  pkt->pos = pos;
303  pkt->stream_index = ast->index;
304  return pkt->size;
305  } else if (tag == TAG_VIDEOFRAME) {
306  int ch_id = avio_rl16(pb);
307  len -= 2;
308  for(i=0; i<s->nb_streams; i++) {
309  st = s->streams[i];
310  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
311  int pkt_flags = 0;
312  frame = avio_rl16(pb);
313  len -= 2;
314  if (len <= 0)
315  goto skip;
316  if (st->codecpar->codec_id == AV_CODEC_ID_FLASHSV) {
317  unsigned flags = avio_r8(pb);
318  len--;
319  if (len <= 0)
320  goto skip;
322  }
323  if ((res = av_get_packet(pb, pkt, len)) < 0)
324  return res;
325  pkt->pos = pos;
326  pkt->pts = frame;
327  pkt->stream_index = st->index;
328  pkt->flags |= pkt_flags;
329  return pkt->size;
330  }
331  }
333 #if CONFIG_ZLIB
334  long out_len;
335  uint8_t *buf = NULL, *zbuf = NULL, *pal;
336  uint32_t colormap[AVPALETTE_COUNT] = {0};
337  const int alpha_bmp = tag == TAG_DEFINEBITSLOSSLESS2;
338  const int colormapbpp = 3 + alpha_bmp;
339  int linesize, colormapsize = 0;
340 
341  const int ch_id = avio_rl16(pb);
342  const int bmp_fmt = avio_r8(pb);
343  const int width = avio_rl16(pb);
344  const int height = avio_rl16(pb);
345  int pix_fmt;
346 
347  len -= 2+1+2+2;
348 
349  switch (bmp_fmt) {
350  case 3: // PAL-8
351  linesize = width;
352  colormapsize = avio_r8(pb) + 1;
353  len--;
354  break;
355  case 4: // RGB15
356  linesize = width * 2;
357  break;
358  case 5: // RGB24 (0RGB)
359  linesize = width * 4;
360  break;
361  default:
362  av_log(s, AV_LOG_ERROR, "invalid bitmap format %d, skipped\n", bmp_fmt);
363  goto bitmap_end_skip;
364  }
365 
366  linesize = FFALIGN(linesize, 4);
367 
368  if (av_image_check_size(width, height, 0, s) < 0 ||
369  linesize >= INT_MAX / height ||
370  linesize * height >= INT_MAX - colormapsize * colormapbpp) {
371  av_log(s, AV_LOG_ERROR, "invalid frame size %dx%d\n", width, height);
372  goto bitmap_end_skip;
373  }
374 
375  out_len = colormapsize * colormapbpp + linesize * height;
376 
377  ff_dlog(s, "bitmap: ch=%d fmt=%d %dx%d (linesize=%d) len=%d->%ld pal=%d\n",
378  ch_id, bmp_fmt, width, height, linesize, len, out_len, colormapsize);
379 
380  if (len * 17373LL < out_len)
381  goto bitmap_end_skip;
382 
383  zbuf = av_malloc(len);
384  if (!zbuf) {
385  res = AVERROR(ENOMEM);
386  goto bitmap_end;
387  }
388 
389  len = avio_read(pb, zbuf, len);
390  if (len < 0)
391  goto bitmap_end_skip;
392 
393  buf = av_malloc(out_len);
394  if (!buf) {
395  res = AVERROR(ENOMEM);
396  goto bitmap_end;
397  }
398  if ((res = uncompress(buf, &out_len, zbuf, len)) != Z_OK) {
399  av_log(s, AV_LOG_WARNING, "Failed to uncompress one bitmap\n");
400  goto bitmap_end_skip;
401  }
402 
403  for (i = 0; i < s->nb_streams; i++) {
404  st = s->streams[i];
405  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO && st->id == -3)
406  break;
407  }
408  if (i == s->nb_streams) {
409  vst = avformat_new_stream(s, NULL);
410  if (!vst) {
411  res = AVERROR(ENOMEM);
412  goto bitmap_end;
413  }
414  vst->id = -3; /* -3 to avoid clash with video stream and audio stream */
417  avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
418  st = vst;
419  }
420 
421  if ((res = av_new_packet(pkt, out_len - colormapsize * colormapbpp)) < 0)
422  goto bitmap_end;
423  if (!st->codecpar->width && !st->codecpar->height) {
424  st->codecpar->width = width;
425  st->codecpar->height = height;
426  } else {
427  ff_add_param_change(pkt, 0, 0, 0, width, height);
428  }
429  pkt->pos = pos;
430  pkt->stream_index = st->index;
431 
432  if (linesize * height > pkt->size) {
433  res = AVERROR_INVALIDDATA;
434  goto bitmap_end;
435  }
436 
437  switch (bmp_fmt) {
438  case 3:
440  for (i = 0; i < colormapsize; i++)
441  if (alpha_bmp) colormap[i] = buf[3]<<24 | AV_RB24(buf + 4*i);
442  else colormap[i] = 0xffU <<24 | AV_RB24(buf + 3*i);
444  if (!pal) {
445  res = AVERROR(ENOMEM);
446  goto bitmap_end;
447  }
448  memcpy(pal, colormap, AVPALETTE_SIZE);
449  break;
450  case 4:
452  break;
453  case 5:
454  pix_fmt = alpha_bmp ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;
455  break;
456  default:
457  av_assert0(0);
458  }
459  if (st->codecpar->format != AV_PIX_FMT_NONE && st->codecpar->format != pix_fmt) {
460  av_log(s, AV_LOG_ERROR, "pixel format change unsupported\n");
461  } else
462  st->codecpar->format = pix_fmt;
463 
464  memcpy(pkt->data, buf + colormapsize*colormapbpp, linesize * height);
465 
466  res = pkt->size;
467 
468 bitmap_end:
469  av_freep(&zbuf);
470  av_freep(&buf);
471  return res;
472 bitmap_end_skip:
473  av_freep(&zbuf);
474  av_freep(&buf);
475 #else
476  av_log(s, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
477 #endif
478  } else if (tag == TAG_STREAMBLOCK) {
479  for (i = 0; i < s->nb_streams; i++) {
480  st = s->streams[i];
481  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
482  if (st->codecpar->codec_id == AV_CODEC_ID_MP3) {
483  avio_skip(pb, 4);
484  len -= 4;
485  if (len <= 0)
486  goto skip;
487  if ((res = av_get_packet(pb, pkt, len)) < 0)
488  return res;
489  } else { // ADPCM, PCM
490  if (len <= 0)
491  goto skip;
492  if ((res = av_get_packet(pb, pkt, len)) < 0)
493  return res;
494  }
495  pkt->pos = pos;
496  pkt->stream_index = st->index;
497  return pkt->size;
498  }
499  }
500  } else if (tag == TAG_JPEG2) {
501  for (i=0; i<s->nb_streams; i++) {
502  st = s->streams[i];
503  if (st->codecpar->codec_id == AV_CODEC_ID_MJPEG && st->id == -2)
504  break;
505  }
506  if (i == s->nb_streams) {
507  vst = avformat_new_stream(s, NULL);
508  if (!vst)
509  return AVERROR(ENOMEM);
510  vst->id = -2; /* -2 to avoid clash with video stream and audio stream */
513  avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
514  st = vst;
515  }
516  avio_rl16(pb); /* BITMAP_ID */
517  len -= 2;
518  if (len < 4)
519  goto skip;
520  if ((res = av_new_packet(pkt, len)) < 0)
521  return res;
522  if (avio_read(pb, pkt->data, 4) != 4) {
523  return AVERROR_INVALIDDATA;
524  }
525  if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
526  AV_RB32(pkt->data) == 0xffd9ffd8) {
527  /* old SWF files containing SOI/EOI as data start */
528  /* files created by swink have reversed tag */
529  pkt->size -= 4;
530  memset(pkt->data+pkt->size, 0, 4);
531  res = avio_read(pb, pkt->data, pkt->size);
532  } else {
533  res = avio_read(pb, pkt->data + 4, pkt->size - 4);
534  if (res >= 0)
535  res += 4;
536  }
537  if (res != pkt->size) {
538  if (res < 0) {
539  return res;
540  }
541  av_shrink_packet(pkt, res);
542  }
543 
544  pkt->pos = pos;
545  pkt->stream_index = st->index;
546  return pkt->size;
547  } else {
548  av_log(s, AV_LOG_DEBUG, "Unknown tag: %d\n", tag);
549  }
550  skip:
551  if(len<0)
552  av_log(s, AV_LOG_WARNING, "Clipping len %d\n", len);
553  len = FFMAX(0, len);
554  avio_skip(pb, len);
555  }
556 }
557 
558 #if CONFIG_ZLIB
559 static av_cold int swf_read_close(AVFormatContext *avctx)
560 {
561  SWFDecContext *s = avctx->priv_data;
562  inflateEnd(&s->zstream);
563  av_freep(&s->zbuf_in);
564  av_freep(&s->zbuf_out);
565  avio_context_free(&s->zpb);
566  return 0;
567 }
568 #endif
569 
571  .name = "swf",
572  .long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
573  .priv_data_size = sizeof(SWFDecContext),
577 #if CONFIG_ZLIB
578  .read_close = swf_read_close,
579 #endif
580 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:314
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:303
SWFDecContext
Definition: swfdec.c:38
swf_read_header
static int swf_read_header(AVFormatContext *s)
Definition: swfdec.c:148
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: utils.c:760
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
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
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:547
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:63
AVPacket::data
uint8_t * data
Definition: packet.h:373
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:46
swf_audio_codec_tags
static const AVCodecTag swf_audio_codec_tags[]
Definition: swfdec.c:50
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:450
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
TAG_JPEG2
@ TAG_JPEG2
Definition: swf.h:53
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:459
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:434
U
#define U(x)
Definition: vp56_arith.h:37
TAG_VIDEOSTREAM
@ TAG_VIDEOSTREAM
Definition: swf.h:74
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.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:193
GetBitContext
Definition: get_bits.h:62
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:141
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:504
TAG_DEFINEBITSLOSSLESS2
@ TAG_DEFINEBITSLOSSLESS2
Definition: swf.h:63
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:424
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:743
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
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:643
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:678
AVCodecTag
Definition: internal.h:50
TAG_STREAMHEAD
@ TAG_STREAMHEAD
Definition: swf.h:50
swf.h
width
#define width
swf_read_packet
static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: swfdec.c:217
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
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: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:648
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:449
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:116
info
MIPS optimizations info
Definition: mips.txt:2
FLV_VIDEO_FRAMETYPE_MASK
#define FLV_VIDEO_FRAMETYPE_MASK
Definition: flv.h:45
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
TAG_STREAMHEAD2
@ TAG_STREAMHEAD2
Definition: swf.h:67
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
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:407
AVFormatContext
Format I/O context.
Definition: avformat.h:1193
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1088
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
NULL
#define NULL
Definition: coverity.c:32
TAG_DEFINEBITSLOSSLESS
@ TAG_DEFINEBITSLOSSLESS
Definition: swf.h:52
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:1144
TAG_VIDEOFRAME
@ TAG_VIDEOFRAME
Definition: swf.h:75
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:447
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:136
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:457
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
TAG_DEFINESOUND
@ TAG_DEFINESOUND
Definition: swf.h:47
flv.h
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVPacket::size
int size
Definition: packet.h:374
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
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:325
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:358
TAG_STREAMBLOCK
@ TAG_STREAMBLOCK
Definition: swf.h:51
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:366
get_swf_tag
static int get_swf_tag(AVIOContext *pb, int *len_ptr)
Definition: swfdec.c:59
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:379
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
internal.h
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:392
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
swf_probe
static int swf_probe(const AVProbeData *p)
Definition: swfdec.c:77
len
int len
Definition: vorbis_enc_data.h:426
SWFDecContext::frame_rate
int frame_rate
Definition: swfdec.c:40
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: utils.c:1313
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:197
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:1595
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:942
ret
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:928
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:39
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:225
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
create_new_audio_stream
static AVStream * create_new_audio_stream(AVFormatContext *s, int id, int info)
Definition: swfdec.c:191
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: utils.c:1186
AVPacket::stream_index
int stream_index
Definition: packet.h:375
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:319
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:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
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:393
ff_swf_demuxer
const AVInputFormat ff_swf_demuxer
Definition: swfdec.c:570
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:785
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:28
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:1221
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:456
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:375