cosmetics
[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 AVCodecTag 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_VP6,     FLV_CODECID_VP6   },
33     {CODEC_ID_NONE,    0}
34 };
35
36 static const AVCodecTag flv_audio_codec_ids[] = {
37     {CODEC_ID_MP3,       FLV_CODECID_MP3    >> FLV_AUDIO_CODECID_OFFSET},
38     {CODEC_ID_PCM_S8,    FLV_CODECID_PCM_BE >> FLV_AUDIO_CODECID_OFFSET},
39     {CODEC_ID_PCM_S16BE, FLV_CODECID_PCM_BE >> FLV_AUDIO_CODECID_OFFSET},
40     {CODEC_ID_PCM_S16LE, FLV_CODECID_PCM_LE >> FLV_AUDIO_CODECID_OFFSET},
41     {CODEC_ID_ADPCM_SWF, FLV_CODECID_ADPCM  >> FLV_AUDIO_CODECID_OFFSET},
42     {CODEC_ID_NONE,      0}
43 };
44
45 typedef struct FLVContext {
46     int hasAudio;
47     int hasVideo;
48     int reserved;
49     offset_t duration_offset;
50     offset_t filesize_offset;
51     int64_t duration;
52 } FLVContext;
53
54 static int get_audio_flags(AVCodecContext *enc){
55     int flags = (enc->bits_per_sample == 16) ? FLV_SAMPLESSIZE_16BIT : FLV_SAMPLESSIZE_8BIT;
56
57     switch (enc->sample_rate) {
58         case    44100:
59             flags |= FLV_SAMPLERATE_44100HZ;
60             break;
61         case    22050:
62             flags |= FLV_SAMPLERATE_22050HZ;
63             break;
64         case    11025:
65             flags |= FLV_SAMPLERATE_11025HZ;
66             break;
67         case     8000: //nellymoser only
68         case     5512: //not mp3
69             if(enc->codec_id != CODEC_ID_MP3){
70                 flags |= FLV_SAMPLERATE_SPECIAL;
71                 break;
72             }
73         default:
74             av_log(enc, AV_LOG_ERROR, "flv does not support that sample rate, choose from (44100, 22050, 11025).\n");
75             return -1;
76     }
77
78     if (enc->channels > 1) {
79         flags |= FLV_STEREO;
80     }
81
82     switch(enc->codec_id){
83     case CODEC_ID_MP3:
84         flags |= FLV_CODECID_MP3    | FLV_SAMPLESSIZE_16BIT;
85         break;
86     case CODEC_ID_PCM_S8:
87         flags |= FLV_CODECID_PCM_BE | FLV_SAMPLESSIZE_8BIT;
88         break;
89     case CODEC_ID_PCM_S16BE:
90         flags |= FLV_CODECID_PCM_BE | FLV_SAMPLESSIZE_16BIT;
91         break;
92     case CODEC_ID_PCM_S16LE:
93         flags |= FLV_CODECID_PCM_LE | FLV_SAMPLESSIZE_16BIT;
94         break;
95     case CODEC_ID_ADPCM_SWF:
96         flags |= FLV_CODECID_ADPCM | FLV_SAMPLESSIZE_16BIT;
97         break;
98     case 0:
99         flags |= enc->codec_tag<<4;
100         break;
101     default:
102         av_log(enc, AV_LOG_ERROR, "codec not compatible with flv\n");
103         return -1;
104     }
105
106     return flags;
107 }
108
109 static void put_amf_string(ByteIOContext *pb, const char *str)
110 {
111     size_t len = strlen(str);
112     put_be16(pb, len);
113     put_buffer(pb, str, len);
114 }
115
116 static void put_amf_double(ByteIOContext *pb, double d)
117 {
118     put_byte(pb, AMF_DATA_TYPE_NUMBER);
119     put_be64(pb, av_dbl2int(d));
120 }
121
122 static void put_amf_bool(ByteIOContext *pb, int b) {
123     put_byte(pb, AMF_DATA_TYPE_BOOL);
124     put_byte(pb, !!b);
125 }
126
127 static int flv_write_header(AVFormatContext *s)
128 {
129     ByteIOContext *pb = s->pb;
130     FLVContext *flv = s->priv_data;
131     int i, width, height, samplerate, samplesize, channels, audiocodecid, videocodecid;
132     double framerate = 0.0;
133     int metadata_size_pos, data_size;
134
135     flv->hasAudio = 0;
136     flv->hasVideo = 0;
137
138     for(i=0; i<s->nb_streams; i++){
139         AVCodecContext *enc = s->streams[i]->codec;
140         if (enc->codec_type == CODEC_TYPE_VIDEO) {
141             width = enc->width;
142             height = enc->height;
143             if (s->streams[i]->r_frame_rate.den && s->streams[i]->r_frame_rate.num) {
144                 framerate = av_q2d(s->streams[i]->r_frame_rate);
145             } else {
146                 framerate = 1/av_q2d(s->streams[i]->codec->time_base);
147             }
148             flv->hasVideo=1;
149
150             videocodecid = enc->codec_tag;
151             if(videocodecid == 0) {
152                 av_log(enc, AV_LOG_ERROR, "video codec not compatible with flv\n");
153                 return -1;
154             }
155         } else {
156             flv->hasAudio=1;
157             samplerate = enc->sample_rate;
158             channels = enc->channels;
159
160             audiocodecid = enc->codec_tag;
161             samplesize = (enc->codec_id == CODEC_ID_PCM_S8) ? 8 : 16;
162
163             if(get_audio_flags(enc)<0)
164                 return -1;
165         }
166         av_set_pts_info(s->streams[i], 24, 1, 1000); /* 24 bit pts in ms */
167     }
168     put_tag(pb,"FLV");
169     put_byte(pb,1);
170     put_byte(pb,   FLV_HEADER_FLAG_HASAUDIO * flv->hasAudio
171                  + FLV_HEADER_FLAG_HASVIDEO * flv->hasVideo);
172     put_be32(pb,9);
173     put_be32(pb,0);
174
175     for(i=0; i<s->nb_streams; i++){
176         if(s->streams[i]->codec->codec_tag == 5){
177             put_byte(pb,8); // message type
178             put_be24(pb,0); // include flags
179             put_be24(pb,0); // time stamp
180             put_be32(pb,0); // reserved
181             put_be32(pb,11); // size
182             flv->reserved=5;
183         }
184     }
185
186     /* write meta_tag */
187     put_byte(pb, 18);         // tag type META
188     metadata_size_pos= url_ftell(pb);
189     put_be24(pb, 0);          // size of data part (sum of all parts below)
190     put_be24(pb, 0);          // time stamp
191     put_be32(pb, 0);          // reserved
192
193     /* now data of data_size size */
194
195     /* first event name as a string */
196     put_byte(pb, AMF_DATA_TYPE_STRING);
197     put_amf_string(pb, "onMetaData"); // 12 bytes
198
199     /* mixed array (hash) with size and string/type/data tuples */
200     put_byte(pb, AMF_DATA_TYPE_MIXEDARRAY);
201     put_be32(pb, 5*flv->hasVideo + 4*flv->hasAudio + 2); // +2 for duration and file size
202
203     put_amf_string(pb, "duration");
204     flv->duration_offset= url_ftell(pb);
205     put_amf_double(pb, 0); // delayed write
206
207     if(flv->hasVideo){
208         put_amf_string(pb, "width");
209         put_amf_double(pb, width);
210
211         put_amf_string(pb, "height");
212         put_amf_double(pb, height);
213
214         put_amf_string(pb, "videodatarate");
215         put_amf_double(pb, s->bit_rate / 1024.0);
216
217         put_amf_string(pb, "framerate");
218         put_amf_double(pb, framerate);
219
220         put_amf_string(pb, "videocodecid");
221         put_amf_double(pb, videocodecid);
222     }
223
224     if(flv->hasAudio){
225         put_amf_string(pb, "audiosamplerate");
226         put_amf_double(pb, samplerate);
227
228         put_amf_string(pb, "audiosamplesize");
229         put_amf_double(pb, samplesize);
230
231         put_amf_string(pb, "stereo");
232         put_amf_bool(pb, (channels == 2));
233
234         put_amf_string(pb, "audiocodecid");
235         put_amf_double(pb, audiocodecid);
236     }
237
238     put_amf_string(pb, "filesize");
239     flv->filesize_offset= url_ftell(pb);
240     put_amf_double(pb, 0); // delayed write
241
242     put_amf_string(pb, "");
243     put_byte(pb, AMF_END_OF_OBJECT);
244
245     /* write total size of tag */
246     data_size= url_ftell(pb) - metadata_size_pos - 10;
247     url_fseek(pb, metadata_size_pos, SEEK_SET);
248     put_be24(pb, data_size);
249     url_fseek(pb, data_size + 10 - 3, SEEK_CUR);
250     put_be32(pb, data_size + 11);
251
252     return 0;
253 }
254
255 static int flv_write_trailer(AVFormatContext *s)
256 {
257     int64_t file_size;
258
259     ByteIOContext *pb = s->pb;
260     FLVContext *flv = s->priv_data;
261
262     file_size = url_ftell(pb);
263
264     /* update informations */
265     url_fseek(pb, flv->duration_offset, SEEK_SET);
266     put_amf_double(pb, flv->duration / (double)1000);
267     url_fseek(pb, flv->filesize_offset, SEEK_SET);
268     put_amf_double(pb, file_size);
269
270     url_fseek(pb, file_size, SEEK_SET);
271     return 0;
272 }
273
274 static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
275 {
276     ByteIOContext *pb = s->pb;
277     AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
278     FLVContext *flv = s->priv_data;
279     int size= pkt->size;
280     int flags, flags_size;
281
282 //    av_log(s, AV_LOG_DEBUG, "type:%d pts: %"PRId64" size:%d\n", enc->codec_type, timestamp, size);
283
284     if(enc->codec_id == CODEC_ID_VP6 || enc->codec_id == CODEC_ID_VP6F)
285         flags_size= 2;
286     else
287         flags_size= 1;
288
289     if (enc->codec_type == CODEC_TYPE_VIDEO) {
290         put_byte(pb, FLV_TAG_TYPE_VIDEO);
291
292         flags = enc->codec_tag;
293         if(flags == 0) {
294             av_log(enc, AV_LOG_ERROR, "video codec %X not compatible with flv\n",enc->codec_id);
295             return -1;
296         }
297
298         flags |= pkt->flags & PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
299     } else {
300         assert(enc->codec_type == CODEC_TYPE_AUDIO);
301         flags = get_audio_flags(enc);
302
303         assert(size);
304
305         put_byte(pb, FLV_TAG_TYPE_AUDIO);
306     }
307
308     put_be24(pb,size + flags_size);
309     put_be24(pb,pkt->pts);
310     put_byte(pb,pkt->pts >> 24);
311     put_be24(pb,flv->reserved);
312     put_byte(pb,flags);
313     if (enc->codec_id == CODEC_ID_VP6)
314         put_byte(pb,0);
315     if (enc->codec_id == CODEC_ID_VP6F)
316         put_byte(pb, enc->extradata_size ? enc->extradata[0] : 0);
317     put_buffer(pb, pkt->data, size);
318     put_be32(pb,size+flags_size+11); // previous tag size
319     flv->duration = pkt->pts + pkt->duration;
320
321     put_flush_packet(pb);
322     return 0;
323 }
324
325 AVOutputFormat flv_muxer = {
326     "flv",
327     "flv format",
328     "video/x-flv",
329     "flv",
330     sizeof(FLVContext),
331 #ifdef CONFIG_LIBMP3LAME
332     CODEC_ID_MP3,
333 #else // CONFIG_LIBMP3LAME
334     CODEC_ID_ADPCM_SWF,
335 #endif // CONFIG_LIBMP3LAME
336     CODEC_ID_FLV1,
337     flv_write_header,
338     flv_write_packet,
339     flv_write_trailer,
340     .codec_tag= (const AVCodecTag*[]){flv_video_codec_ids, flv_audio_codec_ids, 0},
341 };