dca: Switch dca_sample_rates to avpriv_ prefix; it is used across libs
[ffmpeg.git] / libavformat / swfenc.c
1 /*
2  * Flash Compatible Streaming Format muxer
3  * Copyright (c) 2000 Fabrice Bellard
4  * Copyright (c) 2003 Tinic Uro
5  *
6  * This file is part of Libav.
7  *
8  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include "libavcodec/put_bits.h"
24 #include "avformat.h"
25 #include "swf.h"
26
27 static void put_swf_tag(AVFormatContext *s, int tag)
28 {
29     SWFContext *swf = s->priv_data;
30     AVIOContext *pb = s->pb;
31
32     swf->tag_pos = avio_tell(pb);
33     swf->tag = tag;
34     /* reserve some room for the tag */
35     if (tag & TAG_LONG) {
36         avio_wl16(pb, 0);
37         avio_wl32(pb, 0);
38     } else {
39         avio_wl16(pb, 0);
40     }
41 }
42
43 static void put_swf_end_tag(AVFormatContext *s)
44 {
45     SWFContext *swf = s->priv_data;
46     AVIOContext *pb = s->pb;
47     int64_t pos;
48     int tag_len, tag;
49
50     pos = avio_tell(pb);
51     tag_len = pos - swf->tag_pos - 2;
52     tag = swf->tag;
53     avio_seek(pb, swf->tag_pos, SEEK_SET);
54     if (tag & TAG_LONG) {
55         tag &= ~TAG_LONG;
56         avio_wl16(pb, (tag << 6) | 0x3f);
57         avio_wl32(pb, tag_len - 4);
58     } else {
59         assert(tag_len < 0x3f);
60         avio_wl16(pb, (tag << 6) | tag_len);
61     }
62     avio_seek(pb, pos, SEEK_SET);
63 }
64
65 static inline void max_nbits(int *nbits_ptr, int val)
66 {
67     int n;
68
69     if (val == 0)
70         return;
71     val = abs(val);
72     n = 1;
73     while (val != 0) {
74         n++;
75         val >>= 1;
76     }
77     if (n > *nbits_ptr)
78         *nbits_ptr = n;
79 }
80
81 static void put_swf_rect(AVIOContext *pb,
82                          int xmin, int xmax, int ymin, int ymax)
83 {
84     PutBitContext p;
85     uint8_t buf[256];
86     int nbits, mask;
87
88     init_put_bits(&p, buf, sizeof(buf));
89
90     nbits = 0;
91     max_nbits(&nbits, xmin);
92     max_nbits(&nbits, xmax);
93     max_nbits(&nbits, ymin);
94     max_nbits(&nbits, ymax);
95     mask = (1 << nbits) - 1;
96
97     /* rectangle info */
98     put_bits(&p, 5, nbits);
99     put_bits(&p, nbits, xmin & mask);
100     put_bits(&p, nbits, xmax & mask);
101     put_bits(&p, nbits, ymin & mask);
102     put_bits(&p, nbits, ymax & mask);
103
104     flush_put_bits(&p);
105     avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
106 }
107
108 static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)
109 {
110     int nbits, mask;
111
112     put_bits(pb, 1, 1); /* edge */
113     put_bits(pb, 1, 1); /* line select */
114     nbits = 2;
115     max_nbits(&nbits, dx);
116     max_nbits(&nbits, dy);
117
118     mask = (1 << nbits) - 1;
119     put_bits(pb, 4, nbits - 2); /* 16 bits precision */
120     if (dx == 0) {
121         put_bits(pb, 1, 0);
122         put_bits(pb, 1, 1);
123         put_bits(pb, nbits, dy & mask);
124     } else if (dy == 0) {
125         put_bits(pb, 1, 0);
126         put_bits(pb, 1, 0);
127         put_bits(pb, nbits, dx & mask);
128     } else {
129         put_bits(pb, 1, 1);
130         put_bits(pb, nbits, dx & mask);
131         put_bits(pb, nbits, dy & mask);
132     }
133 }
134
135 #define FRAC_BITS 16
136
137 static void put_swf_matrix(AVIOContext *pb,
138                            int a, int b, int c, int d, int tx, int ty)
139 {
140     PutBitContext p;
141     uint8_t buf[256];
142     int nbits;
143
144     init_put_bits(&p, buf, sizeof(buf));
145
146     put_bits(&p, 1, 1); /* a, d present */
147     nbits = 1;
148     max_nbits(&nbits, a);
149     max_nbits(&nbits, d);
150     put_bits(&p, 5, nbits); /* nb bits */
151     put_bits(&p, nbits, a);
152     put_bits(&p, nbits, d);
153
154     put_bits(&p, 1, 1); /* b, c present */
155     nbits = 1;
156     max_nbits(&nbits, c);
157     max_nbits(&nbits, b);
158     put_bits(&p, 5, nbits); /* nb bits */
159     put_bits(&p, nbits, c);
160     put_bits(&p, nbits, b);
161
162     nbits = 1;
163     max_nbits(&nbits, tx);
164     max_nbits(&nbits, ty);
165     put_bits(&p, 5, nbits); /* nb bits */
166     put_bits(&p, nbits, tx);
167     put_bits(&p, nbits, ty);
168
169     flush_put_bits(&p);
170     avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
171 }
172
173 static int swf_write_header(AVFormatContext *s)
174 {
175     SWFContext *swf = s->priv_data;
176     AVIOContext *pb = s->pb;
177     PutBitContext p;
178     uint8_t buf1[256];
179     int i, width, height, rate, rate_base;
180     int version;
181
182     swf->sound_samples = 0;
183     swf->swf_frame_number = 0;
184     swf->video_frame_number = 0;
185
186     for(i=0;i<s->nb_streams;i++) {
187         AVCodecContext *enc = s->streams[i]->codec;
188         if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
189             if (enc->codec_id == CODEC_ID_MP3) {
190                 swf->audio_enc = enc;
191                 swf->audio_fifo= av_fifo_alloc(AUDIO_FIFO_SIZE);
192                 if (!swf->audio_fifo)
193                     return AVERROR(ENOMEM);
194             } else {
195                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports MP3\n");
196                 return -1;
197             }
198         } else {
199             if (enc->codec_id == CODEC_ID_VP6F ||
200                 enc->codec_id == CODEC_ID_FLV1 ||
201                 enc->codec_id == CODEC_ID_MJPEG) {
202                 swf->video_enc = enc;
203             } else {
204                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports VP6, FLV1 and MJPEG\n");
205                 return -1;
206             }
207         }
208     }
209
210     if (!swf->video_enc) {
211         /* currently, cannot work correctly if audio only */
212         width = 320;
213         height = 200;
214         rate = 10;
215         rate_base= 1;
216     } else {
217         width = swf->video_enc->width;
218         height = swf->video_enc->height;
219         rate = swf->video_enc->time_base.den;
220         rate_base = swf->video_enc->time_base.num;
221     }
222
223     if (!swf->audio_enc)
224         swf->samples_per_frame = (44100. * rate_base) / rate;
225     else
226         swf->samples_per_frame = (swf->audio_enc->sample_rate * rate_base) / rate;
227
228     avio_write(pb, "FWS", 3);
229
230     if (!strcmp("avm2", s->oformat->name))
231         version = 9;
232     else if (swf->video_enc && swf->video_enc->codec_id == CODEC_ID_VP6F)
233         version = 8; /* version 8 and above support VP6 codec */
234     else if (swf->video_enc && swf->video_enc->codec_id == CODEC_ID_FLV1)
235         version = 6; /* version 6 and above support FLV1 codec */
236     else
237         version = 4; /* version 4 for mpeg audio support */
238     avio_w8(pb, version);
239
240     avio_wl32(pb, DUMMY_FILE_SIZE); /* dummy size
241                                       (will be patched if not streamed) */
242
243     put_swf_rect(pb, 0, width * 20, 0, height * 20);
244     avio_wl16(pb, (rate * 256) / rate_base); /* frame rate */
245     swf->duration_pos = avio_tell(pb);
246     avio_wl16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
247
248     /* avm2/swf v9 (also v8?) files require a file attribute tag */
249     if (version == 9) {
250         put_swf_tag(s, TAG_FILEATTRIBUTES);
251         avio_wl32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */
252         put_swf_end_tag(s);
253     }
254
255     /* define a shape with the jpeg inside */
256     if (swf->video_enc && swf->video_enc->codec_id == CODEC_ID_MJPEG) {
257         put_swf_tag(s, TAG_DEFINESHAPE);
258
259         avio_wl16(pb, SHAPE_ID); /* ID of shape */
260         /* bounding rectangle */
261         put_swf_rect(pb, 0, width, 0, height);
262         /* style info */
263         avio_w8(pb, 1); /* one fill style */
264         avio_w8(pb, 0x41); /* clipped bitmap fill */
265         avio_wl16(pb, BITMAP_ID); /* bitmap ID */
266         /* position of the bitmap */
267         put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0,
268                        0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0);
269         avio_w8(pb, 0); /* no line style */
270
271         /* shape drawing */
272         init_put_bits(&p, buf1, sizeof(buf1));
273         put_bits(&p, 4, 1); /* one fill bit */
274         put_bits(&p, 4, 0); /* zero line bit */
275
276         put_bits(&p, 1, 0); /* not an edge */
277         put_bits(&p, 5, FLAG_MOVETO | FLAG_SETFILL0);
278         put_bits(&p, 5, 1); /* nbits */
279         put_bits(&p, 1, 0); /* X */
280         put_bits(&p, 1, 0); /* Y */
281         put_bits(&p, 1, 1); /* set fill style 1 */
282
283         /* draw the rectangle ! */
284         put_swf_line_edge(&p, width, 0);
285         put_swf_line_edge(&p, 0, height);
286         put_swf_line_edge(&p, -width, 0);
287         put_swf_line_edge(&p, 0, -height);
288
289         /* end of shape */
290         put_bits(&p, 1, 0); /* not an edge */
291         put_bits(&p, 5, 0);
292
293         flush_put_bits(&p);
294         avio_write(pb, buf1, put_bits_ptr(&p) - p.buf);
295
296         put_swf_end_tag(s);
297     }
298
299     if (swf->audio_enc && swf->audio_enc->codec_id == CODEC_ID_MP3) {
300         int v = 0;
301
302         /* start sound */
303         put_swf_tag(s, TAG_STREAMHEAD2);
304         switch(swf->audio_enc->sample_rate) {
305         case 11025: v |= 1 << 2; break;
306         case 22050: v |= 2 << 2; break;
307         case 44100: v |= 3 << 2; break;
308         default:
309             /* not supported */
310             av_log(s, AV_LOG_ERROR, "swf does not support that sample rate, choose from (44100, 22050, 11025).\n");
311             return -1;
312         }
313         v |= 0x02; /* 16 bit playback */
314         if (swf->audio_enc->channels == 2)
315             v |= 0x01; /* stereo playback */
316         avio_w8(s->pb, v);
317         v |= 0x20; /* mp3 compressed */
318         avio_w8(s->pb, v);
319         avio_wl16(s->pb, swf->samples_per_frame);  /* avg samples per frame */
320         avio_wl16(s->pb, 0);
321
322         put_swf_end_tag(s);
323     }
324
325     avio_flush(s->pb);
326     return 0;
327 }
328
329 static int swf_write_video(AVFormatContext *s,
330                            AVCodecContext *enc, const uint8_t *buf, int size)
331 {
332     SWFContext *swf = s->priv_data;
333     AVIOContext *pb = s->pb;
334
335     /* Flash Player limit */
336     if (swf->swf_frame_number == 16000)
337         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
338
339     if (enc->codec_id == CODEC_ID_VP6F ||
340         enc->codec_id == CODEC_ID_FLV1) {
341         if (swf->video_frame_number == 0) {
342             /* create a new video object */
343             put_swf_tag(s, TAG_VIDEOSTREAM);
344             avio_wl16(pb, VIDEO_ID);
345             swf->vframes_pos = avio_tell(pb);
346             avio_wl16(pb, 15000); /* hard flash player limit */
347             avio_wl16(pb, enc->width);
348             avio_wl16(pb, enc->height);
349             avio_w8(pb, 0);
350             avio_w8(pb,ff_codec_get_tag(swf_codec_tags,enc->codec_id));
351             put_swf_end_tag(s);
352
353             /* place the video object for the first time */
354             put_swf_tag(s, TAG_PLACEOBJECT2);
355             avio_w8(pb, 0x36);
356             avio_wl16(pb, 1);
357             avio_wl16(pb, VIDEO_ID);
358             put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
359             avio_wl16(pb, swf->video_frame_number);
360             avio_write(pb, "video", 5);
361             avio_w8(pb, 0x00);
362             put_swf_end_tag(s);
363         } else {
364             /* mark the character for update */
365             put_swf_tag(s, TAG_PLACEOBJECT2);
366             avio_w8(pb, 0x11);
367             avio_wl16(pb, 1);
368             avio_wl16(pb, swf->video_frame_number);
369             put_swf_end_tag(s);
370         }
371
372         /* set video frame data */
373         put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);
374         avio_wl16(pb, VIDEO_ID);
375         avio_wl16(pb, swf->video_frame_number++);
376         avio_write(pb, buf, size);
377         put_swf_end_tag(s);
378     } else if (enc->codec_id == CODEC_ID_MJPEG) {
379         if (swf->swf_frame_number > 0) {
380             /* remove the shape */
381             put_swf_tag(s, TAG_REMOVEOBJECT);
382             avio_wl16(pb, SHAPE_ID); /* shape ID */
383             avio_wl16(pb, 1); /* depth */
384             put_swf_end_tag(s);
385
386             /* free the bitmap */
387             put_swf_tag(s, TAG_FREECHARACTER);
388             avio_wl16(pb, BITMAP_ID);
389             put_swf_end_tag(s);
390         }
391
392         put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
393
394         avio_wl16(pb, BITMAP_ID); /* ID of the image */
395
396         /* a dummy jpeg header seems to be required */
397         avio_wb32(pb, 0xffd8ffd9);
398         /* write the jpeg image */
399         avio_write(pb, buf, size);
400
401         put_swf_end_tag(s);
402
403         /* draw the shape */
404
405         put_swf_tag(s, TAG_PLACEOBJECT);
406         avio_wl16(pb, SHAPE_ID); /* shape ID */
407         avio_wl16(pb, 1); /* depth */
408         put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);
409         put_swf_end_tag(s);
410     }
411
412     swf->swf_frame_number++;
413
414     /* streaming sound always should be placed just before showframe tags */
415     if (swf->audio_enc && av_fifo_size(swf->audio_fifo)) {
416         int frame_size = av_fifo_size(swf->audio_fifo);
417         put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
418         avio_wl16(pb, swf->sound_samples);
419         avio_wl16(pb, 0); // seek samples
420         av_fifo_generic_read(swf->audio_fifo, pb, frame_size, &avio_write);
421         put_swf_end_tag(s);
422
423         /* update FIFO */
424         swf->sound_samples = 0;
425     }
426
427     /* output the frame */
428     put_swf_tag(s, TAG_SHOWFRAME);
429     put_swf_end_tag(s);
430
431     avio_flush(s->pb);
432
433     return 0;
434 }
435
436 static int swf_write_audio(AVFormatContext *s,
437                            AVCodecContext *enc, uint8_t *buf, int size)
438 {
439     SWFContext *swf = s->priv_data;
440
441     /* Flash Player limit */
442     if (swf->swf_frame_number == 16000)
443         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
444
445     if (av_fifo_size(swf->audio_fifo) + size > AUDIO_FIFO_SIZE) {
446         av_log(s, AV_LOG_ERROR, "audio fifo too small to mux audio essence\n");
447         return -1;
448     }
449
450     av_fifo_generic_write(swf->audio_fifo, buf, size, NULL);
451     swf->sound_samples += av_get_audio_frame_duration(enc, size);
452
453     /* if audio only stream make sure we add swf frames */
454     if (!swf->video_enc)
455         swf_write_video(s, enc, 0, 0);
456
457     return 0;
458 }
459
460 static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)
461 {
462     AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
463     if (codec->codec_type == AVMEDIA_TYPE_AUDIO)
464         return swf_write_audio(s, codec, pkt->data, pkt->size);
465     else
466         return swf_write_video(s, codec, pkt->data, pkt->size);
467 }
468
469 static int swf_write_trailer(AVFormatContext *s)
470 {
471     SWFContext *swf = s->priv_data;
472     AVIOContext *pb = s->pb;
473     AVCodecContext *enc, *video_enc;
474     int file_size, i;
475
476     video_enc = NULL;
477     for(i=0;i<s->nb_streams;i++) {
478         enc = s->streams[i]->codec;
479         if (enc->codec_type == AVMEDIA_TYPE_VIDEO)
480             video_enc = enc;
481         else
482             av_fifo_free(swf->audio_fifo);
483     }
484
485     put_swf_tag(s, TAG_END);
486     put_swf_end_tag(s);
487
488     avio_flush(s->pb);
489
490     /* patch file size and number of frames if not streamed */
491     if (s->pb->seekable && video_enc) {
492         file_size = avio_tell(pb);
493         avio_seek(pb, 4, SEEK_SET);
494         avio_wl32(pb, file_size);
495         avio_seek(pb, swf->duration_pos, SEEK_SET);
496         avio_wl16(pb, swf->video_frame_number);
497         avio_seek(pb, swf->vframes_pos, SEEK_SET);
498         avio_wl16(pb, swf->video_frame_number);
499         avio_seek(pb, file_size, SEEK_SET);
500     }
501     return 0;
502 }
503
504 #if CONFIG_SWF_MUXER
505 AVOutputFormat ff_swf_muxer = {
506     .name              = "swf",
507     .long_name         = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
508     .mime_type         = "application/x-shockwave-flash",
509     .extensions        = "swf",
510     .priv_data_size    = sizeof(SWFContext),
511     .audio_codec       = CODEC_ID_MP3,
512     .video_codec       = CODEC_ID_FLV1,
513     .write_header      = swf_write_header,
514     .write_packet      = swf_write_packet,
515     .write_trailer     = swf_write_trailer,
516     .flags             = AVFMT_TS_NONSTRICT,
517 };
518 #endif
519 #if CONFIG_AVM2_MUXER
520 AVOutputFormat ff_avm2_muxer = {
521     .name              = "avm2",
522     .long_name         = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash) (AVM2)"),
523     .mime_type         = "application/x-shockwave-flash",
524     .priv_data_size    = sizeof(SWFContext),
525     .audio_codec       = CODEC_ID_MP3,
526     .video_codec       = CODEC_ID_FLV1,
527     .write_header      = swf_write_header,
528     .write_packet      = swf_write_packet,
529     .write_trailer     = swf_write_trailer,
530     .flags             = AVFMT_TS_NONSTRICT,
531 };
532 #endif