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 + 8, p->buf_size - 8) < 0)
82  return 0;
83 
84  len = get_bits(&gb, 5);
85  if (!len)
86  return 0;
87  xmin = get_bits_long(&gb, len);
88  xmax = get_bits_long(&gb, len);
89  ymin = get_bits_long(&gb, len);
90  ymax = get_bits_long(&gb, len);
91  if (xmin || ymin || !xmax || !ymax)
92  return 0;
93 
94  if (p->buf[3] >= 20 || xmax < 16 || ymax < 16)
95  return AVPROBE_SCORE_MAX / 4;
96 
97  return AVPROBE_SCORE_EXTENSION + 1;
98 }
99 
100 #if CONFIG_ZLIB
101 static int zlib_refill(void *opaque, uint8_t *buf, int buf_size)
102 {
103  AVFormatContext *s = opaque;
104  SWFContext *swf = s->priv_data;
105  z_stream *z = &swf->zstream;
106  int ret;
107 
108 retry:
109  if (!z->avail_in) {
110  int n = avio_read(s->pb, swf->zbuf_in, ZBUF_SIZE);
111  if (n < 0)
112  return n;
113  z->next_in = swf->zbuf_in;
114  z->avail_in = n;
115  }
116 
117  z->next_out = buf;
118  z->avail_out = buf_size;
119 
120  ret = inflate(z, Z_NO_FLUSH);
121  if (ret == Z_STREAM_END)
122  return AVERROR_EOF;
123  if (ret != Z_OK)
124  return AVERROR(EINVAL);
125 
126  if (buf_size - z->avail_out == 0)
127  goto retry;
128 
129  return buf_size - z->avail_out;
130 }
131 #endif
132 
134 {
135  SWFContext *swf = s->priv_data;
136  AVIOContext *pb = s->pb;
137  int nbits, len, tag;
138 
139  tag = avio_rb32(pb) & 0xffffff00;
140  avio_rl32(pb);
141 
142  if (tag == MKBETAG('C', 'W', 'S', 0)) {
143  av_log(s, AV_LOG_INFO, "SWF compressed file detected\n");
144 #if CONFIG_ZLIB
145  swf->zbuf_in = av_malloc(ZBUF_SIZE);
146  swf->zbuf_out = av_malloc(ZBUF_SIZE);
147  swf->zpb = avio_alloc_context(swf->zbuf_out, ZBUF_SIZE, 0, s,
148  zlib_refill, NULL, NULL);
149  if (!swf->zbuf_in || !swf->zbuf_out || !swf->zpb)
150  return AVERROR(ENOMEM);
151  swf->zpb->seekable = 0;
152  if (inflateInit(&swf->zstream) != Z_OK) {
153  av_log(s, AV_LOG_ERROR, "Unable to init zlib context\n");
154  av_freep(&swf->zbuf_in);
155  av_freep(&swf->zbuf_out);
156  return AVERROR(EINVAL);
157  }
158  pb = swf->zpb;
159 #else
160  av_log(s, AV_LOG_ERROR, "zlib support is required to read SWF compressed files\n");
161  return AVERROR(EIO);
162 #endif
163  } else if (tag != MKBETAG('F', 'W', 'S', 0))
164  return AVERROR(EIO);
165  /* skip rectangle size */
166  nbits = avio_r8(pb) >> 3;
167  len = (4 * nbits - 3 + 7) / 8;
168  avio_skip(pb, len);
169  swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */
170  avio_rl16(pb); /* frame count */
171 
172  swf->samples_per_frame = 0;
174  return 0;
175 }
176 
178 {
179  int sample_rate_code, sample_size_code;
180  AVStream *ast = avformat_new_stream(s, NULL);
181  if (!ast)
182  return NULL;
183  ast->id = id;
184  if (info & 1) {
185  ast->codecpar->channels = 2;
187  } else {
188  ast->codecpar->channels = 1;
190  }
192  ast->codecpar->codec_id = ff_codec_get_id(swf_audio_codec_tags, info>>4 & 15);
194  sample_rate_code = info>>2 & 3;
195  sample_size_code = info>>1 & 1;
196  if (!sample_size_code && ast->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE)
198  ast->codecpar->sample_rate = 44100 >> (3 - sample_rate_code);
199  avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
200  return ast;
201 }
202 
204 {
205  SWFContext *swf = s->priv_data;
206  AVIOContext *pb = s->pb;
207  AVStream *vst = NULL, *ast = NULL, *st = 0;
208  int tag, len, i, frame, v, res;
209 
210 #if CONFIG_ZLIB
211  if (swf->zpb)
212  pb = swf->zpb;
213 #endif
214 
215  for(;;) {
216  uint64_t pos = avio_tell(pb);
217  tag = get_swf_tag(pb, &len);
218  if (tag < 0)
219  return tag;
220  if (len < 0) {
221  av_log(s, AV_LOG_ERROR, "invalid tag length: %d\n", len);
222  return AVERROR_INVALIDDATA;
223  }
224  if (tag == TAG_VIDEOSTREAM) {
225  int ch_id = avio_rl16(pb);
226  len -= 2;
227 
228  for (i=0; i<s->nb_streams; i++) {
229  st = s->streams[i];
230  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)
231  goto skip;
232  }
233 
234  avio_rl16(pb);
235  avio_rl16(pb);
236  avio_rl16(pb);
237  avio_r8(pb);
238  /* Check for FLV1 */
239  vst = avformat_new_stream(s, NULL);
240  if (!vst)
241  return AVERROR(ENOMEM);
242  vst->id = ch_id;
245  avpriv_set_pts_info(vst, 16, 256, swf->frame_rate);
246  len -= 8;
247  } else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
248  /* streaming found */
249 
250  for (i=0; i<s->nb_streams; i++) {
251  st = s->streams[i];
252  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
253  goto skip;
254  }
255 
256  avio_r8(pb);
257  v = avio_r8(pb);
258  swf->samples_per_frame = avio_rl16(pb);
259  ast = create_new_audio_stream(s, -1, v); /* -1 to avoid clash with video stream ch_id */
260  if (!ast)
261  return AVERROR(ENOMEM);
262  len -= 4;
263  } else if (tag == TAG_DEFINESOUND) {
264  /* audio stream */
265  int ch_id = avio_rl16(pb);
266 
267  for (i=0; i<s->nb_streams; i++) {
268  st = s->streams[i];
269  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->id == ch_id)
270  goto skip;
271  }
272 
273  // FIXME: The entire audio stream is stored in a single chunk/tag. Normally,
274  // these are smaller audio streams in DEFINESOUND tags, but it's technically
275  // possible they could be huge. Break it up into multiple packets if it's big.
276  v = avio_r8(pb);
277  ast = create_new_audio_stream(s, ch_id, v);
278  if (!ast)
279  return AVERROR(ENOMEM);
280  ast->duration = avio_rl32(pb); // number of samples
281  if (((v>>4) & 15) == 2) { // MP3 sound data record
282  ast->skip_samples = avio_rl16(pb);
283  len -= 2;
284  }
285  len -= 7;
286  if ((res = av_get_packet(pb, pkt, len)) < 0)
287  return res;
288  pkt->pos = pos;
289  pkt->stream_index = ast->index;
290  return pkt->size;
291  } else if (tag == TAG_VIDEOFRAME) {
292  int ch_id = avio_rl16(pb);
293  len -= 2;
294  for(i=0; i<s->nb_streams; i++) {
295  st = s->streams[i];
296  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
297  frame = avio_rl16(pb);
298  len -= 2;
299  if (len <= 0)
300  goto skip;
301  if ((res = av_get_packet(pb, pkt, len)) < 0)
302  return res;
303  pkt->pos = pos;
304  pkt->pts = frame;
305  pkt->stream_index = st->index;
306  return pkt->size;
307  }
308  }
309  } else if (tag == TAG_DEFINEBITSLOSSLESS || tag == TAG_DEFINEBITSLOSSLESS2) {
310 #if CONFIG_ZLIB
311  long out_len;
312  uint8_t *buf = NULL, *zbuf = NULL, *pal;
313  uint32_t colormap[AVPALETTE_COUNT] = {0};
314  const int alpha_bmp = tag == TAG_DEFINEBITSLOSSLESS2;
315  const int colormapbpp = 3 + alpha_bmp;
316  int linesize, colormapsize = 0;
317 
318  const int ch_id = avio_rl16(pb);
319  const int bmp_fmt = avio_r8(pb);
320  const int width = avio_rl16(pb);
321  const int height = avio_rl16(pb);
322  int pix_fmt;
323 
324  len -= 2+1+2+2;
325 
326  switch (bmp_fmt) {
327  case 3: // PAL-8
328  linesize = width;
329  colormapsize = avio_r8(pb) + 1;
330  len--;
331  break;
332  case 4: // RGB15
333  linesize = width * 2;
334  break;
335  case 5: // RGB24 (0RGB)
336  linesize = width * 4;
337  break;
338  default:
339  av_log(s, AV_LOG_ERROR, "invalid bitmap format %d, skipped\n", bmp_fmt);
340  goto bitmap_end_skip;
341  }
342 
343  linesize = FFALIGN(linesize, 4);
344 
345  if (av_image_check_size(width, height, 0, s) < 0 ||
346  linesize >= INT_MAX / height ||
347  linesize * height >= INT_MAX - colormapsize * colormapbpp) {
348  av_log(s, AV_LOG_ERROR, "invalid frame size %dx%d\n", width, height);
349  goto bitmap_end_skip;
350  }
351 
352  out_len = colormapsize * colormapbpp + linesize * height;
353 
354  ff_dlog(s, "bitmap: ch=%d fmt=%d %dx%d (linesize=%d) len=%d->%ld pal=%d\n",
355  ch_id, bmp_fmt, width, height, linesize, len, out_len, colormapsize);
356 
357  zbuf = av_malloc(len);
358  buf = av_malloc(out_len);
359  if (!zbuf || !buf) {
360  res = AVERROR(ENOMEM);
361  goto bitmap_end;
362  }
363 
364  len = avio_read(pb, zbuf, len);
365  if (len < 0 || (res = uncompress(buf, &out_len, zbuf, len)) != Z_OK) {
366  av_log(s, AV_LOG_WARNING, "Failed to uncompress one bitmap\n");
367  goto bitmap_end_skip;
368  }
369 
370  for (i = 0; i < s->nb_streams; i++) {
371  st = s->streams[i];
372  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO && st->id == -3)
373  break;
374  }
375  if (i == s->nb_streams) {
376  vst = avformat_new_stream(s, NULL);
377  if (!vst) {
378  res = AVERROR(ENOMEM);
379  goto bitmap_end;
380  }
381  vst->id = -3; /* -3 to avoid clash with video stream and audio stream */
384  avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
385  st = vst;
386  }
387 
388  if ((res = av_new_packet(pkt, out_len - colormapsize * colormapbpp)) < 0)
389  goto bitmap_end;
390  if (!st->codecpar->width && !st->codecpar->height) {
391  st->codecpar->width = width;
392  st->codecpar->height = height;
393  } else {
394  ff_add_param_change(pkt, 0, 0, 0, width, height);
395  }
396  pkt->pos = pos;
397  pkt->stream_index = st->index;
398 
399  if (linesize * height > pkt->size) {
400  res = AVERROR_INVALIDDATA;
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  return AVERROR_INVALIDDATA;
491  }
492  if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
493  AV_RB32(pkt->data) == 0xffd9ffd8) {
494  /* old SWF files containing SOI/EOI as data start */
495  /* files created by swink have reversed tag */
496  pkt->size -= 4;
497  memset(pkt->data+pkt->size, 0, 4);
498  res = avio_read(pb, pkt->data, pkt->size);
499  } else {
500  res = avio_read(pb, pkt->data + 4, pkt->size - 4);
501  if (res >= 0)
502  res += 4;
503  }
504  if (res != pkt->size) {
505  if (res < 0) {
506  return res;
507  }
508  av_shrink_packet(pkt, res);
509  }
510 
511  pkt->pos = pos;
512  pkt->stream_index = st->index;
513  return pkt->size;
514  } else {
515  av_log(s, AV_LOG_DEBUG, "Unknown tag: %d\n", tag);
516  }
517  skip:
518  if(len<0)
519  av_log(s, AV_LOG_WARNING, "Clipping len %d\n", len);
520  len = FFMAX(0, len);
521  avio_skip(pb, len);
522  }
523 }
524 
525 #if CONFIG_ZLIB
526 static av_cold int swf_read_close(AVFormatContext *avctx)
527 {
528  SWFContext *s = avctx->priv_data;
529  inflateEnd(&s->zstream);
530  av_freep(&s->zbuf_in);
531  av_freep(&s->zbuf_out);
532  avio_context_free(&s->zpb);
533  return 0;
534 }
535 #endif
536 
538  .name = "swf",
539  .long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
540  .priv_data_size = sizeof(SWFContext),
544 #if CONFIG_ZLIB
545  .read_close = swf_read_close,
546 #endif
547 };
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:537
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:177
static int swf_read_header(AVFormatContext *s)
Definition: swfdec.c:133
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 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:203
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