src/stream_output/stream_output.c

   1 /*****************************************************************************
   2  * stream_output.c : stream output module
   3  *****************************************************************************
   4  * Copyright (C) 2002-2007 VLC authors and VideoLAN
   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 it
  12  * under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <assert.h>
  35
  36 #include <vlc_common.h>
  37
  38 #include <stdlib.h>                                                /* free() */
  39 #include <stdio.h>                                              /* sprintf() */
  40 #include <string.h>
  41
  42 #include <vlc_sout.h>
  43
  44 #include "stream_output.h"
  45
  46 #include <vlc_meta.h>
  47 #include <vlc_block.h>
  48 #include <vlc_codec.h>
  49 #include <vlc_modules.h>
  50
  51 #include "input/input_interface.h"
  52
  53 #undef DEBUG_BUFFER
  54 /*****************************************************************************
  55  * Local prototypes
  56  *****************************************************************************/
  57 static char *sout_stream_url_to_chain( bool, const char * );
  58
  59 /*
  60  * Generic MRL parser
  61  *
  62  */
  63
  64 typedef struct
  65 {
  66     char *psz_access;
  67     char *psz_way;
  68     char *psz_name;
  69 } mrl_t;
  70
  71 /* mrl_Parse: parse psz_mrl and fill p_mrl */
  72 static int  mrl_Parse( mrl_t *p_mrl, const char *psz_mrl );
  73 /* mrl_Clean: clean p_mrl  after a call to mrl_Parse */
  74 static void mrl_Clean( mrl_t *p_mrl );
  75
  76 #undef sout_NewInstance
  77
  78 /*****************************************************************************
  79  * sout_NewInstance: creates a new stream output instance
  80  *****************************************************************************/
  81 sout_instance_t *sout_NewInstance( vlc_object_t *p_parent, const char *psz_dest )
  82 {
  83     sout_instance_t *p_sout;
  84     char *psz_chain;
  85
  86     assert( psz_dest != NULL );
  87
  88     if( psz_dest[0] == '#' )
  89     {
  90         psz_chain = strdup( &psz_dest[1] );
  91     }
  92     else
  93     {
  94         psz_chain = sout_stream_url_to_chain(
  95             var_InheritBool(p_parent, "sout-display"), psz_dest );
  96     }
  97     if(!psz_chain)
  98         return NULL;
  99
 100     /* *** Allocate descriptor *** */
 101     p_sout = vlc_custom_create( p_parent, sizeof( *p_sout ), "stream output" );
 102     if( p_sout == NULL )
 103     {
 104         free( psz_chain );
 105         return NULL;
 106     }
 107
 108     msg_Dbg( p_sout, "using sout chain=`%s'", psz_chain );
 109
 110     /* *** init descriptor *** */
 111     p_sout->psz_sout    = strdup( psz_dest );
 112     p_sout->i_out_pace_nocontrol = 0;
 113
 114     vlc_mutex_init( &p_sout->lock );
 115     p_sout->p_stream = NULL;
 116
 117     var_Create( p_sout, "sout-mux-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 118
 119     p_sout->p_stream = sout_StreamChainNew( p_sout, psz_chain, NULL, NULL );
 120     if( p_sout->p_stream )
 121     {
 122         free( psz_chain );
 123         return p_sout;
 124     }
 125
 126     msg_Err( p_sout, "stream chain failed for `%s'", psz_chain );
 127     free( psz_chain );
 128
 129     FREENULL( p_sout->psz_sout );
 130
 131     vlc_mutex_destroy( &p_sout->lock );
 132     vlc_object_release( p_sout );
 133     return NULL;
 134 }
 135
 136 /*****************************************************************************
 137  * sout_DeleteInstance: delete a previously allocated instance
 138  *****************************************************************************/
 139 void sout_DeleteInstance( sout_instance_t * p_sout )
 140 {
 141     /* remove the stream out chain */
 142     sout_StreamChainDelete( p_sout->p_stream, NULL );
 143
 144     /* *** free all string *** */
 145     FREENULL( p_sout->psz_sout );
 146
 147     vlc_mutex_destroy( &p_sout->lock );
 148
 149     /* *** free structure *** */
 150     vlc_object_release( p_sout );
 151 }
 152
 153 /*****************************************************************************
 154  * Packetizer/Input
 155  *****************************************************************************/
 156 sout_packetizer_input_t *sout_InputNew( sout_instance_t *p_sout,
 157                                         const es_format_t *p_fmt )
 158 {
 159     sout_packetizer_input_t *p_input;
 160
 161     /* *** create a packetizer input *** */
 162     if( !p_fmt->i_codec || !(p_input = malloc(sizeof(sout_packetizer_input_t))) )
 163         return NULL;
 164
 165     p_input->p_sout = p_sout;
 166
 167     msg_Dbg( p_sout, "adding a new sout input for `%4.4s` (sout_input: %p)",
 168              (char*) &p_fmt->i_codec, (void *)p_input );
 169
 170     /* *** add it to the stream chain */
 171     vlc_mutex_lock( &p_sout->lock );
 172     p_input->id = p_sout->p_stream->pf_add( p_sout->p_stream, p_fmt );
 173     vlc_mutex_unlock( &p_sout->lock );
 174
 175     if( p_input->id == NULL )
 176     {
 177         msg_Warn( p_sout, "new sout input failed (sout_input: %p)",
 178                  (void *)p_input );
 179         free( p_input );
 180         p_input = NULL;
 181     }
 182
 183     return( p_input );
 184 }
 185
 186 /*****************************************************************************
 187  *
 188  *****************************************************************************/
 189 int sout_InputDelete( sout_packetizer_input_t *p_input )
 190 {
 191     sout_instance_t     *p_sout = p_input->p_sout;
 192
 193     msg_Dbg( p_sout, "removing a sout input (sout_input: %p)",
 194              (void *)p_input );
 195
 196     vlc_mutex_lock( &p_sout->lock );
 197     p_sout->p_stream->pf_del( p_sout->p_stream, p_input->id );
 198     vlc_mutex_unlock( &p_sout->lock );
 199
 200     free( p_input );
 201
 202     return( VLC_SUCCESS);
 203 }
 204
 205 bool sout_InputIsEmpty( sout_packetizer_input_t *p_input )
 206 {
 207     sout_instance_t *p_sout = p_input->p_sout;
 208     bool b;
 209
 210     vlc_mutex_lock( &p_sout->lock );
 211     if( sout_StreamControl( p_sout->p_stream, SOUT_STREAM_EMPTY, &b ) != VLC_SUCCESS )
 212         b = true;
 213     vlc_mutex_unlock( &p_sout->lock );
 214     return b;
 215 }
 216
 217 void sout_InputFlush( sout_packetizer_input_t *p_input )
 218 {
 219     sout_instance_t     *p_sout = p_input->p_sout;
 220
 221     vlc_mutex_lock( &p_sout->lock );
 222     sout_StreamFlush( p_sout->p_stream, p_input->id );
 223     vlc_mutex_unlock( &p_sout->lock );
 224 }
 225
 226 /*****************************************************************************
 227  *
 228  *****************************************************************************/
 229 int sout_InputSendBuffer( sout_packetizer_input_t *p_input,
 230                           block_t *p_buffer )
 231 {
 232     sout_instance_t     *p_sout = p_input->p_sout;
 233     int                 i_ret;
 234
 235     vlc_mutex_lock( &p_sout->lock );
 236     i_ret = p_sout->p_stream->pf_send( p_sout->p_stream,
 237                                        p_input->id, p_buffer );
 238     vlc_mutex_unlock( &p_sout->lock );
 239
 240     return i_ret;
 241 }
 242
 243 #undef sout_AccessOutNew
 244 /*****************************************************************************
 245  * sout_AccessOutNew: allocate a new access out
 246  *****************************************************************************/
 247 sout_access_out_t *sout_AccessOutNew( vlc_object_t *p_sout,
 248                                       const char *psz_access, const char *psz_name )
 249 {
 250     sout_access_out_t *p_access;
 251     char              *psz_next;
 252
 253     p_access = vlc_custom_create( p_sout, sizeof( *p_access ), "access out" );
 254     if( !p_access )
 255         return NULL;
 256
 257     psz_next = config_ChainCreate( &p_access->psz_access, &p_access->p_cfg,
 258                                    psz_access );
 259     free( psz_next );
 260     p_access->psz_path   = strdup( psz_name ? psz_name : "" );
 261     p_access->p_sys      = NULL;
 262     p_access->pf_seek    = NULL;
 263     p_access->pf_read    = NULL;
 264     p_access->pf_write   = NULL;
 265     p_access->pf_control = NULL;
 266     p_access->p_module   = NULL;
 267
 268     p_access->p_module   =
 269         module_need( p_access, "sout access", p_access->psz_access, true );
 270
 271     if( !p_access->p_module )
 272     {
 273         free( p_access->psz_access );
 274         free( p_access->psz_path );
 275         vlc_object_release( p_access );
 276         return( NULL );
 277     }
 278
 279     return p_access;
 280 }
 281 /*****************************************************************************
 282  * sout_AccessDelete: delete an access out
 283  *****************************************************************************/
 284 void sout_AccessOutDelete( sout_access_out_t *p_access )
 285 {
 286     if( p_access->p_module )
 287     {
 288         module_unneed( p_access, p_access->p_module );
 289     }
 290     free( p_access->psz_access );
 291
 292     config_ChainDestroy( p_access->p_cfg );
 293
 294     free( p_access->psz_path );
 295
 296     vlc_object_release( p_access );
 297 }
 298
 299 /*****************************************************************************
 300  * sout_AccessSeek:
 301  *****************************************************************************/
 302 int sout_AccessOutSeek( sout_access_out_t *p_access, off_t i_pos )
 303 {
 304     if (p_access->pf_seek == NULL)
 305         return VLC_EGENERIC;
 306     return p_access->pf_seek( p_access, i_pos );
 307 }
 308
 309 /*****************************************************************************
 310  * sout_AccessRead:
 311  *****************************************************************************/
 312 ssize_t 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 ssize_t sout_AccessOutWrite( sout_access_out_t *p_access, block_t *p_buffer )
 322 {
 323     return p_access->pf_write( p_access, p_buffer );
 324 }
 325
 326 /**
 327  * sout_AccessOutControl
 328  */
 329 int sout_AccessOutControl (sout_access_out_t *access, int query, ...)
 330 {
 331     va_list ap;
 332     int ret;
 333
 334     va_start (ap, query);
 335     if (access->pf_control)
 336         ret = access->pf_control (access, query, ap);
 337     else
 338         ret = VLC_EGENERIC;
 339     va_end (ap);
 340     return ret;
 341 }
 342
 343 /*****************************************************************************
 344  * sout_MuxNew: create a new mux
 345  *****************************************************************************/
 346 sout_mux_t * sout_MuxNew( sout_instance_t *p_sout, const char *psz_mux,
 347                           sout_access_out_t *p_access )
 348 {
 349     sout_mux_t *p_mux;
 350     char       *psz_next;
 351
 352     p_mux = vlc_custom_create( p_sout, sizeof( *p_mux ), "mux" );
 353     if( p_mux == NULL )
 354         return NULL;
 355
 356     p_mux->p_sout = p_sout;
 357     psz_next = config_ChainCreate( &p_mux->psz_mux, &p_mux->p_cfg, psz_mux );
 358     free( psz_next );
 359
 360     p_mux->p_access     = p_access;
 361     p_mux->pf_control   = NULL;
 362     p_mux->pf_addstream = NULL;
 363     p_mux->pf_delstream = NULL;
 364     p_mux->pf_mux       = NULL;
 365     p_mux->i_nb_inputs  = 0;
 366     p_mux->pp_inputs    = NULL;
 367
 368     p_mux->p_sys        = NULL;
 369     p_mux->p_module     = NULL;
 370
 371     p_mux->b_add_stream_any_time = false;
 372     p_mux->b_waiting_stream = true;
 373     p_mux->i_add_stream_start = -1;
 374
 375     p_mux->p_module =
 376         module_need( p_mux, "sout mux", p_mux->psz_mux, true );
 377
 378     if( p_mux->p_module == NULL )
 379     {
 380         FREENULL( p_mux->psz_mux );
 381
 382         vlc_object_release( p_mux );
 383         return NULL;
 384     }
 385
 386     /* *** probe mux capacity *** */
 387     if( p_mux->pf_control )
 388     {
 389         int b_answer = false;
 390
 391         if( sout_MuxControl( p_mux, MUX_CAN_ADD_STREAM_WHILE_MUXING,
 392                              &b_answer ) )
 393         {
 394             b_answer = false;
 395         }
 396
 397         if( b_answer )
 398         {
 399             msg_Dbg( p_sout, "muxer support adding stream at any time" );
 400             p_mux->b_add_stream_any_time = true;
 401             p_mux->b_waiting_stream = false;
 402
 403             /* If we control the output pace then it's better to wait before
 404              * starting muxing (generates better streams/files). */
 405             if( !p_sout->i_out_pace_nocontrol )
 406             {
 407                 b_answer = true;
 408             }
 409             else if( sout_MuxControl( p_mux, MUX_GET_ADD_STREAM_WAIT,
 410                                       &b_answer ) )
 411             {
 412                 b_answer = false;
 413             }
 414
 415             if( b_answer )
 416             {
 417                 msg_Dbg( p_sout, "muxer prefers to wait for all ES before "
 418                          "starting to mux" );
 419                 p_mux->b_waiting_stream = true;
 420             }
 421         }
 422     }
 423
 424     return p_mux;
 425 }
 426
 427 /*****************************************************************************
 428  * sout_MuxDelete:
 429  *****************************************************************************/
 430 void sout_MuxDelete( sout_mux_t *p_mux )
 431 {
 432     if( p_mux->p_module )
 433     {
 434         module_unneed( p_mux, p_mux->p_module );
 435     }
 436     free( p_mux->psz_mux );
 437
 438     config_ChainDestroy( p_mux->p_cfg );
 439
 440     vlc_object_release( p_mux );
 441 }
 442
 443 /*****************************************************************************
 444  * sout_MuxAddStream:
 445  *****************************************************************************/
 446 sout_input_t *sout_MuxAddStream( sout_mux_t *p_mux, const es_format_t *p_fmt )
 447 {
 448     sout_input_t *p_input;
 449
 450     if( !p_mux->b_add_stream_any_time && !p_mux->b_waiting_stream )
 451     {
 452         msg_Err( p_mux, "cannot add a new stream (unsupported while muxing "
 453                         "to this format). You can try increasing sout-mux-caching value" );
 454         return NULL;
 455     }
 456
 457     msg_Dbg( p_mux, "adding a new input" );
 458
 459     /* create a new sout input */
 460     p_input = malloc( sizeof( sout_input_t ) );
 461     if( !p_input )
 462         return NULL;
 463
 464     // FIXME: remove either fmt or p_fmt...
 465     es_format_Copy( &p_input->fmt, p_fmt );
 466     p_input->p_fmt = &p_input->fmt;
 467
 468     p_input->p_fifo = block_FifoNew();
 469     p_input->p_sys  = NULL;
 470
 471     TAB_APPEND( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
 472     if( p_mux->pf_addstream( p_mux, p_input ) < 0 )
 473     {
 474         msg_Err( p_mux, "cannot add this stream" );
 475         TAB_REMOVE( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
 476         block_FifoRelease( p_input->p_fifo );
 477         es_format_Clean( &p_input->fmt );
 478         free( p_input );
 479         return NULL;
 480     }
 481
 482     return p_input;
 483 }
 484
 485 /*****************************************************************************
 486  * sout_MuxDeleteStream:
 487  *****************************************************************************/
 488 void sout_MuxDeleteStream( sout_mux_t *p_mux, sout_input_t *p_input )
 489 {
 490     int i_index;
 491
 492     if( p_mux->b_waiting_stream
 493      && block_FifoCount( p_input->p_fifo ) > 0 )
 494     {
 495         /* We stop waiting, and call the muxer for taking care of the data
 496          * before we remove this es */
 497         p_mux->b_waiting_stream = false;
 498         p_mux->pf_mux( p_mux );
 499     }
 500
 501     TAB_FIND( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input, i_index );
 502     if( i_index >= 0 )
 503     {
 504         p_mux->pf_delstream( p_mux, p_input );
 505
 506         /* remove the entry */
 507         TAB_REMOVE( p_mux->i_nb_inputs, p_mux->pp_inputs, p_input );
 508
 509         if( p_mux->i_nb_inputs == 0 )
 510         {
 511             msg_Warn( p_mux, "no more input streams for this mux" );
 512         }
 513
 514         block_FifoRelease( p_input->p_fifo );
 515         es_format_Clean( &p_input->fmt );
 516         free( p_input );
 517     }
 518 }
 519
 520 /*****************************************************************************
 521  * sout_MuxSendBuffer:
 522  *****************************************************************************/
 523 int sout_MuxSendBuffer( sout_mux_t *p_mux, sout_input_t *p_input,
 524                          block_t *p_buffer )
 525 {
 526     mtime_t i_dts = p_buffer->i_dts;
 527     block_FifoPut( p_input->p_fifo, p_buffer );
 528
 529     if( p_mux->p_sout->i_out_pace_nocontrol )
 530     {
 531         mtime_t current_date = mdate();
 532         if ( current_date > i_dts )
 533             msg_Warn( p_mux, "late buffer for mux input (%"PRId64")",
 534                       current_date - i_dts );
 535     }
 536
 537     if( p_mux->b_waiting_stream )
 538     {
 539         const int64_t i_caching = var_GetInteger( p_mux->p_sout, "sout-mux-caching" ) * INT64_C(1000);
 540
 541         if( p_mux->i_add_stream_start < 0 )
 542             p_mux->i_add_stream_start = i_dts;
 543
 544         /* Wait until we have enough data before muxing */
 545         if( p_mux->i_add_stream_start < 0 ||
 546             i_dts < p_mux->i_add_stream_start + i_caching )
 547             return VLC_SUCCESS;
 548         p_mux->b_waiting_stream = false;
 549     }
 550     return p_mux->pf_mux( p_mux );
 551 }
 552
 553 void sout_MuxFlush( sout_mux_t *p_mux, sout_input_t *p_input )
 554 {
 555     VLC_UNUSED(p_mux);
 556     block_FifoEmpty( p_input->p_fifo );
 557 }
 558
 559 /*****************************************************************************
 560  * sout_MuxGetStream: find stream to be muxed
 561  *****************************************************************************/
 562 int sout_MuxGetStream( sout_mux_t *p_mux, unsigned i_blocks, mtime_t *pi_dts )
 563 {
 564     mtime_t i_dts = 0;
 565     int     i_stream = -1;
 566
 567     assert( i_blocks > 0 );
 568
 569     for( int i = 0; i < p_mux->i_nb_inputs; i++ )
 570     {
 571         sout_input_t *p_input = p_mux->pp_inputs[i];
 572         block_t *p_data;
 573
 574         if( block_FifoCount( p_input->p_fifo ) < i_blocks )
 575         {
 576             if( (!p_mux->b_add_stream_any_time) &&
 577                 (p_input->p_fmt->i_cat != SPU_ES ) )
 578             {
 579                 return -1;
 580             }
 581             /* FIXME: SPU muxing */
 582             continue;
 583         }
 584
 585         p_data = block_FifoShow( p_input->p_fifo );
 586         if( i_stream < 0 || p_data->i_dts < i_dts )
 587         {
 588             i_stream = i;
 589             i_dts    = p_data->i_dts;
 590         }
 591     }
 592
 593     if( pi_dts ) *pi_dts = i_dts;
 594
 595     return i_stream;
 596 }
 597
 598
 599 /*****************************************************************************
 600  *
 601  *****************************************************************************/
 602 static int mrl_Parse( mrl_t *p_mrl, const char *psz_mrl )
 603 {
 604     char * psz_dup = strdup( psz_mrl );
 605     char * psz_parser = psz_dup;
 606     const char * psz_access;
 607     const char * psz_way;
 608     char * psz_name;
 609
 610     /* *** first parse psz_dest */
 611     while( *psz_parser && *psz_parser != ':' )
 612     {
 613         if( *psz_parser == '{' )
 614         {
 615             while( *psz_parser && *psz_parser != '}' )
 616             {
 617                 psz_parser++;
 618             }
 619             if( *psz_parser )
 620             {
 621                 psz_parser++;
 622             }
 623         }
 624         else
 625         {
 626             psz_parser++;
 627         }
 628     }
 629 #if defined( _WIN32 ) || defined( __OS2__ )
 630     if( psz_parser - psz_dup == 1 )
 631     {
 632         /* msg_Warn( p_sout, "drive letter %c: found in source string",
 633                           *psz_dup ) ; */
 634         *psz_parser = '\0';
 635     }
 636 #endif
 637
 638     if( !*psz_parser )
 639     {
 640         psz_access = psz_way = "";
 641         psz_name = psz_dup;
 642     }
 643     else
 644     {
 645         *psz_parser++ = '\0';
 646
 647         /* let's skip '//' */
 648         if( psz_parser[0] == '/' && psz_parser[1] == '/' )
 649         {
 650             psz_parser += 2 ;
 651         }
 652
 653         psz_name = psz_parser ;
 654
 655         /* Come back to parse the access and mux plug-ins */
 656         psz_parser = psz_dup;
 657
 658         if( !*psz_parser )
 659         {
 660             /* No access */
 661             psz_access = "";
 662         }
 663         else if( *psz_parser == '/' )
 664         {
 665             /* No access */
 666             psz_access = "";
 667             psz_parser++;
 668         }
 669         else
 670         {
 671             psz_access = psz_parser;
 672
 673             while( *psz_parser && *psz_parser != '/' )
 674             {
 675                 if( *psz_parser == '{' )
 676                 {
 677                     while( *psz_parser && *psz_parser != '}' )
 678                     {
 679                         psz_parser++;
 680                     }
 681                     if( *psz_parser )
 682                     {
 683                         psz_parser++;
 684                     }
 685                 }
 686                 else
 687                 {
 688                     psz_parser++;
 689                 }
 690             }
 691
 692             if( *psz_parser == '/' )
 693             {
 694                 *psz_parser++ = '\0';
 695             }
 696         }
 697
 698         if( !*psz_parser )
 699         {
 700             /* No mux */
 701             psz_way = "";
 702         }
 703         else
 704         {
 705             psz_way = psz_parser;
 706         }
 707     }
 708
 709     p_mrl->psz_access = strdup( psz_access );
 710     p_mrl->psz_way    = strdup( psz_way );
 711     p_mrl->psz_name   = strdup( psz_name );
 712
 713     free( psz_dup );
 714     return( VLC_SUCCESS );
 715 }
 716
 717
 718 /* mrl_Clean: clean p_mrl  after a call to mrl_Parse */
 719 static void mrl_Clean( mrl_t *p_mrl )
 720 {
 721     FREENULL( p_mrl->psz_access );
 722     FREENULL( p_mrl->psz_way );
 723     FREENULL( p_mrl->psz_name );
 724 }
 725
 726
 727 /****************************************************************************
 728  ****************************************************************************
 729  **
 730  **
 731  **
 732  ****************************************************************************
 733  ****************************************************************************/
 734
 735 /* Destroy a "stream_out" module */
 736 static void sout_StreamDelete( sout_stream_t *p_stream )
 737 {
 738     sout_instance_t *p_sout = (sout_instance_t *)(p_stream->obj.parent);
 739
 740     msg_Dbg( p_stream, "destroying chain... (name=%s)", p_stream->psz_name );
 741
 742     p_sout->i_out_pace_nocontrol -= p_stream->pace_nocontrol;
 743
 744     if( p_stream->p_module != NULL )
 745         module_unneed( p_stream, p_stream->p_module );
 746
 747     FREENULL( p_stream->psz_name );
 748
 749     config_ChainDestroy( p_stream->p_cfg );
 750
 751     msg_Dbg( p_stream, "destroying chain done" );
 752     vlc_object_release( p_stream );
 753 }
 754
 755 /* Destroy a "stream_out" modules chain
 756  *
 757  * p_first is the first module to be destroyed in the chain
 758  * p_last is the last module to be destroyed
 759  *  if NULL, all modules are destroyed
 760  *  if not NULL, modules following it must be destroyed separately
 761  */
 762 void sout_StreamChainDelete(sout_stream_t *p_first, sout_stream_t *p_last)
 763 {
 764     while(p_first != NULL)
 765     {
 766         sout_stream_t *p_next = p_first->p_next;
 767
 768         sout_StreamDelete(p_first);
 769         if(p_first == p_last)
 770            break;
 771         p_first = p_next;
 772     }
 773 }
 774
 775 /* Create a "stream_out" module, which may forward its ES to p_next module */
 776 /*
 777  * XXX name and p_cfg are used (-> do NOT free them)
 778  */
 779 static sout_stream_t *sout_StreamNew( sout_instance_t *p_sout, char *psz_name,
 780                                config_chain_t *p_cfg, sout_stream_t *p_next)
 781 {
 782     sout_stream_t *p_stream;
 783
 784     assert(psz_name);
 785
 786     p_stream = vlc_custom_create( p_sout, sizeof( *p_stream ), "stream out" );
 787     if( !p_stream )
 788         return NULL;
 789
 790     p_stream->p_sout   = p_sout;
 791     p_stream->psz_name = psz_name;
 792     p_stream->p_cfg    = p_cfg;
 793     p_stream->p_next   = p_next;
 794     p_stream->pf_flush = NULL;
 795     p_stream->pf_control = NULL;
 796     p_stream->pace_nocontrol = false;
 797     p_stream->p_sys = NULL;
 798
 799     msg_Dbg( p_sout, "stream=`%s'", p_stream->psz_name );
 800
 801     p_stream->p_module =
 802         module_need( p_stream, "sout stream", p_stream->psz_name, true );
 803
 804     if( !p_stream->p_module )
 805     {
 806         /* those must be freed by the caller if creation failed */
 807         p_stream->psz_name = NULL;
 808         p_stream->p_cfg = NULL;
 809
 810         sout_StreamDelete( p_stream );
 811         return NULL;
 812     }
 813
 814     p_sout->i_out_pace_nocontrol += p_stream->pace_nocontrol;
 815     return p_stream;
 816 }
 817
 818 /* Creates a complete "stream_out" modules chain
 819  *
 820  *  chain format: module1{option=*:option=*}[:module2{option=*:...}]
 821  *
 822  *  The modules are created starting from the last one and linked together
 823  *  A pointer to the last module created is stored if pp_last isn't NULL, to
 824  *  make sure sout_StreamChainDelete doesn't delete modules created in another
 825  *  place.
 826  *
 827  *  Returns a pointer to the first module.
 828  */
 829 sout_stream_t *sout_StreamChainNew(sout_instance_t *p_sout, const char *psz_chain,
 830                                 sout_stream_t *p_next, sout_stream_t **pp_last)
 831 {
 832     if(!psz_chain || !*psz_chain)
 833     {
 834         if(pp_last) *pp_last = NULL;
 835         return p_next;
 836     }
 837
 838     char *psz_parser = strdup(psz_chain);
 839     if(!psz_parser)
 840         return NULL;
 841
 842     vlc_array_t cfg, name;
 843     vlc_array_init(&cfg);
 844     vlc_array_init(&name);
 845
 846     /* parse chain */
 847     while(psz_parser)
 848     {
 849         config_chain_t *p_cfg;
 850         char *psz_name;
 851         char *psz_rest_chain = config_ChainCreate( &psz_name, &p_cfg, psz_parser );
 852         free( psz_parser );
 853         psz_parser = psz_rest_chain;
 854
 855         vlc_array_append(&cfg, p_cfg);
 856         vlc_array_append(&name, psz_name);
 857     }
 858
 859     size_t i = vlc_array_count(&name);
 860     vlc_array_t module;
 861     vlc_array_init(&module);
 862     while(i--)
 863     {
 864         p_next = sout_StreamNew( p_sout, vlc_array_item_at_index(&name, i),
 865             vlc_array_item_at_index(&cfg, i), p_next);
 866
 867         if(!p_next)
 868             goto error;
 869
 870         if(i == vlc_array_count(&name) - 1 && pp_last)
 871             *pp_last = p_next;   /* last module created in the chain */
 872
 873         vlc_array_append(&module, p_next);
 874     }
 875
 876     vlc_array_clear(&name);
 877     vlc_array_clear(&cfg);
 878     vlc_array_clear(&module);
 879
 880     return p_next;
 881
 882 error:
 883
 884     i++;    /* last module couldn't be created */
 885
 886     /* destroy all modules created, starting with the last one */
 887     int modules = vlc_array_count(&module);
 888     while(modules--)
 889         sout_StreamDelete(vlc_array_item_at_index(&module, modules));
 890     vlc_array_clear(&module);
 891
 892     /* then destroy all names and config which weren't destroyed by
 893      * sout_StreamDelete */
 894     while(i--)
 895     {
 896         free(vlc_array_item_at_index(&name, i));
 897         config_ChainDestroy(vlc_array_item_at_index(&cfg, i));
 898     }
 899     vlc_array_clear(&name);
 900     vlc_array_clear(&cfg);
 901
 902     return NULL;
 903 }
 904
 905 static char *sout_stream_url_to_chain( bool b_sout_display,
 906                                        const char *psz_url )
 907 {
 908     mrl_t       mrl;
 909     char        *psz_chain;
 910
 911     mrl_Parse( &mrl, psz_url );
 912
 913     /* Check if the URLs goes to #rtp - otherwise we'll use #standard */
 914     static const char rtplist[] = "dccp\0sctp\0tcp\0udplite\0";
 915     for (const char *a = rtplist; *a; a += strlen (a) + 1)
 916         if (strcmp (a, mrl.psz_access) == 0)
 917             goto rtp;
 918
 919     if (strcmp (mrl.psz_access, "rtp") == 0)
 920     {
 921         char *port;
 922         /* For historical reasons, rtp:// means RTP over UDP */
 923         strcpy (mrl.psz_access, "udp");
 924 rtp:
 925         if (mrl.psz_name[0] == '[')
 926         {
 927             port = strstr (mrl.psz_name, "]:");
 928             if (port != NULL)
 929                 port++;
 930         }
 931         else
 932             port = strchr (mrl.psz_name, ':');
 933         if (port != NULL)
 934             *port++ = '\0'; /* erase ':' */
 935
 936         if (asprintf (&psz_chain,
 937                       "rtp{mux=\"%s\",proto=\"%s\",dst=\"%s%s%s\"}",
 938                       mrl.psz_way, mrl.psz_access, mrl.psz_name,
 939                       port ? "\",port=\"" : "", port ? port : "") == -1)
 940             psz_chain = NULL;
 941     }
 942     else
 943     {
 944         /* Convert the URL to a basic standard sout chain */
 945         if (asprintf (&psz_chain,
 946                       "standard{mux=\"%s\",access=\"%s\",dst=\"%s\"}",
 947                       mrl.psz_way, mrl.psz_access, mrl.psz_name) == -1)
 948             psz_chain = NULL;
 949     }
 950
 951     /* Duplicate and wrap if sout-display is on */
 952     if (psz_chain && b_sout_display)
 953     {
 954         char *tmp;
 955         if (asprintf (&tmp, "duplicate{dst=display,dst=%s}", psz_chain) == -1)
 956             tmp = NULL;
 957         free (psz_chain);
 958         psz_chain = tmp;
 959     }
 960
 961     mrl_Clean( &mrl );
 962     return psz_chain;
 963 }
 964
 965 #undef sout_EncoderCreate
 966 encoder_t *sout_EncoderCreate( vlc_object_t *p_this )
 967 {
 968     return vlc_custom_create( p_this, sizeof( encoder_t ), "encoder" );
 969 }