Reworked/improved the way sout-keep works. (VLM sout-keep does not
[vlc.git] / src / stream_output / stream_output.c
1 /*****************************************************************************
2  * stream_output.c : stream output module
3  *****************************************************************************
4  * Copyright (C) 2002-2007 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_playlist.h>
38
39 #include "stream_output.h"
40
41 #include <vlc_meta.h>
42
43 #include "input/input_internal.h"
44
45 #undef DEBUG_BUFFER
46 /*****************************************************************************
47  * Local prototypes
48  *****************************************************************************/
49 #define sout_stream_url_to_chain( p, s ) \
50     _sout_stream_url_to_chain( VLC_OBJECT(p), s )
51 static char *_sout_stream_url_to_chain( vlc_object_t *, char * );
52
53 /*
54  * Generic MRL parser
55  *
56  */
57
58 typedef struct
59 {
60     char *psz_access;
61     char *psz_way;
62     char *psz_name;
63 } mrl_t;
64
65 /* mrl_Parse: parse psz_mrl and fill p_mrl */
66 static int  mrl_Parse( mrl_t *p_mrl, const char *psz_mrl );
67 /* mrl_Clean: clean p_mrl  after a call to mrl_Parse */
68 static void mrl_Clean( mrl_t *p_mrl );
69
70 /*****************************************************************************
71  * sout_NewInstance: creates a new stream output instance
72  *****************************************************************************/
73 sout_instance_t *__sout_NewInstance( vlc_object_t *p_parent, 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->p_meta      = NULL;
88     p_sout->i_out_pace_nocontrol = 0;
89     p_sout->p_sys       = NULL;
90
91     vlc_mutex_init( p_sout, &p_sout->lock );
92     if( psz_dest && psz_dest[0] == '#' )
93     {
94         p_sout->psz_chain = strdup( &psz_dest[1] );
95     }
96     else
97     {
98         p_sout->psz_chain = sout_stream_url_to_chain( p_sout, psz_dest );
99         msg_Dbg( p_sout, "using sout chain=`%s'", p_sout->psz_chain );
100     }
101     p_sout->p_stream = NULL;
102
103     /* attach it for inherit */
104     vlc_object_attach( p_sout, p_parent );
105
106     p_sout->p_stream = sout_StreamNew( p_sout, p_sout->psz_chain );
107
108     if( p_sout->p_stream == NULL )
109     {
110         msg_Err( p_sout, "stream chain failed for `%s'", p_sout->psz_chain );
111
112         FREENULL( p_sout->psz_sout );
113         FREENULL( p_sout->psz_chain );
114
115         vlc_object_detach( p_sout );
116         vlc_object_destroy( p_sout );
117         return NULL;
118     }
119
120     return p_sout;
121 }
122
123 /*****************************************************************************
124  * sout_DeleteInstance: delete a previously allocated instance
125  *****************************************************************************/
126 void sout_DeleteInstance( sout_instance_t * p_sout )
127 {
128     /* remove the stream out chain */
129     sout_StreamDelete( p_sout->p_stream );
130
131     /* *** free all string *** */
132     FREENULL( p_sout->psz_sout );
133     FREENULL( p_sout->psz_chain );
134
135     /* delete meta */
136     if( p_sout->p_meta )
137     {
138         vlc_meta_Delete( p_sout->p_meta );
139     }
140
141     vlc_mutex_destroy( &p_sout->lock );
142
143     /* *** free structure *** */
144     vlc_object_destroy( p_sout );
145 }
146
147 /*****************************************************************************
148  * Packetizer/Input
149  *****************************************************************************/
150 sout_packetizer_input_t *sout_InputNew( sout_instance_t *p_sout,
151                                         es_format_t *p_fmt )
152 {
153     sout_packetizer_input_t *p_input;
154
155     msg_Dbg( p_sout, "adding a new input" );
156
157     /* *** create a packetizer input *** */
158     p_input         = malloc( sizeof( sout_packetizer_input_t ) );
159     p_input->p_sout = p_sout;
160     p_input->p_fmt  = p_fmt;
161
162     if( p_fmt->i_codec == VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
163     {
164         vlc_object_release( p_sout );
165         return p_input;
166     }
167
168     /* *** add it to the stream chain */
169     vlc_mutex_lock( &p_sout->lock );
170     p_input->id = p_sout->p_stream->pf_add( p_sout->p_stream, p_fmt );
171     vlc_mutex_unlock( &p_sout->lock );
172
173     if( p_input->id == NULL )
174     {
175         free( p_input );
176         return NULL;
177     }
178
179     return( p_input );
180 }
181
182 /*****************************************************************************
183  *
184  *****************************************************************************/
185 int sout_InputDelete( sout_packetizer_input_t *p_input )
186 {
187     sout_instance_t     *p_sout = p_input->p_sout;
188
189     msg_Dbg( p_sout, "removing an input" );
190
191     if( p_input->p_fmt->i_codec != VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
192     {
193         vlc_mutex_lock( &p_sout->lock );
194         p_sout->p_stream->pf_del( p_sout->p_stream, p_input->id );
195         vlc_mutex_unlock( &p_sout->lock );
196     }
197
198     free( p_input );
199
200     return( VLC_SUCCESS);
201 }
202
203 /*****************************************************************************
204  *
205  *****************************************************************************/
206 int sout_InputSendBuffer( sout_packetizer_input_t *p_input,
207                           block_t *p_buffer )
208 {
209     sout_instance_t     *p_sout = p_input->p_sout;
210     int                 i_ret;
211
212     if( p_input->p_fmt->i_codec == VLC_FOURCC( 'n', 'u', 'l', 'l' ) )
213     {
214         block_Release( p_buffer );
215         return VLC_SUCCESS;
216     }
217     if( p_buffer->i_dts <= 0 )
218     {
219         msg_Warn( p_sout, "trying to send non-dated packet to stream output!");
220         block_Release( p_buffer );
221         return VLC_SUCCESS;
222     }
223
224     vlc_mutex_lock( &p_sout->lock );
225     i_ret = p_sout->p_stream->pf_send( p_sout->p_stream,
226                                        p_input->id, p_buffer );
227     vlc_mutex_unlock( &p_sout->lock );
228
229     return i_ret;
230 }
231
232 /*****************************************************************************
233  * sout_AccessOutNew: allocate a new access out
234  *****************************************************************************/
235 sout_access_out_t *sout_AccessOutNew( sout_instance_t *p_sout,
236                                       const char *psz_access, const char *psz_name )
237 {
238     sout_access_out_t *p_access;
239     char              *psz_next;
240
241     if( !( p_access = vlc_object_create( p_sout,
242                                          sizeof( sout_access_out_t ) ) ) )
243     {
244         msg_Err( p_sout, "out of memory" );
245         return NULL;
246     }
247
248     psz_next = config_ChainCreate( &p_access->psz_access, &p_access->p_cfg,
249                                    psz_access );
250     if( psz_next )
251     {
252         free( psz_next );
253     }
254     p_access->psz_path   = strdup( psz_name ? psz_name : "" );
255     p_access->p_sout     = p_sout;
256     p_access->p_sys = NULL;
257     p_access->pf_seek    = NULL;
258     p_access->pf_read    = NULL;
259     p_access->pf_write   = NULL;
260     p_access->pf_control = NULL;
261     p_access->p_module   = NULL;
262
263     p_access->i_writes = 0;
264     p_access->i_sent_bytes = 0;
265
266     vlc_object_attach( p_access, p_sout );
267
268     p_access->p_module   =
269         module_Need( p_access, "sout access", p_access->psz_access, VLC_TRUE );
270
271     if( !p_access->p_module )
272     {
273         free( p_access->psz_access );
274         free( p_access->psz_path );
275         vlc_object_detach( p_access );
276         vlc_object_destroy( p_access );
277         return( NULL );
278     }
279
280     return p_access;
281 }
282 /*****************************************************************************
283  * sout_AccessDelete: delete an access out
284  *****************************************************************************/
285 void sout_AccessOutDelete( sout_access_out_t *p_access )
286 {
287     vlc_object_detach( p_access );
288     if( p_access->p_module )
289     {
290         module_Unneed( p_access, p_access->p_module );
291     }
292     free( p_access->psz_access );
293
294     config_ChainDestroy( p_access->p_cfg );
295
296     free( p_access->psz_path );
297
298     vlc_object_destroy( p_access );
299 }
300
301 /*****************************************************************************
302  * sout_AccessSeek:
303  *****************************************************************************/
304 int sout_AccessOutSeek( sout_access_out_t *p_access, off_t i_pos )
305 {
306     return p_access->pf_seek( p_access, i_pos );
307 }
308
309 /*****************************************************************************
310  * sout_AccessRead:
311  *****************************************************************************/
312 int sout_AccessOutRead( sout_access_out_t *p_access, block_t *p_buffer )
313 {
314     return( p_access->pf_read ?
315             p_access->pf_read( p_access, p_buffer ) : VLC_EGENERIC );
316 }
317
318 /*****************************************************************************
319  * sout_AccessWrite:
320  *****************************************************************************/
321 int sout_AccessOutWrite( sout_access_out_t *p_access, block_t *p_buffer )
322 {
323     int i_total = 0;
324     p_access->i_writes++;
325     p_access->i_sent_bytes += p_buffer->i_buffer;
326     if( p_access->p_libvlc->b_stats && p_access->i_writes % 30 == 0 )
327     {
328         /* Access_out -> sout_instance -> input_thread_t */
329         input_thread_t *p_input =
330             (input_thread_t *)vlc_object_find( p_access, VLC_OBJECT_INPUT,
331                                                FIND_PARENT );
332         if( p_input )
333         {
334             stats_UpdateInteger( p_input, p_input->p->counters.p_sout_sent_packets,
335                                  30, NULL );
336             stats_UpdateInteger( p_input, p_input->p->counters.p_sout_sent_bytes,
337                                  p_access->i_sent_bytes, &i_total );
338             stats_UpdateFloat( p_input, p_input->p->counters.p_sout_send_bitrate,
339                                  (float)i_total, NULL );
340             p_access->i_sent_bytes = 0;
341             vlc_object_release( p_input );
342         }
343     }
344     return p_access->pf_write( p_access, p_buffer );
345 }
346
347 /**
348  * sout_AccessOutControl
349  */
350 int sout_AccessOutControl (sout_access_out_t *access, int query, va_list args)
351 {
352     return (access->pf_control) ? access->pf_control (access, query, args)
353                                 : VLC_EGENERIC;
354 }
355
356 /*****************************************************************************
357  * sout_MuxNew: create a new mux
358  *****************************************************************************/
359 sout_mux_t * sout_MuxNew( sout_instance_t *p_sout, char *psz_mux,
360                           sout_access_out_t *p_access )
361 {
362     sout_mux_t *p_mux;
363     char       *psz_next;
364
365     p_mux = vlc_object_create( p_sout, sizeof( sout_mux_t ) );
366     if( p_mux == NULL )
367     {
368         msg_Err( p_sout, "out of memory" );
369         return NULL;
370     }
371
372     p_mux->p_sout = p_sout;
373     psz_next = config_ChainCreate( &p_mux->psz_mux, &p_mux->p_cfg, psz_mux );
374     if( psz_next ) free( psz_next );
375
376     p_mux->p_access     = p_access;
377     p_mux->pf_control   = NULL;
378     p_mux->pf_addstream = NULL;
379     p_mux->pf_delstream = NULL;
380     p_mux->pf_mux       = NULL;
381     p_mux->i_nb_inputs  = 0;
382     p_mux->pp_inputs    = NULL;
383
384     p_mux->p_sys        = NULL;
385     p_mux->p_module     = NULL;
386
387     p_mux->b_add_stream_any_time = VLC_FALSE;
388     p_mux->b_waiting_stream = VLC_TRUE;
389     p_mux->i_add_stream_start = -1;
390
391     vlc_object_attach( p_mux, p_sout );
392
393     p_mux->p_module =
394         module_Need( p_mux, "sout mux", p_mux->psz_mux, VLC_TRUE );
395
396     if( p_mux->p_module == NULL )
397     {
398         FREENULL( p_mux->psz_mux );
399
400         vlc_object_detach( p_mux );
401         vlc_object_destroy( p_mux );
402         return NULL;
403     }
404
405     /* *** probe mux capacity *** */
406     if( p_mux->pf_control )
407     {
408         int b_answer = VLC_FALSE;
409
410         if( sout_MuxControl( p_mux, MUX_CAN_ADD_STREAM_WHILE_MUXING,
411                              &b_answer ) )
412         {
413             b_answer = VLC_FALSE;
414         }
415
416         if( b_answer )
417         {
418             msg_Dbg( p_sout, "muxer support adding stream at any time" );
419             p_mux->b_add_stream_any_time = VLC_TRUE;
420             p_mux->b_waiting_stream = VLC_FALSE;
421
422             /* If we control the output pace then it's better to wait before
423              * starting muxing (generates better streams/files). */
424             if( !p_sout->i_out_pace_nocontrol )
425             {
426                 b_answer = VLC_TRUE;
427             }
428             else if( sout_MuxControl( p_mux, MUX_GET_ADD_STREAM_WAIT,
429                                       &b_answer ) )
430             {
431                 b_answer = VLC_FALSE;
432             }
433
434             if( b_answer )
435             {
436                 msg_Dbg( p_sout, "muxer prefers to wait for all ES before "
437                          "starting to mux" );
438                 p_mux->b_waiting_stream = VLC_TRUE;
439             }
440         }
441     }
442
443     return p_mux;
444 }
445
446 /*****************************************************************************
447  * sout_MuxDelete:
448  *****************************************************************************/
449 void sout_MuxDelete( sout_mux_t *p_mux )
450 {
451     vlc_object_detach( p_mux );
452     if( p_mux->p_module )
453     {
454         module_Unneed( p_mux, p_mux->p_module );
455     }
456     free( p_mux->psz_mux );
457
458     config_ChainDestroy( p_mux->p_cfg );
459
460     vlc_object_destroy( p_mux );
461 }
462
463 /*****************************************************************************
464  * sout_MuxAddStream:
465  *****************************************************************************/
466 sout_input_t *sout_MuxAddStream( sout_mux_t *p_mux, es_format_t *p_fmt )
467 {
468     sout_input_t *p_input;
469
470     if( !p_mux->b_add_stream_any_time && !p_mux->b_waiting_stream )
471     {
472         msg_Err( p_mux, "cannot add a new stream (unsupported while muxing "
473                         "to this format)" );
474         return NULL;
475     }
476
477     msg_Dbg( p_mux, "adding a new input" );
478
479     /* create a new sout input */
480     p_input = malloc( sizeof( sout_input_t ) );
481     p_input->p_sout = p_mux->p_sout;
482     p_input->p_fmt  = p_fmt;
483     p_input->p_fifo = block_FifoNew( p_mux->p_sout );
484     p_input->p_sys  = NULL;
485
486     TAB_APPEND( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
487     if( p_mux->pf_addstream( p_mux, p_input ) < 0 )
488     {
489             msg_Err( p_mux, "cannot add this stream" );
490             TAB_REMOVE( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
491             block_FifoRelease( p_input->p_fifo );
492             free( p_input );
493             return NULL;
494     }
495
496     return p_input;
497 }
498
499 /*****************************************************************************
500  * sout_MuxDeleteStream:
501  *****************************************************************************/
502 void sout_MuxDeleteStream( sout_mux_t *p_mux, sout_input_t *p_input )
503 {
504     int i_index;
505
506     if( p_mux->b_waiting_stream && p_input->p_fifo->i_depth > 0 )
507     {
508         /* We stop waiting, and call the muxer for taking care of the data
509          * before we remove this es */
510         p_mux->b_waiting_stream = VLC_FALSE;
511         p_mux->pf_mux( p_mux );
512     }
513
514     TAB_FIND( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input, i_index );
515     if( i_index >= 0 )
516     {
517         if( p_mux->pf_delstream( p_mux, p_input ) < 0 )
518         {
519             msg_Err( p_mux, "cannot delete this stream from mux" );
520         }
521
522         /* remove the entry */
523         TAB_REMOVE( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
524
525         if( p_mux->i_nb_inputs == 0 )
526         {
527             msg_Warn( p_mux, "no more input streams for this mux" );
528         }
529
530         block_FifoRelease( p_input->p_fifo );
531         free( p_input );
532     }
533 }
534
535 /*****************************************************************************
536  * sout_MuxSendBuffer:
537  *****************************************************************************/
538 void sout_MuxSendBuffer( sout_mux_t *p_mux, sout_input_t *p_input,
539                          block_t *p_buffer )
540 {
541     block_FifoPut( p_input->p_fifo, p_buffer );
542
543     if( p_mux->p_sout->i_out_pace_nocontrol )
544     {
545         mtime_t current_date = mdate();
546         if ( current_date > p_buffer->i_dts )
547             msg_Warn( p_mux, "late buffer for mux input ("I64Fd")",
548                       current_date - p_buffer->i_dts );
549     }
550
551     if( p_mux->b_waiting_stream )
552     {
553         if( p_mux->i_add_stream_start < 0 )
554         {
555             p_mux->i_add_stream_start = p_buffer->i_dts;
556         }
557
558         if( p_mux->i_add_stream_start >= 0 &&
559             p_mux->i_add_stream_start + I64C(1500000) < p_buffer->i_dts )
560         {
561             /* Wait until we have more than 1.5 seconds worth of data
562              * before start muxing */
563             p_mux->b_waiting_stream = VLC_FALSE;
564         }
565         else
566         {
567             return;
568         }
569     }
570     p_mux->pf_mux( p_mux );
571 }
572
573 /*****************************************************************************
574  *
575  *****************************************************************************/
576 static int mrl_Parse( mrl_t *p_mrl, const char *psz_mrl )
577 {
578     char * psz_dup = strdup( psz_mrl );
579     char * psz_parser = psz_dup;
580     const char * psz_access;
581     const char * psz_way;
582     char * psz_name;
583
584     /* *** first parse psz_dest */
585     while( *psz_parser && *psz_parser != ':' )
586     {
587         if( *psz_parser == '{' )
588         {
589             while( *psz_parser && *psz_parser != '}' )
590             {
591                 psz_parser++;
592             }
593             if( *psz_parser )
594             {
595                 psz_parser++;
596             }
597         }
598         else
599         {
600             psz_parser++;
601         }
602     }
603 #if defined( WIN32 ) || defined( UNDER_CE )
604     if( psz_parser - psz_dup == 1 )
605     {
606         /* msg_Warn( p_sout, "drive letter %c: found in source string",
607                           *psz_dup ) ; */
608         psz_parser = "";
609     }
610 #endif
611
612     if( !*psz_parser )
613     {
614         psz_access = psz_way = "";
615         psz_name = psz_dup;
616     }
617     else
618     {
619         *psz_parser++ = '\0';
620
621         /* let's skip '//' */
622         if( psz_parser[0] == '/' && psz_parser[1] == '/' )
623         {
624             psz_parser += 2 ;
625         }
626
627         psz_name = psz_parser ;
628
629         /* Come back to parse the access and mux plug-ins */
630         psz_parser = psz_dup;
631
632         if( !*psz_parser )
633         {
634             /* No access */
635             psz_access = "";
636         }
637         else if( *psz_parser == '/' )
638         {
639             /* No access */
640             psz_access = "";
641             psz_parser++;
642         }
643         else
644         {
645             psz_access = psz_parser;
646
647             while( *psz_parser && *psz_parser != '/' )
648             {
649                 if( *psz_parser == '{' )
650                 {
651                     while( *psz_parser && *psz_parser != '}' )
652                     {
653                         psz_parser++;
654                     }
655                     if( *psz_parser )
656                     {
657                         psz_parser++;
658                     }
659                 }
660                 else
661                 {
662                     psz_parser++;
663                 }
664             }
665
666             if( *psz_parser == '/' )
667             {
668                 *psz_parser++ = '\0';
669             }
670         }
671
672         if( !*psz_parser )
673         {
674             /* No mux */
675             psz_way = "";
676         }
677         else
678         {
679             psz_way = psz_parser;
680         }
681     }
682
683     p_mrl->psz_access = strdup( psz_access );
684     p_mrl->psz_way    = strdup( psz_way );
685     p_mrl->psz_name   = strdup( psz_name );
686
687     free( psz_dup );
688     return( VLC_SUCCESS );
689 }
690
691
692 /* mrl_Clean: clean p_mrl  after a call to mrl_Parse */
693 static void mrl_Clean( mrl_t *p_mrl )
694 {
695     FREENULL( p_mrl->psz_access );
696     FREENULL( p_mrl->psz_way );
697     FREENULL( p_mrl->psz_name );
698 }
699
700
701 /****************************************************************************
702  ****************************************************************************
703  **
704  **
705  **
706  ****************************************************************************
707  ****************************************************************************/
708
709 /* create a complete chain */
710 /* chain format:
711     module{option=*:option=*}[:module{option=*:...}]
712  */
713
714 /*
715  * parse module{options=str, option="str "}:
716  *  return a pointer on the rest
717  *  XXX: psz_chain is modified
718  */
719 #define SKIPSPACE( p ) { while( *p && ( *p == ' ' || *p == '\t' ) ) p++; }
720 #define SKIPTRAILINGSPACE( p, e ) \
721     { while( e > p && ( *(e-1) == ' ' || *(e-1) == '\t' ) ) e--; }
722
723 /* go accross " " and { } */
724 static char *_get_chain_end( char *str )
725 {
726     char c, *p = str;
727
728     SKIPSPACE( p );
729
730     for( ;; )
731     {
732         if( !*p || *p == ',' || *p == '}' ) return p;
733
734         if( *p != '{' && *p != '"' && *p != '\'' )
735         {
736             p++;
737             continue;
738         }
739
740         if( *p == '{' ) c = '}';
741         else c = *p;
742         p++;
743
744         for( ;; )
745         {
746             if( !*p ) return p;
747
748             if( *p == c ) return ++p;
749             else if( *p == '{' && c == '}' ) p = _get_chain_end( p );
750             else p++;
751         }
752     }
753 }
754
755 /*
756  * XXX name and p_cfg are used (-> do NOT free them)
757  */
758 sout_stream_t *sout_StreamNew( sout_instance_t *p_sout, char *psz_chain )
759 {
760     sout_stream_t *p_stream;
761
762     if( !psz_chain )
763     {
764         msg_Err( p_sout, "invalid chain" );
765         return NULL;
766     }
767
768     p_stream = vlc_object_create( p_sout, sizeof( sout_stream_t ) );
769
770     if( !p_stream )
771     {
772         msg_Err( p_sout, "out of memory" );
773         return NULL;
774     }
775
776     p_stream->p_sout   = p_sout;
777     p_stream->p_sys    = NULL;
778
779     p_stream->psz_next =
780         config_ChainCreate( &p_stream->psz_name, &p_stream->p_cfg, psz_chain);
781
782     msg_Dbg( p_sout, "stream=`%s'", p_stream->psz_name );
783
784     vlc_object_attach( p_stream, p_sout );
785
786     p_stream->p_module =
787         module_Need( p_stream, "sout stream", p_stream->psz_name, VLC_TRUE );
788
789     if( !p_stream->p_module )
790     {
791         sout_StreamDelete( p_stream );
792         return NULL;
793     }
794
795     return p_stream;
796 }
797
798 void sout_StreamDelete( sout_stream_t *p_stream )
799 {
800     msg_Dbg( p_stream, "destroying chain... (name=%s)", p_stream->psz_name );
801
802     vlc_object_detach( p_stream );
803     if( p_stream->p_module ) module_Unneed( p_stream, p_stream->p_module );
804
805     FREENULL( p_stream->psz_name );
806     FREENULL( p_stream->psz_next );
807
808     config_ChainDestroy( p_stream->p_cfg );
809
810     msg_Dbg( p_stream, "destroying chain done" );
811     vlc_object_destroy( p_stream );
812 }
813
814 static char *_sout_stream_url_to_chain( vlc_object_t *p_this, char *psz_url )
815 {
816     mrl_t       mrl;
817     char        *psz_chain, *p;
818
819     mrl_Parse( &mrl, psz_url );
820     p = psz_chain = malloc( 500 + strlen( mrl.psz_way ) +
821                                   strlen( mrl.psz_access ) +
822                                   strlen( mrl.psz_name ) );
823
824
825     if( config_GetInt( p_this, "sout-display" ) )
826     {
827         p += sprintf( p, "duplicate{dst=display,dst=std{mux=\"%s\","
828                       "access=\"%s\",dst=\"%s\"}}",
829                       mrl.psz_way, mrl.psz_access, mrl.psz_name );
830     }
831     else
832     {
833         p += sprintf( p, "std{mux=\"%s\",access=\"%s\",dst=\"%s\"}",
834                       mrl.psz_way, mrl.psz_access, mrl.psz_name );
835     }
836
837     mrl_Clean( &mrl );
838     return( psz_chain );
839 }