FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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(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_MAX;
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  return AVERROR(EINVAL);
156  }
157  pb = swf->zpb;
158 #else
159  av_log(s, AV_LOG_ERROR, "zlib support is required to read SWF compressed files\n");
160  return AVERROR(EIO);
161 #endif
162  } else if (tag != MKBETAG('F', 'W', 'S', 0))
163  return AVERROR(EIO);
164  /* skip rectangle size */
165  nbits = avio_r8(pb) >> 3;
166  len = (4 * nbits - 3 + 7) / 8;
167  avio_skip(pb, len);
168  swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */
169  avio_rl16(pb); /* frame count */
170 
171  swf->samples_per_frame = 0;
173  return 0;
174 }
175 
176 static AVStream *create_new_audio_stream(AVFormatContext *s, int id, int info)
177 {
178  int sample_rate_code, sample_size_code;
179  AVStream *ast = avformat_new_stream(s, NULL);
180  if (!ast)
181  return NULL;
182  ast->id = id;
183  if (info & 1) {
184  ast->codecpar->channels = 2;
186  } else {
187  ast->codecpar->channels = 1;
189  }
191  ast->codecpar->codec_id = ff_codec_get_id(swf_audio_codec_tags, info>>4 & 15);
193  sample_rate_code = info>>2 & 3;
194  sample_size_code = info>>1 & 1;
195  if (!sample_size_code && ast->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE)
197  ast->codecpar->sample_rate = 44100 >> (3 - sample_rate_code);
198  avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
199  return ast;
200 }
201 
203 {
204  SWFContext *swf = s->priv_data;
205  AVIOContext *pb = s->pb;
206  AVStream *vst = NULL, *ast = NULL, *st = 0;
207  int tag, len, i, frame, v, res;
208 
209 #if CONFIG_ZLIB
210  if (swf->zpb)
211  pb = swf->zpb;
212 #endif
213 
214  for(;;) {
215  uint64_t pos = avio_tell(pb);
216  tag = get_swf_tag(pb, &len);
217  if (tag < 0)
218  return tag;
219  if (len < 0) {
220  av_log(s, AV_LOG_ERROR, "invalid tag length: %d\n", len);
221  return AVERROR_INVALIDDATA;
222  }
223  if (tag == TAG_VIDEOSTREAM) {
224  int ch_id = avio_rl16(pb);
225  len -= 2;
226 
227  for (i=0; i<s->nb_streams; i++) {
228  st = s->streams[i];
229  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)
230  goto skip;
231  }
232 
233  avio_rl16(pb);
234  avio_rl16(pb);
235  avio_rl16(pb);
236  avio_r8(pb);
237  /* Check for FLV1 */
238  vst = avformat_new_stream(s, NULL);
239  if (!vst)
240  return AVERROR(ENOMEM);
241  vst->id = ch_id;
244  avpriv_set_pts_info(vst, 16, 256, swf->frame_rate);
245  len -= 8;
246  } else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
247  /* streaming found */
248 
249  for (i=0; i<s->nb_streams; i++) {
250  st = s->streams[i];
251  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
252  goto skip;
253  }
254 
255  avio_r8(pb);
256  v = avio_r8(pb);
257  swf->samples_per_frame = avio_rl16(pb);
258  ast = create_new_audio_stream(s, -1, v); /* -1 to avoid clash with video stream ch_id */
259  if (!ast)
260  return AVERROR(ENOMEM);
261  len -= 4;
262  } else if (tag == TAG_DEFINESOUND) {
263  /* audio stream */
264  int ch_id = avio_rl16(pb);
265 
266  for (i=0; i<s->nb_streams; i++) {
267  st = s->streams[i];
268  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == ch_id)
269  goto skip;
270  }
271 
272  // FIXME: The entire audio stream is stored in a single chunk/tag. Normally,
273  // these are smaller audio streams in DEFINESOUND tags, but it's technically
274  // possible they could be huge. Break it up into multiple packets if it's big.
275  v = avio_r8(pb);
276  ast = create_new_audio_stream(s, ch_id, v);
277  if (!ast)
278  return AVERROR(ENOMEM);
279  ast->duration = avio_rl32(pb); // number of samples
280  if (((v>>4) & 15) == 2) { // MP3 sound data record
281  ast->skip_samples = avio_rl16(pb);
282  len -= 2;
283  }
284  len -= 7;
285  if ((res = av_get_packet(pb, pkt, len)) < 0)
286  return res;
287  pkt->pos = pos;
288  pkt->stream_index = ast->index;
289  return pkt->size;
290  } else if (tag == TAG_VIDEOFRAME) {
291  int ch_id = avio_rl16(pb);
292  len -= 2;
293  for(i=0; i<s->nb_streams; i++) {
294  st = s->streams[i];
295  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
296  frame = avio_rl16(pb);
297  len -= 2;
298  if (len <= 0)
299  goto skip;
300  if ((res = av_get_packet(pb, pkt, len)) < 0)
301  return res;
302  pkt->pos = pos;
303  pkt->pts = frame;
304  pkt->stream_index = st->index;
305  return pkt->size;
306  }
307  }
308  } else if (tag == TAG_DEFINEBITSLOSSLESS || tag == TAG_DEFINEBITSLOSSLESS2) {
309 #if CONFIG_ZLIB
310  long out_len;
311  uint8_t *buf = NULL, *zbuf = NULL, *pal;
312  uint32_t colormap[AVPALETTE_COUNT] = {0};
313  const int alpha_bmp = tag == TAG_DEFINEBITSLOSSLESS2;
314  const int colormapbpp = 3 + alpha_bmp;
315  int linesize, colormapsize = 0;
316 
317  const int ch_id = avio_rl16(pb);
318  const int bmp_fmt = avio_r8(pb);
319  const int width = avio_rl16(pb);
320  const int height = avio_rl16(pb);
321  int pix_fmt;
322 
323  len -= 2+1+2+2;
324 
325  switch (bmp_fmt) {
326  case 3: // PAL-8
327  linesize = width;
328  colormapsize = avio_r8(pb) + 1;
329  len--;
330  break;
331  case 4: // RGB15
332  linesize = width * 2;
333  break;
334  case 5: // RGB24 (0RGB)
335  linesize = width * 4;
336  break;
337  default:
338  av_log(s, AV_LOG_ERROR, "invalid bitmap format %d, skipped\n", bmp_fmt);
339  goto bitmap_end_skip;
340  }
341 
342  linesize = FFALIGN(linesize, 4);
343 
344  if (av_image_check_size(width, height, 0, s) < 0 ||
345  linesize >= INT_MAX / height ||
346  linesize * height >= INT_MAX - colormapsize * colormapbpp) {
347  av_log(s, AV_LOG_ERROR, "invalid frame size %dx%d\n", width, height);
348  goto bitmap_end_skip;
349  }
350 
351  out_len = colormapsize * colormapbpp + linesize * height;
352 
353  ff_dlog(s, "bitmap: ch=%d fmt=%d %dx%d (linesize=%d) len=%d->%ld pal=%d\n",
354  ch_id, bmp_fmt, width, height, linesize, len, out_len, colormapsize);
355 
356  zbuf = av_malloc(len);
357  buf = av_malloc(out_len);
358  if (!zbuf || !buf) {
359  res = AVERROR(ENOMEM);
360  goto bitmap_end;
361  }
362 
363  len = avio_read(pb, zbuf, len);
364  if (len < 0 || (res = uncompress(buf, &out_len, zbuf, len)) != Z_OK) {
365  av_log(s, AV_LOG_WARNING, "Failed to uncompress one bitmap\n");
366  goto bitmap_end_skip;
367  }
368 
369  for (i = 0; i < s->nb_streams; i++) {
370  st = s->streams[i];
371  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO && st->id == -3)
372  break;
373  }
374  if (i == s->nb_streams) {
375  vst = avformat_new_stream(s, NULL);
376  if (!vst) {
377  res = AVERROR(ENOMEM);
378  goto bitmap_end;
379  }
380  vst->id = -3; /* -3 to avoid clash with video stream and audio stream */
383  avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
384  st = vst;
385  }
386 
387  if ((res = av_new_packet(pkt, out_len - colormapsize * colormapbpp)) < 0)
388  goto bitmap_end;
389  if (!st->codecpar->width && !st->codecpar->height) {
390  st->codecpar->width = width;
391  st->codecpar->height = height;
392  } else {
393  ff_add_param_change(pkt, 0, 0, 0, width, height);
394  }
395  pkt->pos = pos;
396  pkt->stream_index = st->index;
397 
398  if (linesize * height > pkt->size) {
399  res = AVERROR_INVALIDDATA;
400  av_packet_unref(pkt);
401  goto bitmap_end;
402  }
403 
404  switch (bmp_fmt) {
405  case 3:
406  pix_fmt = AV_PIX_FMT_PAL8;
407  for (i = 0; i < colormapsize; i++)
408  if (alpha_bmp) colormap[i] = buf[3]<<24 | AV_RB24(buf + 4*i);
409  else colormap[i] = 0xffU <<24 | AV_RB24(buf + 3*i);
411  if (!pal) {
412  res = AVERROR(ENOMEM);
413  goto bitmap_end;
414  }
415  memcpy(pal, colormap, AVPALETTE_SIZE);
416  break;
417  case 4:
418  pix_fmt = AV_PIX_FMT_RGB555;
419  break;
420  case 5:
421  pix_fmt = alpha_bmp ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;
422  break;
423  default:
424  av_assert0(0);
425  }
426  if (st->codecpar->format != AV_PIX_FMT_NONE && st->codecpar->format != pix_fmt) {
427  av_log(s, AV_LOG_ERROR, "pixel format change unsupported\n");
428  } else
429  st->codecpar->format = pix_fmt;
430 
431  memcpy(pkt->data, buf + colormapsize*colormapbpp, linesize * height);
432 
433  res = pkt->size;
434 
435 bitmap_end:
436  av_freep(&zbuf);
437  av_freep(&buf);
438  return res;
439 bitmap_end_skip:
440  av_freep(&zbuf);
441  av_freep(&buf);
442 #else
443  av_log(s, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
444 #endif
445  } else if (tag == TAG_STREAMBLOCK) {
446  for (i = 0; i < s->nb_streams; i++) {
447  st = s->streams[i];
448  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
449  if (st->codecpar->codec_id == AV_CODEC_ID_MP3) {
450  avio_skip(pb, 4);
451  len -= 4;
452  if (len <= 0)
453  goto skip;
454  if ((res = av_get_packet(pb, pkt, len)) < 0)
455  return res;
456  } else { // ADPCM, PCM
457  if (len <= 0)
458  goto skip;
459  if ((res = av_get_packet(pb, pkt, len)) < 0)
460  return res;
461  }
462  pkt->pos = pos;
463  pkt->stream_index = st->index;
464  return pkt->size;
465  }
466  }
467  } else if (tag == TAG_JPEG2) {
468  for (i=0; i<s->nb_streams; i++) {
469  st = s->streams[i];
470  if (st->codecpar->codec_id == AV_CODEC_ID_MJPEG && st->id == -2)
471  break;
472  }
473  if (i == s->nb_streams) {
474  vst = avformat_new_stream(s, NULL);
475  if (!vst)
476  return AVERROR(ENOMEM);
477  vst->id = -2; /* -2 to avoid clash with video stream and audio stream */
480  avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
481  st = vst;
482  }
483  avio_rl16(pb); /* BITMAP_ID */
484  len -= 2;
485  if (len < 4)
486  goto skip;
487  if ((res = av_new_packet(pkt, len)) < 0)
488  return res;
489  if (avio_read(pb, pkt->data, 4) != 4) {
490  av_packet_unref(pkt);
491  return AVERROR_INVALIDDATA;
492  }
493  if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
494  AV_RB32(pkt->data) == 0xffd9ffd8) {
495  /* old SWF files containing SOI/EOI as data start */
496  /* files created by swink have reversed tag */
497  pkt->size -= 4;
498  memset(pkt->data+pkt->size, 0, 4);
499  res = avio_read(pb, pkt->data, pkt->size);
500  } else {
501  res = avio_read(pb, pkt->data + 4, pkt->size - 4);
502  if (res >= 0)
503  res += 4;
504  }
505  if (res != pkt->size) {
506  if (res < 0) {
507  av_packet_unref(pkt);
508  return res;
509  }
510  av_shrink_packet(pkt, res);
511  }
512 
513  pkt->pos = pos;
514  pkt->stream_index = st->index;
515  return pkt->size;
516  } else {
517  av_log(s, AV_LOG_DEBUG, "Unknown tag: %d\n", tag);
518  }
519  skip:
520  if(len<0)
521  av_log(s, AV_LOG_WARNING, "Cliping len %d\n", len);
522  len = FFMAX(0, len);
523  avio_skip(pb, len);
524  }
525 }
526 
527 #if CONFIG_ZLIB
528 static av_cold int swf_read_close(AVFormatContext *avctx)
529 {
530  SWFContext *s = avctx->priv_data;
531  inflateEnd(&s->zstream);
532  av_freep(&s->zbuf_in);
533  av_freep(&s->zbuf_out);
534  av_freep(&s->zpb);
535  return 0;
536 }
537 #endif
538 
540  .name = "swf",
541  .long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
542  .priv_data_size = sizeof(SWFContext),
546 #if CONFIG_ZLIB
547  .read_close = swf_read_close,
548 #endif
549 };
const AVCodecTag ff_swf_codec_tags[]
Definition: swf.c:25
static int swf_probe(AVProbeData *p)
Definition: swfdec.c:64
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
Bytestream IO Context.
Definition: avio.h:147
#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 id
Definition: mxfenc.c:104
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:2962
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:247
#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:1610
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:4507
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3953
int size
Definition: avcodec.h:1591
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:304
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1376
Format I/O context.
Definition: avformat.h:1327
#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:4019
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1280
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:757
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
enum AVStreamParseType need_parsing
Definition: avformat.h:1065
int id
Format-specific stream ID.
Definition: avformat.h:885
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4140
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:1395
static AVFrame * frame
#define height
uint8_t * data
Definition: avcodec.h:1590
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord)
Definition: vf_neighbor.c:129
uint32_t tag
Definition: movenc.c:1376
#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:260
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:511
#define FFALIGN(x, a)
Definition: macros.h:48
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4055
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:604
#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:126
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVInputFormat ff_swf_demuxer
Definition: swfdec.c:539
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:726
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
#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:517
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3949
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:4641
Definition: swf.h:62
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:93
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:595
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:464
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:463
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1383
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:251
audio channel layout utility functions
static const AVCodecTag swf_audio_codec_tags[]
Definition: swfdec.c:37
#define width
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
int n
Definition: avisynth_c.h:684
static AVStream * create_new_audio_stream(AVFormatContext *s, int id, int info)
Definition: swfdec.c:176
static int swf_read_header(AVFormatContext *s)
Definition: swfdec.c:134
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:514
Stream structure.
Definition: avformat.h:878
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:1369
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:437
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:563
void * buf
Definition: avisynth_c.h:690
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:292
This structure contains the data a format has to probe a file.
Definition: avformat.h:461
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:332
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
int sample_rate
Audio only.
Definition: avcodec.h:4063
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:473
static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: swfdec.c:202
full parsing and repack
Definition: avformat.h:808
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:710
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:331
#define MKBETAG(a, b, c, d)
Definition: common.h:343
int len
void * priv_data
Format private data.
Definition: avformat.h:1355
int channels
Audio only.
Definition: avcodec.h:4059
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:662
AVCodecParameters * codecpar
Definition: avformat.h:1230
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:328
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:313
int stream_index
Definition: avcodec.h:1592
#define AV_CH_LAYOUT_MONO
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:250
This structure stores compressed data.
Definition: avcodec.h:1567
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1583