d34d3d90dff46038c96d733429a23c72e7a75635
[ffmpeg.git] / libavformat / swfdec.c
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 "libavutil/avassert.h"
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/imgutils.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavcodec/get_bits.h"
28 #include "swf.h"
29
30 static const AVCodecTag swf_audio_codec_tags[] = {
31     { AV_CODEC_ID_PCM_S16LE,  0x00 },
32     { AV_CODEC_ID_ADPCM_SWF,  0x01 },
33     { AV_CODEC_ID_MP3,        0x02 },
34     { AV_CODEC_ID_PCM_S16LE,  0x03 },
35 //  { AV_CODEC_ID_NELLYMOSER, 0x06 },
36     { AV_CODEC_ID_NONE,          0 },
37 };
38
39 static int get_swf_tag(AVIOContext *pb, int *len_ptr)
40 {
41     int tag, len;
42
43     if (avio_feof(pb))
44         return AVERROR_EOF;
45
46     tag = avio_rl16(pb);
47     len = tag & 0x3f;
48     tag = tag >> 6;
49     if (len == 0x3f) {
50         len = avio_rl32(pb);
51     }
52     *len_ptr = len;
53     return tag;
54 }
55
56
57 static int swf_probe(AVProbeData *p)
58 {
59     GetBitContext gb;
60     int len, xmin, xmax, ymin, ymax;
61
62     if(p->buf_size < 15)
63         return 0;
64
65     /* check file header */
66     if (   AV_RB24(p->buf) != AV_RB24("CWS")
67         && AV_RB24(p->buf) != AV_RB24("FWS"))
68         return 0;
69
70     init_get_bits8(&gb, p->buf + 3, p->buf_size - 3);
71
72     skip_bits(&gb, 40);
73     len = get_bits(&gb, 5);
74     if (!len)
75         return 0;
76     xmin = get_bits_long(&gb, len);
77     xmax = get_bits_long(&gb, len);
78     ymin = get_bits_long(&gb, len);
79     ymax = get_bits_long(&gb, len);
80     if (xmin || ymin || !xmax || !ymax)
81         return 0;
82
83     if (p->buf[3] >= 20 || xmax < 16 || ymax < 16)
84         return AVPROBE_SCORE_MAX / 4;
85
86     return AVPROBE_SCORE_MAX;
87 }
88
89 #if CONFIG_ZLIB
90 static int zlib_refill(void *opaque, uint8_t *buf, int buf_size)
91 {
92     AVFormatContext *s = opaque;
93     SWFContext *swf = s->priv_data;
94     z_stream *z = &swf->zstream;
95     int ret;
96
97 retry:
98     if (!z->avail_in) {
99         int n = avio_read(s->pb, swf->zbuf_in, ZBUF_SIZE);
100         if (n < 0)
101             return n;
102         z->next_in  = swf->zbuf_in;
103         z->avail_in = n;
104     }
105
106     z->next_out  = buf;
107     z->avail_out = buf_size;
108
109     ret = inflate(z, Z_NO_FLUSH);
110     if (ret < 0)
111         return AVERROR(EINVAL);
112     if (ret == Z_STREAM_END)
113         return AVERROR_EOF;
114
115     if (buf_size - z->avail_out == 0)
116         goto retry;
117
118     return buf_size - z->avail_out;
119 }
120 #endif
121
122 static int swf_read_header(AVFormatContext *s)
123 {
124     SWFContext *swf = s->priv_data;
125     AVIOContext *pb = s->pb;
126     int nbits, len, tag;
127
128     tag = avio_rb32(pb) & 0xffffff00;
129     avio_rl32(pb);
130
131     if (tag == MKBETAG('C', 'W', 'S', 0)) {
132         av_log(s, AV_LOG_INFO, "SWF compressed file detected\n");
133 #if CONFIG_ZLIB
134         swf->zbuf_in  = av_malloc(ZBUF_SIZE);
135         swf->zbuf_out = av_malloc(ZBUF_SIZE);
136         swf->zpb = avio_alloc_context(swf->zbuf_out, ZBUF_SIZE, 0, s,
137                                       zlib_refill, NULL, NULL);
138         if (!swf->zbuf_in || !swf->zbuf_out || !swf->zpb)
139             return AVERROR(ENOMEM);
140         swf->zpb->seekable = 0;
141         if (inflateInit(&swf->zstream) != Z_OK) {
142             av_log(s, AV_LOG_ERROR, "Unable to init zlib context\n");
143             return AVERROR(EINVAL);
144         }
145         pb = swf->zpb;
146 #else
147         av_log(s, AV_LOG_ERROR, "zlib support is required to read SWF compressed files\n");
148         return AVERROR(EIO);
149 #endif
150     } else if (tag != MKBETAG('F', 'W', 'S', 0))
151         return AVERROR(EIO);
152     /* skip rectangle size */
153     nbits = avio_r8(pb) >> 3;
154     len = (4 * nbits - 3 + 7) / 8;
155     avio_skip(pb, len);
156     swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */
157     avio_rl16(pb); /* frame count */
158
159     swf->samples_per_frame = 0;
160     s->ctx_flags |= AVFMTCTX_NOHEADER;
161     return 0;
162 }
163
164 static AVStream *create_new_audio_stream(AVFormatContext *s, int id, int info)
165 {
166     int sample_rate_code, sample_size_code;
167     AVStream *ast = avformat_new_stream(s, NULL);
168     if (!ast)
169         return NULL;
170     ast->id = id;
171     if (info & 1) {
172         ast->codec->channels       = 2;
173         ast->codec->channel_layout = AV_CH_LAYOUT_STEREO;
174     } else {
175         ast->codec->channels       = 1;
176         ast->codec->channel_layout = AV_CH_LAYOUT_MONO;
177     }
178     ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
179     ast->codec->codec_id   = ff_codec_get_id(swf_audio_codec_tags, info>>4 & 15);
180     ast->need_parsing = AVSTREAM_PARSE_FULL;
181     sample_rate_code = info>>2 & 3;
182     sample_size_code = info>>1 & 1;
183     if (!sample_size_code && ast->codec->codec_id == AV_CODEC_ID_PCM_S16LE)
184         ast->codec->codec_id = AV_CODEC_ID_PCM_U8;
185     ast->codec->sample_rate = 44100 >> (3 - sample_rate_code);
186     avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
187     return ast;
188 }
189
190 static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
191 {
192     SWFContext *swf = s->priv_data;
193     AVIOContext *pb = s->pb;
194     AVStream *vst = NULL, *ast = NULL, *st = 0;
195     int tag, len, i, frame, v, res;
196
197 #if CONFIG_ZLIB
198     if (swf->zpb)
199         pb = swf->zpb;
200 #endif
201
202     for(;;) {
203         uint64_t pos = avio_tell(pb);
204         tag = get_swf_tag(pb, &len);
205         if (tag < 0)
206             return tag;
207         if (len < 0) {
208             av_log(s, AV_LOG_ERROR, "invalid tag length: %d\n", len);
209             return AVERROR_INVALIDDATA;
210         }
211         if (tag == TAG_VIDEOSTREAM) {
212             int ch_id = avio_rl16(pb);
213             len -= 2;
214
215             for (i=0; i<s->nb_streams; i++) {
216                 st = s->streams[i];
217                 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)
218                     goto skip;
219             }
220
221             avio_rl16(pb);
222             avio_rl16(pb);
223             avio_rl16(pb);
224             avio_r8(pb);
225             /* Check for FLV1 */
226             vst = avformat_new_stream(s, NULL);
227             if (!vst)
228                 return AVERROR(ENOMEM);
229             vst->id = ch_id;
230             vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
231             vst->codec->codec_id = ff_codec_get_id(ff_swf_codec_tags, avio_r8(pb));
232             avpriv_set_pts_info(vst, 16, 256, swf->frame_rate);
233             len -= 8;
234         } else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
235             /* streaming found */
236
237             for (i=0; i<s->nb_streams; i++) {
238                 st = s->streams[i];
239                 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
240                     goto skip;
241             }
242
243             avio_r8(pb);
244             v = avio_r8(pb);
245             swf->samples_per_frame = avio_rl16(pb);
246             ast = create_new_audio_stream(s, -1, v); /* -1 to avoid clash with video stream ch_id */
247             if (!ast)
248                 return AVERROR(ENOMEM);
249             len -= 4;
250         } else if (tag == TAG_DEFINESOUND) {
251             /* audio stream */
252             int ch_id = avio_rl16(pb);
253
254             for (i=0; i<s->nb_streams; i++) {
255                 st = s->streams[i];
256                 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == ch_id)
257                     goto skip;
258             }
259
260             // FIXME: The entire audio stream is stored in a single chunk/tag. Normally,
261             // these are smaller audio streams in DEFINESOUND tags, but it's technically
262             // possible they could be huge. Break it up into multiple packets if it's big.
263             v = avio_r8(pb);
264             ast = create_new_audio_stream(s, ch_id, v);
265             if (!ast)
266                 return AVERROR(ENOMEM);
267             ast->duration = avio_rl32(pb); // number of samples
268             if (((v>>4) & 15) == 2) { // MP3 sound data record
269                 ast->skip_samples = avio_rl16(pb);
270                 len -= 2;
271             }
272             len -= 7;
273             if ((res = av_get_packet(pb, pkt, len)) < 0)
274                 return res;
275             pkt->pos = pos;
276             pkt->stream_index = ast->index;
277             return pkt->size;
278         } else if (tag == TAG_VIDEOFRAME) {
279             int ch_id = avio_rl16(pb);
280             len -= 2;
281             for(i=0; i<s->nb_streams; i++) {
282                 st = s->streams[i];
283                 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
284                     frame = avio_rl16(pb);
285                     len -= 2;
286                     if (len <= 0)
287                         goto skip;
288                     if ((res = av_get_packet(pb, pkt, len)) < 0)
289                         return res;
290                     pkt->pos = pos;
291                     pkt->pts = frame;
292                     pkt->stream_index = st->index;
293                     return pkt->size;
294                 }
295             }
296         } else if (tag == TAG_DEFINEBITSLOSSLESS || tag == TAG_DEFINEBITSLOSSLESS2) {
297 #if CONFIG_ZLIB
298             long out_len;
299             uint8_t *buf = NULL, *zbuf = NULL, *pal;
300             uint32_t colormap[AVPALETTE_COUNT] = {0};
301             const int alpha_bmp = tag == TAG_DEFINEBITSLOSSLESS2;
302             const int colormapbpp = 3 + alpha_bmp;
303             int linesize, colormapsize = 0;
304
305             const int ch_id   = avio_rl16(pb);
306             const int bmp_fmt = avio_r8(pb);
307             const int width   = avio_rl16(pb);
308             const int height  = avio_rl16(pb);
309             int pix_fmt;
310
311             len -= 2+1+2+2;
312
313             switch (bmp_fmt) {
314             case 3: // PAL-8
315                 linesize = width;
316                 colormapsize = avio_r8(pb) + 1;
317                 len--;
318                 break;
319             case 4: // RGB15
320                 linesize = width * 2;
321                 break;
322             case 5: // RGB24 (0RGB)
323                 linesize = width * 4;
324                 break;
325             default:
326                 av_log(s, AV_LOG_ERROR, "invalid bitmap format %d, skipped\n", bmp_fmt);
327                 goto bitmap_end_skip;
328             }
329
330             linesize = FFALIGN(linesize, 4);
331
332             if (av_image_check_size(width, height, 0, s) < 0 ||
333                 linesize >= INT_MAX / height ||
334                 linesize * height >= INT_MAX - colormapsize * colormapbpp) {
335                 av_log(s, AV_LOG_ERROR, "invalid frame size %dx%d\n", width, height);
336                 goto bitmap_end_skip;
337             }
338
339             out_len = colormapsize * colormapbpp + linesize * height;
340
341             av_dlog(s, "bitmap: ch=%d fmt=%d %dx%d (linesize=%d) len=%d->%ld pal=%d\n",
342                     ch_id, bmp_fmt, width, height, linesize, len, out_len, colormapsize);
343
344             zbuf = av_malloc(len);
345             buf  = av_malloc(out_len);
346             if (!zbuf || !buf) {
347                 res = AVERROR(ENOMEM);
348                 goto bitmap_end;
349             }
350
351             len = avio_read(pb, zbuf, len);
352             if (len < 0 || (res = uncompress(buf, &out_len, zbuf, len)) != Z_OK) {
353                 av_log(s, AV_LOG_WARNING, "Failed to uncompress one bitmap\n");
354                 goto bitmap_end_skip;
355             }
356
357             for (i = 0; i < s->nb_streams; i++) {
358                 st = s->streams[i];
359                 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && st->id == -3)
360                     break;
361             }
362             if (i == s->nb_streams) {
363                 vst = avformat_new_stream(s, NULL);
364                 if (!vst) {
365                     res = AVERROR(ENOMEM);
366                     goto bitmap_end;
367                 }
368                 vst->id = -3; /* -3 to avoid clash with video stream and audio stream */
369                 vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
370                 vst->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
371                 avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
372                 st = vst;
373             }
374
375             if ((res = av_new_packet(pkt, out_len - colormapsize * colormapbpp)) < 0)
376                 goto bitmap_end;
377             if (!st->codec->width && !st->codec->height) {
378                 st->codec->width  = width;
379                 st->codec->height = height;
380             } else {
381                 ff_add_param_change(pkt, 0, 0, 0, width, height);
382             }
383             pkt->pos = pos;
384             pkt->stream_index = st->index;
385
386             switch (bmp_fmt) {
387             case 3:
388                 pix_fmt = AV_PIX_FMT_PAL8;
389                 for (i = 0; i < colormapsize; i++)
390                     if (alpha_bmp)  colormap[i] = buf[3]<<24 | AV_RB24(buf + 4*i);
391                     else            colormap[i] = 0xffU <<24 | AV_RB24(buf + 3*i);
392                 pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
393                 if (!pal) {
394                     res = AVERROR(ENOMEM);
395                     goto bitmap_end;
396                 }
397                 memcpy(pal, colormap, AVPALETTE_SIZE);
398                 break;
399             case 4:
400                 pix_fmt = AV_PIX_FMT_RGB555;
401                 break;
402             case 5:
403                 pix_fmt = alpha_bmp ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;
404                 break;
405             default:
406                 av_assert0(0);
407             }
408             if (st->codec->pix_fmt != AV_PIX_FMT_NONE && st->codec->pix_fmt != pix_fmt) {
409                 av_log(s, AV_LOG_ERROR, "pixel format change unsupported\n");
410                 res = AVERROR_PATCHWELCOME;
411                 goto bitmap_end;
412             }
413             st->codec->pix_fmt = pix_fmt;
414
415             if (linesize * height > pkt->size) {
416                 res = AVERROR_INVALIDDATA;
417                 goto bitmap_end;
418             }
419             memcpy(pkt->data, buf + colormapsize*colormapbpp, linesize * height);
420
421             res = pkt->size;
422
423 bitmap_end:
424             av_freep(&zbuf);
425             av_freep(&buf);
426             return res;
427 bitmap_end_skip:
428             av_freep(&zbuf);
429             av_freep(&buf);
430 #else
431             av_log(s, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
432 #endif
433         } else if (tag == TAG_STREAMBLOCK) {
434             for (i = 0; i < s->nb_streams; i++) {
435                 st = s->streams[i];
436                 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
437                     if (st->codec->codec_id == AV_CODEC_ID_MP3) {
438                         avio_skip(pb, 4);
439                         len -= 4;
440                         if (len <= 0)
441                             goto skip;
442                         if ((res = av_get_packet(pb, pkt, len)) < 0)
443                             return res;
444                     } else { // ADPCM, PCM
445                         if (len <= 0)
446                             goto skip;
447                         if ((res = av_get_packet(pb, pkt, len)) < 0)
448                             return res;
449                     }
450                     pkt->pos          = pos;
451                     pkt->stream_index = st->index;
452                     return pkt->size;
453                 }
454             }
455         } else if (tag == TAG_JPEG2) {
456             for (i=0; i<s->nb_streams; i++) {
457                 st = s->streams[i];
458                 if (st->codec->codec_id == AV_CODEC_ID_MJPEG && st->id == -2)
459                     break;
460             }
461             if (i == s->nb_streams) {
462                 vst = avformat_new_stream(s, NULL);
463                 if (!vst)
464                     return AVERROR(ENOMEM);
465                 vst->id = -2; /* -2 to avoid clash with video stream and audio stream */
466                 vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
467                 vst->codec->codec_id = AV_CODEC_ID_MJPEG;
468                 avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
469                 st = vst;
470             }
471             avio_rl16(pb); /* BITMAP_ID */
472             len -= 2;
473             if (len < 4)
474                 goto skip;
475             if ((res = av_new_packet(pkt, len)) < 0)
476                 return res;
477             if (avio_read(pb, pkt->data, 4) != 4) {
478                 av_free_packet(pkt);
479                 return AVERROR_INVALIDDATA;
480             }
481             if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
482                 AV_RB32(pkt->data) == 0xffd9ffd8) {
483                 /* old SWF files containing SOI/EOI as data start */
484                 /* files created by swink have reversed tag */
485                 pkt->size -= 4;
486                 memset(pkt->data+pkt->size, 0, 4);
487                 res = avio_read(pb, pkt->data, pkt->size);
488             } else {
489                 res = avio_read(pb, pkt->data + 4, pkt->size - 4);
490                 if (res >= 0)
491                     res += 4;
492             }
493             if (res != pkt->size) {
494                 if (res < 0) {
495                     av_free_packet(pkt);
496                     return res;
497                 }
498                 av_shrink_packet(pkt, res);
499             }
500
501             pkt->pos = pos;
502             pkt->stream_index = st->index;
503             return pkt->size;
504         } else {
505             av_log(s, AV_LOG_DEBUG, "Unknown tag: %d\n", tag);
506         }
507     skip:
508         if(len<0)
509             av_log(s, AV_LOG_WARNING, "Cliping len %d\n", len);
510         len = FFMAX(0, len);
511         avio_skip(pb, len);
512     }
513 }
514
515 #if CONFIG_ZLIB
516 static av_cold int swf_read_close(AVFormatContext *avctx)
517 {
518     SWFContext *s = avctx->priv_data;
519     inflateEnd(&s->zstream);
520     av_freep(&s->zbuf_in);
521     av_freep(&s->zbuf_out);
522     av_freep(&s->zpb);
523     return 0;
524 }
525 #endif
526
527 AVInputFormat ff_swf_demuxer = {
528     .name           = "swf",
529     .long_name      = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
530     .priv_data_size = sizeof(SWFContext),
531     .read_probe     = swf_probe,
532     .read_header    = swf_read_header,
533     .read_packet    = swf_read_packet,
534 #if CONFIG_ZLIB
535     .read_close     = swf_read_close,
536 #endif
537 };