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  goto bitmap_end;
403  }
404 
405  switch (bmp_fmt) {
406  case 3:
407  pix_fmt = AV_PIX_FMT_PAL8;
408  for (i = 0; i < colormapsize; i++)
409  if (alpha_bmp) colormap[i] = buf[3]<<24 | AV_RB24(buf + 4*i);
410  else colormap[i] = 0xffU <<24 | AV_RB24(buf + 3*i);
412  if (!pal) {
413  res = AVERROR(ENOMEM);
414  goto bitmap_end;
415  }
416  memcpy(pal, colormap, AVPALETTE_SIZE);
417  break;
418  case 4:
419  pix_fmt = AV_PIX_FMT_RGB555;
420  break;
421  case 5:
422  pix_fmt = alpha_bmp ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;
423  break;
424  default:
425  av_assert0(0);
426  }
427  if (st->codecpar->format != AV_PIX_FMT_NONE && st->codecpar->format != pix_fmt) {
428  av_log(s, AV_LOG_ERROR, "pixel format change unsupported\n");
429  } else
430  st->codecpar->format = pix_fmt;
431 
432  memcpy(pkt->data, buf + colormapsize*colormapbpp, linesize * height);
433 
434  res = pkt->size;
435 
436 bitmap_end:
437  av_freep(&zbuf);
438  av_freep(&buf);
439  return res;
440 bitmap_end_skip:
441  av_freep(&zbuf);
442  av_freep(&buf);
443 #else
444  av_log(s, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
445 #endif
446  } else if (tag == TAG_STREAMBLOCK) {
447  for (i = 0; i < s->nb_streams; i++) {
448  st = s->streams[i];
449  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
450  if (st->codecpar->codec_id == AV_CODEC_ID_MP3) {
451  avio_skip(pb, 4);
452  len -= 4;
453  if (len <= 0)
454  goto skip;
455  if ((res = av_get_packet(pb, pkt, len)) < 0)
456  return res;
457  } else { // ADPCM, PCM
458  if (len <= 0)
459  goto skip;
460  if ((res = av_get_packet(pb, pkt, len)) < 0)
461  return res;
462  }
463  pkt->pos = pos;
464  pkt->stream_index = st->index;
465  return pkt->size;
466  }
467  }
468  } else if (tag == TAG_JPEG2) {
469  for (i=0; i<s->nb_streams; i++) {
470  st = s->streams[i];
471  if (st->codecpar->codec_id == AV_CODEC_ID_MJPEG && st->id == -2)
472  break;
473  }
474  if (i == s->nb_streams) {
475  vst = avformat_new_stream(s, NULL);
476  if (!vst)
477  return AVERROR(ENOMEM);
478  vst->id = -2; /* -2 to avoid clash with video stream and audio stream */
481  avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
482  st = vst;
483  }
484  avio_rl16(pb); /* BITMAP_ID */
485  len -= 2;
486  if (len < 4)
487  goto skip;
488  if ((res = av_new_packet(pkt, len)) < 0)
489  return res;
490  if (avio_read(pb, pkt->data, 4) != 4) {
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  return res;
508  }
509  av_shrink_packet(pkt, res);
510  }
511 
512  pkt->pos = pos;
513  pkt->stream_index = st->index;
514  return pkt->size;
515  } else {
516  av_log(s, AV_LOG_DEBUG, "Unknown tag: %d\n", tag);
517  }
518  skip:
519  if(len<0)
520  av_log(s, AV_LOG_WARNING, "Clipping len %d\n", len);
521  len = FFMAX(0, len);
522  avio_skip(pb, len);
523  }
524 }
525 
526 #if CONFIG_ZLIB
527 static av_cold int swf_read_close(AVFormatContext *avctx)
528 {
529  SWFContext *s = avctx->priv_data;
530  inflateEnd(&s->zstream);
531  av_freep(&s->zbuf_in);
532  av_freep(&s->zbuf_out);
533  avio_context_free(&s->zpb);
534  return 0;
535 }
536 #endif
537 
539  .name = "swf",
540  .long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
541  .priv_data_size = sizeof(SWFContext),
545 #if CONFIG_ZLIB
546  .read_close = swf_read_close,
547 #endif
548 };
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:3096
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:4869
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:1400
Format I/O context.
Definition: avformat.h:1351
#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: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:1295
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
enum AVStreamParseType need_parsing
Definition: avformat.h:1094
int id
Format-specific stream ID.
Definition: avformat.h:883
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4450
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:1419
#define height
uint8_t * data
Definition: packet.h:363
uint32_t tag
Definition: movenc.c:1532
#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:305
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
Definition: swf.h:62
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVInputFormat ff_swf_demuxer
Definition: swfdec.c:538
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:759
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
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:415
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:5001
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:1407
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:317
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
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:527
Stream structure.
Definition: avformat.h:876
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:87
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
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: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:204
full parsing and repack
Definition: avformat.h:795
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:743
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:407
int len
void * priv_data
Format private data.
Definition: avformat.h:1379
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:650
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
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