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