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  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 
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, "Clipping 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  avio_context_free(&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
#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:3131
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:1497
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:4892
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
int size
Definition: avcodec.h:1478
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:4023
#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:4465
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:1477
uint32_t tag
Definition: movenc.c:1496
#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:4059
#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
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVInputFormat ff_swf_demuxer
Definition: swfdec.c:539
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1190
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:565
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
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:5024
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:176
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:197
#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:4067
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: swfdec.c:202
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:4063
#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:1479
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:1454
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
Definition: swf.h:62