use ch_id as AVStream id and simplify
[ffmpeg.git] / libavformat / swf.c
1 /*
2  * Flash Compatible Streaming Format
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 #include "avformat.h"
23 #include "bitstream.h"
24 #include "riff.h"    /* for CodecTag */
25
26 /* should have a generic way to indicate probable size */
27 #define DUMMY_FILE_SIZE   (100 * 1024 * 1024)
28 #define DUMMY_DURATION    600 /* in seconds */
29
30 #define TAG_END           0
31 #define TAG_SHOWFRAME     1
32 #define TAG_DEFINESHAPE   2
33 #define TAG_FREECHARACTER 3
34 #define TAG_PLACEOBJECT   4
35 #define TAG_REMOVEOBJECT  5
36 #define TAG_STREAMHEAD    18
37 #define TAG_STREAMBLOCK   19
38 #define TAG_JPEG2         21
39 #define TAG_PLACEOBJECT2  26
40 #define TAG_STREAMHEAD2   45
41 #define TAG_VIDEOSTREAM   60
42 #define TAG_VIDEOFRAME    61
43
44 #define TAG_LONG         0x100
45
46 /* flags for shape definition */
47 #define FLAG_MOVETO      0x01
48 #define FLAG_SETFILL0    0x02
49 #define FLAG_SETFILL1    0x04
50
51 #define AUDIO_FIFO_SIZE 65536
52
53 /* character id used */
54 #define BITMAP_ID 0
55 #define VIDEO_ID 0
56 #define SHAPE_ID  1
57
58 #undef NDEBUG
59 #include <assert.h>
60
61 typedef struct {
62
63     offset_t duration_pos;
64     offset_t tag_pos;
65
66     int samples_per_frame;
67     int sound_samples;
68     int video_samples;
69     int swf_frame_number;
70     int video_frame_number;
71     int ms_per_frame;
72     int tag;
73
74     uint8_t *audio_fifo;
75     int audio_in_pos;
76     int audio_out_pos;
77     int audio_size;
78
79     int video_type;
80     int audio_type;
81 } SWFContext;
82
83 static const CodecTag swf_codec_tags[] = {
84     {CODEC_ID_FLV1, 0x02},
85     {CODEC_ID_VP6F, 0x04},
86     {0, 0},
87 };
88
89 static const int sSampleRates[3][4] = {
90     {44100, 48000, 32000, 0},
91     {22050, 24000, 16000, 0},
92     {11025, 12000,  8000, 0},
93 };
94
95 static const int sBitRates[2][3][15] = {
96     {   {  0, 32, 64, 96,128,160,192,224,256,288,320,352,384,416,448},
97         {  0, 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384},
98         {  0, 32, 40, 48, 56, 64, 80, 96,112,128,160,192,224,256,320}
99     },
100     {   {  0, 32, 48, 56, 64, 80, 96,112,128,144,160,176,192,224,256},
101         {  0,  8, 16, 24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160},
102         {  0,  8, 16, 24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160}
103     },
104 };
105
106 static const int sSamplesPerFrame[3][3] =
107 {
108     {  384,     1152,    1152 },
109     {  384,     1152,     576 },
110     {  384,     1152,     576 }
111 };
112
113 static const int sBitsPerSlot[3] = {
114     32,
115     8,
116     8
117 };
118
119 static int swf_mp3_info(void *data, int *byteSize, int *samplesPerFrame, int *sampleRate, int *isMono )
120 {
121     uint8_t *dataTmp = (uint8_t *)data;
122     uint32_t header = ( (uint32_t)dataTmp[0] << 24 ) | ( (uint32_t)dataTmp[1] << 16 ) | ( (uint32_t)dataTmp[2] << 8 ) | (uint32_t)dataTmp[3];
123     int layerID = 3 - ((header >> 17) & 0x03);
124     int bitRateID = ((header >> 12) & 0x0f);
125     int sampleRateID = ((header >> 10) & 0x03);
126     int bitRate = 0;
127     int bitsPerSlot = sBitsPerSlot[layerID];
128     int isPadded = ((header >> 9) & 0x01);
129
130     if ( (( header >> 21 ) & 0x7ff) != 0x7ff ) {
131         return 0;
132     }
133
134     *isMono = ((header >>  6) & 0x03) == 0x03;
135
136     if ( (header >> 19 ) & 0x01 ) {
137         *sampleRate = sSampleRates[0][sampleRateID];
138         bitRate = sBitRates[0][layerID][bitRateID] * 1000;
139         *samplesPerFrame = sSamplesPerFrame[0][layerID];
140     } else {
141         if ( (header >> 20) & 0x01 ) {
142             *sampleRate = sSampleRates[1][sampleRateID];
143             bitRate = sBitRates[1][layerID][bitRateID] * 1000;
144             *samplesPerFrame = sSamplesPerFrame[1][layerID];
145         } else {
146             *sampleRate = sSampleRates[2][sampleRateID];
147             bitRate = sBitRates[1][layerID][bitRateID] * 1000;
148             *samplesPerFrame = sSamplesPerFrame[2][layerID];
149         }
150     }
151
152     *byteSize = ( ( ( ( *samplesPerFrame * (bitRate / bitsPerSlot) ) / *sampleRate ) + isPadded ) );
153
154     return 1;
155 }
156
157 #ifdef CONFIG_MUXERS
158 static void put_swf_tag(AVFormatContext *s, int tag)
159 {
160     SWFContext *swf = s->priv_data;
161     ByteIOContext *pb = &s->pb;
162
163     swf->tag_pos = url_ftell(pb);
164     swf->tag = tag;
165     /* reserve some room for the tag */
166     if (tag & TAG_LONG) {
167         put_le16(pb, 0);
168         put_le32(pb, 0);
169     } else {
170         put_le16(pb, 0);
171     }
172 }
173
174 static void put_swf_end_tag(AVFormatContext *s)
175 {
176     SWFContext *swf = s->priv_data;
177     ByteIOContext *pb = &s->pb;
178     offset_t pos;
179     int tag_len, tag;
180
181     pos = url_ftell(pb);
182     tag_len = pos - swf->tag_pos - 2;
183     tag = swf->tag;
184     url_fseek(pb, swf->tag_pos, SEEK_SET);
185     if (tag & TAG_LONG) {
186         tag &= ~TAG_LONG;
187         put_le16(pb, (tag << 6) | 0x3f);
188         put_le32(pb, tag_len - 4);
189     } else {
190         assert(tag_len < 0x3f);
191         put_le16(pb, (tag << 6) | tag_len);
192     }
193     url_fseek(pb, pos, SEEK_SET);
194 }
195
196 static inline void max_nbits(int *nbits_ptr, int val)
197 {
198     int n;
199
200     if (val == 0)
201         return;
202     val = abs(val);
203     n = 1;
204     while (val != 0) {
205         n++;
206         val >>= 1;
207     }
208     if (n > *nbits_ptr)
209         *nbits_ptr = n;
210 }
211
212 static void put_swf_rect(ByteIOContext *pb,
213                          int xmin, int xmax, int ymin, int ymax)
214 {
215     PutBitContext p;
216     uint8_t buf[256];
217     int nbits, mask;
218
219     init_put_bits(&p, buf, sizeof(buf));
220
221     nbits = 0;
222     max_nbits(&nbits, xmin);
223     max_nbits(&nbits, xmax);
224     max_nbits(&nbits, ymin);
225     max_nbits(&nbits, ymax);
226     mask = (1 << nbits) - 1;
227
228     /* rectangle info */
229     put_bits(&p, 5, nbits);
230     put_bits(&p, nbits, xmin & mask);
231     put_bits(&p, nbits, xmax & mask);
232     put_bits(&p, nbits, ymin & mask);
233     put_bits(&p, nbits, ymax & mask);
234
235     flush_put_bits(&p);
236     put_buffer(pb, buf, pbBufPtr(&p) - p.buf);
237 }
238
239 static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)
240 {
241     int nbits, mask;
242
243     put_bits(pb, 1, 1); /* edge */
244     put_bits(pb, 1, 1); /* line select */
245     nbits = 2;
246     max_nbits(&nbits, dx);
247     max_nbits(&nbits, dy);
248
249     mask = (1 << nbits) - 1;
250     put_bits(pb, 4, nbits - 2); /* 16 bits precision */
251     if (dx == 0) {
252       put_bits(pb, 1, 0);
253       put_bits(pb, 1, 1);
254       put_bits(pb, nbits, dy & mask);
255     } else if (dy == 0) {
256       put_bits(pb, 1, 0);
257       put_bits(pb, 1, 0);
258       put_bits(pb, nbits, dx & mask);
259     } else {
260       put_bits(pb, 1, 1);
261       put_bits(pb, nbits, dx & mask);
262       put_bits(pb, nbits, dy & mask);
263     }
264 }
265
266 #define FRAC_BITS 16
267
268 /* put matrix */
269 static void put_swf_matrix(ByteIOContext *pb,
270                            int a, int b, int c, int d, int tx, int ty)
271 {
272     PutBitContext p;
273     uint8_t buf[256];
274     int nbits;
275
276     init_put_bits(&p, buf, sizeof(buf));
277
278     put_bits(&p, 1, 1); /* a, d present */
279     nbits = 1;
280     max_nbits(&nbits, a);
281     max_nbits(&nbits, d);
282     put_bits(&p, 5, nbits); /* nb bits */
283     put_bits(&p, nbits, a);
284     put_bits(&p, nbits, d);
285
286     put_bits(&p, 1, 1); /* b, c present */
287     nbits = 1;
288     max_nbits(&nbits, c);
289     max_nbits(&nbits, b);
290     put_bits(&p, 5, nbits); /* nb bits */
291     put_bits(&p, nbits, c);
292     put_bits(&p, nbits, b);
293
294     nbits = 1;
295     max_nbits(&nbits, tx);
296     max_nbits(&nbits, ty);
297     put_bits(&p, 5, nbits); /* nb bits */
298     put_bits(&p, nbits, tx);
299     put_bits(&p, nbits, ty);
300
301     flush_put_bits(&p);
302     put_buffer(pb, buf, pbBufPtr(&p) - p.buf);
303 }
304
305 /* */
306 static int swf_write_header(AVFormatContext *s)
307 {
308     SWFContext *swf = s->priv_data;
309     ByteIOContext *pb = &s->pb;
310     AVCodecContext *enc, *audio_enc, *video_enc;
311     PutBitContext p;
312     uint8_t buf1[256];
313     int i, width, height, rate, rate_base;
314
315     swf->audio_in_pos = 0;
316     swf->audio_out_pos = 0;
317     swf->audio_size = 0;
318     swf->audio_fifo = av_malloc(AUDIO_FIFO_SIZE);
319     swf->sound_samples = 0;
320     swf->video_samples = 0;
321     swf->swf_frame_number = 0;
322     swf->video_frame_number = 0;
323
324     video_enc = NULL;
325     audio_enc = NULL;
326     for(i=0;i<s->nb_streams;i++) {
327         enc = s->streams[i]->codec;
328         if (enc->codec_type == CODEC_TYPE_AUDIO)
329             audio_enc = enc;
330         else {
331             if ( enc->codec_id == CODEC_ID_VP6F ||
332                  enc->codec_id == CODEC_ID_FLV1 ||
333                  enc->codec_id == CODEC_ID_MJPEG ) {
334                 video_enc = enc;
335             } else {
336                 av_log(enc, AV_LOG_ERROR, "SWF only supports VP6, FLV1 and MJPEG\n");
337                 return -1;
338             }
339         }
340     }
341
342     if (!video_enc) {
343         /* currenty, cannot work correctly if audio only */
344         swf->video_type = 0;
345         width = 320;
346         height = 200;
347         rate = 10;
348         rate_base= 1;
349     } else {
350         swf->video_type = video_enc->codec_id;
351         width = video_enc->width;
352         height = video_enc->height;
353         rate = video_enc->time_base.den;
354         rate_base = video_enc->time_base.num;
355     }
356
357     if (!audio_enc ) {
358         swf->audio_type = 0;
359         swf->samples_per_frame = ( 44100. * rate_base ) / rate;
360     } else {
361         swf->audio_type = audio_enc->codec_id;
362         swf->samples_per_frame = ( ( audio_enc->sample_rate ) * rate_base ) / rate;
363     }
364
365     put_tag(pb, "FWS");
366     if ( video_enc && video_enc->codec_id == CODEC_ID_VP6F ) {
367         put_byte(pb, 8); /* version (version 8 and above support VP6 codec) */
368     } else if ( video_enc && video_enc->codec_id == CODEC_ID_FLV1 ) {
369         put_byte(pb, 6); /* version (version 6 and above support FLV1 codec) */
370     } else {
371         put_byte(pb, 4); /* version (should use 4 for mpeg audio support) */
372     }
373     put_le32(pb, DUMMY_FILE_SIZE); /* dummy size
374                                       (will be patched if not streamed) */
375
376     put_swf_rect(pb, 0, width * 20, 0, height * 20);
377     put_le16(pb, (rate * 256) / rate_base); /* frame rate */
378     swf->duration_pos = url_ftell(pb);
379     put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
380
381     /* define a shape with the jpeg inside */
382     if ( video_enc && (video_enc->codec_id == CODEC_ID_VP6F ||
383                        video_enc->codec_id == CODEC_ID_FLV1 )) {
384     } else if ( video_enc && video_enc->codec_id == CODEC_ID_MJPEG ) {
385         put_swf_tag(s, TAG_DEFINESHAPE);
386
387         put_le16(pb, SHAPE_ID); /* ID of shape */
388         /* bounding rectangle */
389         put_swf_rect(pb, 0, width, 0, height);
390         /* style info */
391         put_byte(pb, 1); /* one fill style */
392         put_byte(pb, 0x41); /* clipped bitmap fill */
393         put_le16(pb, BITMAP_ID); /* bitmap ID */
394         /* position of the bitmap */
395         put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0,
396                         0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0);
397         put_byte(pb, 0); /* no line style */
398
399         /* shape drawing */
400         init_put_bits(&p, buf1, sizeof(buf1));
401         put_bits(&p, 4, 1); /* one fill bit */
402         put_bits(&p, 4, 0); /* zero line bit */
403
404         put_bits(&p, 1, 0); /* not an edge */
405         put_bits(&p, 5, FLAG_MOVETO | FLAG_SETFILL0);
406         put_bits(&p, 5, 1); /* nbits */
407         put_bits(&p, 1, 0); /* X */
408         put_bits(&p, 1, 0); /* Y */
409         put_bits(&p, 1, 1); /* set fill style 1 */
410
411         /* draw the rectangle ! */
412         put_swf_line_edge(&p, width, 0);
413         put_swf_line_edge(&p, 0, height);
414         put_swf_line_edge(&p, -width, 0);
415         put_swf_line_edge(&p, 0, -height);
416
417         /* end of shape */
418         put_bits(&p, 1, 0); /* not an edge */
419         put_bits(&p, 5, 0);
420
421         flush_put_bits(&p);
422         put_buffer(pb, buf1, pbBufPtr(&p) - p.buf);
423
424         put_swf_end_tag(s);
425     }
426
427     if (audio_enc && audio_enc->codec_id == CODEC_ID_MP3 ) {
428         int v;
429
430         /* start sound */
431         put_swf_tag(s, TAG_STREAMHEAD2);
432
433         v = 0;
434         switch(audio_enc->sample_rate) {
435         case 11025:
436             v |= 1 << 2;
437             break;
438         case 22050:
439             v |= 2 << 2;
440             break;
441         case 44100:
442             v |= 3 << 2;
443             break;
444         default:
445             /* not supported */
446             av_log(s, AV_LOG_ERROR, "swf doesnt support that sample rate, choose from (44100, 22050, 11025)\n");
447             av_free(swf->audio_fifo);
448             return -1;
449         }
450         v |= 0x02; /* 16 bit playback */
451         if (audio_enc->channels == 2)
452             v |= 0x01; /* stereo playback */
453         put_byte(&s->pb, v);
454         v |= 0x20; /* mp3 compressed */
455         put_byte(&s->pb, v);
456         put_le16(&s->pb, swf->samples_per_frame);  /* avg samples per frame */
457         put_le16(&s->pb, 0);
458
459         put_swf_end_tag(s);
460     }
461
462     put_flush_packet(&s->pb);
463     return 0;
464 }
465
466 static int swf_write_video(AVFormatContext *s,
467                            AVCodecContext *enc, const uint8_t *buf, int size)
468 {
469     SWFContext *swf = s->priv_data;
470     ByteIOContext *pb = &s->pb;
471     int c = 0;
472     int outSize = 0;
473     int outSamples = 0;
474
475     /* Flash Player limit */
476     if ( swf->swf_frame_number == 16000 ) {
477         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
478     }
479
480     if ( swf->audio_type ) {
481         /* Prescan audio data for this swf frame */
482 retry_swf_audio_packet:
483         if ( ( swf->audio_size-outSize ) >= 4 ) {
484             int mp3FrameSize = 0;
485             int mp3SampleRate = 0;
486             int mp3IsMono = 0;
487             int mp3SamplesPerFrame = 0;
488
489             /* copy out mp3 header from ring buffer */
490             uint8_t header[4];
491             for (c=0; c<4; c++) {
492                 header[c] = swf->audio_fifo[(swf->audio_in_pos+outSize+c) % AUDIO_FIFO_SIZE];
493             }
494
495             if ( swf_mp3_info(header,&mp3FrameSize,&mp3SamplesPerFrame,&mp3SampleRate,&mp3IsMono) ) {
496                 if ( ( swf->audio_size-outSize ) >= mp3FrameSize ) {
497                     outSize += mp3FrameSize;
498                     outSamples += mp3SamplesPerFrame;
499                     if ( ( swf->sound_samples + outSamples + swf->samples_per_frame ) < swf->video_samples ) {
500                         goto retry_swf_audio_packet;
501                     }
502                 }
503             } else {
504                 /* invalid mp3 data, skip forward
505                 we need to do this since the Flash Player
506                 does not like custom headers */
507                 swf->audio_in_pos ++;
508                 swf->audio_size --;
509                 swf->audio_in_pos %= AUDIO_FIFO_SIZE;
510                 goto retry_swf_audio_packet;
511             }
512         }
513
514         /* audio stream is behind video stream, bail */
515         if ( ( swf->sound_samples + outSamples + swf->samples_per_frame ) < swf->video_samples ) {
516             return 0;
517         }
518     }
519
520             if ( swf->video_type == CODEC_ID_VP6F ||
521                  swf->video_type == CODEC_ID_FLV1 ) {
522                 if ( swf->video_frame_number == 0 ) {
523                     /* create a new video object */
524                     put_swf_tag(s, TAG_VIDEOSTREAM);
525                     put_le16(pb, VIDEO_ID);
526                     put_le16(pb, 15000 ); /* hard flash player limit */
527                     put_le16(pb, enc->width);
528                     put_le16(pb, enc->height);
529                     put_byte(pb, 0);
530                     put_byte(pb,codec_get_tag(swf_codec_tags,swf->video_type));
531                     put_swf_end_tag(s);
532
533                     /* place the video object for the first time */
534                     put_swf_tag(s, TAG_PLACEOBJECT2);
535                     put_byte(pb, 0x36);
536                     put_le16(pb, 1);
537                     put_le16(pb, VIDEO_ID);
538                     put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
539                     put_le16(pb, swf->video_frame_number );
540                     put_byte(pb, 'v');
541                     put_byte(pb, 'i');
542                     put_byte(pb, 'd');
543                     put_byte(pb, 'e');
544                     put_byte(pb, 'o');
545                     put_byte(pb, 0x00);
546                     put_swf_end_tag(s);
547                 } else {
548                     /* mark the character for update */
549                     put_swf_tag(s, TAG_PLACEOBJECT2);
550                     put_byte(pb, 0x11);
551                     put_le16(pb, 1);
552                     put_le16(pb, swf->video_frame_number );
553                     put_swf_end_tag(s);
554                 }
555
556                     /* set video frame data */
557                     put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);
558                     put_le16(pb, VIDEO_ID);
559                     put_le16(pb, swf->video_frame_number++ );
560                     put_buffer(pb, buf, size);
561                     put_swf_end_tag(s);
562             } else if ( swf->video_type == CODEC_ID_MJPEG ) {
563                 if (swf->swf_frame_number > 0) {
564                     /* remove the shape */
565                     put_swf_tag(s, TAG_REMOVEOBJECT);
566                     put_le16(pb, SHAPE_ID); /* shape ID */
567                     put_le16(pb, 1); /* depth */
568                     put_swf_end_tag(s);
569
570                     /* free the bitmap */
571                     put_swf_tag(s, TAG_FREECHARACTER);
572                     put_le16(pb, BITMAP_ID);
573                     put_swf_end_tag(s);
574                 }
575
576                 put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
577
578                 put_le16(pb, BITMAP_ID); /* ID of the image */
579
580                 /* a dummy jpeg header seems to be required */
581                 put_byte(pb, 0xff);
582                 put_byte(pb, 0xd8);
583                 put_byte(pb, 0xff);
584                 put_byte(pb, 0xd9);
585                 /* write the jpeg image */
586                 put_buffer(pb, buf, size);
587
588                 put_swf_end_tag(s);
589
590                 /* draw the shape */
591
592                 put_swf_tag(s, TAG_PLACEOBJECT);
593                 put_le16(pb, SHAPE_ID); /* shape ID */
594                 put_le16(pb, 1); /* depth */
595                 put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);
596                 put_swf_end_tag(s);
597             } else {
598                 /* invalid codec */
599             }
600
601             swf->swf_frame_number ++;
602
603     swf->video_samples += swf->samples_per_frame;
604
605     /* streaming sound always should be placed just before showframe tags */
606     if ( outSize > 0 ) {
607         put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
608         put_le16(pb, outSamples);
609         put_le16(pb, 0);
610         for (c=0; c<outSize; c++) {
611             put_byte(pb,swf->audio_fifo[(swf->audio_in_pos+c) % AUDIO_FIFO_SIZE]);
612         }
613         put_swf_end_tag(s);
614
615         /* update FIFO */
616         swf->sound_samples += outSamples;
617         swf->audio_in_pos += outSize;
618         swf->audio_size -= outSize;
619         swf->audio_in_pos %= AUDIO_FIFO_SIZE;
620     }
621
622     /* output the frame */
623     put_swf_tag(s, TAG_SHOWFRAME);
624     put_swf_end_tag(s);
625
626     put_flush_packet(&s->pb);
627
628     return 0;
629 }
630
631 static int swf_write_audio(AVFormatContext *s,
632                            AVCodecContext *enc, const uint8_t *buf, int size)
633 {
634     SWFContext *swf = s->priv_data;
635     int c = 0;
636
637     /* Flash Player limit */
638     if ( swf->swf_frame_number == 16000 ) {
639         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
640     }
641
642     if (enc->codec_id == CODEC_ID_MP3 ) {
643         for (c=0; c<size; c++) {
644             swf->audio_fifo[(swf->audio_out_pos+c)%AUDIO_FIFO_SIZE] = buf[c];
645         }
646         swf->audio_size += size;
647         swf->audio_out_pos += size;
648         swf->audio_out_pos %= AUDIO_FIFO_SIZE;
649     }
650
651     /* if audio only stream make sure we add swf frames */
652     if ( swf->video_type == 0 ) {
653         swf_write_video(s, enc, 0, 0);
654     }
655
656     return 0;
657 }
658
659 static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)
660 {
661     AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
662     if (codec->codec_type == CODEC_TYPE_AUDIO)
663         return swf_write_audio(s, codec, pkt->data, pkt->size);
664     else
665         return swf_write_video(s, codec, pkt->data, pkt->size);
666 }
667
668 static int swf_write_trailer(AVFormatContext *s)
669 {
670     SWFContext *swf = s->priv_data;
671     ByteIOContext *pb = &s->pb;
672     AVCodecContext *enc, *video_enc;
673     int file_size, i;
674
675     video_enc = NULL;
676     for(i=0;i<s->nb_streams;i++) {
677         enc = s->streams[i]->codec;
678         if (enc->codec_type == CODEC_TYPE_VIDEO)
679             video_enc = enc;
680     }
681
682     put_swf_tag(s, TAG_END);
683     put_swf_end_tag(s);
684
685     put_flush_packet(&s->pb);
686
687     /* patch file size and number of frames if not streamed */
688     if (!url_is_streamed(&s->pb) && video_enc) {
689         file_size = url_ftell(pb);
690         url_fseek(pb, 4, SEEK_SET);
691         put_le32(pb, file_size);
692         url_fseek(pb, swf->duration_pos, SEEK_SET);
693         put_le16(pb, video_enc->frame_number);
694     }
695
696     av_free(swf->audio_fifo);
697
698     return 0;
699 }
700 #endif //CONFIG_MUXERS
701
702 /*********************************************/
703 /* Extract FLV encoded frame and MP3 from swf
704    Note that the detection of the real frame
705    is inaccurate at this point as it can be
706    quite tricky to determine, you almost certainly
707    will get a bad audio/video sync */
708
709 static int get_swf_tag(ByteIOContext *pb, int *len_ptr)
710 {
711     int tag, len;
712
713     if (url_feof(pb))
714         return -1;
715
716     tag = get_le16(pb);
717     len = tag & 0x3f;
718     tag = tag >> 6;
719     if (len == 0x3f) {
720         len = get_le32(pb);
721     }
722 //    av_log(NULL, AV_LOG_DEBUG, "Tag: %d - Len: %d\n", tag, len);
723     *len_ptr = len;
724     return tag;
725 }
726
727
728 static int swf_probe(AVProbeData *p)
729 {
730     /* check file header */
731     if (p->buf_size <= 16)
732         return 0;
733     if ((p->buf[0] == 'F' || p->buf[0] == 'C') && p->buf[1] == 'W' &&
734         p->buf[2] == 'S')
735         return AVPROBE_SCORE_MAX;
736     else
737         return 0;
738 }
739
740 static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
741 {
742     SWFContext *swf = 0;
743     ByteIOContext *pb = &s->pb;
744     int nbits, len, frame_rate, tag, v;
745     offset_t firstTagOff;
746     AVStream *ast = 0;
747     AVStream *vst = 0;
748
749     swf = av_malloc(sizeof(SWFContext));
750     if (!swf)
751         return -1;
752     s->priv_data = swf;
753
754     tag = get_be32(pb) & 0xffffff00;
755
756     if (tag == MKBETAG('C', 'W', 'S', 0))
757     {
758         av_log(s, AV_LOG_ERROR, "Compressed SWF format not supported\n");
759         return AVERROR_IO;
760     }
761     if (tag != MKBETAG('F', 'W', 'S', 0))
762         return AVERROR_IO;
763     get_le32(pb);
764     /* skip rectangle size */
765     nbits = get_byte(pb) >> 3;
766     len = (4 * nbits - 3 + 7) / 8;
767     url_fskip(pb, len);
768     frame_rate = get_le16(pb);
769     get_le16(pb); /* frame count */
770
771     /* The Flash Player converts 8.8 frame rates
772        to milliseconds internally. Do the same to get
773        a correct framerate */
774     swf->ms_per_frame = ( 1000 * 256 ) / frame_rate;
775     swf->samples_per_frame = 0;
776
777     firstTagOff = url_ftell(pb);
778     for(;;) {
779         tag = get_swf_tag(pb, &len);
780         if (tag < 0) {
781             if ( ast || vst ) {
782                 if ( vst && ast ) {
783                     vst->codec->time_base.den = ast->codec->sample_rate / swf->samples_per_frame;
784                     vst->codec->time_base.num = 1;
785                 }
786                 break;
787             }
788             av_log(s, AV_LOG_ERROR, "No media found in SWF\n");
789             return AVERROR_IO;
790         }
791         if ( tag == TAG_VIDEOSTREAM && !vst) {
792             int ch_id = get_le16(pb);
793             get_le16(pb);
794             get_le16(pb);
795             get_le16(pb);
796             get_byte(pb);
797             /* Check for FLV1 */
798             vst = av_new_stream(s, ch_id);
799             av_set_pts_info(vst, 24, 1, 1000); /* 24 bit pts in ms */
800             vst->codec->codec_type = CODEC_TYPE_VIDEO;
801             vst->codec->codec_id = codec_get_id(swf_codec_tags, get_byte(pb));
802             if (swf->samples_per_frame) {
803                 vst->codec->time_base.den = 1000. / swf->ms_per_frame;
804                 vst->codec->time_base.num = 1;
805             }
806         } else if ( ( tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2 ) && !ast) {
807             /* streaming found */
808             get_byte(pb);
809             v = get_byte(pb);
810             swf->samples_per_frame = get_le16(pb);
811             ast = av_new_stream(s, 1);
812             av_set_pts_info(ast, 24, 1, 1000); /* 24 bit pts in ms */
813             ast->codec->channels = 1 + (v&1);
814             ast->codec->codec_type = CODEC_TYPE_AUDIO;
815             if (v & 0x20)
816                 ast->codec->codec_id = CODEC_ID_MP3;
817             ast->need_parsing = 1;
818             switch((v>> 2) & 0x03) {
819             case 1:
820                 ast->codec->sample_rate = 11025;
821                 break;
822             case 2:
823                 ast->codec->sample_rate = 22050;
824                 break;
825             case 3:
826                 ast->codec->sample_rate = 44100;
827                 break;
828             default:
829                 return AVERROR_IO;
830             }
831
832             if (len > 4)
833                 url_fskip(pb,len-4);
834
835         } else {
836             url_fskip(pb, len);
837         }
838     }
839     url_fseek(pb, firstTagOff, SEEK_SET);
840
841     return 0;
842 }
843
844 static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
845 {
846     SWFContext *swf = s->priv_data;
847     ByteIOContext *pb = &s->pb;
848     AVStream *st = 0;
849     int tag, len, i, frame;
850
851     for(;;) {
852         tag = get_swf_tag(pb, &len);
853         if (tag < 0)
854             return AVERROR_IO;
855         if (tag == TAG_VIDEOFRAME) {
856             int ch_id = get_le16(pb);
857             for( i=0; i<s->nb_streams; i++ ) {
858                 st = s->streams[i];
859                 if (st->codec->codec_type == CODEC_TYPE_VIDEO && st->id == ch_id) {
860                     frame = get_le16(pb);
861                     av_get_packet(pb, pkt, len-4);
862                     pkt->pts = frame * swf->ms_per_frame;
863                     pkt->stream_index = st->index;
864                     return pkt->size;
865                 }
866             }
867             url_fskip(pb, len-2);
868         } else if (tag == TAG_STREAMBLOCK) {
869             for( i=0; i<s->nb_streams; i++ ) {
870                 st = s->streams[i];
871                 if (st->id == 1) {
872                     url_fskip(pb, 4);
873                     av_get_packet(pb, pkt, len-4);
874                     pkt->stream_index = st->index;
875                     return pkt->size;
876                 }
877             }
878             url_fskip(pb, len);
879         } else {
880             url_fskip(pb, len);
881         }
882     }
883     return 0;
884 }
885
886 static int swf_read_close(AVFormatContext *s)
887 {
888      return 0;
889 }
890
891 #ifdef CONFIG_SWF_DEMUXER
892 AVInputFormat swf_demuxer = {
893     "swf",
894     "Flash format",
895     sizeof(SWFContext),
896     swf_probe,
897     swf_read_header,
898     swf_read_packet,
899     swf_read_close,
900 };
901 #endif
902 #ifdef CONFIG_SWF_MUXER
903 AVOutputFormat swf_muxer = {
904     "swf",
905     "Flash format",
906     "application/x-shockwave-flash",
907     "swf",
908     sizeof(SWFContext),
909     CODEC_ID_MP3,
910     CODEC_ID_FLV1,
911     swf_write_header,
912     swf_write_packet,
913     swf_write_trailer,
914 };
915 #endif