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 "libavutil/mem.h"
35 #include "libavcodec/get_bits.h"
36 #include "demux.h"
37 #include "swf.h"
38 #include "flv.h"
39 
40 typedef struct SWFDecContext {
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
51 
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 };
60 
61 static int get_swf_tag(AVIOContext *pb, int *len_ptr)
62 {
63  int tag, len;
64 
65  if (avio_feof(pb))
66  return AVERROR_EOF;
67 
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 }
77 
78 
79 static int swf_probe(const AVProbeData *p)
80 {
81  GetBitContext gb;
82  int len, xmin, xmax, ymin, ymax;
83 
84  if(p->buf_size < 15)
85  return 0;
86 
87  /* check file header */
88  if ( AV_RB24(p->buf) != AV_RB24("CWS")
89  && AV_RB24(p->buf) != AV_RB24("FWS"))
90  return 0;
91 
92  if ( AV_RB24(p->buf) == AV_RB24("CWS")
93  && p->buf[3] <= 20)
94  return AVPROBE_SCORE_MAX / 4 + 1;
95 
96  if (init_get_bits8(&gb, p->buf + 8, p->buf_size - 8) < 0)
97  return 0;
98 
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 
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 
194 {
195  int sample_rate_code, sample_size_code;
197  if (!ast)
198  return NULL;
199  ast->id = id;
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)
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 
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;
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;
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  }
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 */
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:
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);
440  if (!pal) {
441  res = AVERROR(ENOMEM);
442  goto bitmap_end;
443  }
444  memcpy(pal, colormap, AVPALETTE_SIZE);
445  break;
446  case 4:
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 */
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 
567  .p.name = "swf",
568  .p.long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
569  .priv_data_size = sizeof(SWFDecContext),
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:328
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:273
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
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:131
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
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:421
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
AVPacket::data
uint8_t * data
Definition: packet.h:524
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
TAG_DEFINESOUND
@ TAG_DEFINESOUND
Definition: swf.h:47
swf_audio_codec_tags
static const AVCodecTag swf_audio_codec_tags[]
Definition: swfdec.c:52
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
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:579
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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:335
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:853
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:417
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
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:108
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:441
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:714
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
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:180
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:545
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
TAG_DEFINEBITSLOSSLESS2
@ TAG_DEFINEBITSLOSSLESS2
Definition: swf.h:63
width
#define width
swf_read_packet
static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: swfdec.c:213
intreadwrite.h
s
#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:98
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:553
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
info
MIPS optimizations info
Definition: mips.txt:2
TAG_STREAMBLOCK
@ TAG_STREAMBLOCK
Definition: swf.h:51
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
TAG_VIDEOSTREAM
@ TAG_VIDEOSTREAM
Definition: swf.h:74
FLV_VIDEO_FRAMETYPE_MASK
#define FLV_VIDEO_FRAMETYPE_MASK
Definition: flv.h:51
TAG_STREAMHEAD2
@ TAG_STREAMHEAD2
Definition: swf.h:67
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
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:1206
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
TAG_DEFINEBITSLOSSLESS
@ TAG_DEFINEBITSLOSSLESS
Definition: swf.h:52
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
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
TAG_JPEG2
@ TAG_JPEG2
Definition: swf.h:53
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:730
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVPacket::size
int size
Definition: packet.h:525
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:146
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:380
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: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
TAG_STREAMHEAD
@ TAG_STREAMHEAD
Definition: swf.h:50
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
height
#define height
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
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: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:831
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: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:517
internal.h
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:466
demux.h
swf_probe
static int swf_probe(const AVProbeData *p)
Definition: swfdec.c:79
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:104
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:1788
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:755
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
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:414
id
enum AVCodecID id
Definition: dts2pts.c:365
U
#define U(x)
Definition: vpx_arith.h:37
SWFDecContext::samples_per_frame
int samples_per_frame
Definition: swfdec.c:41
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: packet.c:231
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
create_new_audio_stream
static AVStream * create_new_audio_stream(AVFormatContext *s, int id, int info)
Definition: swfdec.c:193
AVPacket::stream_index
int stream_index
Definition: packet.h:526
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
ff_swf_demuxer
const FFInputFormat ff_swf_demuxer
Definition: swfdec.c:566
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
mem.h
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:333
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:501
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:544
FFInputFormat
Definition: demux.h:37
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
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
TAG_VIDEOFRAME
@ TAG_VIDEOFRAME
Definition: swf.h:75
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:1283
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:473
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346