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