Bump dates to 2013
[x262.git] / output / flv.c
1 /*****************************************************************************
2  * flv.c: flv muxer
3  *****************************************************************************
4  * Copyright (C) 2009-2013 x264 project
5  *
6  * Authors: Kieran Kunhya <kieran@kunhya.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program 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
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
21  *
22  * This program is also available under a commercial proprietary license.
23  * For more information, contact us at licensing@x264.com.
24  *****************************************************************************/
25
26 #include "output.h"
27 #include "flv_bytestream.h"
28
29 #define CHECK(x)\
30 do {\
31     if( (x) < 0 )\
32         return -1;\
33 } while( 0 )
34
35 typedef struct
36 {
37     flv_buffer *c;
38
39     uint8_t *sei;
40     int sei_len;
41
42     int64_t i_fps_num;
43     int64_t i_fps_den;
44     int64_t i_framenum;
45
46     uint64_t i_framerate_pos;
47     uint64_t i_duration_pos;
48     uint64_t i_filesize_pos;
49     uint64_t i_bitrate_pos;
50
51     uint8_t b_write_length;
52     int64_t i_prev_dts;
53     int64_t i_prev_cts;
54     int64_t i_delay_time;
55     int64_t i_init_delta;
56     int i_delay_frames;
57
58     double d_timebase;
59     int b_vfr_input;
60     int b_dts_compress;
61
62     unsigned start;
63 } flv_hnd_t;
64
65 static int write_header( flv_buffer *c )
66 {
67     flv_put_tag( c, "FLV" ); // Signature
68     flv_put_byte( c, 1 );    // Version
69     flv_put_byte( c, 1 );    // Video Only
70     flv_put_be32( c, 9 );    // DataOffset
71     flv_put_be32( c, 0 );    // PreviousTagSize0
72
73     return flv_flush_data( c );
74 }
75
76 static int open_file( char *psz_filename, hnd_t *p_handle, cli_output_opt_t *opt )
77 {
78     flv_hnd_t *p_flv = malloc( sizeof(*p_flv) );
79     *p_handle = NULL;
80     if( !p_flv )
81         return -1;
82     memset( p_flv, 0, sizeof(*p_flv) );
83
84     p_flv->b_dts_compress = opt->use_dts_compress;
85
86     p_flv->c = flv_create_writer( psz_filename );
87     if( !p_flv->c )
88         return -1;
89
90     CHECK( write_header( p_flv->c ) );
91     *p_handle = p_flv;
92
93     return 0;
94 }
95
96 static int set_param( hnd_t handle, x264_param_t *p_param )
97 {
98     flv_hnd_t *p_flv = handle;
99     flv_buffer *c = p_flv->c;
100
101     flv_put_byte( c, FLV_TAG_TYPE_META ); // Tag Type "script data"
102
103     int start = c->d_cur;
104     flv_put_be24( c, 0 ); // data length
105     flv_put_be24( c, 0 ); // timestamp
106     flv_put_be32( c, 0 ); // reserved
107
108     flv_put_byte( c, AMF_DATA_TYPE_STRING );
109     flv_put_amf_string( c, "onMetaData" );
110
111     flv_put_byte( c, AMF_DATA_TYPE_MIXEDARRAY );
112     flv_put_be32( c, 7 );
113
114     flv_put_amf_string( c, "width" );
115     flv_put_amf_double( c, p_param->i_width );
116
117     flv_put_amf_string( c, "height" );
118     flv_put_amf_double( c, p_param->i_height );
119
120     flv_put_amf_string( c, "framerate" );
121
122     if( !p_param->b_vfr_input )
123         flv_put_amf_double( c, (double)p_param->i_fps_num / p_param->i_fps_den );
124     else
125     {
126         p_flv->i_framerate_pos = c->d_cur + c->d_total + 1;
127         flv_put_amf_double( c, 0 ); // written at end of encoding
128     }
129
130     flv_put_amf_string( c, "videocodecid" );
131     flv_put_amf_double( c, FLV_CODECID_H264 );
132
133     flv_put_amf_string( c, "duration" );
134     p_flv->i_duration_pos = c->d_cur + c->d_total + 1;
135     flv_put_amf_double( c, 0 ); // written at end of encoding
136
137     flv_put_amf_string( c, "filesize" );
138     p_flv->i_filesize_pos = c->d_cur + c->d_total + 1;
139     flv_put_amf_double( c, 0 ); // written at end of encoding
140
141     flv_put_amf_string( c, "videodatarate" );
142     p_flv->i_bitrate_pos = c->d_cur + c->d_total + 1;
143     flv_put_amf_double( c, 0 ); // written at end of encoding
144
145     flv_put_amf_string( c, "" );
146     flv_put_byte( c, AMF_END_OF_OBJECT );
147
148     unsigned length = c->d_cur - start;
149     flv_rewrite_amf_be24( c, length - 10, start );
150
151     flv_put_be32( c, length + 1 ); // tag length
152
153     p_flv->i_fps_num = p_param->i_fps_num;
154     p_flv->i_fps_den = p_param->i_fps_den;
155     p_flv->d_timebase = (double)p_param->i_timebase_num / p_param->i_timebase_den;
156     p_flv->b_vfr_input = p_param->b_vfr_input;
157     p_flv->i_delay_frames = p_param->i_bframe ? (p_param->i_bframe_pyramid ? 2 : 1) : 0;
158
159     return 0;
160 }
161
162 static int write_headers( hnd_t handle, x264_nal_t *p_nal )
163 {
164     flv_hnd_t *p_flv = handle;
165     flv_buffer *c = p_flv->c;
166
167     int sps_size = p_nal[0].i_payload;
168     int pps_size = p_nal[1].i_payload;
169     int sei_size = p_nal[2].i_payload;
170
171     // SEI
172     /* It is within the spec to write this as-is but for
173      * mplayer/ffmpeg playback this is deferred until before the first frame */
174
175     p_flv->sei = malloc( sei_size );
176     if( !p_flv->sei )
177         return -1;
178     p_flv->sei_len = sei_size;
179
180     memcpy( p_flv->sei, p_nal[2].p_payload, sei_size );
181
182     // SPS
183     uint8_t *sps = p_nal[0].p_payload + 4;
184
185     flv_put_byte( c, FLV_TAG_TYPE_VIDEO );
186     flv_put_be24( c, 0 ); // rewrite later
187     flv_put_be24( c, 0 ); // timestamp
188     flv_put_byte( c, 0 ); // timestamp extended
189     flv_put_be24( c, 0 ); // StreamID - Always 0
190     p_flv->start = c->d_cur; // needed for overwriting length
191
192     flv_put_byte( c, 7 | FLV_FRAME_KEY ); // Frametype and CodecID
193     flv_put_byte( c, 0 ); // AVC sequence header
194     flv_put_be24( c, 0 ); // composition time
195
196     flv_put_byte( c, 1 );      // version
197     flv_put_byte( c, sps[1] ); // profile
198     flv_put_byte( c, sps[2] ); // profile
199     flv_put_byte( c, sps[3] ); // level
200     flv_put_byte( c, 0xff );   // 6 bits reserved (111111) + 2 bits nal size length - 1 (11)
201     flv_put_byte( c, 0xe1 );   // 3 bits reserved (111) + 5 bits number of sps (00001)
202
203     flv_put_be16( c, sps_size - 4 );
204     flv_append_data( c, sps, sps_size - 4 );
205
206     // PPS
207     flv_put_byte( c, 1 ); // number of pps
208     flv_put_be16( c, pps_size - 4 );
209     flv_append_data( c, p_nal[1].p_payload + 4, pps_size - 4 );
210
211     // rewrite data length info
212     unsigned length = c->d_cur - p_flv->start;
213     flv_rewrite_amf_be24( c, length, p_flv->start - 10 );
214     flv_put_be32( c, length + 11 ); // Last tag size
215     CHECK( flv_flush_data( c ) );
216
217     return sei_size + sps_size + pps_size;
218 }
219
220 static int write_frame( hnd_t handle, uint8_t *p_nalu, int i_size, x264_picture_t *p_picture )
221 {
222     flv_hnd_t *p_flv = handle;
223     flv_buffer *c = p_flv->c;
224
225 #define convert_timebase_ms( timestamp, timebase ) (int64_t)((timestamp) * (timebase) * 1000 + 0.5)
226
227     if( !p_flv->i_framenum )
228     {
229         p_flv->i_delay_time = p_picture->i_dts * -1;
230         if( !p_flv->b_dts_compress && p_flv->i_delay_time )
231             x264_cli_log( "flv", X264_LOG_INFO, "initial delay %"PRId64" ms\n",
232                           convert_timebase_ms( p_picture->i_pts + p_flv->i_delay_time, p_flv->d_timebase ) );
233     }
234
235     int64_t dts;
236     int64_t cts;
237     int64_t offset;
238
239     if( p_flv->b_dts_compress )
240     {
241         if( p_flv->i_framenum == 1 )
242             p_flv->i_init_delta = convert_timebase_ms( p_picture->i_dts + p_flv->i_delay_time, p_flv->d_timebase );
243         dts = p_flv->i_framenum > p_flv->i_delay_frames
244             ? convert_timebase_ms( p_picture->i_dts, p_flv->d_timebase )
245             : p_flv->i_framenum * p_flv->i_init_delta / (p_flv->i_delay_frames + 1);
246         cts = convert_timebase_ms( p_picture->i_pts, p_flv->d_timebase );
247     }
248     else
249     {
250         dts = convert_timebase_ms( p_picture->i_dts + p_flv->i_delay_time, p_flv->d_timebase );
251         cts = convert_timebase_ms( p_picture->i_pts + p_flv->i_delay_time, p_flv->d_timebase );
252     }
253     offset = cts - dts;
254
255     if( p_flv->i_framenum )
256     {
257         if( p_flv->i_prev_dts == dts )
258             x264_cli_log( "flv", X264_LOG_WARNING, "duplicate DTS %"PRId64" generated by rounding\n"
259                           "               decoding framerate cannot exceed 1000fps\n", dts );
260         if( p_flv->i_prev_cts == cts )
261             x264_cli_log( "flv", X264_LOG_WARNING, "duplicate CTS %"PRId64" generated by rounding\n"
262                           "               composition framerate cannot exceed 1000fps\n", cts );
263     }
264     p_flv->i_prev_dts = dts;
265     p_flv->i_prev_cts = cts;
266
267     // A new frame - write packet header
268     flv_put_byte( c, FLV_TAG_TYPE_VIDEO );
269     flv_put_be24( c, 0 ); // calculated later
270     flv_put_be24( c, dts );
271     flv_put_byte( c, dts >> 24 );
272     flv_put_be24( c, 0 );
273
274     p_flv->start = c->d_cur;
275     flv_put_byte( c, p_picture->b_keyframe ? FLV_FRAME_KEY : FLV_FRAME_INTER );
276     flv_put_byte( c, 1 ); // AVC NALU
277     flv_put_be24( c, offset );
278
279     if( p_flv->sei )
280     {
281         flv_append_data( c, p_flv->sei, p_flv->sei_len );
282         free( p_flv->sei );
283         p_flv->sei = NULL;
284     }
285     flv_append_data( c, p_nalu, i_size );
286
287     unsigned length = c->d_cur - p_flv->start;
288     flv_rewrite_amf_be24( c, length, p_flv->start - 10 );
289     flv_put_be32( c, 11 + length ); // Last tag size
290     CHECK( flv_flush_data( c ) );
291
292     p_flv->i_framenum++;
293
294     return i_size;
295 }
296
297 static void rewrite_amf_double( FILE *fp, uint64_t position, double value )
298 {
299     uint64_t x = endian_fix64( flv_dbl2int( value ) );
300     fseek( fp, position, SEEK_SET );
301     fwrite( &x, 8, 1, fp );
302 }
303
304 static int close_file( hnd_t handle, int64_t largest_pts, int64_t second_largest_pts )
305 {
306     flv_hnd_t *p_flv = handle;
307     flv_buffer *c = p_flv->c;
308
309     CHECK( flv_flush_data( c ) );
310
311     double total_duration = (2 * largest_pts - second_largest_pts) * p_flv->d_timebase;
312
313     if( x264_is_regular_file( c->fp ) && total_duration > 0 )
314     {
315         double framerate;
316         uint64_t filesize = ftell( c->fp );
317
318         if( p_flv->i_framerate_pos )
319         {
320             framerate = (double)p_flv->i_framenum / total_duration;
321             rewrite_amf_double( c->fp, p_flv->i_framerate_pos, framerate );
322         }
323
324         rewrite_amf_double( c->fp, p_flv->i_duration_pos, total_duration );
325         rewrite_amf_double( c->fp, p_flv->i_filesize_pos, filesize );
326         rewrite_amf_double( c->fp, p_flv->i_bitrate_pos, filesize * 8 / ( total_duration * 1000 ) );
327     }
328
329     fclose( c->fp );
330     free( p_flv );
331     free( c );
332
333     return 0;
334 }
335
336 const cli_output_t flv_output = { open_file, set_param, write_headers, write_frame, close_file };