c83325f4bbed1b51fa14653319c516c2420f8b1f
[ffmpeg.git] / libavformat / flvenc.c
1 /*
2  * FLV muxer
3  * Copyright (c) 2003 The FFmpeg Project.
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 #include "avformat.h"
22 #include "flv.h"
23 #include "riff.h"
24
25 #undef NDEBUG
26 #include <assert.h>
27
28 static const CodecTag flv_video_codec_ids[] = {
29     {CODEC_ID_FLV1,    FLV_CODECID_H263  },
30     {CODEC_ID_FLASHSV, FLV_CODECID_SCREEN},
31     {CODEC_ID_VP6F,    FLV_CODECID_VP6   },
32     {CODEC_ID_NONE,    0}
33 };
34
35 static const CodecTag flv_audio_codec_ids[] = {
36     {CODEC_ID_MP3,       FLV_CODECID_MP3    >> FLV_AUDIO_CODECID_OFFSET},
37     {CODEC_ID_PCM_S8,    FLV_CODECID_PCM_BE >> FLV_AUDIO_CODECID_OFFSET},
38     {CODEC_ID_PCM_S16BE, FLV_CODECID_PCM_BE >> FLV_AUDIO_CODECID_OFFSET},
39     {CODEC_ID_PCM_S16LE, FLV_CODECID_PCM_LE >> FLV_AUDIO_CODECID_OFFSET},
40     {CODEC_ID_ADPCM_SWF, FLV_CODECID_ADPCM  >> FLV_AUDIO_CODECID_OFFSET},
41     {CODEC_ID_NONE,      0}
42 };
43
44 typedef struct FLVContext {
45     int hasAudio;
46     int hasVideo;
47     int reserved;
48     offset_t duration_offset;
49     offset_t filesize_offset;
50     int64_t duration;
51 } FLVContext;
52
53 static int get_audio_flags(AVCodecContext *enc){
54     int flags = (enc->bits_per_sample == 16) ? FLV_SAMPLESSIZE_16BIT : FLV_SAMPLESSIZE_8BIT;
55
56     switch (enc->sample_rate) {
57         case    44100:
58             flags |= FLV_SAMPLERATE_44100HZ;
59             break;
60         case    22050:
61             flags |= FLV_SAMPLERATE_22050HZ;
62             break;
63         case    11025:
64             flags |= FLV_SAMPLERATE_11025HZ;
65             break;
66         case     8000: //nellymoser only
67         case     5512: //not mp3
68             flags |= FLV_SAMPLERATE_SPECIAL;
69             break;
70         default:
71             av_log(enc, AV_LOG_ERROR, "flv doesnt support that sample rate, choose from (44100, 22050, 11025)\n");
72             return -1;
73     }
74
75     if (enc->channels > 1) {
76         flags |= FLV_STEREO;
77     }
78
79     switch(enc->codec_id){
80     case CODEC_ID_MP3:
81         flags |= FLV_CODECID_MP3    | FLV_SAMPLESSIZE_16BIT;
82         break;
83     case CODEC_ID_PCM_S8:
84         flags |= FLV_CODECID_PCM_BE | FLV_SAMPLESSIZE_8BIT;
85         break;
86     case CODEC_ID_PCM_S16BE:
87         flags |= FLV_CODECID_PCM_BE | FLV_SAMPLESSIZE_16BIT;
88         break;
89     case CODEC_ID_PCM_S16LE:
90         flags |= FLV_CODECID_PCM_LE | FLV_SAMPLESSIZE_16BIT;
91         break;
92     case CODEC_ID_ADPCM_SWF:
93         flags |= FLV_CODECID_ADPCM;
94         break;
95     case 0:
96         flags |= enc->codec_tag<<4;
97         break;
98     default:
99         av_log(enc, AV_LOG_ERROR, "codec not compatible with flv\n");
100         return -1;
101     }
102
103     return flags;
104 }
105
106 static void put_amf_string(ByteIOContext *pb, const char *str)
107 {
108     size_t len = strlen(str);
109     put_be16(pb, len);
110     put_buffer(pb, str, len);
111 }
112
113 static void put_amf_double(ByteIOContext *pb, double d)
114 {
115     put_byte(pb, AMF_DATA_TYPE_NUMBER);
116     put_be64(pb, av_dbl2int(d));
117 }
118
119 static void put_amf_bool(ByteIOContext *pb, int b) {
120     put_byte(pb, AMF_DATA_TYPE_BOOL);
121     put_byte(pb, !!b);
122 }
123
124 static int flv_write_header(AVFormatContext *s)
125 {
126     ByteIOContext *pb = &s->pb;
127     FLVContext *flv = s->priv_data;
128     int i, width, height, samplerate, samplesize, channels, audiocodecid, videocodecid;
129     double framerate = 0.0;
130     int metadata_size_pos, data_size;
131
132     flv->hasAudio = 0;
133     flv->hasVideo = 0;
134
135     for(i=0; i<s->nb_streams; i++){
136         AVCodecContext *enc = s->streams[i]->codec;
137         if (enc->codec_type == CODEC_TYPE_VIDEO) {
138             width = enc->width;
139             height = enc->height;
140             if (s->streams[i]->r_frame_rate.den && s->streams[i]->r_frame_rate.num) {
141                 framerate = av_q2d(s->streams[i]->r_frame_rate);
142             } else {
143                 framerate = 1/av_q2d(s->streams[i]->codec->time_base);
144             }
145             flv->hasVideo=1;
146
147             videocodecid = codec_get_tag(flv_video_codec_ids, enc->codec_id);
148             if(videocodecid == 0) {
149                 av_log(enc, AV_LOG_ERROR, "video codec not compatible with flv\n");
150                 return -1;
151             }
152         } else {
153             flv->hasAudio=1;
154             samplerate = enc->sample_rate;
155             channels = enc->channels;
156
157             audiocodecid = codec_get_tag(flv_audio_codec_ids, enc->codec_id);
158             samplesize = (enc->codec_id == CODEC_ID_PCM_S8) ? 8 : 16;
159
160             if(get_audio_flags(enc)<0)
161                 return -1;
162         }
163         av_set_pts_info(s->streams[i], 24, 1, 1000); /* 24 bit pts in ms */
164     }
165     put_tag(pb,"FLV");
166     put_byte(pb,1);
167     put_byte(pb,   FLV_HEADER_FLAG_HASAUDIO * flv->hasAudio
168                  + FLV_HEADER_FLAG_HASVIDEO * flv->hasVideo);
169     put_be32(pb,9);
170     put_be32(pb,0);
171
172     for(i=0; i<s->nb_streams; i++){
173         if(s->streams[i]->codec->codec_tag == 5){
174             put_byte(pb,8); // message type
175             put_be24(pb,0); // include flags
176             put_be24(pb,0); // time stamp
177             put_be32(pb,0); // reserved
178             put_be32(pb,11); // size
179             flv->reserved=5;
180         }
181     }
182
183     /* write meta_tag */
184     put_byte(pb, 18);         // tag type META
185     metadata_size_pos= url_ftell(pb);
186     put_be24(pb, 0);          // size of data part (sum of all parts below)
187     put_be24(pb, 0);          // time stamp
188     put_be32(pb, 0);          // reserved
189
190     /* now data of data_size size */
191
192     /* first event name as a string */
193     put_byte(pb, AMF_DATA_TYPE_STRING);
194     put_amf_string(pb, "onMetaData"); // 12 bytes
195
196     /* mixed array (hash) with size and string/type/data tuples */
197     put_byte(pb, AMF_DATA_TYPE_MIXEDARRAY);
198     put_be32(pb, 5*flv->hasVideo + 4*flv->hasAudio + 2); // +2 for duration and file size
199
200     put_amf_string(pb, "duration");
201     flv->duration_offset= url_ftell(pb);
202     put_amf_double(pb, 0); // delayed write
203
204     if(flv->hasVideo){
205         put_amf_string(pb, "width");
206         put_amf_double(pb, width);
207
208         put_amf_string(pb, "height");
209         put_amf_double(pb, height);
210
211         put_amf_string(pb, "videodatarate");
212         put_amf_double(pb, s->bit_rate / 1024.0);
213
214         put_amf_string(pb, "framerate");
215         put_amf_double(pb, framerate);
216
217         put_amf_string(pb, "videocodecid");
218         put_amf_double(pb, videocodecid);
219     }
220
221     if(flv->hasAudio){
222         put_amf_string(pb, "audiosamplerate");
223         put_amf_double(pb, samplerate);
224
225         put_amf_string(pb, "audiosamplesize");
226         put_amf_double(pb, samplesize);
227
228         put_amf_string(pb, "stereo");
229         put_amf_bool(pb, (channels == 2));
230
231         put_amf_string(pb, "audiocodecid");
232         put_amf_double(pb, audiocodecid);
233     }
234
235     put_amf_string(pb, "filesize");
236     flv->filesize_offset= url_ftell(pb);
237     put_amf_double(pb, 0); // delayed write
238
239     put_amf_string(pb, "");
240     put_byte(pb, AMF_END_OF_OBJECT);
241
242     /* write total size of tag */
243     data_size= url_ftell(pb) - metadata_size_pos - 10;
244     url_fseek(pb, metadata_size_pos, SEEK_SET);
245     put_be24(pb, data_size);
246     url_fseek(pb, data_size + 10 - 3, SEEK_CUR);
247     put_be32(pb, data_size + 11);
248
249     return 0;
250 }
251
252 static int flv_write_trailer(AVFormatContext *s)
253 {
254     int64_t file_size;
255
256     ByteIOContext *pb = &s->pb;
257     FLVContext *flv = s->priv_data;
258
259     file_size = url_ftell(pb);
260
261     /* update informations */
262     url_fseek(pb, flv->duration_offset, SEEK_SET);
263     put_amf_double(pb, flv->duration / (double)1000);
264     url_fseek(pb, flv->filesize_offset, SEEK_SET);
265     put_amf_double(pb, file_size);
266
267     url_fseek(pb, file_size, SEEK_SET);
268     return 0;
269 }
270
271 static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
272 {
273     ByteIOContext *pb = &s->pb;
274     AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
275     FLVContext *flv = s->priv_data;
276     int size= pkt->size;
277     int flags;
278
279 //    av_log(s, AV_LOG_DEBUG, "type:%d pts: %"PRId64" size:%d\n", enc->codec_type, timestamp, size);
280
281     if (enc->codec_type == CODEC_TYPE_VIDEO) {
282         put_byte(pb, FLV_TAG_TYPE_VIDEO);
283         flags = FLV_CODECID_H263;
284         flags |= pkt->flags & PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
285     } else {
286         assert(enc->codec_type == CODEC_TYPE_AUDIO);
287         flags = get_audio_flags(enc);
288
289         assert(size);
290
291         put_byte(pb, FLV_TAG_TYPE_AUDIO);
292     }
293
294     put_be24(pb,size+1); // include flags
295     put_be24(pb,pkt->pts);
296     put_be32(pb,flv->reserved);
297     put_byte(pb,flags);
298     put_buffer(pb, pkt->data, size);
299     put_be32(pb,size+1+11); // previous tag size
300     flv->duration = pkt->pts + pkt->duration;
301
302     put_flush_packet(pb);
303     return 0;
304 }
305
306 AVOutputFormat flv_muxer = {
307     "flv",
308     "flv format",
309     "video/x-flv",
310     "flv",
311     sizeof(FLVContext),
312 #ifdef CONFIG_MP3LAME
313     CODEC_ID_MP3,
314 #else // CONFIG_MP3LAME
315     CODEC_ID_NONE,
316 #endif // CONFIG_MP3LAME
317     CODEC_ID_FLV1,
318     flv_write_header,
319     flv_write_packet,
320     flv_write_trailer,
321 };