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 
37 typedef struct SWFDecContext {
40 #if CONFIG_ZLIB
41 #define ZBUF_SIZE 4096
42  AVIOContext *zpb;
43  uint8_t *zbuf_in;
44  uint8_t *zbuf_out;
45  z_stream zstream;
46 #endif
48 
49 static const AVCodecTag swf_audio_codec_tags[] = {
50  { AV_CODEC_ID_PCM_S16LE, 0x00 },
51  { AV_CODEC_ID_ADPCM_SWF, 0x01 },
52  { AV_CODEC_ID_MP3, 0x02 },
53  { AV_CODEC_ID_PCM_S16LE, 0x03 },
54 // { AV_CODEC_ID_NELLYMOSER, 0x06 },
55  { AV_CODEC_ID_NONE, 0 },
56 };
57 
58 static int get_swf_tag(AVIOContext *pb, int *len_ptr)
59 {
60  int tag, len;
61 
62  if (avio_feof(pb))
63  return AVERROR_EOF;
64 
65  tag = avio_rl16(pb);
66  len = tag & 0x3f;
67  tag = tag >> 6;
68  if (len == 0x3f) {
69  len = avio_rl32(pb);
70  }
71  *len_ptr = len;
72  return tag;
73 }
74 
75 
76 static int swf_probe(const AVProbeData *p)
77 {
78  GetBitContext gb;
79  int len, xmin, xmax, ymin, ymax;
80 
81  if(p->buf_size < 15)
82  return 0;
83 
84  /* check file header */
85  if ( AV_RB24(p->buf) != AV_RB24("CWS")
86  && AV_RB24(p->buf) != AV_RB24("FWS"))
87  return 0;
88 
89  if ( AV_RB24(p->buf) == AV_RB24("CWS")
90  && p->buf[3] <= 20)
91  return AVPROBE_SCORE_MAX / 4 + 1;
92 
93  if (init_get_bits8(&gb, p->buf + 8, p->buf_size - 8) < 0)
94  return 0;
95 
96  len = get_bits(&gb, 5);
97  if (!len)
98  return 0;
99  xmin = get_bits_long(&gb, len);
100  xmax = get_bits_long(&gb, len);
101  ymin = get_bits_long(&gb, len);
102  ymax = get_bits_long(&gb, len);
103  if (xmin || ymin || !xmax || !ymax)
104  return 0;
105 
106  if (p->buf[3] >= 20 || xmax < 16 || ymax < 16)
107  return AVPROBE_SCORE_MAX / 4;
108 
109  return AVPROBE_SCORE_EXTENSION + 1;
110 }
111 
112 #if CONFIG_ZLIB
113 static int zlib_refill(void *opaque, uint8_t *buf, int buf_size)
114 {
115  AVFormatContext *s = opaque;
116  SWFDecContext *swf = s->priv_data;
117  z_stream *z = &swf->zstream;
118  int ret;
119 
120 retry:
121  if (!z->avail_in) {
122  int n = avio_read(s->pb, swf->zbuf_in, ZBUF_SIZE);
123  if (n < 0)
124  return n;
125  z->next_in = swf->zbuf_in;
126  z->avail_in = n;
127  }
128 
129  z->next_out = buf;
130  z->avail_out = buf_size;
131 
132  ret = inflate(z, Z_NO_FLUSH);
133  if (ret == Z_STREAM_END)
134  return AVERROR_EOF;
135  if (ret != Z_OK)
136  return AVERROR(EINVAL);
137 
138  if (buf_size - z->avail_out == 0)
139  goto retry;
140 
141  return buf_size - z->avail_out;
142 }
143 
144 static av_cold int swf_read_close(AVFormatContext *avctx);
145 #endif
146 
148 {
149  SWFDecContext *swf = s->priv_data;
150  AVIOContext *pb = s->pb;
151  int nbits, len, tag;
152 
153  tag = avio_rb32(pb) & 0xffffff00;
154  avio_rl32(pb);
155 
156  if (tag == MKBETAG('C', 'W', 'S', 0)) {
157  av_log(s, AV_LOG_INFO, "SWF compressed file detected\n");
158 #if CONFIG_ZLIB
159  if (inflateInit(&swf->zstream) != Z_OK) {
160  av_log(s, AV_LOG_ERROR, "Unable to init zlib context\n");
161  return AVERROR(EINVAL);
162  }
163  if (!(swf->zbuf_in = av_malloc(ZBUF_SIZE)) ||
164  !(swf->zbuf_out = av_malloc(ZBUF_SIZE)) ||
165  !(swf->zpb = avio_alloc_context(swf->zbuf_out, ZBUF_SIZE, 0,
166  s, zlib_refill, NULL, NULL))) {
167  swf_read_close(s);
168  return AVERROR(ENOMEM);
169  }
170  swf->zpb->seekable = 0;
171  pb = swf->zpb;
172 #else
173  av_log(s, AV_LOG_ERROR, "zlib support is required to read SWF compressed files\n");
174  return AVERROR(EIO);
175 #endif
176  } else if (tag != MKBETAG('F', 'W', 'S', 0))
177  return AVERROR(EIO);
178  /* skip rectangle size */
179  nbits = avio_r8(pb) >> 3;
180  len = (4 * nbits - 3 + 7) / 8;
181  avio_skip(pb, len);
182  swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */
183  avio_rl16(pb); /* frame count */
184 
185  swf->samples_per_frame = 0;
187  return 0;
188 }
189 
191 {
192  int sample_rate_code, sample_size_code;
193  AVStream *ast = avformat_new_stream(s, NULL);
194  if (!ast)
195  return NULL;
196  ast->id = id;
197  if (info & 1) {
198  ast->codecpar->channels = 2;
200  } else {
201  ast->codecpar->channels = 1;
203  }
205  ast->codecpar->codec_id = ff_codec_get_id(swf_audio_codec_tags, info>>4 & 15);
207  sample_rate_code = info>>2 & 3;
208  sample_size_code = info>>1 & 1;
209  if (!sample_size_code && ast->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE)
211  ast->codecpar->sample_rate = 44100 >> (3 - sample_rate_code);
212  avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
213  return ast;
214 }
215 
217 {
218  SWFDecContext *swf = s->priv_data;
219  AVIOContext *pb = s->pb;
220  AVStream *vst = NULL, *ast = NULL, *st = 0;
221  int tag, len, i, frame, v, res;
222 
223 #if CONFIG_ZLIB
224  if (swf->zpb)
225  pb = swf->zpb;
226 #endif
227 
228  for(;;) {
229  uint64_t pos = avio_tell(pb);
230  tag = get_swf_tag(pb, &len);
231  if (tag < 0)
232  return tag;
233  if (len < 0) {
234  av_log(s, AV_LOG_ERROR, "invalid tag length: %d\n", len);
235  return AVERROR_INVALIDDATA;
236  }
237  if (tag == TAG_VIDEOSTREAM) {
238  int ch_id = avio_rl16(pb);
239  len -= 2;
240 
241  for (i=0; i<s->nb_streams; i++) {
242  st = s->streams[i];
243  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)
244  goto skip;
245  }
246 
247  avio_rl16(pb);
248  avio_rl16(pb);
249  avio_rl16(pb);
250  avio_r8(pb);
251  /* Check for FLV1 */
252  vst = avformat_new_stream(s, NULL);
253  if (!vst)
254  return AVERROR(ENOMEM);
255  vst->id = ch_id;
258  avpriv_set_pts_info(vst, 16, 256, swf->frame_rate);
259  len -= 8;
260  } else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
261  /* streaming found */
262 
263  for (i=0; i<s->nb_streams; i++) {
264  st = s->streams[i];
265  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
266  goto skip;
267  }
268 
269  avio_r8(pb);
270  v = avio_r8(pb);
271  swf->samples_per_frame = avio_rl16(pb);
272  ast = create_new_audio_stream(s, -1, v); /* -1 to avoid clash with video stream ch_id */
273  if (!ast)
274  return AVERROR(ENOMEM);
275  len -= 4;
276  } else if (tag == TAG_DEFINESOUND) {
277  /* audio stream */
278  int ch_id = avio_rl16(pb);
279 
280  for (i=0; i<s->nb_streams; i++) {
281  st = s->streams[i];
282  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == ch_id)
283  goto skip;
284  }
285 
286  // FIXME: The entire audio stream is stored in a single chunk/tag. Normally,
287  // these are smaller audio streams in DEFINESOUND tags, but it's technically
288  // possible they could be huge. Break it up into multiple packets if it's big.
289  v = avio_r8(pb);
290  ast = create_new_audio_stream(s, ch_id, v);
291  if (!ast)
292  return AVERROR(ENOMEM);
293  ast->duration = avio_rl32(pb); // number of samples
294  if (((v>>4) & 15) == 2) { // MP3 sound data record
295  ast->internal->skip_samples = avio_rl16(pb);
296  len -= 2;
297  }
298  len -= 7;
299  if ((res = av_get_packet(pb, pkt, len)) < 0)
300  return res;
301  pkt->pos = pos;
302  pkt->stream_index = ast->index;
303  return pkt->size;
304  } else if (tag == TAG_VIDEOFRAME) {
305  int ch_id = avio_rl16(pb);
306  len -= 2;
307  for(i=0; i<s->nb_streams; i++) {
308  st = s->streams[i];
309  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
310  frame = avio_rl16(pb);
311  len -= 2;
312  if (len <= 0)
313  goto skip;
314  if ((res = av_get_packet(pb, pkt, len)) < 0)
315  return res;
316  pkt->pos = pos;
317  pkt->pts = frame;
318  pkt->stream_index = st->index;
319  return pkt->size;
320  }
321  }
322  } else if (tag == TAG_DEFINEBITSLOSSLESS || tag == TAG_DEFINEBITSLOSSLESS2) {
323 #if CONFIG_ZLIB
324  long out_len;
325  uint8_t *buf = NULL, *zbuf = NULL, *pal;
326  uint32_t colormap[AVPALETTE_COUNT] = {0};
327  const int alpha_bmp = tag == TAG_DEFINEBITSLOSSLESS2;
328  const int colormapbpp = 3 + alpha_bmp;
329  int linesize, colormapsize = 0;
330 
331  const int ch_id = avio_rl16(pb);
332  const int bmp_fmt = avio_r8(pb);
333  const int width = avio_rl16(pb);
334  const int height = avio_rl16(pb);
335  int pix_fmt;
336 
337  len -= 2+1+2+2;
338 
339  switch (bmp_fmt) {
340  case 3: // PAL-8
341  linesize = width;
342  colormapsize = avio_r8(pb) + 1;
343  len--;
344  break;
345  case 4: // RGB15
346  linesize = width * 2;
347  break;
348  case 5: // RGB24 (0RGB)
349  linesize = width * 4;
350  break;
351  default:
352  av_log(s, AV_LOG_ERROR, "invalid bitmap format %d, skipped\n", bmp_fmt);
353  goto bitmap_end_skip;
354  }
355 
356  linesize = FFALIGN(linesize, 4);
357 
358  if (av_image_check_size(width, height, 0, s) < 0 ||
359  linesize >= INT_MAX / height ||
360  linesize * height >= INT_MAX - colormapsize * colormapbpp) {
361  av_log(s, AV_LOG_ERROR, "invalid frame size %dx%d\n", width, height);
362  goto bitmap_end_skip;
363  }
364 
365  out_len = colormapsize * colormapbpp + linesize * height;
366 
367  ff_dlog(s, "bitmap: ch=%d fmt=%d %dx%d (linesize=%d) len=%d->%ld pal=%d\n",
368  ch_id, bmp_fmt, width, height, linesize, len, out_len, colormapsize);
369 
370  zbuf = av_malloc(len);
371  if (!zbuf) {
372  res = AVERROR(ENOMEM);
373  goto bitmap_end;
374  }
375 
376  len = avio_read(pb, zbuf, len);
377  if (len < 0)
378  goto bitmap_end_skip;
379 
380  buf = av_malloc(out_len);
381  if (!buf) {
382  res = AVERROR(ENOMEM);
383  goto bitmap_end;
384  }
385  if ((res = uncompress(buf, &out_len, zbuf, len)) != Z_OK) {
386  av_log(s, AV_LOG_WARNING, "Failed to uncompress one bitmap\n");
387  goto bitmap_end_skip;
388  }
389 
390  for (i = 0; i < s->nb_streams; i++) {
391  st = s->streams[i];
392  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO && st->id == -3)
393  break;
394  }
395  if (i == s->nb_streams) {
396  vst = avformat_new_stream(s, NULL);
397  if (!vst) {
398  res = AVERROR(ENOMEM);
399  goto bitmap_end;
400  }
401  vst->id = -3; /* -3 to avoid clash with video stream and audio stream */
404  avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
405  st = vst;
406  }
407 
408  if ((res = av_new_packet(pkt, out_len - colormapsize * colormapbpp)) < 0)
409  goto bitmap_end;
410  if (!st->codecpar->width && !st->codecpar->height) {
411  st->codecpar->width = width;
412  st->codecpar->height = height;
413  } else {
414  ff_add_param_change(pkt, 0, 0, 0, width, height);
415  }
416  pkt->pos = pos;
417  pkt->stream_index = st->index;
418 
419  if (linesize * height > pkt->size) {
420  res = AVERROR_INVALIDDATA;
421  goto bitmap_end;
422  }
423 
424  switch (bmp_fmt) {
425  case 3:
426  pix_fmt = AV_PIX_FMT_PAL8;
427  for (i = 0; i < colormapsize; i++)
428  if (alpha_bmp) colormap[i] = buf[3]<<24 | AV_RB24(buf + 4*i);
429  else colormap[i] = 0xffU <<24 | AV_RB24(buf + 3*i);
431  if (!pal) {
432  res = AVERROR(ENOMEM);
433  goto bitmap_end;
434  }
435  memcpy(pal, colormap, AVPALETTE_SIZE);
436  break;
437  case 4:
438  pix_fmt = AV_PIX_FMT_RGB555;
439  break;
440  case 5:
441  pix_fmt = alpha_bmp ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;
442  break;
443  default:
444  av_assert0(0);
445  }
446  if (st->codecpar->format != AV_PIX_FMT_NONE && st->codecpar->format != pix_fmt) {
447  av_log(s, AV_LOG_ERROR, "pixel format change unsupported\n");
448  } else
449  st->codecpar->format = pix_fmt;
450 
451  memcpy(pkt->data, buf + colormapsize*colormapbpp, linesize * height);
452 
453  res = pkt->size;
454 
455 bitmap_end:
456  av_freep(&zbuf);
457  av_freep(&buf);
458  return res;
459 bitmap_end_skip:
460  av_freep(&zbuf);
461  av_freep(&buf);
462 #else
463  av_log(s, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
464 #endif
465  } else if (tag == TAG_STREAMBLOCK) {
466  for (i = 0; i < s->nb_streams; i++) {
467  st = s->streams[i];
468  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
469  if (st->codecpar->codec_id == AV_CODEC_ID_MP3) {
470  avio_skip(pb, 4);
471  len -= 4;
472  if (len <= 0)
473  goto skip;
474  if ((res = av_get_packet(pb, pkt, len)) < 0)
475  return res;
476  } else { // ADPCM, PCM
477  if (len <= 0)
478  goto skip;
479  if ((res = av_get_packet(pb, pkt, len)) < 0)
480  return res;
481  }
482  pkt->pos = pos;
483  pkt->stream_index = st->index;
484  return pkt->size;
485  }
486  }
487  } else if (tag == TAG_JPEG2) {
488  for (i=0; i<s->nb_streams; i++) {
489  st = s->streams[i];
490  if (st->codecpar->codec_id == AV_CODEC_ID_MJPEG && st->id == -2)
491  break;
492  }
493  if (i == s->nb_streams) {
494  vst = avformat_new_stream(s, NULL);
495  if (!vst)
496  return AVERROR(ENOMEM);
497  vst->id = -2; /* -2 to avoid clash with video stream and audio stream */
500  avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
501  st = vst;
502  }
503  avio_rl16(pb); /* BITMAP_ID */
504  len -= 2;
505  if (len < 4)
506  goto skip;
507  if ((res = av_new_packet(pkt, len)) < 0)
508  return res;
509  if (avio_read(pb, pkt->data, 4) != 4) {
510  return AVERROR_INVALIDDATA;
511  }
512  if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
513  AV_RB32(pkt->data) == 0xffd9ffd8) {
514  /* old SWF files containing SOI/EOI as data start */
515  /* files created by swink have reversed tag */
516  pkt->size -= 4;
517  memset(pkt->data+pkt->size, 0, 4);
518  res = avio_read(pb, pkt->data, pkt->size);
519  } else {
520  res = avio_read(pb, pkt->data + 4, pkt->size - 4);
521  if (res >= 0)
522  res += 4;
523  }
524  if (res != pkt->size) {
525  if (res < 0) {
526  return res;
527  }
528  av_shrink_packet(pkt, res);
529  }
530 
531  pkt->pos = pos;
532  pkt->stream_index = st->index;
533  return pkt->size;
534  } else {
535  av_log(s, AV_LOG_DEBUG, "Unknown tag: %d\n", tag);
536  }
537  skip:
538  if(len<0)
539  av_log(s, AV_LOG_WARNING, "Clipping len %d\n", len);
540  len = FFMAX(0, len);
541  avio_skip(pb, len);
542  }
543 }
544 
545 #if CONFIG_ZLIB
546 static av_cold int swf_read_close(AVFormatContext *avctx)
547 {
548  SWFDecContext *s = avctx->priv_data;
549  inflateEnd(&s->zstream);
550  av_freep(&s->zbuf_in);
551  av_freep(&s->zbuf_out);
552  avio_context_free(&s->zpb);
553  return 0;
554 }
555 #endif
556 
558  .name = "swf",
559  .long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
560  .priv_data_size = sizeof(SWFDecContext),
564 #if CONFIG_ZLIB
565  .read_close = swf_read_close,
566 #endif
567 };
const AVCodecTag ff_swf_codec_tags[]
Definition: swf.c:25
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static enum AVPixelFormat pix_fmt
static int get_swf_tag(AVIOContext *pb, int *len_ptr)
Definition: swfdec.c:58
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3102
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:103
void avpriv_set_pts_info(AVStream *s, 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:4899
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int size
Definition: packet.h:364
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1288
Format I/O context.
Definition: avformat.h:1239
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
int width
Video only.
Definition: codec_par.h:126
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1183
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:785
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
enum AVStreamParseType need_parsing
Definition: avformat.h:1088
int id
Format-specific stream ID.
Definition: avformat.h:887
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4480
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:91
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1307
#define height
uint8_t * data
Definition: packet.h:363
uint32_t tag
Definition: movenc.c:1597
#define ff_dlog(a,...)
#define AVERROR_EOF
End of file.
Definition: error.h:55
bitstream reader API header.
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
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:310
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
#define FFALIGN(x, a)
Definition: macros.h:48
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
#define U(x)
Definition: vp56_arith.h:37
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
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:138
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVInputFormat ff_swf_demuxer
Definition: swfdec.c:557
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: packet.h:46
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:754
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:422
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
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:5031
simple assert() macros that are a bit more flexible than ISO C assert().
#define FFMAX(a, b)
Definition: common.h:94
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1295
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:317
MIPS optimizations info
Definition: mips.txt:2
audio channel layout utility functions
static const AVCodecTag swf_audio_codec_tags[]
Definition: swfdec.c:49
#define width
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
#define s(width, name)
Definition: cbs_vp9.c:257
static int swf_probe(const AVProbeData *p)
Definition: swfdec.c:76
static AVStream * create_new_audio_stream(AVFormatContext *s, int id, int info)
Definition: swfdec.c:190
int frame_rate
Definition: swfdec.c:39
static int swf_read_header(AVFormatContext *s)
Definition: swfdec.c:147
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
Stream structure.
Definition: avformat.h:880
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
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:91
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
int samples_per_frame
Definition: swfdec.c:38
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
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:198
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
int sample_rate
Audio only.
Definition: codec_par.h:170
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: swfdec.c:216
full parsing and repack
Definition: avformat.h:799
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:738
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:155
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:387
#define MKBETAG(a, b, c, d)
Definition: common.h:406
int len
void * priv_data
Format private data.
Definition: avformat.h:1267
int channels
Audio only.
Definition: codec_par.h:166
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:652
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
int stream_index
Definition: packet.h:365
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
#define AV_CH_LAYOUT_MONO
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:237
enum AVCodecID id
This structure stores compressed data.
Definition: packet.h:340
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
Definition: swf.h:53