* stream_output.c: fixed a segfault when muxer isn't specified.
[vlc.git] / src / stream_output / stream_output.c
1 /*****************************************************************************
2  * stream_output.c : stream output module
3  *****************************************************************************
4  * Copyright (C) 2002 VideoLAN
5  * $Id: stream_output.c,v 1.32 2003/08/01 18:42:56 fenrir Exp $
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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29 #include <stdlib.h>                                                /* free() */
30 #include <stdio.h>                                              /* sprintf() */
31 #include <string.h>                                            /* strerror() */
32
33 #include <vlc/vlc.h>
34
35 #include <vlc/sout.h>
36 #undef DEBUG_BUFFER
37 /*****************************************************************************
38  * Local prototypes
39  *****************************************************************************/
40 static void sout_cfg_free( sout_cfg_t * );
41
42 #define sout_stream_url_to_chain( p, s ) _sout_stream_url_to_chain( VLC_OBJECT(p), s )
43 static char *_sout_stream_url_to_chain( vlc_object_t *, char * );
44
45 #define module_NeedStrict(a,b,c) __module_NeedStrict(VLC_OBJECT(a),b,c)
46 static module_t *__module_NeedStrict( vlc_object_t *, const char *, const char * );
47
48 /*
49  * Generic MRL parser
50  *
51  */
52
53 typedef struct
54 {
55     char            *psz_access;
56
57     char            *psz_way;
58
59     char *psz_name;
60 } mrl_t;
61
62 /* mrl_Parse: parse psz_mrl and fill p_mrl */
63 static int  mrl_Parse( mrl_t *p_mrl, char *psz_mrl );
64 /* mrl_Clean: clean p_mrl  after a call to mrl_Parse */
65 static void mrl_Clean( mrl_t *p_mrl );
66
67 #define FREE( p ) if( p ) { free( p ); (p) = NULL; }
68
69 /*****************************************************************************
70  * sout_NewInstance: creates a new stream output instance
71  *****************************************************************************/
72 sout_instance_t * __sout_NewInstance ( vlc_object_t *p_parent,
73                                        char * psz_dest )
74 {
75     sout_instance_t *p_sout;
76
77     /* *** Allocate descriptor *** */
78     p_sout = vlc_object_create( p_parent, VLC_OBJECT_SOUT );
79     if( p_sout == NULL )
80     {
81         msg_Err( p_parent, "out of memory" );
82         return NULL;
83     }
84
85     /* *** init descriptor *** */
86     p_sout->psz_sout    = strdup( psz_dest );
87     p_sout->i_preheader = 0;
88     p_sout->p_sys       = NULL;
89
90     vlc_mutex_init( p_sout, &p_sout->lock );
91     if( psz_dest && psz_dest[0] == '#' )
92     {
93         p_sout->psz_chain = strdup( &psz_dest[1] );
94     }
95     else
96     {
97         p_sout->psz_chain = sout_stream_url_to_chain( p_sout, psz_dest );
98         msg_Dbg( p_sout, "using sout chain=`%s'", p_sout->psz_chain );
99     }
100
101     p_sout->p_stream = sout_stream_new( p_sout, p_sout->psz_chain );
102
103     if( p_sout->p_stream == NULL )
104     {
105         msg_Err( p_sout, "stream chained failed for `%s'", p_sout->psz_chain );
106
107         FREE( p_sout->psz_sout );
108         FREE( p_sout->psz_chain );
109
110         vlc_object_destroy( p_sout );
111         return( NULL );
112     }
113
114     vlc_object_attach( p_sout, p_parent );
115
116     return p_sout;
117 }
118 /*****************************************************************************
119  * sout_DeleteInstance: delete a previously allocated instance
120  *****************************************************************************/
121 void sout_DeleteInstance( sout_instance_t * p_sout )
122 {
123     /* Unlink object */
124     vlc_object_detach( p_sout );
125
126     /* *** free all string *** */
127     FREE( p_sout->psz_sout );
128     FREE( p_sout->psz_chain );
129
130     sout_stream_delete( p_sout->p_stream );
131     vlc_mutex_destroy( &p_sout->lock );
132
133     /* *** free structure *** */
134     vlc_object_destroy( p_sout );
135 }
136
137 /*****************************************************************************
138  * Packetizer/Input
139  *****************************************************************************/
140 sout_packetizer_input_t *__sout_InputNew( vlc_object_t  *p_this,
141                                           sout_format_t *p_fmt )
142 {
143     sout_instance_t         *p_sout = NULL;
144     sout_packetizer_input_t *p_input;
145
146     int             i_try;
147
148     /* search an stream output */
149     for( i_try = 0; i_try < 12; i_try++ )
150     {
151         p_sout = vlc_object_find( p_this, VLC_OBJECT_SOUT, FIND_ANYWHERE );
152         if( p_sout )
153         {
154             break;
155         }
156
157         msleep( 100*1000 );
158         msg_Dbg( p_this, "waiting for sout" );
159     }
160
161     if( !p_sout )
162     {
163         msg_Err( p_this, "cannot find any stream ouput" );
164         return( NULL );
165     }
166
167     msg_Dbg( p_sout, "adding a new input" );
168
169     /* *** create a packetizer input *** */
170     p_input         = malloc( sizeof( sout_packetizer_input_t ) );
171     p_input->p_sout = p_sout;
172     p_input->p_fmt  = p_fmt;
173
174     if( p_fmt->i_fourcc == VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
175     {
176         vlc_object_release( p_sout );
177         return p_input;
178     }
179
180     /* *** add it to the stream chain */
181     vlc_mutex_lock( &p_sout->lock );
182     p_input->id = p_sout->p_stream->pf_add( p_sout->p_stream,
183                                             p_fmt );
184     vlc_mutex_unlock( &p_sout->lock );
185
186     vlc_object_release( p_sout );
187
188     if( p_input->id == NULL )
189     {
190         free( p_input );
191         return( NULL );
192     }
193
194     return( p_input );
195 }
196
197
198 int sout_InputDelete( sout_packetizer_input_t *p_input )
199 {
200     sout_instance_t     *p_sout = p_input->p_sout;
201
202     msg_Dbg( p_sout, "removing an input" );
203
204     if( p_input->p_fmt->i_fourcc != VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
205     {
206         vlc_mutex_lock( &p_sout->lock );
207         p_sout->p_stream->pf_del( p_sout->p_stream, p_input->id );
208         vlc_mutex_unlock( &p_sout->lock );
209     }
210
211     free( p_input );
212
213     return( VLC_SUCCESS);
214 }
215
216
217 int sout_InputSendBuffer( sout_packetizer_input_t *p_input, sout_buffer_t *p_buffer )
218 {
219     sout_instance_t     *p_sout = p_input->p_sout;
220     int                 i_ret;
221
222     if( p_input->p_fmt->i_fourcc == VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
223     {
224         sout_BufferDelete( p_input->p_sout, p_buffer );
225         return VLC_SUCCESS;
226     }
227
228     vlc_mutex_lock( &p_sout->lock );
229     i_ret = p_sout->p_stream->pf_send( p_sout->p_stream, p_input->id, p_buffer );
230     vlc_mutex_unlock( &p_sout->lock );
231
232     return i_ret;
233 }
234
235 /*****************************************************************************
236  * sout_AccessOutNew: allocate a new access out
237  *****************************************************************************/
238 sout_access_out_t *sout_AccessOutNew( sout_instance_t *p_sout,
239                                       char *psz_access, char *psz_name )
240 {
241     sout_access_out_t *p_access;
242     char              *psz_next;
243
244     if( !( p_access = vlc_object_create( p_sout,
245                                          sizeof( sout_access_out_t ) ) ) )
246     {
247         msg_Err( p_sout, "out of memory" );
248         return NULL;
249     }
250
251     psz_next = sout_cfg_parser( &p_access->psz_access, &p_access->p_cfg, psz_access );
252     if( psz_next )
253     {
254         free( psz_next );
255     }
256     p_access->psz_name   = strdup( psz_name ? psz_name : "" );
257     p_access->p_sout     = p_sout;
258     p_access->p_sys = NULL;
259     p_access->pf_seek    = NULL;
260     p_access->pf_write   = NULL;
261
262     p_access->p_module   =
263         module_NeedStrict( p_access, "sout access", p_access->psz_access );
264
265     if( !p_access->p_module )
266     {
267         free( p_access->psz_access );
268         free( p_access->psz_name );
269         vlc_object_destroy( p_access );
270         return( NULL );
271     }
272
273     return p_access;
274 }
275 /*****************************************************************************
276  * sout_AccessDelete: delete an access out
277  *****************************************************************************/
278 void sout_AccessOutDelete( sout_access_out_t *p_access )
279 {
280     if( p_access->p_module )
281     {
282         module_Unneed( p_access, p_access->p_module );
283     }
284     free( p_access->psz_access );
285
286     sout_cfg_free( p_access->p_cfg );
287
288     free( p_access->psz_name );
289
290     vlc_object_destroy( p_access );
291 }
292
293 /*****************************************************************************
294  * sout_AccessSeek:
295  *****************************************************************************/
296 int  sout_AccessOutSeek( sout_access_out_t *p_access, off_t i_pos )
297 {
298     return( p_access->pf_seek( p_access, i_pos ) );
299 }
300
301 /*****************************************************************************
302  * sout_AccessWrite:
303  *****************************************************************************/
304 int  sout_AccessOutWrite( sout_access_out_t *p_access, sout_buffer_t *p_buffer )
305 {
306     return( p_access->pf_write( p_access, p_buffer ) );
307 }
308
309
310 /*****************************************************************************
311  * MuxNew: allocate a new mux
312  *****************************************************************************/
313 sout_mux_t * sout_MuxNew         ( sout_instance_t *p_sout,
314                                    char *psz_mux,
315                                    sout_access_out_t *p_access )
316 {
317     sout_mux_t *p_mux;
318     char       *psz_next;
319
320     p_mux = vlc_object_create( p_sout,
321                                sizeof( sout_mux_t ) );
322     if( p_mux == NULL )
323     {
324         msg_Err( p_sout, "out of memory" );
325         return NULL;
326     }
327
328     p_mux->p_sout       = p_sout;
329     psz_next = sout_cfg_parser( &p_mux->psz_mux, &p_mux->p_cfg, psz_mux );
330     if( psz_next )
331     {
332         free( psz_next );
333     }
334     p_mux->p_access     = p_access;
335     p_mux->i_preheader  = 0;
336     p_mux->pf_capacity  = NULL;
337     p_mux->pf_addstream = NULL;
338     p_mux->pf_delstream = NULL;
339     p_mux->pf_mux       = NULL;
340     p_mux->i_nb_inputs  = 0;
341     p_mux->pp_inputs    = NULL;
342
343     p_mux->p_sys        = NULL;
344
345     p_mux->p_module     =
346         module_NeedStrict( p_mux, "sout mux", p_mux->psz_mux );
347
348     if( p_mux->p_module == NULL )
349     {
350         FREE( p_mux->psz_mux );
351
352         vlc_object_destroy( p_mux );
353         return NULL;
354     }
355
356     /* *** probe mux capacity *** */
357     if( p_mux->pf_capacity )
358     {
359         int b_answer;
360         if( p_mux->pf_capacity( p_mux,
361                                 SOUT_MUX_CAP_GET_ADD_STREAM_ANY_TIME,
362                                 NULL, (void*)&b_answer ) != SOUT_MUX_CAP_ERR_OK )
363         {
364             b_answer = VLC_FALSE;
365         }
366         if( b_answer )
367         {
368             msg_Dbg( p_sout, "muxer support adding stream at any time" );
369             p_mux->b_add_stream_any_time = VLC_TRUE;
370             p_mux->b_waiting_stream = VLC_FALSE;
371         }
372         else
373         {
374             p_mux->b_add_stream_any_time = VLC_FALSE;
375             p_mux->b_waiting_stream = VLC_TRUE;
376         }
377     }
378     else
379     {
380         p_mux->b_add_stream_any_time = VLC_FALSE;
381         p_mux->b_waiting_stream = VLC_TRUE;
382     }
383     p_mux->i_add_stream_start = -1;
384
385     return p_mux;
386 }
387
388 void sout_MuxDelete              ( sout_mux_t *p_mux )
389 {
390     if( p_mux->p_module )
391     {
392         module_Unneed( p_mux, p_mux->p_module );
393     }
394     free( p_mux->psz_mux );
395
396     sout_cfg_free( p_mux->p_cfg );
397
398     vlc_object_destroy( p_mux );
399 }
400
401 sout_input_t *sout_MuxAddStream( sout_mux_t *p_mux,
402                                  sout_format_t *p_fmt )
403 {
404     sout_input_t *p_input;
405
406     if( !p_mux->b_add_stream_any_time && !p_mux->b_waiting_stream)
407     {
408         msg_Err( p_mux, "cannot add a new stream (unsuported while muxing for this format)" );
409         return NULL;
410     }
411     if( p_mux->i_add_stream_start < 0 )
412     {
413         /* we wait for one second */
414         p_mux->i_add_stream_start = mdate();
415     }
416
417     msg_Dbg( p_mux, "adding a new input" );
418
419     /* create a new sout input */
420     p_input = malloc( sizeof( sout_input_t ) );
421     p_input->p_sout = p_mux->p_sout;
422     p_input->p_fmt  = p_fmt;
423     p_input->p_fifo = sout_FifoCreate( p_mux->p_sout );
424     p_input->p_sys  = NULL;
425
426     TAB_APPEND( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
427     if( p_mux->pf_addstream( p_mux, p_input ) < 0 )
428     {
429             msg_Err( p_mux, "cannot add this stream" );
430             TAB_REMOVE( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
431             sout_FifoDestroy( p_mux->p_sout, p_input->p_fifo );
432             free( p_input );
433             return( NULL );
434     }
435
436     return( p_input );
437 }
438
439 void sout_MuxDeleteStream     ( sout_mux_t *p_mux,
440                                 sout_input_t *p_input )
441 {
442     int i_index;
443
444     TAB_FIND( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input, i_index );
445     if( i_index >= 0 )
446     {
447         if( p_mux->pf_delstream( p_mux, p_input ) < 0 )
448         {
449             msg_Err( p_mux, "cannot del this stream from mux" );
450         }
451
452         /* remove the entry */
453         TAB_REMOVE( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
454
455         if( p_mux->i_nb_inputs == 0 )
456         {
457             msg_Warn( p_mux, "no more input stream for this mux" );
458         }
459
460         sout_FifoDestroy( p_mux->p_sout, p_input->p_fifo );
461         free( p_input );
462     }
463 }
464
465 void sout_MuxSendBuffer       ( sout_mux_t    *p_mux,
466                                 sout_input_t  *p_input,
467                                 sout_buffer_t *p_buffer )
468 {
469     sout_FifoPut( p_input->p_fifo, p_buffer );
470
471     if( p_mux->b_waiting_stream )
472     {
473         if( p_mux->i_add_stream_start > 0 &&
474             p_mux->i_add_stream_start + (mtime_t)1500000 < mdate() )
475         {
476             /* more than 1.5 second, start muxing */
477             p_mux->b_waiting_stream = VLC_FALSE;
478         }
479         else
480         {
481             return;
482         }
483     }
484     p_mux->pf_mux( p_mux );
485 }
486
487
488
489 sout_fifo_t *sout_FifoCreate( sout_instance_t *p_sout )
490 {
491     sout_fifo_t *p_fifo;
492
493     if( !( p_fifo = malloc( sizeof( sout_fifo_t ) ) ) )
494     {
495         return( NULL );
496     }
497
498     vlc_mutex_init( p_sout, &p_fifo->lock );
499     vlc_cond_init ( p_sout, &p_fifo->wait );
500     p_fifo->i_depth = 0;
501     p_fifo->p_first = NULL;
502     p_fifo->pp_last = &p_fifo->p_first;
503
504     return( p_fifo );
505 }
506
507 void       sout_FifoFree( sout_instance_t *p_sout, sout_fifo_t *p_fifo )
508 {
509     sout_buffer_t *p_buffer;
510
511     vlc_mutex_lock( &p_fifo->lock );
512     p_buffer = p_fifo->p_first;
513     while( p_buffer )
514     {
515         sout_buffer_t *p_next;
516         p_next = p_buffer->p_next;
517         sout_BufferDelete( p_sout, p_buffer );
518         p_buffer = p_next;
519     }
520     vlc_mutex_unlock( &p_fifo->lock );
521
522     return;
523 }
524 void       sout_FifoDestroy( sout_instance_t *p_sout, sout_fifo_t *p_fifo )
525 {
526     sout_FifoFree( p_sout, p_fifo );
527     vlc_mutex_destroy( &p_fifo->lock );
528     vlc_cond_destroy ( &p_fifo->wait );
529
530     free( p_fifo );
531 }
532
533 void        sout_FifoPut( sout_fifo_t *p_fifo, sout_buffer_t *p_buffer )
534 {
535     vlc_mutex_lock( &p_fifo->lock );
536
537     do
538     {
539         *p_fifo->pp_last = p_buffer;
540         p_fifo->pp_last = &p_buffer->p_next;
541         p_fifo->i_depth++;
542
543         p_buffer = p_buffer->p_next;
544
545     } while( p_buffer );
546
547     /* warm there is data in this fifo */
548     vlc_cond_signal( &p_fifo->wait );
549     vlc_mutex_unlock( &p_fifo->lock );
550 }
551
552 sout_buffer_t *sout_FifoGet( sout_fifo_t *p_fifo )
553 {
554     sout_buffer_t *p_buffer;
555
556     vlc_mutex_lock( &p_fifo->lock );
557
558     if( p_fifo->p_first == NULL )
559     {
560         vlc_cond_wait( &p_fifo->wait, &p_fifo->lock );
561     }
562
563     p_buffer = p_fifo->p_first;
564
565     p_fifo->p_first = p_buffer->p_next;
566     p_fifo->i_depth--;
567
568     if( p_fifo->p_first == NULL )
569     {
570         p_fifo->pp_last = &p_fifo->p_first;
571     }
572
573     vlc_mutex_unlock( &p_fifo->lock );
574
575     p_buffer->p_next = NULL;
576     return( p_buffer );
577 }
578
579 sout_buffer_t *sout_FifoShow( sout_fifo_t *p_fifo )
580 {
581     sout_buffer_t *p_buffer;
582
583     vlc_mutex_lock( &p_fifo->lock );
584
585     if( p_fifo->p_first == NULL )
586     {
587         vlc_cond_wait( &p_fifo->wait, &p_fifo->lock );
588     }
589
590     p_buffer = p_fifo->p_first;
591
592     vlc_mutex_unlock( &p_fifo->lock );
593
594     return( p_buffer );
595 }
596
597 sout_buffer_t *sout_BufferNew( sout_instance_t *p_sout, size_t i_size )
598 {
599     sout_buffer_t *p_buffer;
600     size_t        i_preheader;
601
602 #ifdef DEBUG_BUFFER
603     msg_Dbg( p_sout, "allocating an new buffer, size:%d", (uint32_t)i_size );
604 #endif
605
606     p_buffer = malloc( sizeof( sout_buffer_t ) );
607     i_preheader = p_sout->i_preheader;
608
609     if( i_size > 0 )
610     {
611         p_buffer->p_allocated_buffer = malloc( i_size + i_preheader );
612         p_buffer->p_buffer = p_buffer->p_allocated_buffer + i_preheader;
613     }
614     else
615     {
616         p_buffer->p_allocated_buffer = NULL;
617         p_buffer->p_buffer = NULL;
618     }
619     p_buffer->i_allocated_size = i_size + i_preheader;
620     p_buffer->i_buffer_size = i_size;
621
622     p_buffer->i_size    = i_size;
623     p_buffer->i_length  = 0;
624     p_buffer->i_dts     = 0;
625     p_buffer->i_pts     = 0;
626     p_buffer->i_bitrate = 0;
627     p_buffer->i_flags   = 0x0000;
628     p_buffer->p_next = NULL;
629
630     return( p_buffer );
631 }
632 int sout_BufferRealloc( sout_instance_t *p_sout, sout_buffer_t *p_buffer, size_t i_size )
633 {
634     size_t          i_preheader;
635
636 #ifdef DEBUG_BUFFER
637     msg_Dbg( p_sout,
638              "realloc buffer old size:%d new size:%d",
639              (uint32_t)p_buffer->i_allocated_size,
640              (uint32_t)i_size );
641 #endif
642
643     i_preheader = p_buffer->p_buffer - p_buffer->p_allocated_buffer;
644
645     if( !( p_buffer->p_allocated_buffer = realloc( p_buffer->p_allocated_buffer, i_size + i_preheader ) ) )
646     {
647         msg_Err( p_sout, "realloc failed" );
648         p_buffer->i_allocated_size = 0;
649         p_buffer->i_buffer_size = 0;
650         p_buffer->i_size = 0;
651         p_buffer->p_buffer = NULL;
652         return( -1 );
653     }
654     p_buffer->p_buffer = p_buffer->p_allocated_buffer + i_preheader;
655
656     p_buffer->i_allocated_size = i_size + i_preheader;
657     p_buffer->i_buffer_size = i_size;
658
659     return( 0 );
660 }
661
662 int sout_BufferReallocFromPreHeader( sout_instance_t *p_sout, sout_buffer_t *p_buffer, size_t i_size )
663 {
664     size_t  i_preheader;
665
666     i_preheader = p_buffer->p_buffer - p_buffer->p_allocated_buffer;
667
668     if( i_preheader < i_size )
669     {
670         return( -1 );
671     }
672
673     p_buffer->p_buffer -= i_size;
674     p_buffer->i_size += i_size;
675     p_buffer->i_buffer_size += i_size;
676
677     return( 0 );
678 }
679
680 int sout_BufferDelete( sout_instance_t *p_sout, sout_buffer_t *p_buffer )
681 {
682 #ifdef DEBUG_BUFFER
683     msg_Dbg( p_sout, "freeing buffer, size:%d", p_buffer->i_size );
684 #endif
685     if( p_buffer->p_allocated_buffer )
686     {
687         free( p_buffer->p_allocated_buffer );
688     }
689     free( p_buffer );
690     return( 0 );
691 }
692
693 sout_buffer_t *sout_BufferDuplicate( sout_instance_t *p_sout,
694                                      sout_buffer_t *p_buffer )
695 {
696     sout_buffer_t *p_dup;
697
698     p_dup = sout_BufferNew( p_sout, p_buffer->i_size );
699
700     p_dup->i_bitrate= p_buffer->i_bitrate;
701     p_dup->i_dts    = p_buffer->i_dts;
702     p_dup->i_pts    = p_buffer->i_pts;
703     p_dup->i_length = p_buffer->i_length;
704     p_dup->i_flags  = p_buffer->i_flags;
705     p_sout->p_vlc->pf_memcpy( p_dup->p_buffer, p_buffer->p_buffer, p_buffer->i_size );
706
707     return( p_dup );
708 }
709
710 void sout_BufferChain( sout_buffer_t **pp_chain,
711                        sout_buffer_t *p_buffer )
712 {
713     if( *pp_chain == NULL )
714     {
715         *pp_chain = p_buffer;
716     }
717     else if( p_buffer != NULL )
718     {
719         sout_buffer_t *p = *pp_chain;
720
721         while( p->p_next )
722         {
723             p = p->p_next;
724         }
725
726         p->p_next = p_buffer;
727     }
728 }
729
730 static int  mrl_Parse( mrl_t *p_mrl, char *psz_mrl )
731 {
732     char * psz_dup = strdup( psz_mrl );
733     char * psz_parser = psz_dup;
734     char * psz_access = "";
735     char * psz_way = "";
736     char * psz_name = "";
737
738     /* *** first parse psz_dest */
739     while( *psz_parser && *psz_parser != ':' )
740     {
741         if( *psz_parser == '{' )
742         {
743             while( *psz_parser && *psz_parser != '}' )
744             {
745                 psz_parser++;
746             }
747             if( *psz_parser )
748             {
749                 psz_parser++;
750             }
751         }
752         else
753         {
754             psz_parser++;
755         }
756     }
757 #if defined( WIN32 ) || defined( UNDER_CE )
758     if( psz_parser - psz_dup == 1 )
759     {
760         /* msg_Warn( p_sout, "drive letter %c: found in source string",
761                           *psz_dup ) ; */
762         psz_parser = "";
763     }
764 #endif
765
766     if( !*psz_parser )
767     {
768         psz_access = psz_way = "";
769         psz_name = psz_dup;
770     }
771     else
772     {
773         *psz_parser++ = '\0';
774
775         /* let's skip '//' */
776         if( psz_parser[0] == '/' && psz_parser[1] == '/' )
777         {
778             psz_parser += 2 ;
779         }
780
781         psz_name = psz_parser ;
782
783         /* Come back to parse the access and mux plug-ins */
784         psz_parser = psz_dup;
785
786         if( !*psz_parser )
787         {
788             /* No access */
789             psz_access = "";
790         }
791         else if( *psz_parser == '/' )
792         {
793             /* No access */
794             psz_access = "";
795             psz_parser++;
796         }
797         else
798         {
799             psz_access = psz_parser;
800
801             while( *psz_parser && *psz_parser != '/' )
802             {
803                 if( *psz_parser == '{' )
804                 {
805                     while( *psz_parser && *psz_parser != '}' )
806                     {
807                         psz_parser++;
808                     }
809                     if( *psz_parser )
810                     {
811                         psz_parser++;
812                     }
813                 }
814                 else
815                 {
816                     psz_parser++;
817                 }
818             }
819
820             if( *psz_parser == '/' )
821             {
822                 *psz_parser++ = '\0';
823             }
824         }
825
826         if( !*psz_parser )
827         {
828             /* No mux */
829             psz_way = "";
830         }
831         else
832         {
833             psz_way = psz_parser;
834         }
835     }
836
837     p_mrl->psz_access = strdup( psz_access );
838     p_mrl->psz_way    = strdup( psz_way );
839     p_mrl->psz_name   = strdup( psz_name );
840
841     free( psz_dup );
842     return( VLC_SUCCESS );
843 }
844
845
846 /* mrl_Clean: clean p_mrl  after a call to mrl_Parse */
847 static void mrl_Clean( mrl_t *p_mrl )
848 {
849     FREE( p_mrl->psz_access );
850     FREE( p_mrl->psz_way );
851     FREE( p_mrl->psz_name );
852 }
853
854
855 /****************************************************************************
856  ****************************************************************************
857  **
858  **
859  **
860  ****************************************************************************
861  ****************************************************************************/
862
863 /* create a complete chain */
864 /* chain format:
865     module{option=*:option=*}[:module{option=*:...}]
866  */
867
868 static char *_strndup( char *str, int i_len )
869 {
870     char *p;
871
872     p = malloc( i_len + 1 );
873     strncpy( p, str, i_len );
874     p[i_len] = '\0';
875
876     return( p );
877 }
878
879 /*
880  * parse module{options=str, option="str "}:
881  *  return a pointer on the rest
882  *  XXX: psz_chain is modified
883  */
884 #define SKIPSPACE( p ) { while( *p && ( *p == ' ' || *p == '\t' ) ) p++; }
885 /* go accross " " and { } */
886 static char *_get_chain_end( char *str )
887 {
888     char *p = str;
889
890     SKIPSPACE( p );
891
892     for( ;; )
893     {
894         if( *p == '{' || *p == '"' || *p == '\'')
895         {
896             char c;
897
898             if( *p == '{' )
899             {
900                 c = '}';
901             }
902             else
903             {
904                 c = *p;
905             }
906             p++;
907
908             for( ;; )
909             {
910                 if( *p == '\0' )
911                 {
912                     return p;
913                 }
914
915                 if( *p == c )
916                 {
917                     p++;
918                     return p;
919                 }
920                 else if( *p == '{' && c == '}' )
921                 {
922                     p = _get_chain_end( p );
923                 }
924                 else
925                 {
926                     p++;
927                 }
928             }
929         }
930         else if( *p == '\0' || *p == ',' || *p == '}' || *p == ' ' || *p == '\t' )
931         {
932             return p;
933         }
934         else
935         {
936             p++;
937         }
938     }
939 }
940
941 char * sout_cfg_parser( char **ppsz_name, sout_cfg_t **pp_cfg, char *psz_chain )
942 {
943     sout_cfg_t *p_cfg = NULL;
944     char       *p = psz_chain;
945
946     *ppsz_name = NULL;
947     *pp_cfg    = NULL;
948
949     if( p == NULL )
950     {
951         return NULL;
952     }
953
954     SKIPSPACE( p );
955
956     while( *p && *p != '{' && *p != ':' && *p != ' ' && *p != '\t' )
957     {
958         p++;
959     }
960
961     if( p == psz_chain )
962     {
963         return NULL;
964     }
965
966     *ppsz_name = _strndup( psz_chain, p - psz_chain );
967
968     /* fprintf( stderr, "name=%s - rest=%s\n", *ppsz_name, p ); */
969
970     SKIPSPACE( p );
971
972     if( *p == '{' )
973     {
974         char *psz_name;
975
976         p++;
977
978         for( ;; )
979         {
980             sout_cfg_t cfg;
981
982             SKIPSPACE( p );
983
984             psz_name = p;
985
986             while( *p && *p != '=' && *p != ',' && *p != '}' && *p != ' ' && *p != '\t' )
987             {
988                 p++;
989             }
990
991             /* fprintf( stderr, "name=%s - rest=%s\n", psz_name, p ); */
992             if( p == psz_name )
993             {
994                 fprintf( stderr, "invalid options (empty)" );
995                 break;
996             }
997
998             cfg.psz_name = _strndup( psz_name, p - psz_name );
999
1000             SKIPSPACE( p );
1001
1002             if( *p == '=' )
1003             {
1004                 char *end;
1005
1006                 p++;
1007 #if 0
1008                 SKIPSPACE( p );
1009
1010                 if( *p == '"' )
1011                 {
1012                     char *end;
1013
1014                     p++;
1015                     end = strchr( p, '"' );
1016
1017                     if( end )
1018                     {
1019 /*                        fprintf( stderr, "##%s -- %s\n", p, end ); */
1020                         cfg.psz_value = _strndup( p, end - p );
1021                         p = end + 1;
1022                     }
1023                     else
1024                     {
1025                         cfg.psz_value = strdup( p );
1026                         p += strlen( p );
1027                     }
1028
1029                 }
1030                 else
1031                 {
1032                     psz_value = p;
1033                     while( *p && *p != ',' && *p != '}' && *p != ' ' && *p != '\t' )
1034                     {
1035                         p++;
1036                     }
1037                     cfg.psz_value = _strndup( psz_value, p - psz_value );
1038                 }
1039 #endif
1040                 end = _get_chain_end( p );
1041                 if( end <= p )
1042                 {
1043                     cfg.psz_value = NULL;
1044                 }
1045                 else
1046                 {
1047                     if( *p == '\'' || *p =='"' || *p == '{' )
1048                     {
1049                         p++;
1050                         end--;
1051                     }
1052                     if( end <= p )
1053                     {
1054                         cfg.psz_value = NULL;
1055                     }
1056                     else
1057                     {
1058                         cfg.psz_value = _strndup( p, end - p );
1059                     }
1060                 }
1061
1062                 p = end;
1063                 SKIPSPACE( p );
1064             }
1065             else
1066             {
1067                 cfg.psz_value = NULL;
1068             }
1069
1070             cfg.p_next = NULL;
1071             if( p_cfg )
1072             {
1073                 p_cfg->p_next = malloc( sizeof( sout_cfg_t ) );
1074                 memcpy( p_cfg->p_next, &cfg, sizeof( sout_cfg_t ) );
1075
1076                 p_cfg = p_cfg->p_next;
1077             }
1078             else
1079             {
1080                 p_cfg = malloc( sizeof( sout_cfg_t ) );
1081                 memcpy( p_cfg, &cfg, sizeof( sout_cfg_t ) );
1082
1083                 *pp_cfg = p_cfg;
1084             }
1085
1086             if( *p == ',' )
1087             {
1088                 p++;
1089             }
1090
1091             if( *p == '}' )
1092             {
1093                 p++;
1094
1095                 break;
1096             }
1097         }
1098     }
1099
1100     if( *p == ':' )
1101     {
1102         return( strdup( p + 1 ) );
1103     }
1104
1105     return( NULL );
1106 }
1107
1108 static void sout_cfg_free( sout_cfg_t *p_cfg )
1109 {
1110     while( p_cfg != NULL )
1111     {
1112         sout_cfg_t *p_next;
1113
1114         p_next = p_cfg->p_next;
1115
1116         FREE( p_cfg->psz_name );
1117         FREE( p_cfg->psz_value );
1118         free( p_cfg );
1119
1120         p_cfg = p_next;
1121     }
1122 }
1123
1124
1125 /*
1126  * XXX name and p_cfg are used (-> do NOT free them)
1127  */
1128 sout_stream_t *sout_stream_new( sout_instance_t *p_sout,
1129                                 char *psz_chain )
1130 {
1131     sout_stream_t *p_stream;
1132
1133     if( !psz_chain )
1134     {
1135         msg_Err( p_sout, "invalid chain" );
1136         return NULL;
1137     }
1138
1139     p_stream = vlc_object_create( p_sout, sizeof( sout_stream_t ) );
1140
1141     if( !p_stream )
1142     {
1143         msg_Err( p_sout, "out of memory" );
1144         return NULL;
1145     }
1146
1147     p_stream->p_sout   = p_sout;
1148     p_stream->p_sys    = NULL;
1149
1150     p_stream->psz_next =
1151         sout_cfg_parser( &p_stream->psz_name, &p_stream->p_cfg, psz_chain);
1152
1153     msg_Dbg( p_sout, "stream=`%s'", p_stream->psz_name );
1154
1155     p_stream->p_module =
1156         module_NeedStrict( p_stream, "sout stream", p_stream->psz_name );
1157
1158     if( !p_stream->p_module )
1159     {
1160         sout_stream_delete( p_stream );
1161         return NULL;
1162     }
1163
1164     return p_stream;
1165 }
1166
1167 void sout_stream_delete( sout_stream_t *p_stream )
1168 {
1169     msg_Dbg( p_stream, "destroying chain... (name=%s)", p_stream->psz_name );
1170     if( p_stream->p_module ) module_Unneed( p_stream, p_stream->p_module );
1171
1172     FREE( p_stream->psz_name );
1173     FREE( p_stream->psz_next );
1174
1175     sout_cfg_free( p_stream->p_cfg );
1176
1177     msg_Dbg( p_stream, "destroying chain done" );
1178     vlc_object_destroy( p_stream );
1179 }
1180
1181 static char *_sout_stream_url_to_chain( vlc_object_t *p_this, char *psz_url )
1182 {
1183     mrl_t       mrl;
1184     char        *psz_chain, *p;
1185     char        *psz_vcodec, *psz_acodec;
1186
1187     mrl_Parse( &mrl, psz_url );
1188     p = psz_chain = malloc( 500 + strlen( mrl.psz_way ) + strlen( mrl.psz_access ) + strlen( mrl.psz_name ) );
1189
1190     psz_vcodec = config_GetPsz( p_this, "sout-vcodec" );
1191     if( psz_vcodec && *psz_vcodec == '\0')
1192     {
1193         FREE( psz_vcodec );
1194     }
1195     psz_acodec = config_GetPsz( p_this, "sout-acodec" );
1196     if( psz_acodec && *psz_acodec == '\0' )
1197     {
1198         FREE( psz_acodec );
1199     }
1200     /* set transcoding */
1201     if( psz_vcodec || psz_acodec )
1202     {
1203         p += sprintf( p, "transcode{" );
1204         if( psz_vcodec )
1205         {
1206             int br;
1207
1208             p += sprintf( p, "vcodec=%s,", psz_vcodec );
1209
1210             if( ( br = config_GetInt( p_this, "sout-vbitrate" ) ) > 0 )
1211             {
1212                 p += sprintf( p, "vb=%d,", br * 1000 );
1213             }
1214             free( psz_vcodec );
1215         }
1216         if( psz_acodec )
1217         {
1218             int br;
1219
1220             p += sprintf( p, "acodec=%s,", psz_acodec );
1221             if( ( br = config_GetInt( p_this, "sout-abitrate" ) ) > 0 )
1222             {
1223                 p += sprintf( p, "ab=%d,", br * 1000 );
1224             }
1225
1226             free( psz_acodec );
1227         }
1228         p += sprintf( p, "}:" );
1229     }
1230
1231
1232     if( config_GetInt( p_this, "sout-display" ) )
1233     {
1234         p += sprintf( p, "duplicate{dst=display,dst=std{mux=\"%s\",access=\"%s\",url=\"%s\"}}", mrl.psz_way, mrl.psz_access, mrl.psz_name );
1235     }
1236     else
1237     {
1238         p += sprintf( p, "std{mux=\"%s\",access=\"%s\",url=\"%s\"}", mrl.psz_way, mrl.psz_access, mrl.psz_name );
1239     }
1240
1241     mrl_Clean( &mrl );
1242     return( psz_chain );
1243 }
1244
1245 /*****************************************************************************/
1246 static module_t *__module_NeedStrict( vlc_object_t *p_obj, const char *psz_capacity, const char *psz_name )
1247 {
1248     module_t *p_module;
1249
1250     if( !psz_name || !*psz_name )
1251     {
1252         p_module = module_Need( p_obj, psz_capacity, psz_name );
1253     }
1254     else
1255     {
1256         char *psz_name_strict = malloc( strlen( psz_name ) + 6 );
1257         strcpy( psz_name_strict, psz_name );
1258         strcat( psz_name_strict, ",none" );
1259
1260         p_module = module_Need( p_obj, psz_capacity, psz_name_strict );
1261
1262         free( psz_name_strict );
1263     }
1264
1265     return p_module;
1266 }
1267
1268