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 "demux.h"
36 #include "swf.h"
37 #include "flv.h"
38 
39 typedef struct SWFDecContext {
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
50 
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 };
59 
60 static int get_swf_tag(AVIOContext *pb, int *len_ptr)
61 {
62  int tag, len;
63 
64  if (avio_feof(pb))
65  return AVERROR_EOF;
66 
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 }
76 
77 
78 static int swf_probe(const AVProbeData *p)
79 {
80  GetBitContext gb;
81  int len, xmin, xmax, ymin, ymax;
82 
83  if(p->buf_size < 15)
84  return 0;
85 
86  /* check file header */
87  if ( AV_RB24(p->buf) != AV_RB24("CWS")
88  && AV_RB24(p->buf) != AV_RB24("FWS"))
89  return 0;
90 
91  if ( AV_RB24(p->buf) == AV_RB24("CWS")
92  && p->buf[3] <= 20)
93  return AVPROBE_SCORE_MAX / 4 + 1;
94 
95  if (init_get_bits8(&gb, p->buf + 8, p->buf_size - 8) < 0)
96  return 0;
97 
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 
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 
193 {
194  int sample_rate_code, sample_size_code;
196  if (!ast)
197  return NULL;
198  ast->id = id;
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)
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 
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;
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;
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  }
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 */
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:
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);
439  if (!pal) {
440  res = AVERROR(ENOMEM);
441  goto bitmap_end;
442  }
443  memcpy(pal, colormap, AVPALETTE_SIZE);
444  break;
445  case 4:
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 */
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 
566  .name = "swf",
567  .long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
568  .priv_data_size = sizeof(SWFDecContext),
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:326
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
TAG_STREAMBLOCK
@ TAG_STREAMBLOCK
Definition: swf.h:51
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:275
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:58
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:65
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
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:763
TAG_VIDEOFRAME
@ TAG_VIDEOFRAME
Definition: swf.h:75
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:413
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:510
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:436
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:745
TAG_VIDEOSTREAM
@ TAG_VIDEOSTREAM
Definition: swf.h:74
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:792
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:49
swf.h
width
#define width
swf_read_packet
static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: swfdec.c:212
intreadwrite.h
s
#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:128
info
MIPS optimizations info
Definition: mips.txt:2
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:386
AVFormatContext
Format I/O context.
Definition: avformat.h:1216
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:533
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:1167
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:453
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:213
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:178
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:761
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
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:115
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:378
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
TAG_DEFINEBITSLOSSLESS
@ TAG_DEFINEBITSLOSSLESS
Definition: swf.h:52
TAG_DEFINESOUND
@ TAG_DEFINESOUND
Definition: swf.h:47
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:634
height
#define height
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
TAG_DEFINEBITSLOSSLESS2
@ TAG_DEFINEBITSLOSSLESS2
Definition: swf.h:63
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_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:962
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
i
#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:447
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:1647
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:962
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: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
U
#define U(x)
Definition: vpx_arith.h:37
id
enum AVCodecID id
Definition: dts2pts_bsf.c:362
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:643
create_new_audio_stream
static AVStream * create_new_audio_stream(AVFormatContext *s, int id, int info)
Definition: swfdec.c:192
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:349
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:331
TAG_JPEG2
@ TAG_JPEG2
Definition: swf.h:53
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:62
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:255
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
TAG_STREAMHEAD
@ TAG_STREAMHEAD
Definition: swf.h:50
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
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:116
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1244
TAG_STREAMHEAD2
@ TAG_STREAMHEAD2
Definition: swf.h:67
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:468
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:377