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