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