c8bc465ce401ec792da446f60b198391685342e3
[vlc.git] / src / stream_output / stream_output.c
1 /*****************************************************************************
2  * stream_output.c : stream output module
3  *****************************************************************************
4  * Copyright (C) 2002-2004 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
8  *          Laurent Aimar <fenrir@via.ecp.fr>
9  *          Eric Petit <titer@videolan.org>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29
30 #include <vlc/vlc.h>
31
32 #include <stdlib.h>                                                /* free() */
33 #include <stdio.h>                                              /* sprintf() */
34 #include <string.h>                                            /* strerror() */
35
36 #include <vlc/sout.h>
37 #include <vlc/input.h>
38
39 #include "vlc_meta.h"
40
41 #undef DEBUG_BUFFER
42 /*****************************************************************************
43  * Local prototypes
44  *****************************************************************************/
45 static void sout_CfgDestroy( sout_cfg_t * );
46
47 #define sout_stream_url_to_chain( p, s ) \
48     _sout_stream_url_to_chain( VLC_OBJECT(p), s )
49 static char *_sout_stream_url_to_chain( vlc_object_t *, char * );
50
51 /*
52  * Generic MRL parser
53  *
54  */
55
56 typedef struct
57 {
58     char *psz_access;
59     char *psz_way;
60     char *psz_name;
61 } mrl_t;
62
63 /* mrl_Parse: parse psz_mrl and fill p_mrl */
64 static int  mrl_Parse( mrl_t *p_mrl, char *psz_mrl );
65 /* mrl_Clean: clean p_mrl  after a call to mrl_Parse */
66 static void mrl_Clean( mrl_t *p_mrl );
67
68 /*****************************************************************************
69  * sout_NewInstance: creates a new stream output instance
70  *****************************************************************************/
71 sout_instance_t *__sout_NewInstance( vlc_object_t *p_parent, char * psz_dest )
72 {
73     sout_instance_t *p_sout;
74     vlc_value_t keep;
75
76     if( var_Get( p_parent, "sout-keep", &keep ) < 0 )
77     {
78         msg_Warn( p_parent, "cannot get sout-keep value" );
79         keep.b_bool = VLC_FALSE;
80     }
81     if( keep.b_bool )
82     {
83         if( ( p_sout = vlc_object_find( p_parent, VLC_OBJECT_SOUT,
84                                         FIND_ANYWHERE ) ) != NULL )
85         {
86             if( !strcmp( p_sout->psz_sout, psz_dest ) )
87             {
88                 msg_Dbg( p_parent, "sout keep: reusing sout" );
89                 msg_Dbg( p_parent, "sout keep: you probably want to use "
90                           "gather stream_out" );
91                 vlc_object_detach( p_sout );
92                 vlc_object_attach( p_sout, p_parent );
93                 vlc_object_release( p_sout );
94                 return p_sout;
95             }
96             else
97             {
98                 msg_Dbg( p_parent, "sout keep: destroying unusable sout" );
99                 vlc_object_release( p_sout );
100                 sout_DeleteInstance( p_sout );
101             }
102         }
103     }
104     else if( !keep.b_bool )
105     {
106         while( ( p_sout = vlc_object_find( p_parent, VLC_OBJECT_SOUT,
107                                            FIND_PARENT ) ) != NULL )
108         {
109             msg_Dbg( p_parent, "sout keep: destroying old sout" );
110             vlc_object_release( p_sout );
111             sout_DeleteInstance( p_sout );
112         }
113     }
114
115     /* *** Allocate descriptor *** */
116     p_sout = vlc_object_create( p_parent, VLC_OBJECT_SOUT );
117     if( p_sout == NULL )
118     {
119         msg_Err( p_parent, "out of memory" );
120         return NULL;
121     }
122
123     /* *** init descriptor *** */
124     p_sout->psz_sout    = strdup( psz_dest );
125     p_sout->p_meta      = NULL;
126     p_sout->i_out_pace_nocontrol = 0;
127     p_sout->p_sys       = NULL;
128
129     vlc_mutex_init( p_sout, &p_sout->lock );
130     if( psz_dest && psz_dest[0] == '#' )
131     {
132         p_sout->psz_chain = strdup( &psz_dest[1] );
133     }
134     else
135     {
136         p_sout->psz_chain = sout_stream_url_to_chain( p_sout, psz_dest );
137         msg_Dbg( p_sout, "using sout chain=`%s'", p_sout->psz_chain );
138     }
139     p_sout->p_stream = NULL;
140
141     /* attach it for inherit */
142     vlc_object_attach( p_sout, p_parent );
143
144     p_sout->p_stream = sout_StreamNew( p_sout, p_sout->psz_chain );
145
146     if( p_sout->p_stream == NULL )
147     {
148         msg_Err( p_sout, "stream chain failed for `%s'", p_sout->psz_chain );
149
150         FREENULL( p_sout->psz_sout );
151         FREENULL( p_sout->psz_chain );
152
153         vlc_object_detach( p_sout );
154         vlc_object_destroy( p_sout );
155         return NULL;
156     }
157
158     return p_sout;
159 }
160
161 /*****************************************************************************
162  * sout_DeleteInstance: delete a previously allocated instance
163  *****************************************************************************/
164 void sout_DeleteInstance( sout_instance_t * p_sout )
165 {
166     /* Unlink object */
167     vlc_object_detach( p_sout );
168
169     /* remove the stream out chain */
170     sout_StreamDelete( p_sout->p_stream );
171
172     /* *** free all string *** */
173     FREENULL( p_sout->psz_sout );
174     FREENULL( p_sout->psz_chain );
175
176     /* delete meta */
177     if( p_sout->p_meta )
178     {
179         vlc_meta_Delete( p_sout->p_meta );
180     }
181
182     vlc_mutex_destroy( &p_sout->lock );
183
184     /* *** free structure *** */
185     vlc_object_destroy( p_sout );
186 }
187
188 /*****************************************************************************
189  * Packetizer/Input
190  *****************************************************************************/
191 sout_packetizer_input_t *sout_InputNew( sout_instance_t *p_sout,
192                                         es_format_t *p_fmt )
193 {
194     sout_packetizer_input_t *p_input;
195
196     msg_Dbg( p_sout, "adding a new input" );
197
198     /* *** create a packetizer input *** */
199     p_input         = malloc( sizeof( sout_packetizer_input_t ) );
200     p_input->p_sout = p_sout;
201     p_input->p_fmt  = p_fmt;
202
203     if( p_fmt->i_codec == VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
204     {
205         vlc_object_release( p_sout );
206         return p_input;
207     }
208
209     /* *** add it to the stream chain */
210     vlc_mutex_lock( &p_sout->lock );
211     p_input->id = p_sout->p_stream->pf_add( p_sout->p_stream, p_fmt );
212     vlc_mutex_unlock( &p_sout->lock );
213
214     if( p_input->id == NULL )
215     {
216         free( p_input );
217         return NULL;
218     }
219
220     return( p_input );
221 }
222
223 /*****************************************************************************
224  *
225  *****************************************************************************/
226 int sout_InputDelete( sout_packetizer_input_t *p_input )
227 {
228     sout_instance_t     *p_sout = p_input->p_sout;
229
230     msg_Dbg( p_sout, "removing an input" );
231
232     if( p_input->p_fmt->i_codec != VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
233     {
234         vlc_mutex_lock( &p_sout->lock );
235         p_sout->p_stream->pf_del( p_sout->p_stream, p_input->id );
236         vlc_mutex_unlock( &p_sout->lock );
237     }
238
239     free( p_input );
240
241     return( VLC_SUCCESS);
242 }
243
244 /*****************************************************************************
245  *
246  *****************************************************************************/
247 int sout_InputSendBuffer( sout_packetizer_input_t *p_input,
248                           block_t *p_buffer )
249 {
250     sout_instance_t     *p_sout = p_input->p_sout;
251     int                 i_ret;
252
253     if( p_input->p_fmt->i_codec == VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
254     {
255         block_Release( p_buffer );
256         return VLC_SUCCESS;
257     }
258     if( p_buffer->i_dts <= 0 )
259     {
260         msg_Warn( p_sout, "trying to send non-dated packet to stream output!");
261         block_Release( p_buffer );
262         return VLC_SUCCESS;
263     }
264
265     vlc_mutex_lock( &p_sout->lock );
266     i_ret = p_sout->p_stream->pf_send( p_sout->p_stream,
267                                        p_input->id, p_buffer );
268     vlc_mutex_unlock( &p_sout->lock );
269
270     return i_ret;
271 }
272
273 /*****************************************************************************
274  * sout_AccessOutNew: allocate a new access out
275  *****************************************************************************/
276 sout_access_out_t *sout_AccessOutNew( sout_instance_t *p_sout,
277                                       char *psz_access, char *psz_name )
278 {
279     sout_access_out_t *p_access;
280     char              *psz_next;
281
282     if( !( p_access = vlc_object_create( p_sout,
283                                          sizeof( sout_access_out_t ) ) ) )
284     {
285         msg_Err( p_sout, "out of memory" );
286         return NULL;
287     }
288
289     psz_next = sout_CfgCreate( &p_access->psz_access, &p_access->p_cfg,
290                                 psz_access );
291     if( psz_next )
292     {
293         free( psz_next );
294     }
295     p_access->psz_name   = strdup( psz_name ? psz_name : "" );
296     p_access->p_sout     = p_sout;
297     p_access->p_sys = NULL;
298     p_access->pf_seek    = NULL;
299     p_access->pf_read    = NULL;
300     p_access->pf_write   = NULL;
301     p_access->p_module   = NULL;
302
303     p_access->i_writes = 0;
304     p_access->i_sent_bytes = 0;
305
306     vlc_object_attach( p_access, p_sout );
307
308     p_access->p_module   =
309         module_Need( p_access, "sout access", p_access->psz_access, VLC_TRUE );
310
311     if( !p_access->p_module )
312     {
313         free( p_access->psz_access );
314         free( p_access->psz_name );
315         vlc_object_detach( p_access );
316         vlc_object_destroy( p_access );
317         return( NULL );
318     }
319
320     return p_access;
321 }
322 /*****************************************************************************
323  * sout_AccessDelete: delete an access out
324  *****************************************************************************/
325 void sout_AccessOutDelete( sout_access_out_t *p_access )
326 {
327     vlc_object_detach( p_access );
328     if( p_access->p_module )
329     {
330         module_Unneed( p_access, p_access->p_module );
331     }
332     free( p_access->psz_access );
333
334     sout_CfgDestroy( p_access->p_cfg );
335
336     free( p_access->psz_name );
337
338     vlc_object_destroy( p_access );
339 }
340
341 /*****************************************************************************
342  * sout_AccessSeek:
343  *****************************************************************************/
344 int sout_AccessOutSeek( sout_access_out_t *p_access, off_t i_pos )
345 {
346     return p_access->pf_seek( p_access, i_pos );
347 }
348
349 /*****************************************************************************
350  * sout_AccessRead:
351  *****************************************************************************/
352 int sout_AccessOutRead( sout_access_out_t *p_access, block_t *p_buffer )
353 {
354     return( p_access->pf_read ?
355             p_access->pf_read( p_access, p_buffer ) : VLC_EGENERIC );
356 }
357
358 /*****************************************************************************
359  * sout_AccessWrite:
360  *****************************************************************************/
361 int sout_AccessOutWrite( sout_access_out_t *p_access, block_t *p_buffer )
362 {
363     int i_total = 0;
364     p_access->i_writes++;
365     p_access->i_sent_bytes += p_buffer->i_buffer;
366     if( p_access->p_libvlc->b_stats && p_access->i_writes % 30 == 0 )
367     {
368         /* Access_out -> sout_instance -> input_thread_t */
369         input_thread_t *p_input =
370             (input_thread_t *)vlc_object_find( p_access, VLC_OBJECT_INPUT,
371                                                FIND_PARENT );
372         if( p_input )
373         {
374             stats_UpdateInteger( p_input, p_input->counters.p_sout_sent_packets,
375                                  30, NULL );
376             stats_UpdateInteger( p_input, p_input->counters.p_sout_sent_bytes,
377                                  p_access->i_sent_bytes, &i_total );
378             stats_UpdateFloat( p_input, p_input->counters.p_sout_send_bitrate,
379                                  (float)i_total, NULL );
380             p_access->i_sent_bytes = 0;
381             vlc_object_release( p_input );
382         }
383     }
384     return p_access->pf_write( p_access, p_buffer );
385 }
386
387 /*****************************************************************************
388  * sout_MuxNew: create a new mux
389  *****************************************************************************/
390 sout_mux_t * sout_MuxNew( sout_instance_t *p_sout, char *psz_mux,
391                           sout_access_out_t *p_access )
392 {
393     sout_mux_t *p_mux;
394     char       *psz_next;
395
396     p_mux = vlc_object_create( p_sout, sizeof( sout_mux_t ) );
397     if( p_mux == NULL )
398     {
399         msg_Err( p_sout, "out of memory" );
400         return NULL;
401     }
402
403     p_mux->p_sout = p_sout;
404     psz_next = sout_CfgCreate( &p_mux->psz_mux, &p_mux->p_cfg, psz_mux );
405     if( psz_next ) free( psz_next );
406
407     p_mux->p_access     = p_access;
408     p_mux->pf_control   = NULL;
409     p_mux->pf_addstream = NULL;
410     p_mux->pf_delstream = NULL;
411     p_mux->pf_mux       = NULL;
412     p_mux->i_nb_inputs  = 0;
413     p_mux->pp_inputs    = NULL;
414
415     p_mux->p_sys        = NULL;
416     p_mux->p_module     = NULL;
417
418     p_mux->b_add_stream_any_time = VLC_FALSE;
419     p_mux->b_waiting_stream = VLC_TRUE;
420     p_mux->i_add_stream_start = -1;
421
422     vlc_object_attach( p_mux, p_sout );
423
424     p_mux->p_module =
425         module_Need( p_mux, "sout mux", p_mux->psz_mux, VLC_TRUE );
426
427     if( p_mux->p_module == NULL )
428     {
429         FREENULL( p_mux->psz_mux );
430
431         vlc_object_detach( p_mux );
432         vlc_object_destroy( p_mux );
433         return NULL;
434     }
435
436     /* *** probe mux capacity *** */
437     if( p_mux->pf_control )
438     {
439         int b_answer = VLC_FALSE;
440
441         if( sout_MuxControl( p_mux, MUX_CAN_ADD_STREAM_WHILE_MUXING,
442                              &b_answer ) )
443         {
444             b_answer = VLC_FALSE;
445         }
446
447         if( b_answer )
448         {
449             msg_Dbg( p_sout, "muxer support adding stream at any time" );
450             p_mux->b_add_stream_any_time = VLC_TRUE;
451             p_mux->b_waiting_stream = VLC_FALSE;
452
453             /* If we control the output pace then it's better to wait before
454              * starting muxing (generates better streams/files). */
455             if( !p_sout->i_out_pace_nocontrol )
456             {
457                 b_answer = VLC_TRUE;
458             }
459             else if( sout_MuxControl( p_mux, MUX_GET_ADD_STREAM_WAIT,
460                                       &b_answer ) )
461             {
462                 b_answer = VLC_FALSE;
463             }
464
465             if( b_answer )
466             {
467                 msg_Dbg( p_sout, "muxer prefers to wait for all ES before "
468                          "starting to mux" );
469                 p_mux->b_waiting_stream = VLC_TRUE;
470             }
471         }
472     }
473
474     return p_mux;
475 }
476
477 /*****************************************************************************
478  * sout_MuxDelete:
479  *****************************************************************************/
480 void sout_MuxDelete( sout_mux_t *p_mux )
481 {
482     vlc_object_detach( p_mux );
483     if( p_mux->p_module )
484     {
485         module_Unneed( p_mux, p_mux->p_module );
486     }
487     free( p_mux->psz_mux );
488
489     sout_CfgDestroy( p_mux->p_cfg );
490
491     vlc_object_destroy( p_mux );
492 }
493
494 /*****************************************************************************
495  * sout_MuxAddStream:
496  *****************************************************************************/
497 sout_input_t *sout_MuxAddStream( sout_mux_t *p_mux, es_format_t *p_fmt )
498 {
499     sout_input_t *p_input;
500
501     if( !p_mux->b_add_stream_any_time && !p_mux->b_waiting_stream )
502     {
503         msg_Err( p_mux, "cannot add a new stream (unsupported while muxing "
504                         "to this format)" );
505         return NULL;
506     }
507
508     msg_Dbg( p_mux, "adding a new input" );
509
510     /* create a new sout input */
511     p_input = malloc( sizeof( sout_input_t ) );
512     p_input->p_sout = p_mux->p_sout;
513     p_input->p_fmt  = p_fmt;
514     p_input->p_fifo = block_FifoNew( p_mux->p_sout );
515     p_input->p_sys  = NULL;
516
517     TAB_APPEND( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
518     if( p_mux->pf_addstream( p_mux, p_input ) < 0 )
519     {
520             msg_Err( p_mux, "cannot add this stream" );
521             TAB_REMOVE( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
522             block_FifoRelease( p_input->p_fifo );
523             free( p_input );
524             return NULL;
525     }
526
527     return p_input;
528 }
529
530 /*****************************************************************************
531  * sout_MuxDeleteStream:
532  *****************************************************************************/
533 void sout_MuxDeleteStream( sout_mux_t *p_mux, sout_input_t *p_input )
534 {
535     int i_index;
536
537     if( p_mux->b_waiting_stream && p_input->p_fifo->i_depth > 0 )
538     {
539         /* We stop waiting, and call the muxer for taking care of the data
540          * before we remove this es */
541         p_mux->b_waiting_stream = VLC_FALSE;
542         p_mux->pf_mux( p_mux );
543     }
544
545     TAB_FIND( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input, i_index );
546     if( i_index >= 0 )
547     {
548         if( p_mux->pf_delstream( p_mux, p_input ) < 0 )
549         {
550             msg_Err( p_mux, "cannot delete this stream from mux" );
551         }
552
553         /* remove the entry */
554         TAB_REMOVE( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
555
556         if( p_mux->i_nb_inputs == 0 )
557         {
558             msg_Warn( p_mux, "no more input streams for this mux" );
559         }
560
561         block_FifoRelease( p_input->p_fifo );
562         free( p_input );
563     }
564 }
565
566 /*****************************************************************************
567  * sout_MuxSendBuffer:
568  *****************************************************************************/
569 void sout_MuxSendBuffer( sout_mux_t *p_mux, sout_input_t *p_input,
570                          block_t *p_buffer )
571 {
572     block_FifoPut( p_input->p_fifo, p_buffer );
573
574     if( p_mux->p_sout->i_out_pace_nocontrol )
575     {
576         mtime_t current_date = mdate();
577         if ( current_date > p_buffer->i_dts )
578             msg_Warn( p_mux, "late buffer for mux input ("I64Fd")",
579                       current_date - p_buffer->i_dts );
580     }
581
582     if( p_mux->b_waiting_stream )
583     {
584         if( p_mux->i_add_stream_start < 0 )
585         {
586             p_mux->i_add_stream_start = p_buffer->i_dts;
587         }
588
589         if( p_mux->i_add_stream_start >= 0 &&
590             p_mux->i_add_stream_start + I64C(1500000) < p_buffer->i_dts )
591         {
592             /* Wait until we have more than 1.5 seconds worth of data
593              * before start muxing */
594             p_mux->b_waiting_stream = VLC_FALSE;
595         }
596         else
597         {
598             return;
599         }
600     }
601     p_mux->pf_mux( p_mux );
602 }
603
604 /*****************************************************************************
605  *
606  *****************************************************************************/
607 static int mrl_Parse( mrl_t *p_mrl, char *psz_mrl )
608 {
609     char * psz_dup = strdup( psz_mrl );
610     char * psz_parser = psz_dup;
611     char * psz_access = "";
612     char * psz_way = "";
613     char * psz_name = "";
614
615     /* *** first parse psz_dest */
616     while( *psz_parser && *psz_parser != ':' )
617     {
618         if( *psz_parser == '{' )
619         {
620             while( *psz_parser && *psz_parser != '}' )
621             {
622                 psz_parser++;
623             }
624             if( *psz_parser )
625             {
626                 psz_parser++;
627             }
628         }
629         else
630         {
631             psz_parser++;
632         }
633     }
634 #if defined( WIN32 ) || defined( UNDER_CE )
635     if( psz_parser - psz_dup == 1 )
636     {
637         /* msg_Warn( p_sout, "drive letter %c: found in source string",
638                           *psz_dup ) ; */
639         psz_parser = "";
640     }
641 #endif
642
643     if( !*psz_parser )
644     {
645         psz_access = psz_way = "";
646         psz_name = psz_dup;
647     }
648     else
649     {
650         *psz_parser++ = '\0';
651
652         /* let's skip '//' */
653         if( psz_parser[0] == '/' && psz_parser[1] == '/' )
654         {
655             psz_parser += 2 ;
656         }
657
658         psz_name = psz_parser ;
659
660         /* Come back to parse the access and mux plug-ins */
661         psz_parser = psz_dup;
662
663         if( !*psz_parser )
664         {
665             /* No access */
666             psz_access = "";
667         }
668         else if( *psz_parser == '/' )
669         {
670             /* No access */
671             psz_access = "";
672             psz_parser++;
673         }
674         else
675         {
676             psz_access = psz_parser;
677
678             while( *psz_parser && *psz_parser != '/' )
679             {
680                 if( *psz_parser == '{' )
681                 {
682                     while( *psz_parser && *psz_parser != '}' )
683                     {
684                         psz_parser++;
685                     }
686                     if( *psz_parser )
687                     {
688                         psz_parser++;
689                     }
690                 }
691                 else
692                 {
693                     psz_parser++;
694                 }
695             }
696
697             if( *psz_parser == '/' )
698             {
699                 *psz_parser++ = '\0';
700             }
701         }
702
703         if( !*psz_parser )
704         {
705             /* No mux */
706             psz_way = "";
707         }
708         else
709         {
710             psz_way = psz_parser;
711         }
712     }
713
714     p_mrl->psz_access = strdup( psz_access );
715     p_mrl->psz_way    = strdup( psz_way );
716     p_mrl->psz_name   = strdup( psz_name );
717
718     free( psz_dup );
719     return( VLC_SUCCESS );
720 }
721
722
723 /* mrl_Clean: clean p_mrl  after a call to mrl_Parse */
724 static void mrl_Clean( mrl_t *p_mrl )
725 {
726     FREENULL( p_mrl->psz_access );
727     FREENULL( p_mrl->psz_way );
728     FREENULL( p_mrl->psz_name );
729 }
730
731
732 /****************************************************************************
733  ****************************************************************************
734  **
735  **
736  **
737  ****************************************************************************
738  ****************************************************************************/
739
740 /* create a complete chain */
741 /* chain format:
742     module{option=*:option=*}[:module{option=*:...}]
743  */
744
745 /*
746  * parse module{options=str, option="str "}:
747  *  return a pointer on the rest
748  *  XXX: psz_chain is modified
749  */
750 #define SKIPSPACE( p ) { while( *p && ( *p == ' ' || *p == '\t' ) ) p++; }
751 #define SKIPTRAILINGSPACE( p, e ) \
752     { while( e > p && ( *(e-1) == ' ' || *(e-1) == '\t' ) ) e--; }
753
754 /* go accross " " and { } */
755 static char *_get_chain_end( char *str )
756 {
757     char c, *p = str;
758
759     SKIPSPACE( p );
760
761     for( ;; )
762     {
763         if( !*p || *p == ',' || *p == '}' ) return p;
764
765         if( *p != '{' && *p != '"' && *p != '\'' )
766         {
767             p++;
768             continue;
769         }
770
771         if( *p == '{' ) c = '}';
772         else c = *p;
773         p++;
774
775         for( ;; )
776         {
777             if( !*p ) return p;
778
779             if( *p == c ) return ++p;
780             else if( *p == '{' && c == '}' ) p = _get_chain_end( p );
781             else p++;
782         }
783     }
784 }
785
786 char *sout_CfgCreate( char **ppsz_name, sout_cfg_t **pp_cfg, char *psz_chain )
787 {
788     sout_cfg_t *p_cfg = NULL;
789     char       *p = psz_chain;
790
791     *ppsz_name = NULL;
792     *pp_cfg    = NULL;
793
794     if( !p ) return NULL;
795
796     SKIPSPACE( p );
797
798     while( *p && *p != '{' && *p != ':' && *p != ' ' && *p != '\t' ) p++;
799
800     if( p == psz_chain ) return NULL;
801
802     *ppsz_name = strndup( psz_chain, p - psz_chain );
803
804     SKIPSPACE( p );
805
806     if( *p == '{' )
807     {
808         char *psz_name;
809
810         p++;
811
812         for( ;; )
813         {
814             sout_cfg_t cfg;
815
816             SKIPSPACE( p );
817
818             psz_name = p;
819
820             while( *p && *p != '=' && *p != ',' && *p != '{' && *p != '}' &&
821                    *p != ' ' && *p != '\t' ) p++;
822
823             /* fprintf( stderr, "name=%s - rest=%s\n", psz_name, p ); */
824             if( p == psz_name )
825             {
826                 fprintf( stderr, "invalid options (empty)" );
827                 break;
828             }
829
830             cfg.psz_name = strndup( psz_name, p - psz_name );
831
832             SKIPSPACE( p );
833
834             if( *p == '=' || *p == '{' )
835             {
836                 char *end;
837                 vlc_bool_t b_keep_brackets = (*p == '{');
838
839                 if( *p == '=' ) p++;
840
841                 end = _get_chain_end( p );
842                 if( end <= p )
843                 {
844                     cfg.psz_value = NULL;
845                 }
846                 else
847                 {
848                     /* Skip heading and trailing spaces.
849                      * This ain't necessary but will avoid simple
850                      * user mistakes. */
851                     SKIPSPACE( p );
852                 }
853
854                 if( end <= p )
855                 {
856                     cfg.psz_value = NULL;
857                 }
858                 else
859                 {
860                     if( *p == '\'' || *p == '"' ||
861                         ( !b_keep_brackets && *p == '{' ) )
862                     {
863                         p++;
864
865                         if( *(end-1) != '\'' && *(end-1) == '"' )
866                             SKIPTRAILINGSPACE( p, end );
867
868                         if( end - 1 <= p ) cfg.psz_value = NULL;
869                         else cfg.psz_value = strndup( p, end -1 - p );
870                     }
871                     else
872                     {
873                         SKIPTRAILINGSPACE( p, end );
874                         if( end <= p ) cfg.psz_value = NULL;
875                         else cfg.psz_value = strndup( p, end - p );
876                     }
877                 }
878
879                 p = end;
880                 SKIPSPACE( p );
881             }
882             else
883             {
884                 cfg.psz_value = NULL;
885             }
886
887             cfg.p_next = NULL;
888             if( p_cfg )
889             {
890                 p_cfg->p_next = malloc( sizeof( sout_cfg_t ) );
891                 memcpy( p_cfg->p_next, &cfg, sizeof( sout_cfg_t ) );
892
893                 p_cfg = p_cfg->p_next;
894             }
895             else
896             {
897                 p_cfg = malloc( sizeof( sout_cfg_t ) );
898                 memcpy( p_cfg, &cfg, sizeof( sout_cfg_t ) );
899
900                 *pp_cfg = p_cfg;
901             }
902
903             if( *p == ',' ) p++;
904
905             if( *p == '}' )
906             {
907                 p++;
908                 break;
909             }
910         }
911     }
912
913     if( *p == ':' ) return( strdup( p + 1 ) );
914
915     return NULL;
916 }
917
918 static void sout_CfgDestroy( sout_cfg_t *p_cfg )
919 {
920     while( p_cfg != NULL )
921     {
922         sout_cfg_t *p_next;
923
924         p_next = p_cfg->p_next;
925
926         FREENULL( p_cfg->psz_name );
927         FREENULL( p_cfg->psz_value );
928         free( p_cfg );
929
930         p_cfg = p_next;
931     }
932 }
933
934 void __sout_CfgParse( vlc_object_t *p_this, char *psz_prefix,
935                       const char **ppsz_options, sout_cfg_t *cfg )
936 {
937     char *psz_name;
938     int  i_type;
939     int  i;
940
941     /* First, var_Create all variables */
942     for( i = 0; ppsz_options[i] != NULL; i++ )
943     {
944         asprintf( &psz_name, "%s%s", psz_prefix,
945                   *ppsz_options[i] == '*' ? &ppsz_options[i][1] : ppsz_options[i] );
946
947         i_type = config_GetType( p_this, psz_name );
948
949         var_Create( p_this, psz_name, i_type | VLC_VAR_DOINHERIT );
950         free( psz_name );
951     }
952
953     /* Now parse options and set value */
954     if( psz_prefix == NULL ) psz_prefix = "";
955
956     while( cfg )
957     {
958         vlc_value_t val;
959         vlc_bool_t b_yes = VLC_TRUE;
960         vlc_bool_t b_once = VLC_FALSE;
961         module_config_t *p_conf;
962
963         if( cfg->psz_name == NULL || *cfg->psz_name == '\0' )
964         {
965             cfg = cfg->p_next;
966             continue;
967         }
968         for( i = 0; ppsz_options[i] != NULL; i++ )
969         {
970             if( !strcmp( ppsz_options[i], cfg->psz_name ) )
971             {
972                 break;
973             }
974             if( ( !strncmp( cfg->psz_name, "no-", 3 ) &&
975                   !strcmp( ppsz_options[i], cfg->psz_name + 3 ) ) ||
976                 ( !strncmp( cfg->psz_name, "no", 2 ) &&
977                   !strcmp( ppsz_options[i], cfg->psz_name + 2 ) ) )
978             {
979                 b_yes = VLC_FALSE;
980                 break;
981             }
982
983             if( *ppsz_options[i] == '*' &&
984                 !strcmp( &ppsz_options[i][1], cfg->psz_name ) )
985             {
986                 b_once = VLC_TRUE;
987                 break;
988             }
989
990         }
991         if( ppsz_options[i] == NULL )
992         {
993             msg_Warn( p_this, "option %s is unknown", cfg->psz_name );
994             cfg = cfg->p_next;
995             continue;
996         }
997
998         /* create name */
999         asprintf( &psz_name, "%s%s", psz_prefix, b_once ? &ppsz_options[i][1] : ppsz_options[i] );
1000
1001         /* Check if the option is deprecated */
1002         p_conf = config_FindConfig( p_this, psz_name );
1003
1004         /* This is basically cut and paste from src/misc/configuration.c
1005          * with slight changes */
1006         if( p_conf && p_conf->psz_current )
1007         {
1008             if( !strcmp( p_conf->psz_current, "SUPPRESSED" ) )
1009             {
1010                 msg_Err( p_this, "Option %s is no longer used.",
1011                          p_conf->psz_name );
1012                 goto next;
1013             }
1014             else if( p_conf->b_strict )
1015             {
1016                 msg_Err( p_this, "Option %s is deprecated. Use %s instead.",
1017                          p_conf->psz_name, p_conf->psz_current );
1018                 /* TODO: this should return an error and end option parsing
1019                  * ... but doing this would change the VLC API and all the
1020                  * modules so i'll do it later */
1021                 goto next;
1022             }
1023             else
1024             {
1025                 msg_Warn( p_this, "Option %s is deprecated. You should use "
1026                         "%s instead.", p_conf->psz_name, p_conf->psz_current );
1027                 free( psz_name );
1028                 psz_name = strdup( p_conf->psz_current );
1029             }
1030         }
1031         /* </Check if the option is deprecated> */
1032
1033         /* get the type of the variable */
1034         i_type = config_GetType( p_this, psz_name );
1035         if( !i_type )
1036         {
1037             msg_Warn( p_this, "unknown option %s (value=%s)",
1038                       cfg->psz_name, cfg->psz_value );
1039             goto next;
1040         }
1041         if( i_type != VLC_VAR_BOOL && cfg->psz_value == NULL )
1042         {
1043             msg_Warn( p_this, "missing value for option %s", cfg->psz_name );
1044             goto next;
1045         }
1046         if( i_type != VLC_VAR_STRING && b_once )
1047         {
1048             msg_Warn( p_this, "*option_name need to be a string option" );
1049             goto next;
1050         }
1051
1052         switch( i_type )
1053         {
1054             case VLC_VAR_BOOL:
1055                 val.b_bool = b_yes;
1056                 break;
1057             case VLC_VAR_INTEGER:
1058                 val.i_int = strtol( cfg->psz_value ? cfg->psz_value : "0",
1059                                     NULL, 0 );
1060                 break;
1061             case VLC_VAR_FLOAT:
1062                 val.f_float = atof( cfg->psz_value ? cfg->psz_value : "0" );
1063                 break;
1064             case VLC_VAR_STRING:
1065             case VLC_VAR_MODULE:
1066                 val.psz_string = cfg->psz_value;
1067                 break;
1068             default:
1069                 msg_Warn( p_this, "unhandled config var type" );
1070                 memset( &val, 0, sizeof( vlc_value_t ) );
1071                 break;
1072         }
1073         if( b_once )
1074         {
1075             vlc_value_t val2;
1076
1077             var_Get( p_this, psz_name, &val2 );
1078             if( *val2.psz_string )
1079             {
1080                 free( val2.psz_string );
1081                 msg_Dbg( p_this, "ignoring option %s (not first occurrence)", psz_name );
1082                 goto next;
1083             }
1084             free( val2.psz_string );
1085         }
1086         var_Set( p_this, psz_name, val );
1087         msg_Dbg( p_this, "set sout option: %s to %s", psz_name, cfg->psz_value );
1088
1089     next:
1090         free( psz_name );
1091         cfg = cfg->p_next;
1092     }
1093 }
1094
1095
1096 /*
1097  * XXX name and p_cfg are used (-> do NOT free them)
1098  */
1099 sout_stream_t *sout_StreamNew( sout_instance_t *p_sout, char *psz_chain )
1100 {
1101     sout_stream_t *p_stream;
1102
1103     if( !psz_chain )
1104     {
1105         msg_Err( p_sout, "invalid chain" );
1106         return NULL;
1107     }
1108
1109     p_stream = vlc_object_create( p_sout, sizeof( sout_stream_t ) );
1110
1111     if( !p_stream )
1112     {
1113         msg_Err( p_sout, "out of memory" );
1114         return NULL;
1115     }
1116
1117     p_stream->p_sout   = p_sout;
1118     p_stream->p_sys    = NULL;
1119
1120     p_stream->psz_next =
1121         sout_CfgCreate( &p_stream->psz_name, &p_stream->p_cfg, psz_chain);
1122
1123     msg_Dbg( p_sout, "stream=`%s'", p_stream->psz_name );
1124
1125     vlc_object_attach( p_stream, p_sout );
1126
1127     p_stream->p_module =
1128         module_Need( p_stream, "sout stream", p_stream->psz_name, VLC_TRUE );
1129
1130     if( !p_stream->p_module )
1131     {
1132         sout_StreamDelete( p_stream );
1133         return NULL;
1134     }
1135
1136     return p_stream;
1137 }
1138
1139 void sout_StreamDelete( sout_stream_t *p_stream )
1140 {
1141     msg_Dbg( p_stream, "destroying chain... (name=%s)", p_stream->psz_name );
1142
1143     vlc_object_detach( p_stream );
1144     if( p_stream->p_module ) module_Unneed( p_stream, p_stream->p_module );
1145
1146     FREENULL( p_stream->psz_name );
1147     FREENULL( p_stream->psz_next );
1148
1149     sout_CfgDestroy( p_stream->p_cfg );
1150
1151     msg_Dbg( p_stream, "destroying chain done" );
1152     vlc_object_destroy( p_stream );
1153 }
1154
1155 static char *_sout_stream_url_to_chain( vlc_object_t *p_this, char *psz_url )
1156 {
1157     mrl_t       mrl;
1158     char        *psz_chain, *p;
1159
1160     mrl_Parse( &mrl, psz_url );
1161     p = psz_chain = malloc( 500 + strlen( mrl.psz_way ) +
1162                                   strlen( mrl.psz_access ) +
1163                                   strlen( mrl.psz_name ) );
1164
1165
1166     if( config_GetInt( p_this, "sout-display" ) )
1167     {
1168         p += sprintf( p, "duplicate{dst=display,dst=std{mux=\"%s\","
1169                       "access=\"%s\",dst=\"%s\"}}",
1170                       mrl.psz_way, mrl.psz_access, mrl.psz_name );
1171     }
1172     else
1173     {
1174         p += sprintf( p, "std{mux=\"%s\",access=\"%s\",dst=\"%s\"}",
1175                       mrl.psz_way, mrl.psz_access, mrl.psz_name );
1176     }
1177
1178     mrl_Clean( &mrl );
1179     return( psz_chain );
1180 }