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