git.sesse.net Git - vlc/blob - modules/stream_out/duplicate.c

   1 /*****************************************************************************
   2  * duplicate.c: duplicate stream output module
   3  *****************************************************************************
   4  * Copyright (C) 2003-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Author: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc/vlc.h>
  33 #include <vlc_sout.h>
  34 #include <vlc_block.h>
  35
  36 /*****************************************************************************
  37  * Module descriptor
  38  *****************************************************************************/
  39 static int      Open    ( vlc_object_t * );
  40 static void     Close   ( vlc_object_t * );
  41
  42 vlc_module_begin();
  43     set_description( _("Duplicate stream output") );
  44     set_capability( "sout stream", 50 );
  45     add_shortcut( "duplicate" );
  46     add_shortcut( "dup" );
  47     set_category( CAT_SOUT );
  48     set_subcategory( SUBCAT_SOUT_STREAM );
  49     set_callbacks( Open, Close );
  50 vlc_module_end();
  51
  52
  53 /*****************************************************************************
  54  * Exported prototypes
  55  *****************************************************************************/
  56 static sout_stream_id_t *Add ( sout_stream_t *, es_format_t * );
  57 static int               Del ( sout_stream_t *, sout_stream_id_t * );
  58 static int               Send( sout_stream_t *, sout_stream_id_t *,
  59                                block_t* );
  60
  61 struct sout_stream_sys_t
  62 {
  63     int             i_nb_streams;
  64     sout_stream_t   **pp_streams;
  65
  66     int             i_nb_select;
  67     char            **ppsz_select;
  68 };
  69
  70 struct sout_stream_id_t
  71 {
  72     int                 i_nb_ids;
  73     void                **pp_ids;
  74 };
  75
  76 static vlc_bool_t ESSelected( es_format_t *fmt, char *psz_select );
  77
  78 /*****************************************************************************
  79  * Open:
  80  *****************************************************************************/
  81 static int Open( vlc_object_t *p_this )
  82 {
  83     sout_stream_t     *p_stream = (sout_stream_t*)p_this;
  84     sout_stream_sys_t *p_sys;
  85     config_chain_t        *p_cfg;
  86
  87     msg_Dbg( p_stream, "creating 'duplicate'" );
  88
  89     p_sys = malloc( sizeof( sout_stream_sys_t ) );
  90
  91     p_sys->i_nb_streams = 0;
  92     p_sys->pp_streams   = NULL;
  93     p_sys->i_nb_select  = 0;
  94     p_sys->ppsz_select  = NULL;
  95
  96     for( p_cfg = p_stream->p_cfg; p_cfg != NULL; p_cfg = p_cfg->p_next )
  97     {
  98         if( !strncmp( p_cfg->psz_name, "dst", strlen( "dst" ) ) )
  99         {
 100             sout_stream_t *s;
 101
 102             msg_Dbg( p_stream, " * adding `%s'", p_cfg->psz_value );
 103             s = sout_StreamNew( p_stream->p_sout, p_cfg->psz_value );
 104
 105             if( s )
 106             {
 107                 TAB_APPEND( p_sys->i_nb_streams, p_sys->pp_streams, s );
 108                 TAB_APPEND( p_sys->i_nb_select,  p_sys->ppsz_select, NULL );
 109             }
 110         }
 111         else if( !strncmp( p_cfg->psz_name, "select", strlen( "select" ) ) )
 112         {
 113             char *psz = p_cfg->psz_value;
 114             if( p_sys->i_nb_select > 0 && psz && *psz )
 115             {
 116                 msg_Dbg( p_stream, " * apply selection %s", psz );
 117                 p_sys->ppsz_select[p_sys->i_nb_select - 1] = strdup( psz );
 118             }
 119         }
 120     }
 121
 122     if( p_sys->i_nb_streams == 0 )
 123     {
 124         msg_Err( p_stream, "no destination given" );
 125         free( p_sys );
 126
 127         return VLC_EGENERIC;
 128     }
 129
 130     p_stream->pf_add    = Add;
 131     p_stream->pf_del    = Del;
 132     p_stream->pf_send   = Send;
 133
 134     p_stream->p_sys     = p_sys;
 135
 136     return VLC_SUCCESS;
 137 }
 138
 139 /*****************************************************************************
 140  * Close:
 141  *****************************************************************************/
 142 static void Close( vlc_object_t * p_this )
 143 {
 144     sout_stream_t     *p_stream = (sout_stream_t*)p_this;
 145     sout_stream_sys_t *p_sys = p_stream->p_sys;
 146
 147     int i;
 148
 149     msg_Dbg( p_stream, "closing a duplication" );
 150     for( i = 0; i < p_sys->i_nb_streams; i++ )
 151     {
 152         sout_StreamDelete( p_sys->pp_streams[i] );
 153         if( p_sys->ppsz_select[i] )
 154         {
 155             free( p_sys->ppsz_select[i] );
 156         }
 157     }
 158     if( p_sys->pp_streams )
 159     {
 160         free( p_sys->pp_streams );
 161     }
 162     if( p_sys->ppsz_select )
 163     {
 164         free( p_sys->ppsz_select );
 165     }
 166
 167     free( p_sys );
 168 }
 169
 170 /*****************************************************************************
 171  * Add:
 172  *****************************************************************************/
 173 static sout_stream_id_t * Add( sout_stream_t *p_stream, es_format_t *p_fmt )
 174 {
 175     sout_stream_sys_t *p_sys = p_stream->p_sys;
 176     sout_stream_id_t  *id;
 177     int i_stream, i_valid_streams = 0;
 178
 179     id = malloc( sizeof( sout_stream_id_t ) );
 180     id->i_nb_ids = 0;
 181     id->pp_ids   = NULL;
 182
 183     msg_Dbg( p_stream, "duplicated a new stream codec=%4.4s (es=%d group=%d)",
 184              (char*)&p_fmt->i_codec, p_fmt->i_id, p_fmt->i_group );
 185
 186     for( i_stream = 0; i_stream < p_sys->i_nb_streams; i_stream++ )
 187     {
 188         void *id_new = NULL;
 189
 190         if( ESSelected( p_fmt, p_sys->ppsz_select[i_stream] ) )
 191         {
 192             sout_stream_t *out = p_sys->pp_streams[i_stream];
 193
 194             id_new = (void*)out->pf_add( out, p_fmt );
 195             if( id_new )
 196             {
 197                 msg_Dbg( p_stream, "    - added for output %d", i_stream );
 198                 i_valid_streams++;
 199             }
 200             else
 201             {
 202                 msg_Dbg( p_stream, "    - failed for output %d", i_stream );
 203             }
 204         }
 205         else
 206         {
 207             msg_Dbg( p_stream, "    - ignored for output %d", i_stream );
 208         }
 209
 210         /* Append failed attempts as well to keep track of which pp_id
 211          * belongs to which duplicated stream */
 212         TAB_APPEND( id->i_nb_ids, id->pp_ids, id_new );
 213     }
 214
 215     if( i_valid_streams <= 0 )
 216     {
 217         Del( p_stream, id );
 218         return NULL;
 219     }
 220
 221     return id;
 222 }
 223
 224 /*****************************************************************************
 225  * Del:
 226  *****************************************************************************/
 227 static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
 228 {
 229     sout_stream_sys_t *p_sys = p_stream->p_sys;
 230     int               i_stream;
 231
 232     for( i_stream = 0; i_stream < p_sys->i_nb_streams; i_stream++ )
 233     {
 234         if( id->pp_ids[i_stream] )
 235         {
 236             sout_stream_t *out = p_sys->pp_streams[i_stream];
 237             out->pf_del( out, id->pp_ids[i_stream] );
 238         }
 239     }
 240
 241     free( id->pp_ids );
 242     free( id );
 243     return VLC_SUCCESS;
 244 }
 245
 246 /*****************************************************************************
 247  * Send:
 248  *****************************************************************************/
 249 static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
 250                  block_t *p_buffer )
 251 {
 252     sout_stream_sys_t *p_sys = p_stream->p_sys;
 253     sout_stream_t     *p_dup_stream;
 254     int               i_stream;
 255
 256     /* Loop through the linked list of buffers */
 257     while( p_buffer )
 258     {
 259         block_t *p_next = p_buffer->p_next;
 260
 261         p_buffer->p_next = NULL;
 262
 263         for( i_stream = 0; i_stream < p_sys->i_nb_streams - 1; i_stream++ )
 264         {
 265             block_t *p_dup;
 266             p_dup_stream = p_sys->pp_streams[i_stream];
 267
 268             if( id->pp_ids[i_stream] )
 269             {
 270                 p_dup = block_Duplicate( p_buffer );
 271
 272                 p_dup_stream->pf_send( p_dup_stream, id->pp_ids[i_stream],
 273                                        p_dup );
 274             }
 275         }
 276
 277         if( i_stream < p_sys->i_nb_streams && id->pp_ids[i_stream] )
 278         {
 279             p_dup_stream = p_sys->pp_streams[i_stream];
 280             p_dup_stream->pf_send( p_dup_stream, id->pp_ids[i_stream],
 281                                    p_buffer );
 282         }
 283         else
 284         {
 285             block_Release( p_buffer );
 286         }
 287
 288         p_buffer = p_next;
 289     }
 290     return VLC_SUCCESS;
 291 }
 292
 293 /*****************************************************************************
 294  * Divers
 295  *****************************************************************************/
 296 static vlc_bool_t NumInRange( char *psz_range, int i_num )
 297 {
 298     char *psz = strchr( psz_range, '-' );
 299     char *end;
 300     int  i_start, i_stop;
 301
 302     if( psz )
 303     {
 304         i_start = strtol( psz_range, &end, 0 );
 305         if( end == psz_range ) i_start = i_num;
 306
 307         i_stop  = strtol( psz,       &end, 0 );
 308         if( end == psz_range ) i_stop = i_num;
 309     }
 310     else
 311     {
 312         i_start = i_stop = strtol( psz_range, NULL, 0 );
 313     }
 314
 315     return i_start <= i_num && i_num <= i_stop ? VLC_TRUE : VLC_FALSE;
 316 }
 317
 318 static vlc_bool_t ESSelected( es_format_t *fmt, char *psz_select )
 319 {
 320     char  *psz_dup;
 321     char  *psz;
 322
 323     /* We have tri-state variable : no tested (-1), failed(0), succeed(1) */
 324     int i_cat = -1;
 325     int i_es  = -1;
 326     int i_prgm= -1;
 327
 328     /* If empty all es are selected */
 329     if( psz_select == NULL || *psz_select == '\0' )
 330     {
 331         return VLC_TRUE;
 332     }
 333     psz_dup = strdup( psz_select );
 334     psz     = psz_dup;
 335
 336     /* If non empty, parse the selection:
 337      * We have selection[,selection[,..]] where following selection are recognized:
 338      *      (no(-))audio
 339      *      (no(-))spu
 340      *      (no(-))video
 341      *      (no(-))es=[start]-[end] or es=num
 342      *      (no(-))prgm=[start]-[end] or prgm=num (program works too)
 343      *      if a negative test failed we exit directly
 344      */
 345     while( psz && *psz )
 346     {
 347         char *p;
 348
 349         /* Skip space */
 350         while( *psz == ' ' || *psz == '\t' ) psz++;
 351
 352         /* Search end */
 353         p = strchr( psz, ',' );
 354         if( p == psz )
 355         {
 356             /* Empty */
 357             psz = p + 1;
 358             continue;
 359         }
 360         if( p )
 361         {
 362             *p++ = '\0';
 363         }
 364
 365         if( !strncmp( psz, "no-audio", strlen( "no-audio" ) ) ||
 366             !strncmp( psz, "noaudio", strlen( "noaudio" ) ) )
 367         {
 368             if( i_cat == -1 )
 369             {
 370                 i_cat = fmt->i_cat != AUDIO_ES ? 1 : 0;
 371             }
 372         }
 373         else if( !strncmp( psz, "no-video", strlen( "no-video" ) ) ||
 374                  !strncmp( psz, "novideo", strlen( "novideo" ) ) )
 375         {
 376             if( i_cat == -1 )
 377             {
 378                 i_cat = fmt->i_cat != VIDEO_ES ? 1 : 0;
 379             }
 380         }
 381         else if( !strncmp( psz, "no-spu", strlen( "no-spu" ) ) ||
 382                  !strncmp( psz, "nospu", strlen( "nospu" ) ) )
 383         {
 384             if( i_cat == -1 )
 385             {
 386                 i_cat = fmt->i_cat != SPU_ES ? 1 : 0;
 387             }
 388         }
 389         else if( !strncmp( psz, "audio", strlen( "audio" ) ) )
 390         {
 391             if( i_cat == -1 )
 392             {
 393                 i_cat = fmt->i_cat == AUDIO_ES ? 1 : 0;
 394             }
 395         }
 396         else if( !strncmp( psz, "video", strlen( "video" ) ) )
 397         {
 398             if( i_cat == -1 )
 399             {
 400                 i_cat = fmt->i_cat == VIDEO_ES ? 1 : 0;
 401             }
 402         }
 403         else if( !strncmp( psz, "spu", strlen( "spu" ) ) )
 404         {
 405             if( i_cat == -1 )
 406             {
 407                 i_cat = fmt->i_cat == SPU_ES ? 1 : 0;
 408             }
 409         }
 410         else if( strchr( psz, '=' ) != NULL )
 411         {
 412             char *psz_arg = strchr( psz, '=' );
 413             *psz_arg++ = '\0';
 414
 415             if( !strcmp( psz, "no-es" ) || !strcmp( psz, "noes" ) )
 416             {
 417                 if( i_es == -1 )
 418                 {
 419                     i_es = NumInRange( psz_arg, fmt->i_id ) ? 0 : -1;
 420                 }
 421             }
 422             else if( !strcmp( psz, "es" ) )
 423             {
 424                 if( i_es == -1 )
 425                 {
 426                     i_es = NumInRange( psz_arg, fmt->i_id) ? 1 : -1;
 427                 }
 428             }
 429             else if( !strcmp( psz, "no-prgm" ) || !strcmp( psz, "noprgm" ) ||
 430                       !strcmp( psz, "no-program" ) || !strcmp( psz, "noprogram" ) )
 431             {
 432                 if( fmt->i_group >= 0 && i_prgm == -1 )
 433                 {
 434                     i_prgm = NumInRange( psz_arg, fmt->i_group ) ? 0 : -1;
 435                 }
 436             }
 437             else if( !strcmp( psz, "prgm" ) || !strcmp( psz, "program" ) )
 438             {
 439                 if( fmt->i_group >= 0 && i_prgm == -1 )
 440                 {
 441                     i_prgm = NumInRange( psz_arg, fmt->i_group ) ? 1 : -1;
 442                 }
 443             }
 444         }
 445         else
 446         {
 447             fprintf( stderr, "unknown args (%s)\n", psz );
 448         }
 449         /* Next */
 450         psz = p;
 451     }
 452
 453     free( psz_dup );
 454
 455     if( i_cat == 1 || i_es == 1 || i_prgm == 1 )
 456     {
 457         return VLC_TRUE;
 458     }
 459     return VLC_FALSE;
 460 }