Remove useless memset
[vlc.git] / modules / stream_out / record.c
1 /*****************************************************************************
2  * record.c: record stream output module
3  *****************************************************************************
4  * Copyright (C) 2008 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <limits.h>
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_block.h>
37 #include <vlc_sout.h>
38 #include <vlc_charset.h>
39 #include <assert.h>
40
41 /*****************************************************************************
42  * Exported prototypes
43  *****************************************************************************/
44 static int      Open    ( vlc_object_t * );
45 static void     Close   ( vlc_object_t * );
46
47 /*****************************************************************************
48  * Module descriptor
49  *****************************************************************************/
50 #define DST_PREFIX_TEXT N_("Destination prefix")
51 #define DST_PREFIX_LONGTEXT N_( \
52     "Prefix of the destination file automatically generated" )
53
54 #define SOUT_CFG_PREFIX "sout-record-"
55
56 vlc_module_begin ()
57     set_description( N_("Record stream output") )
58     set_capability( "sout stream", 0 )
59     add_shortcut( "record" )
60     set_shortname( N_("Record") )
61
62     set_category( CAT_SOUT )
63     set_subcategory( SUBCAT_SOUT_STREAM )
64
65     add_string( SOUT_CFG_PREFIX "dst-prefix", "", NULL, DST_PREFIX_TEXT,
66                 DST_PREFIX_LONGTEXT, true )
67
68     set_callbacks( Open, Close )
69 vlc_module_end ()
70
71 /* */
72 static const char *const ppsz_sout_options[] = {
73     "dst-prefix",
74     NULL
75 };
76
77 /* */
78 static sout_stream_id_t *Add ( sout_stream_t *, es_format_t * );
79 static int               Del ( sout_stream_t *, sout_stream_id_t * );
80 static int               Send( sout_stream_t *, sout_stream_id_t *, block_t* );
81
82 /* */
83 struct sout_stream_id_t
84 {
85     es_format_t fmt;
86
87     block_t *p_first;
88     block_t **pp_last;
89
90     sout_stream_id_t *id;
91
92     bool b_wait_key;
93     bool b_wait_start;
94 };
95
96 struct sout_stream_sys_t
97 {
98     char *psz_prefix;
99
100     sout_stream_t *p_out;
101
102     mtime_t     i_date_start;
103     size_t      i_size;
104
105     mtime_t     i_max_wait;
106     size_t      i_max_size;
107
108     bool        b_drop;
109
110     int              i_id;
111     sout_stream_id_t **id;
112     mtime_t     i_dts_start;
113 };
114
115 static void OutputStart( sout_stream_t *p_stream );
116 static void OutputSend( sout_stream_t *p_stream, sout_stream_id_t *id, block_t * );
117
118 /*****************************************************************************
119  * Open:
120  *****************************************************************************/
121 static int Open( vlc_object_t *p_this )
122 {
123     sout_stream_t *p_stream = (sout_stream_t*)p_this;
124     sout_stream_sys_t *p_sys;
125
126     p_stream->pf_add    = Add;
127     p_stream->pf_del    = Del;
128     p_stream->pf_send   = Send;
129
130     p_stream->p_sys = p_sys = malloc( sizeof(*p_sys) );
131     if( !p_sys )
132         return VLC_ENOMEM;
133
134     config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options, p_stream->p_cfg );
135
136     p_sys->p_out = NULL;
137     p_sys->psz_prefix = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "dst-prefix" );
138     if( !p_sys->psz_prefix  )
139     {
140         p_sys->psz_prefix = strdup( "sout-record-" );
141         if( !p_sys->psz_prefix )
142         {
143             free( p_sys );
144             return VLC_ENOMEM;
145         }
146     }
147
148     p_sys->i_date_start = -1;
149     p_sys->i_size = 0;
150 #ifdef OPTIMIZE_MEMORY
151     p_sys->i_max_wait = 5*1000000; /* 5s */
152     p_sys->i_max_size = 1*1000000; /* 1 Mbyte */
153 #else
154     p_sys->i_max_wait = 30*1000000; /* 30s */
155     p_sys->i_max_size = 20*1000000; /* 20 Mbyte */
156 #endif
157     p_sys->b_drop = false;
158     p_sys->i_dts_start = 0;
159     TAB_INIT( p_sys->i_id, p_sys->id );
160
161     return VLC_SUCCESS;
162 }
163
164 /*****************************************************************************
165  * Close:
166  *****************************************************************************/
167 static void Close( vlc_object_t * p_this )
168 {
169     sout_stream_t *p_stream = (sout_stream_t*)p_this;
170     sout_stream_sys_t *p_sys = p_stream->p_sys;
171
172     if( p_sys->p_out )
173         sout_StreamDelete( p_sys->p_out );
174
175     TAB_CLEAN( p_sys->i_id, p_sys->id );
176     free( p_sys->psz_prefix );
177     free( p_sys );
178 }
179
180 /*****************************************************************************
181  *
182  *****************************************************************************/
183 static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
184 {
185     sout_stream_sys_t *p_sys = p_stream->p_sys;
186     sout_stream_id_t *id;
187
188     id = malloc( sizeof(*id) );
189     if( !id )
190         return NULL;
191
192     es_format_Copy( &id->fmt, p_fmt );
193     id->p_first = NULL;
194     id->pp_last = &id->p_first;
195     id->id = NULL;
196     id->b_wait_key = true;
197     id->b_wait_start = true;
198
199     TAB_APPEND( p_sys->i_id, p_sys->id, id );
200
201     return id;
202 }
203
204 static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
205 {
206     sout_stream_sys_t *p_sys = p_stream->p_sys;
207
208     if( !p_sys->p_out )
209         OutputStart( p_stream );
210
211     if( id->p_first )
212         block_ChainRelease( id->p_first );
213
214     assert( !id->id || p_sys->p_out );
215     if( id->id )
216         sout_StreamIdDel( p_sys->p_out, id->id );
217
218     es_format_Clean( &id->fmt );
219
220     TAB_REMOVE( p_sys->i_id, p_sys->id, id );
221
222     if( p_sys->i_id <= 0 )
223     {
224         if( !p_sys->p_out )
225             p_sys->b_drop = false;
226     }
227
228     free( id );
229
230     return VLC_SUCCESS;
231 }
232
233 static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
234                  block_t *p_buffer )
235 {
236     sout_stream_sys_t *p_sys = p_stream->p_sys;
237
238     if( p_sys->i_date_start < 0 )
239         p_sys->i_date_start = mdate();
240     if( !p_sys->p_out &&
241         ( mdate() - p_sys->i_date_start > p_sys->i_max_wait ||
242           p_sys->i_size > p_sys->i_max_size ) )
243     {
244         msg_Dbg( p_stream, "Starting recording, waited %ds and %dbyte",
245                  (int)((mdate() - p_sys->i_date_start)/1000000), (int)p_sys->i_size );
246         OutputStart( p_stream );
247     }
248
249     OutputSend( p_stream, id, p_buffer );
250
251     return VLC_SUCCESS;
252 }
253
254 /*****************************************************************************
255  *
256  *****************************************************************************/
257 typedef struct
258 {
259     const char  *psz_muxer;
260     const char  *psz_extension;
261     int         i_es_max;
262     vlc_fourcc_t codec[128];
263 } muxer_properties_t;
264
265 #define M(muxer, ext, count, ... ) { .psz_muxer = muxer, .psz_extension = ext, .i_es_max = count, .codec = { __VA_ARGS__, 0 } }
266 /* Table of native codec support,
267  * Do not do non native and non standard association !
268  * Muxer will be probe if no entry found */
269 static const muxer_properties_t p_muxers[] = {
270     M( "raw", "mp3", 1,         VLC_FOURCC('m','p','g','a') ),
271     M( "raw", "a52", 1,         VLC_FOURCC('a','5','2',' ') ),
272     M( "raw", "dts", 1,         VLC_FOURCC('d','t','s',' ') ),
273     M( "raw", "mpc", 1,         VLC_FOURCC('m','p','c',' ') ),
274     M( "raw", "ape", 1,         VLC_FOURCC('A','P','E',' ') ),
275
276     M( "wav", "wav", 1,         VLC_FOURCC('a','r','a','w'), VLC_FOURCC('u','8',' ',' '), VLC_FOURCC('s','1','6','l'),
277                                 VLC_FOURCC('s','2','4','l'), VLC_FOURCC('s','3','2','l'), VLC_FOURCC('f','l','3','2') ),
278
279     //M( "ffmpeg{mux=flac}", "flac", 1, VLC_FOURCC('f','l','a','c') ), BROKEN
280
281     M( "ogg", "ogg", INT_MAX,   VLC_FOURCC('v','o','r','b'), VLC_FOURCC('s','p','x',' '), VLC_FOURCC('f','l','a','c'),
282                                 VLC_FOURCC('s','u','b','t'), VLC_FOURCC('t','h','e','o'), VLC_FOURCC('d','r','a','c')  ),
283
284     M( "asf", "asf", 127,       VLC_FOURCC('w','m','a','1'), VLC_FOURCC('w','m','a','2'), VLC_FOURCC('w','m','a',' '),
285                                 VLC_FOURCC('w','m','a','p'), VLC_FOURCC('w','m','a','l'),
286                                 VLC_FOURCC('W','M','V','1'), VLC_FOURCC('W','M','V','2'), VLC_FOURCC('W','M','V','3'),
287                                 VLC_FOURCC('W','V','C','1')),
288
289     M( "mp4", "mp4", INT_MAX,   VLC_FOURCC('m','p','4','a'), VLC_FOURCC('h','2','6','4'), VLC_FOURCC('m','p','4','v'),
290                                 VLC_FOURCC('s','u','b','t') ),
291
292     M( "ps", "mpg", 16/* FIXME*/,VLC_FOURCC('m','p','g','v'), VLC_FOURCC('m','p','1','v'), VLC_FOURCC('m','p','2','v'),
293                                 VLC_FOURCC('m','p','g','a'), VLC_FOURCC('l','p','c','m'), VLC_FOURCC('a','5','2',' '),
294                                 VLC_FOURCC('d','t','s',' '),
295                                 VLC_FOURCC('s','p','u',' ') ),
296
297     M( "ts", "ts", 8000,        VLC_FOURCC('m','p','g','v'), VLC_FOURCC('m','p','1','v'), VLC_FOURCC('m','p','2','v'),
298                                 VLC_FOURCC('h','2','6','4'),
299                                 VLC_FOURCC('m','p','g','a'), VLC_FOURCC('l','p','c','m'), VLC_FOURCC('a','5','2',' '),
300                                 VLC_FOURCC('d','t','s',' '), VLC_FOURCC('m','p','4','a'),
301                                 VLC_FOURCC('d','v','b','s'), VLC_FOURCC('t','e','l','x') ),
302
303     M( NULL, NULL, 0, 0 )
304 };
305 #undef M
306
307 static int OutputNew( sout_stream_t *p_stream,
308                       const char *psz_muxer, const char *psz_prefix, const char *psz_extension  )
309 {
310     sout_stream_sys_t *p_sys = p_stream->p_sys;
311     char *psz_output;
312     int i_count;
313
314     if( asprintf( &psz_output, "std{access=file,mux='%s',dst='%s%s%s'}",
315                   psz_muxer, psz_prefix, psz_extension ? "." : "", psz_extension ? psz_extension : "" ) < 0 )
316         return -1;
317
318     /* Create the output */
319     msg_Dbg( p_stream, "Using record output `%s'", psz_output );
320     p_sys->p_out = sout_StreamNew( p_stream->p_sout, psz_output );
321
322     free( psz_output );
323
324     if( !p_sys->p_out )
325         return -1;
326
327     /* Add es */
328     i_count = 0;
329     for( int i = 0; i < p_sys->i_id; i++ )
330     {
331         sout_stream_id_t *id = p_sys->id[i];
332
333         id->id = sout_StreamIdAdd( p_sys->p_out, &id->fmt );
334         if( id->id )
335             i_count++;
336     }
337
338     return i_count;
339 }
340
341 static void OutputStart( sout_stream_t *p_stream )
342 {
343     sout_stream_sys_t *p_sys = p_stream->p_sys;
344
345     /* */
346     if( p_sys->b_drop )
347         return;
348
349     /* From now on drop packet that cannot be handled */
350     p_sys->b_drop = true;
351
352     /* Detect streams to smart select muxer */
353     const char *psz_muxer = NULL;
354     const char *psz_extension = NULL;
355
356     /* Look for prefered muxer
357      * TODO we could insert transcode in a few cases like
358      * s16l <-> s16b
359      */
360     for( int i = 0; p_muxers[i].psz_muxer != NULL; i++ )
361     {
362         bool b_ok;
363         if( p_sys->i_id > p_muxers[i].i_es_max )
364             continue;
365
366         b_ok = true;
367         for( int j = 0; j < p_sys->i_id; j++ )
368         {
369             es_format_t *p_fmt = &p_sys->id[j]->fmt;
370
371             b_ok = false;
372             for( int k = 0; p_muxers[i].codec[k] != 0; k++ )
373             {
374                 if( p_fmt->i_codec == p_muxers[i].codec[k] )
375                 {
376                     b_ok = true;
377                     break;
378                 }
379             }
380             if( !b_ok )
381                 break;
382         }
383         if( !b_ok )
384             continue;
385
386         psz_muxer = p_muxers[i].psz_muxer;
387         psz_extension = p_muxers[i].psz_extension;
388         break;
389     }
390
391     /* If failed, brute force our demuxers and select the one that
392      * keeps most of our stream */
393     if( !psz_muxer || !psz_extension )
394     {
395         static const char *ppsz_muxers[][2] = {
396             { "avi", "avi" }, { "mp4", "mp4" }, { "ogg", "ogg" },
397             { "asf", "asf" }, {  "ts",  "ts" }, {  "ps", "mpg" },
398 #if 0
399             // XXX ffmpeg sefault really easily if you try an unsupported codec
400             // mov and avi at least segfault
401             { "ffmpeg{mux=avi}", "avi" },
402             { "ffmpeg{mux=mov}", "mov" },
403             { "ffmpeg{mux=mp4}", "mp4" },
404             { "ffmpeg{mux=nsv}", "nsv" },
405             { "ffmpeg{mux=flv}", "flv" },
406 #endif
407             { NULL, NULL }
408         };
409         int i_best = 0;
410         int i_best_es = 0;
411
412         msg_Warn( p_stream, "failed to find an adequate muxer, probing muxers" );
413         for( int i = 0; ppsz_muxers[i][0] != NULL; i++ )
414         {
415             char *psz_file;
416             int i_es;
417
418             psz_file = tempnam( NULL, "vlc" );
419             if( !psz_file )
420                 continue;
421
422             msg_Dbg( p_stream, "probing muxer %s", ppsz_muxers[i][0] );
423             i_es = OutputNew( p_stream, ppsz_muxers[i][0], psz_file, NULL );
424
425             if( i_es < 0 )
426             {
427                 utf8_unlink( psz_file );
428                 free( psz_file );
429                 continue;
430             }
431
432             /* */
433             for( int i = 0; i < p_sys->i_id; i++ )
434             {
435                 sout_stream_id_t *id = p_sys->id[i];
436
437                 if( id->id )
438                     sout_StreamIdDel( p_sys->p_out, id->id );
439                 id->id = NULL;
440             }
441             if( p_sys->p_out )
442                 sout_StreamDelete( p_sys->p_out );
443             p_sys->p_out = NULL;
444
445             if( i_es > i_best_es )
446             {
447                 i_best_es = i_es;
448                 i_best = i;
449
450                 if( i_best_es >= p_sys->i_id )
451                     break;
452             }
453             utf8_unlink( psz_file );
454             free( psz_file );
455         }
456
457         /* */
458         psz_muxer = ppsz_muxers[i_best][0];
459         psz_extension = ppsz_muxers[i_best][1];
460         msg_Dbg( p_stream, "using muxer %s with extension %s (%d/%d streams accepted)",
461                  psz_muxer, psz_extension, i_best_es, p_sys->i_id );
462     }
463
464     /* Create the output */
465     if( OutputNew( p_stream, psz_muxer, p_sys->psz_prefix, psz_extension ) < 0 )
466     {
467         msg_Err( p_stream, "failed to open output");
468         return;
469     }
470
471     /* Compute highest timestamp of first I over all streams */
472     p_sys->i_dts_start = 0;
473     for( int i = 0; i < p_sys->i_id; i++ )
474     {
475         sout_stream_id_t *id = p_sys->id[i];
476         block_t *p_block;
477
478         if( !id->id || !id->p_first )
479             continue;
480
481         mtime_t i_dts = id->p_first->i_dts;
482         for( p_block = id->p_first; p_block != NULL; p_block = p_block->p_next )
483         {
484             if( p_block->i_flags & BLOCK_FLAG_TYPE_I )
485             {
486                 i_dts = p_block->i_dts;
487                 break;
488             }
489         }
490
491         if( i_dts > p_sys->i_dts_start )
492             p_sys->i_dts_start = i_dts;
493     }
494
495     /* Send buffered data */
496     for( int i = 0; i < p_sys->i_id; i++ )
497     {
498         sout_stream_id_t *id = p_sys->id[i];
499
500         if( !id->id )
501             continue;
502
503         block_t *p_block = id->p_first;
504         while( p_block )
505         {
506             block_t *p_next = p_block->p_next;
507
508             p_block->p_next = NULL;
509
510             OutputSend( p_stream, id, p_block );
511
512             p_block = p_next;
513         }
514
515         id->p_first = NULL;
516         id->pp_last = &id->p_first;
517     }
518 }
519
520 static void OutputSend( sout_stream_t *p_stream, sout_stream_id_t *id, block_t *p_block )
521 {
522     sout_stream_sys_t *p_sys = p_stream->p_sys;
523
524     if( id->id )
525     {
526         /* We wait until the first key frame (if needed) and
527          * to be beyong i_dts_start (for stream without key frame) */
528         if( id->b_wait_key )
529         {
530             if( p_block->i_flags & BLOCK_FLAG_TYPE_I )
531             {
532                 id->b_wait_key = false;
533                 id->b_wait_start = false;
534             }
535
536             if( ( p_block->i_flags & BLOCK_FLAG_TYPE_MASK ) == 0 )
537                 id->b_wait_key = false;
538         }
539         if( id->b_wait_start )
540         {
541             if( p_block->i_dts >=p_sys->i_dts_start )
542                 id->b_wait_start = false;
543         }
544         if( id->b_wait_key || id->b_wait_start )
545             block_ChainRelease( p_block );
546         else
547             sout_StreamIdSend( p_sys->p_out, id->id, p_block );
548     }
549     else if( p_sys->b_drop )
550     {
551         block_ChainRelease( p_block );
552     }
553     else
554     {
555         size_t i_size;
556
557         block_ChainProperties( p_block, NULL, &i_size, NULL );
558         p_sys->i_size += i_size;
559         block_ChainLastAppend( &id->pp_last, p_block );
560     }
561 }
562