Typo
[vlc.git] / 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 }