1 /*****************************************************************************
2 * input.c: input thread
3 * Read an MPEG2 stream, demultiplex and parse it before sending it to
5 *****************************************************************************
6 * Copyright (C) 1998-2001 VideoLAN
7 * $Id: input.c,v 1.184 2002/03/03 17:34:27 xav Exp $
9 * Authors: Christophe Massiot <massiot@via.ecp.fr>
10 * Alexis Guillard <alexis.guillard@bt.com>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
25 *****************************************************************************/
27 /*****************************************************************************
29 *****************************************************************************/
31 #include <sys/types.h>
35 #include <videolan/vlc.h>
40 #ifdef HAVE_SYS_TIMES_H
41 # include <sys/times.h>
46 #include "intf_playlist.h"
48 #include "stream_control.h"
49 #include "input_ext-intf.h"
50 #include "input_ext-dec.h"
51 #include "input_ext-plugins.h"
53 #include "interface.h"
55 /*****************************************************************************
57 *****************************************************************************/
58 static int RunThread ( input_thread_t *p_input );
59 static int InitThread ( input_thread_t *p_input );
60 static void ErrorThread ( input_thread_t *p_input );
61 static void CloseThread ( input_thread_t *p_input );
62 static void DestroyThread ( input_thread_t *p_input );
63 static void EndThread ( input_thread_t *p_input );
65 /*****************************************************************************
66 * input_InitBank: initialize the input bank.
67 *****************************************************************************/
68 void input_InitBank ( void )
70 p_input_bank->i_count = 0;
72 /* XXX: Workaround for old interface modules */
73 p_input_bank->pp_input[0] = NULL;
75 vlc_mutex_init( &p_input_bank->lock );
78 /*****************************************************************************
79 * input_EndBank: empty the input bank.
80 *****************************************************************************
81 * This function ends all unused inputs and empties the bank in
83 *****************************************************************************/
84 void input_EndBank ( void )
88 /* Ask all remaining video outputs to die */
89 for( i_input = 0; i_input < p_input_bank->i_count; i_input++ )
92 p_input_bank->pp_input[ i_input ], NULL );
94 p_input_bank->pp_input[ i_input ] );
97 vlc_mutex_destroy( &p_input_bank->lock );
100 /*****************************************************************************
101 * input_CreateThread: creates a new input thread
102 *****************************************************************************
103 * This function creates a new input, and returns a pointer
104 * to its description. On error, it returns NULL.
105 * If pi_status is NULL, then the function will block until the thread is ready.
106 * If not, it will be updated using one of the THREAD_* constants.
107 *****************************************************************************/
108 input_thread_t *input_CreateThread ( playlist_item_t *p_item, int *pi_status )
110 input_thread_t * p_input; /* thread descriptor */
112 /* Allocate descriptor */
113 p_input = (input_thread_t *)malloc( sizeof(input_thread_t) );
114 if( p_input == NULL )
116 intf_ErrMsg( "input error: can't allocate input thread (%s)",
121 /* Initialize thread properties */
123 p_input->b_error = 0;
127 p_input->psz_source = strdup( p_item->psz_name );
130 p_input->i_status = THREAD_CREATE;
133 p_input->p_demux_module = NULL;
134 p_input->pf_init = NULL;
135 p_input->pf_end = NULL;
136 p_input->pf_demux = NULL;
137 p_input->pf_rewind = NULL;
140 p_input->p_access_module = NULL;
141 p_input->pf_open = NULL;
142 p_input->pf_close = NULL;
143 p_input->pf_read = NULL;
144 p_input->pf_seek = NULL;
145 p_input->pf_set_area = NULL;
146 p_input->pf_set_program = NULL;
148 p_input->i_bufsize = 0;
151 /* Initialize statistics */
152 p_input->c_loops = 0;
153 p_input->stream.c_packets_read = 0;
154 p_input->stream.c_packets_trashed = 0;
157 vlc_mutex_init( &p_input->stream.stream_lock );
158 vlc_cond_init( &p_input->stream.stream_wait );
159 vlc_mutex_init( &p_input->stream.control.control_lock );
161 /* Initialize stream description */
162 p_input->stream.b_changed = 0;
163 p_input->stream.i_es_number = 0;
164 p_input->stream.i_selected_es_number = 0;
165 p_input->stream.i_pgrm_number = 0;
166 p_input->stream.i_new_status = p_input->stream.i_new_rate = 0;
167 p_input->stream.b_new_mute = MUTE_NO_CHANGE;
168 p_input->stream.i_mux_rate = 0;
170 /* no stream, no program, no area, no es */
171 p_input->stream.p_new_program = NULL;
173 p_input->stream.i_area_nb = 0;
174 p_input->stream.pp_areas = NULL;
175 p_input->stream.p_selected_area = NULL;
176 p_input->stream.p_new_area = NULL;
178 p_input->stream.pp_selected_es = NULL;
179 p_input->stream.p_removed_es = NULL;
180 p_input->stream.p_newly_selected_es = NULL;
182 /* By default there is one area in a stream */
183 input_AddArea( p_input );
184 p_input->stream.p_selected_area = p_input->stream.pp_areas[0];
186 /* Initialize stream control properties. */
187 p_input->stream.control.i_status = PLAYING_S;
188 p_input->stream.control.i_rate = DEFAULT_RATE;
189 p_input->stream.control.b_mute = 0;
190 p_input->stream.control.b_grayscale = config_GetIntVariable(
191 VOUT_GRAYSCALE_VAR );
192 p_input->stream.control.i_smp = config_GetIntVariable( VDEC_SMP_VAR );
194 intf_WarnMsg( 1, "input: playlist item `%s'", p_input->psz_source );
197 if( vlc_thread_create( &p_input->thread_id, "input",
198 (vlc_thread_func_t)RunThread, (void *) p_input ) )
200 intf_ErrMsg( "input error: can't create input thread (%s)",
207 /* If status is NULL, wait until the thread is created */
208 if( pi_status == NULL )
212 msleep( THREAD_SLEEP );
213 } while( (i_status != THREAD_READY) && (i_status != THREAD_ERROR)
214 && (i_status != THREAD_FATAL) );
221 /*****************************************************************************
222 * input_StopThread: mark an input thread as zombie
223 *****************************************************************************
224 * This function should not return until the thread is effectively cancelled.
225 *****************************************************************************/
226 void input_StopThread( input_thread_t *p_input, int *pi_status )
228 /* Make the thread exit from a possible vlc_cond_wait() */
229 vlc_mutex_lock( &p_input->stream.stream_lock );
231 /* Request thread destruction */
234 vlc_cond_signal( &p_input->stream.stream_wait );
235 vlc_mutex_unlock( &p_input->stream.stream_lock );
237 /* If status is NULL, wait until thread has been destroyed */
239 if( pi_status == NULL )
243 msleep( THREAD_SLEEP );
244 } while ( (i_status != THREAD_OVER) && (i_status != THREAD_ERROR)
245 && (i_status != THREAD_FATAL) );
250 /*****************************************************************************
251 * input_DestroyThread: mark an input thread as zombie
252 *****************************************************************************
253 * This function should not return until the thread is effectively cancelled.
254 *****************************************************************************/
255 void input_DestroyThread( input_thread_t *p_input )
257 /* Join the thread */
258 vlc_thread_join( p_input->thread_id );
260 /* Destroy Mutex locks */
261 vlc_mutex_destroy( &p_input->stream.control.control_lock );
262 vlc_cond_destroy( &p_input->stream.stream_wait );
263 vlc_mutex_destroy( &p_input->stream.stream_lock );
265 /* Free input structure */
269 /*****************************************************************************
270 * RunThread: main thread loop
271 *****************************************************************************
272 * Thread in charge of processing the network packets and demultiplexing.
273 *****************************************************************************/
274 static int RunThread( input_thread_t *p_input )
276 if( InitThread( p_input ) )
278 /* If we failed, wait before we are killed, and exit */
279 p_input->i_status = THREAD_ERROR;
280 p_input->b_error = 1;
281 ErrorThread( p_input );
282 DestroyThread( p_input );
286 p_input->i_status = THREAD_READY;
288 /* initialization is complete */
289 vlc_mutex_lock( &p_input->stream.stream_lock );
290 p_input->stream.b_changed = 1;
291 vlc_mutex_unlock( &p_input->stream.stream_lock );
293 while( !p_input->b_die && !p_input->b_error && !p_input->b_eof )
299 vlc_mutex_lock( &p_input->stream.stream_lock );
301 if( p_input->stream.p_new_program )
303 if( p_input->pf_set_program != NULL )
306 p_input->pf_set_program( p_input,
307 p_input->stream.p_new_program );
309 for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
311 pgrm_descriptor_t * p_pgrm
312 = p_input->stream.pp_programs[i];
313 /* Escape all decoders for the stream discontinuity they
315 input_EscapeDiscontinuity( p_input, p_pgrm );
317 /* Reinitialize synchro. */
318 p_pgrm->i_synchro_state = SYNCHRO_REINIT;
321 p_input->stream.p_new_program = NULL;
324 if( p_input->stream.p_new_area )
326 if( p_input->stream.b_seekable && p_input->pf_set_area != NULL )
329 p_input->pf_set_area( p_input, p_input->stream.p_new_area );
331 for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
333 pgrm_descriptor_t * p_pgrm
334 = p_input->stream.pp_programs[i];
335 /* Escape all decoders for the stream discontinuity they
337 input_EscapeDiscontinuity( p_input, p_pgrm );
339 /* Reinitialize synchro. */
340 p_pgrm->i_synchro_state = SYNCHRO_REINIT;
343 p_input->stream.p_new_area = NULL;
346 if( p_input->stream.p_selected_area->i_seek != NO_SEEK )
348 if( p_input->stream.b_seekable && p_input->pf_seek != NULL )
350 off_t i_new_pos = p_input->stream.p_selected_area->i_seek;
351 vlc_mutex_unlock( &p_input->stream.stream_lock );
352 p_input->pf_seek( p_input, i_new_pos );
353 vlc_mutex_lock( &p_input->stream.stream_lock );
355 for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
357 pgrm_descriptor_t * p_pgrm
358 = p_input->stream.pp_programs[i];
359 /* Escape all decoders for the stream discontinuity they
361 input_EscapeDiscontinuity( p_input, p_pgrm );
363 /* Reinitialize synchro. */
364 p_pgrm->i_synchro_state = SYNCHRO_REINIT;
367 /* Reinitialize buffer manager. */
368 input_AccessReinit( p_input );
370 p_input->stream.p_selected_area->i_seek = NO_SEEK;
373 if( p_input->stream.p_removed_es )
375 input_UnselectES( p_input, p_input->stream.p_removed_es );
376 p_input->stream.p_removed_es = NULL;
379 if( p_input->stream.p_newly_selected_es )
381 input_SelectES( p_input, p_input->stream.p_newly_selected_es );
382 p_input->stream.p_newly_selected_es = NULL;
385 if( p_input->stream.b_new_mute != MUTE_NO_CHANGE )
387 if( p_input->stream.b_new_mute )
389 input_EscapeAudioDiscontinuity( p_input );
392 vlc_mutex_lock( &p_input->stream.control.control_lock );
393 p_input->stream.control.b_mute = p_input->stream.b_new_mute;
394 vlc_mutex_unlock( &p_input->stream.control.control_lock );
396 p_input->stream.b_new_mute = MUTE_NO_CHANGE;
399 vlc_mutex_unlock( &p_input->stream.stream_lock );
401 /* Read and demultiplex some data. */
402 i_count = p_input->pf_demux( p_input );
404 if( i_count == 0 && p_input->stream.b_seekable )
406 /* End of file - we do not set b_die because only the
407 * interface is allowed to do so. */
408 intf_WarnMsg( 3, "input: EOF reached" );
411 else if( i_count < 0 )
413 p_input->b_error = 1;
417 if( p_input->b_error || p_input->b_eof )
419 ErrorThread( p_input );
422 EndThread( p_input );
424 DestroyThread( p_input );
429 /*****************************************************************************
430 * InitThread: init the input Thread
431 *****************************************************************************/
432 static int InitThread( input_thread_t * p_input )
434 /* Parse source string. Syntax : [[<access>][/<demux>]:][<source>] */
435 char * psz_parser = p_input->psz_source;
437 struct stat stat_info ;
438 int i_Win32_Access = 0 ;
440 /* Skip the plug-in names */
441 while( *psz_parser && *psz_parser != ':' )
448 p_input->psz_access = p_input->psz_demux = NULL;
449 p_input->psz_name = p_input->psz_source;
454 if ( ( psz_parser-p_input->psz_source == 1) &&
455 ( stat( p_input->psz_source, &stat_info ) != -1 ) )
457 intf_WarnMsg (2, "Okay, found a valid device in p_input->psz_source") ;
458 psz_parser = p_input->psz_source ;
459 p_input->psz_access = NULL ;
460 p_input->psz_demux = NULL ;
465 *psz_parser++ = '\0';
468 *psz_parser++ = '\0';
471 p_input->psz_name = psz_parser;
473 /* Come back to parse the access and demux plug-ins */
474 psz_parser = p_input->psz_source;
476 if( (!*psz_parser) || (i_Win32_Access == 1))
482 p_input->psz_access = NULL;
484 else if( *psz_parser == '/' )
487 p_input->psz_access = NULL;
492 p_input->psz_access = psz_parser;
494 while( *psz_parser && *psz_parser != '/' )
499 if( *psz_parser == '/' )
501 *psz_parser++ = '\0';
507 if( (!*psz_parser) || (i_Win32_Access == 1))
511 p_input->psz_demux = NULL;
515 p_input->psz_demux = psz_parser;
519 intf_WarnMsg( 2, "input: access=%s demux=%s name=%s",
520 p_input->psz_access, p_input->psz_demux,
523 if( input_AccessInit( p_input ) == -1 )
528 /* Find and open appropriate access plug-in. */
529 p_input->p_access_module = module_Need( MODULE_CAPABILITY_ACCESS,
533 if( p_input->p_access_module == NULL )
535 intf_ErrMsg( "input error: no suitable access plug-in for `%s/%s:%s'",
536 p_input->psz_access, p_input->psz_demux,
541 #define f p_input->p_access_module->p_functions->access.functions.access
542 p_input->pf_open = f.pf_open;
543 p_input->pf_close = f.pf_close;
544 p_input->pf_read = f.pf_read;
545 p_input->pf_set_area = f.pf_set_area;
546 p_input->pf_set_program = f.pf_set_program;
547 p_input->pf_seek = f.pf_seek;
550 /* Waiting for stream. */
553 p_input->i_bufsize = p_input->i_mtu;
557 p_input->i_bufsize = INPUT_DEFAULT_BUFSIZE;
560 if( p_input->p_current_data == NULL && p_input->pf_read != NULL )
562 while( !input_FillBuffer( p_input ) )
564 if( p_input->b_die || p_input->b_error )
566 module_Unneed( p_input->p_access_module );
572 /* Find and open appropriate demux plug-in. */
573 p_input->p_demux_module = module_Need( MODULE_CAPABILITY_DEMUX,
577 if( p_input->p_demux_module == NULL )
579 intf_ErrMsg( "input error: no suitable demux plug-in for `%s/%s:%s'",
580 p_input->psz_access, p_input->psz_demux,
582 module_Unneed( p_input->p_access_module );
586 #define f p_input->p_demux_module->p_functions->demux.functions.demux
587 p_input->pf_init = f.pf_init;
588 p_input->pf_end = f.pf_end;
589 p_input->pf_demux = f.pf_demux;
590 p_input->pf_rewind = f.pf_rewind;
596 /*****************************************************************************
597 * ErrorThread: RunThread() error loop
598 *****************************************************************************
599 * This function is called when an error occured during thread main's loop.
600 *****************************************************************************/
601 static void ErrorThread( input_thread_t *p_input )
603 while( !p_input->b_die )
606 msleep( INPUT_IDLE_SLEEP );
610 /*****************************************************************************
611 * EndThread: end the input thread
612 *****************************************************************************/
613 static void EndThread( input_thread_t * p_input )
616 p_input->i_status = THREAD_END;
618 if( p_main->b_stats )
620 #ifdef HAVE_SYS_TIMES_H
621 /* Display statistics */
622 struct tms cpu_usage;
625 intf_StatMsg( "input stats: %d loops consuming user: %d, system: %d",
627 cpu_usage.tms_utime, cpu_usage.tms_stime );
629 intf_StatMsg( "input stats: %d loops", p_input->c_loops );
632 input_DumpStream( p_input );
635 /* Free all ES and destroy all decoder threads */
636 input_EndStream( p_input );
638 /* Free demultiplexer's data */
639 p_input->pf_end( p_input );
640 module_Unneed( p_input->p_demux_module );
642 /* Close the access plug-in */
643 CloseThread( p_input );
646 /*****************************************************************************
647 * CloseThread: close the target
648 *****************************************************************************/
649 static void CloseThread( input_thread_t * p_input )
651 p_input->pf_close( p_input );
652 module_Unneed( p_input->p_access_module );
654 input_AccessEnd( p_input );
656 free( p_input->psz_source );
659 /*****************************************************************************
660 * DestroyThread: destroy the input thread
661 *****************************************************************************/
662 static void DestroyThread( input_thread_t * p_input )
665 p_input->i_status = THREAD_OVER;