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     if( !p_sys )
  92         return VLC_ENOMEM;
  93
  94     TAB_INIT( p_sys->i_nb_streams, p_sys->pp_streams );
  95     TAB_INIT( p_sys->i_nb_select, p_sys->ppsz_select );
  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                 char **ppsz_select = &p_sys->ppsz_select[p_sys->i_nb_select - 1];
 118
 119                 if( *ppsz_select )
 120                 {
 121                     msg_Err( p_stream, " * ignore selection `%s' (it already has `%s')",
 122                              psz, *ppsz_select );
 123                 }
 124                 else
 125                 {
 126                     msg_Dbg( p_stream, " * apply selection `%s'", psz );
 127                     *ppsz_select = strdup( psz );
 128                 }
 129             }
 130         }
 131         else
 132         {
 133             msg_Err( p_stream, " * ignore unknown option `%s'", p_cfg->psz_name );
 134         }
 135     }
 136
 137     if( p_sys->i_nb_streams == 0 )
 138     {
 139         msg_Err( p_stream, "no destination given" );
 140         free( p_sys );
 141
 142         return VLC_EGENERIC;
 143     }
 144
 145     p_stream->pf_add    = Add;
 146     p_stream->pf_del    = Del;
 147     p_stream->pf_send   = Send;
 148
 149     p_stream->p_sys     = p_sys;
 150
 151     return VLC_SUCCESS;
 152 }
 153
 154 /*****************************************************************************
 155  * Close:
 156  *****************************************************************************/
 157 static void Close( vlc_object_t * p_this )
 158 {
 159     sout_stream_t     *p_stream = (sout_stream_t*)p_this;
 160     sout_stream_sys_t *p_sys = p_stream->p_sys;
 161
 162     int i;
 163
 164     msg_Dbg( p_stream, "closing a duplication" );
 165     for( i = 0; i < p_sys->i_nb_streams; i++ )
 166     {
 167         sout_StreamDelete( p_sys->pp_streams[i] );
 168         free( p_sys->ppsz_select[i] );
 169     }
 170     free( p_sys->pp_streams );
 171     free( p_sys->ppsz_select );
 172
 173     free( p_sys );
 174 }
 175
 176 /*****************************************************************************
 177  * Add:
 178  *****************************************************************************/
 179 static sout_stream_id_t * Add( sout_stream_t *p_stream, es_format_t *p_fmt )
 180 {
 181     sout_stream_sys_t *p_sys = p_stream->p_sys;
 182     sout_stream_id_t  *id;
 183     int i_stream, i_valid_streams = 0;
 184
 185     id = malloc( sizeof( sout_stream_id_t ) );
 186     if( !id )
 187         return NULL;
 188
 189     TAB_INIT( id->i_nb_ids, id->pp_ids );
 190
 191     msg_Dbg( p_stream, "duplicated a new stream codec=%4.4s (es=%d group=%d)",
 192              (char*)&p_fmt->i_codec, p_fmt->i_id, p_fmt->i_group );
 193
 194     for( i_stream = 0; i_stream < p_sys->i_nb_streams; i_stream++ )
 195     {
 196         void *id_new = NULL;
 197
 198         if( ESSelected( p_fmt, p_sys->ppsz_select[i_stream] ) )
 199         {
 200             sout_stream_t *out = p_sys->pp_streams[i_stream];
 201
 202             id_new = (void*)sout_StreamIdAdd( out, p_fmt );
 203             if( id_new )
 204             {
 205                 msg_Dbg( p_stream, "    - added for output %d", i_stream );
 206                 i_valid_streams++;
 207             }
 208             else
 209             {
 210                 msg_Dbg( p_stream, "    - failed for output %d", i_stream );
 211             }
 212         }
 213         else
 214         {
 215             msg_Dbg( p_stream, "    - ignored for output %d", i_stream );
 216         }
 217
 218         /* Append failed attempts as well to keep track of which pp_id
 219          * belongs to which duplicated stream */
 220         TAB_APPEND( id->i_nb_ids, id->pp_ids, id_new );
 221     }
 222
 223     if( i_valid_streams <= 0 )
 224     {
 225         Del( p_stream, id );
 226         return NULL;
 227     }
 228
 229     return id;
 230 }
 231
 232 /*****************************************************************************
 233  * Del:
 234  *****************************************************************************/
 235 static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
 236 {
 237     sout_stream_sys_t *p_sys = p_stream->p_sys;
 238     int               i_stream;
 239
 240     for( i_stream = 0; i_stream < p_sys->i_nb_streams; i_stream++ )
 241     {
 242         if( id->pp_ids[i_stream] )
 243         {
 244             sout_stream_t *out = p_sys->pp_streams[i_stream];
 245             sout_StreamIdDel( out, id->pp_ids[i_stream] );
 246         }
 247     }
 248
 249     free( id->pp_ids );
 250     free( id );
 251     return VLC_SUCCESS;
 252 }
 253
 254 /*****************************************************************************
 255  * Send:
 256  *****************************************************************************/
 257 static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
 258                  block_t *p_buffer )
 259 {
 260     sout_stream_sys_t *p_sys = p_stream->p_sys;
 261     sout_stream_t     *p_dup_stream;
 262     int               i_stream;
 263
 264     /* Loop through the linked list of buffers */
 265     while( p_buffer )
 266     {
 267         block_t *p_next = p_buffer->p_next;
 268
 269         p_buffer->p_next = NULL;
 270
 271         for( i_stream = 0; i_stream < p_sys->i_nb_streams - 1; i_stream++ )
 272         {
 273             p_dup_stream = p_sys->pp_streams[i_stream];
 274
 275             if( id->pp_ids[i_stream] )
 276             {
 277                 block_t *p_dup = block_Duplicate( p_buffer );
 278
 279                 if( p_dup )
 280                     sout_StreamIdSend( p_dup_stream, id->pp_ids[i_stream], p_dup );
 281             }
 282         }
 283
 284         if( i_stream < p_sys->i_nb_streams && id->pp_ids[i_stream] )
 285         {
 286             p_dup_stream = p_sys->pp_streams[i_stream];
 287             sout_StreamIdSend( p_dup_stream, id->pp_ids[i_stream], p_buffer );
 288         }
 289         else
 290         {
 291             block_Release( p_buffer );
 292         }
 293
 294         p_buffer = p_next;
 295     }
 296     return VLC_SUCCESS;
 297 }
 298
 299 /*****************************************************************************
 300  * Divers
 301  *****************************************************************************/
 302 static bool NumInRange( const char *psz_range, int i_num )
 303 {
 304     const char *psz = strchr( psz_range, '-' );
 305     char *end;
 306     int  i_start, i_stop;
 307
 308     i_start = strtol( psz_range, &end, 0 );
 309     if( end == psz_range )
 310         i_start = i_num;
 311
 312     if( psz )
 313     {
 314         psz++;
 315         i_stop = strtol( psz, &end, 0 );
 316         if( end == psz )
 317             i_stop = i_num;
 318     }
 319     else
 320         i_stop = i_start;
 321
 322     return i_start <= i_num && i_num <= i_stop;
 323 }
 324
 325 static bool ESSelected( es_format_t *fmt, char *psz_select )
 326 {
 327     char  *psz_dup;
 328     char  *psz;
 329
 330     /* We have tri-state variable : no tested (-1), failed(0), succeed(1) */
 331     int i_cat = -1;
 332     int i_es  = -1;
 333     int i_prgm= -1;
 334
 335     /* If empty all es are selected */
 336     if( psz_select == NULL || *psz_select == '\0' )
 337     {
 338         return true;
 339     }
 340     psz_dup = strdup( psz_select );
 341     if( !psz_dup )
 342         return false;
 343     psz = psz_dup;
 344
 345     /* If non empty, parse the selection:
 346      * We have selection[,selection[,..]] where following selection are recognized:
 347      *      (no(-))audio
 348      *      (no(-))spu
 349      *      (no(-))video
 350      *      (no(-))es=[start]-[end] or es=num
 351      *      (no(-))prgm=[start]-[end] or prgm=num (program works too)
 352      *      if a negative test failed we exit directly
 353      */
 354     while( psz && *psz )
 355     {
 356         char *p;
 357
 358         /* Skip space */
 359         while( *psz == ' ' || *psz == '\t' ) psz++;
 360
 361         /* Search end */
 362         p = strchr( psz, ',' );
 363         if( p == psz )
 364         {
 365             /* Empty */
 366             psz = p + 1;
 367             continue;
 368         }
 369         if( p )
 370         {
 371             *p++ = '\0';
 372         }
 373
 374         if( !strncmp( psz, "no-audio", strlen( "no-audio" ) ) ||
 375             !strncmp( psz, "noaudio", strlen( "noaudio" ) ) )
 376         {
 377             if( i_cat == -1 )
 378             {
 379                 i_cat = fmt->i_cat != AUDIO_ES ? 1 : 0;
 380             }
 381         }
 382         else if( !strncmp( psz, "no-video", strlen( "no-video" ) ) ||
 383                  !strncmp( psz, "novideo", strlen( "novideo" ) ) )
 384         {
 385             if( i_cat == -1 )
 386             {
 387                 i_cat = fmt->i_cat != VIDEO_ES ? 1 : 0;
 388             }
 389         }
 390         else if( !strncmp( psz, "no-spu", strlen( "no-spu" ) ) ||
 391                  !strncmp( psz, "nospu", strlen( "nospu" ) ) )
 392         {
 393             if( i_cat == -1 )
 394             {
 395                 i_cat = fmt->i_cat != SPU_ES ? 1 : 0;
 396             }
 397         }
 398         else if( !strncmp( psz, "audio", strlen( "audio" ) ) )
 399         {
 400             if( i_cat == -1 )
 401             {
 402                 i_cat = fmt->i_cat == AUDIO_ES ? 1 : 0;
 403             }
 404         }
 405         else if( !strncmp( psz, "video", strlen( "video" ) ) )
 406         {
 407             if( i_cat == -1 )
 408             {
 409                 i_cat = fmt->i_cat == VIDEO_ES ? 1 : 0;
 410             }
 411         }
 412         else if( !strncmp( psz, "spu", strlen( "spu" ) ) )
 413         {
 414             if( i_cat == -1 )
 415             {
 416                 i_cat = fmt->i_cat == SPU_ES ? 1 : 0;
 417             }
 418         }
 419         else if( strchr( psz, '=' ) != NULL )
 420         {
 421             char *psz_arg = strchr( psz, '=' );
 422             *psz_arg++ = '\0';
 423
 424             if( !strcmp( psz, "no-es" ) || !strcmp( psz, "noes" ) )
 425             {
 426                 if( i_es == -1 )
 427                 {
 428                     i_es = NumInRange( psz_arg, fmt->i_id ) ? 0 : -1;
 429                 }
 430             }
 431             else if( !strcmp( psz, "es" ) )
 432             {
 433                 if( i_es == -1 )
 434                 {
 435                     i_es = NumInRange( psz_arg, fmt->i_id) ? 1 : -1;
 436                 }
 437             }
 438             else if( !strcmp( psz, "no-prgm" ) || !strcmp( psz, "noprgm" ) ||
 439                       !strcmp( psz, "no-program" ) || !strcmp( psz, "noprogram" ) )
 440             {
 441                 if( fmt->i_group >= 0 && i_prgm == -1 )
 442                 {
 443                     i_prgm = NumInRange( psz_arg, fmt->i_group ) ? 0 : -1;
 444                 }
 445             }
 446             else if( !strcmp( psz, "prgm" ) || !strcmp( psz, "program" ) )
 447             {
 448                 if( fmt->i_group >= 0 && i_prgm == -1 )
 449                 {
 450                     i_prgm = NumInRange( psz_arg, fmt->i_group ) ? 1 : -1;
 451                 }
 452             }
 453         }
 454         else
 455         {
 456             fprintf( stderr, "unknown args (%s)\n", psz );
 457         }
 458         /* Next */
 459         psz = p;
 460     }
 461
 462     free( psz_dup );
 463
 464     if( i_cat == 1 || i_es == 1 || i_prgm == 1 )
 465     {
 466         return true;
 467     }
 468     return false;
 469 }