5bdfbddc24f19c42c6ca67a4437cf94a28267d6c
[vlc.git] / src / input / input.c
1 /*****************************************************************************
2  * input.c: input thread
3  * Read an MPEG2 stream, demultiplex and parse it before sending it to
4  * decoders.
5  *****************************************************************************
6  * Copyright (C) 1998-2002 VideoLAN
7  * $Id: input.c,v 1.218 2002/12/06 16:34:08 sam Exp $
8  *
9  * Authors: Christophe Massiot <massiot@via.ecp.fr>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29 #include <stdlib.h>
30
31 #include <vlc/vlc.h>
32
33 #include <string.h>
34
35 #ifdef HAVE_SYS_TIMES_H
36 #   include <sys/times.h>
37 #endif
38
39 #include "netutils.h"
40 #include "vlc_playlist.h"
41
42 #include "stream_control.h"
43 #include "input_ext-intf.h"
44 #include "input_ext-dec.h"
45 #include "input_ext-plugins.h"
46
47 #include "stream_output.h"
48
49 #include "interface.h"
50
51 /*****************************************************************************
52  * Local prototypes
53  *****************************************************************************/
54 static  int RunThread       ( input_thread_t *p_input );
55 static  int InitThread      ( input_thread_t *p_input );
56 static void ErrorThread     ( input_thread_t *p_input );
57 static void EndThread       ( input_thread_t *p_input );
58
59 /*****************************************************************************
60  * input_CreateThread: creates a new input thread
61  *****************************************************************************
62  * This function creates a new input, and returns a pointer
63  * to its description. On error, it returns NULL.
64  *****************************************************************************/
65 input_thread_t *__input_CreateThread( vlc_object_t *p_parent,
66                                       playlist_item_t *p_item )
67 {
68     input_thread_t *    p_input;                        /* thread descriptor */
69     input_info_category_t * p_info;
70
71     /* Allocate descriptor */
72     p_input = vlc_object_create( p_parent, VLC_OBJECT_INPUT );
73     if( p_input == NULL )
74     {
75         msg_Err( p_parent, "out of memory" );
76         return NULL;
77     }
78
79     /* Initialize thread properties */
80     p_input->b_eof      = 0;
81
82     /* Set target */
83     p_input->psz_source = strdup( p_item->psz_uri );
84
85     /* Demux */
86     p_input->p_demux = NULL;
87
88     /* Access */
89     p_input->p_access = NULL;
90
91     p_input->i_bufsize = 0;
92     p_input->i_mtu = 0;
93
94     /* Initialize statistics */
95     p_input->c_loops                    = 0;
96     p_input->stream.c_packets_read      = 0;
97     p_input->stream.c_packets_trashed   = 0;
98
99     /* Set locks. */
100     vlc_mutex_init( p_input, &p_input->stream.stream_lock );
101     vlc_cond_init( p_input, &p_input->stream.stream_wait );
102     vlc_mutex_init( p_input, &p_input->stream.control.control_lock );
103
104     /* Initialize stream description */
105     p_input->stream.b_changed = 0;
106     p_input->stream.i_es_number = 0;
107     p_input->stream.i_selected_es_number = 0;
108     p_input->stream.i_pgrm_number = 0;
109     p_input->stream.i_new_status = p_input->stream.i_new_rate = 0;
110     p_input->stream.b_new_mute = MUTE_NO_CHANGE;
111     p_input->stream.i_mux_rate = 0;
112     p_input->stream.b_seekable = 0;
113     p_input->stream.p_sout = NULL;
114
115     /* no stream, no program, no area, no es */
116     p_input->stream.p_new_program = NULL;
117
118     p_input->stream.i_area_nb = 0;
119     p_input->stream.pp_areas = NULL;
120     p_input->stream.p_selected_area = NULL;
121     p_input->stream.p_new_area = NULL;
122
123     p_input->stream.pp_selected_es = NULL;
124     p_input->stream.p_removed_es = NULL;
125     p_input->stream.p_newly_selected_es = NULL;
126
127     /* By default there is one area in a stream */
128     input_AddArea( p_input );
129     p_input->stream.p_selected_area = p_input->stream.pp_areas[0];
130
131     /* Initialize stream control properties. */
132     p_input->stream.control.i_status = PLAYING_S;
133     p_input->stream.control.i_rate = DEFAULT_RATE;
134     p_input->stream.control.b_mute = 0;
135     p_input->stream.control.b_grayscale = config_GetInt( p_input, "grayscale" );
136
137     /* Initialize input info */
138     p_input->stream.p_info = malloc( sizeof( input_info_category_t ) );
139     if( !p_input->stream.p_info )
140     {
141         msg_Err( p_input, "No memory!" );
142         return NULL;
143     }
144     p_input->stream.p_info->psz_name = strdup("General") ;
145     p_input->stream.p_info->p_info = NULL;
146     p_input->stream.p_info->p_next = NULL;
147
148     msg_Info( p_input, "playlist item `%s'", p_input->psz_source );
149
150     p_info = input_InfoCategory( p_input, "General" );
151     input_AddInfo( p_info, "playlist item", p_input->psz_source );
152     vlc_object_attach( p_input, p_parent );
153
154     /* Create thread and wait for its readiness. */
155     if( vlc_thread_create( p_input, "input", RunThread,
156                            VLC_THREAD_PRIORITY_INPUT, VLC_TRUE ) )
157     {
158         msg_Err( p_input, "cannot create input thread" );
159         free( p_input );
160         return NULL;
161     }
162
163     return p_input;
164 }
165
166 /*****************************************************************************
167  * input_StopThread: mark an input thread as zombie
168  *****************************************************************************
169  * This function should not return until the thread is effectively cancelled.
170  *****************************************************************************/
171 void input_StopThread( input_thread_t *p_input )
172 {
173     /* Make the thread exit from a possible vlc_cond_wait() */
174     vlc_mutex_lock( &p_input->stream.stream_lock );
175     /* Request thread destruction */
176     p_input->b_die = 1;
177
178     vlc_cond_signal( &p_input->stream.stream_wait );
179     vlc_mutex_unlock( &p_input->stream.stream_lock );
180 }
181
182 /*****************************************************************************
183  * input_DestroyThread: mark an input thread as zombie
184  *****************************************************************************
185  * This function should not return until the thread is effectively cancelled.
186  *****************************************************************************/
187 void input_DestroyThread( input_thread_t *p_input )
188 {
189     /* Join the thread */
190     vlc_thread_join( p_input );
191
192     /* Destroy Mutex locks */
193     vlc_mutex_destroy( &p_input->stream.control.control_lock );
194     vlc_cond_destroy( &p_input->stream.stream_wait );
195     vlc_mutex_destroy( &p_input->stream.stream_lock );
196 }
197
198 /*****************************************************************************
199  * RunThread: main thread loop
200  *****************************************************************************
201  * Thread in charge of processing the network packets and demultiplexing.
202  *****************************************************************************/
203 static int RunThread( input_thread_t *p_input )
204 {
205     /* Signal right now, otherwise we'll get stuck in a peek */
206     vlc_thread_ready( p_input );
207
208     if( InitThread( p_input ) )
209     {
210         /* If we failed, wait before we are killed, and exit */
211         p_input->b_error = 1;
212         ErrorThread( p_input );
213         p_input->b_dead = 1;
214         return 0;
215     }
216
217     /* initialization is complete */
218     vlc_mutex_lock( &p_input->stream.stream_lock );
219     p_input->stream.b_changed = 1;
220     vlc_mutex_unlock( &p_input->stream.stream_lock );
221
222     while( !p_input->b_die && !p_input->b_error && !p_input->b_eof )
223     {
224         unsigned int i, i_count;
225
226         p_input->c_loops++;
227
228         vlc_mutex_lock( &p_input->stream.stream_lock );
229
230         if( p_input->stream.p_new_program )
231         {
232             if( p_input->pf_set_program != NULL )
233             {
234
235                 /* Reinitialize buffer manager. */
236                 input_AccessReinit( p_input );
237
238                 p_input->pf_set_program( p_input,
239                                          p_input->stream.p_new_program );
240
241                 /* Escape all decoders for the stream discontinuity they
242                  * will encounter. */
243                 input_EscapeDiscontinuity( p_input );
244
245                 for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
246                 {
247                     pgrm_descriptor_t * p_pgrm
248                                             = p_input->stream.pp_programs[i];
249
250                     /* Reinitialize synchro. */
251                     p_pgrm->i_synchro_state = SYNCHRO_REINIT;
252                 }
253             }
254             p_input->stream.p_new_program = NULL;
255         }
256
257         if( p_input->stream.p_new_area )
258         {
259             if( p_input->stream.b_seekable && p_input->pf_set_area != NULL )
260             {
261                 input_AccessReinit( p_input );
262
263                 p_input->pf_set_area( p_input, p_input->stream.p_new_area );
264
265                 /* Escape all decoders for the stream discontinuity they
266                  * will encounter. */
267                 input_EscapeDiscontinuity( p_input );
268
269                 for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
270                 {
271                     pgrm_descriptor_t * p_pgrm
272                                             = p_input->stream.pp_programs[i];
273
274                     /* Reinitialize synchro. */
275                     p_pgrm->i_synchro_state = SYNCHRO_REINIT;
276                 }
277             }
278             p_input->stream.p_new_area = NULL;
279         }
280
281         if( p_input->stream.p_selected_area->i_seek != NO_SEEK )
282         {
283             if( p_input->stream.b_seekable
284                  && p_input->pf_seek != NULL )
285             {
286                 off_t i_new_pos;
287
288                 /* Reinitialize buffer manager. */
289                 input_AccessReinit( p_input );
290
291                 i_new_pos = p_input->stream.p_selected_area->i_seek;
292                 vlc_mutex_unlock( &p_input->stream.stream_lock );
293                 p_input->pf_seek( p_input, i_new_pos );
294                 vlc_mutex_lock( &p_input->stream.stream_lock );
295
296                 /* Escape all decoders for the stream discontinuity they
297                  * will encounter. */
298                 input_EscapeDiscontinuity( p_input );
299
300                 for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
301                 {
302                     pgrm_descriptor_t * p_pgrm
303                                             = p_input->stream.pp_programs[i];
304
305                     /* Reinitialize synchro. */
306                     p_pgrm->i_synchro_state = SYNCHRO_REINIT;
307                 }
308             }
309             p_input->stream.p_selected_area->i_seek = NO_SEEK;
310         }
311
312         if( p_input->stream.p_removed_es )
313         {
314             input_UnselectES( p_input, p_input->stream.p_removed_es );
315             p_input->stream.p_removed_es = NULL;
316         }
317
318         if( p_input->stream.p_newly_selected_es )
319         {
320             input_SelectES( p_input, p_input->stream.p_newly_selected_es );
321             p_input->stream.p_newly_selected_es = NULL;
322         }
323
324         if( p_input->stream.b_new_mute != MUTE_NO_CHANGE )
325         {
326             if( p_input->stream.b_new_mute )
327             {
328                 input_EscapeAudioDiscontinuity( p_input );
329             }
330
331             vlc_mutex_lock( &p_input->stream.control.control_lock );
332             p_input->stream.control.b_mute = p_input->stream.b_new_mute;
333             vlc_mutex_unlock( &p_input->stream.control.control_lock );
334
335             p_input->stream.b_new_mute = MUTE_NO_CHANGE;
336         }
337
338         vlc_mutex_unlock( &p_input->stream.stream_lock );
339
340         /* Read and demultiplex some data. */
341         i_count = p_input->pf_demux( p_input );
342
343         if( i_count == 0 && p_input->stream.b_seekable )
344         {
345             /* End of file - we do not set b_die because only the
346              * playlist is allowed to do so. */
347             msg_Info( p_input, "EOF reached" );
348             p_input->b_eof = 1;
349         }
350         else if( i_count < 0 )
351         {
352             p_input->b_error = 1;
353         }
354     }
355
356     if( p_input->b_error || p_input->b_eof )
357     {
358         ErrorThread( p_input );
359     }
360
361     EndThread( p_input );
362
363     return 0;
364 }
365
366 /*****************************************************************************
367  * InitThread: init the input Thread
368  *****************************************************************************/
369 static int InitThread( input_thread_t * p_input )
370 {
371     /* Parse source string. Syntax : [[<access>][/<demux>]:][<source>] */
372     char * psz_parser = p_input->psz_source;
373
374     /* Skip the plug-in names */
375     while( *psz_parser && *psz_parser != ':' )
376     {
377         psz_parser++;
378     }
379 #if defined( WIN32 ) || defined( UNDER_CE )
380     if( psz_parser - p_input->psz_source == 1 )
381     {
382         msg_Warn( p_input, "drive letter %c: found in source string",
383                            p_input->psz_source[0] ) ;
384         psz_parser = "";
385     }
386 #endif
387
388     if( !*psz_parser )
389     {
390         p_input->psz_access = p_input->psz_demux = "";
391         p_input->psz_name = p_input->psz_source;
392     }
393     else
394     {
395         *psz_parser++ = '\0';
396
397         /* let's skip '//' */
398         if( psz_parser[0] == '/' && psz_parser[1] == '/' )
399         {
400             psz_parser += 2 ;
401         }
402
403         p_input->psz_name = psz_parser ;
404
405         /* Come back to parse the access and demux plug-ins */
406         psz_parser = p_input->psz_source;
407
408         if( !*psz_parser )
409         {
410             /* No access */
411             p_input->psz_access = "";
412         }
413         else if( *psz_parser == '/' )
414         {
415             /* No access */
416             p_input->psz_access = "";
417             psz_parser++;
418         }
419         else
420         {
421             p_input->psz_access = psz_parser;
422
423             while( *psz_parser && *psz_parser != '/' )
424             {
425                 psz_parser++;
426             }
427
428             if( *psz_parser == '/' )
429             {
430                 *psz_parser++ = '\0';
431             }
432         }
433
434         if( !*psz_parser )
435         {
436             /* No demux */
437             p_input->psz_demux = "";
438         }
439         else
440         {
441             p_input->psz_demux = psz_parser;
442         }
443     }
444
445     msg_Dbg( p_input, "access `%s', demux `%s', name `%s'",
446              p_input->psz_access, p_input->psz_demux, p_input->psz_name );
447
448     if( input_AccessInit( p_input ) == -1 )
449     {
450         return -1;
451     }
452
453     /* Find and open appropriate access module */
454     p_input->p_access = module_Need( p_input, "access",
455                                      p_input->psz_access );
456
457     if( p_input->p_access == NULL )
458     {
459         msg_Err( p_input, "no suitable access module for `%s/%s://%s'",
460                  p_input->psz_access, p_input->psz_demux, p_input->psz_name );
461         return -1;
462     }
463
464     /* Waiting for stream. */
465     if( p_input->i_mtu )
466     {
467         p_input->i_bufsize = p_input->i_mtu;
468     }
469     else
470     {
471         p_input->i_bufsize = INPUT_DEFAULT_BUFSIZE;
472     }
473
474     if( p_input->p_current_data == NULL && p_input->pf_read != NULL )
475     {
476         while( !input_FillBuffer( p_input ) )
477         {
478             if( p_input->b_die || p_input->b_error || p_input->b_eof )
479             {
480                 module_Unneed( p_input, p_input->p_access );
481                 return -1;
482             }
483         }
484     }
485
486     /* Find and open appropriate demux module */
487     p_input->p_demux = module_Need( p_input, "demux",
488                                     p_input->psz_demux );
489
490     if( p_input->p_demux== NULL )
491     {
492         msg_Err( p_input, "no suitable demux module for `%s/%s://%s'",
493                  p_input->psz_access, p_input->psz_demux, p_input->psz_name );
494         module_Unneed( p_input, p_input->p_access );
495         return -1;
496     }
497
498     /* Initialize optional stream output. */
499     psz_parser = config_GetPsz( p_input, "sout" );
500     if ( psz_parser != NULL )
501     {
502         if ( *psz_parser &&
503              (p_input->stream.p_sout = sout_NewInstance( p_input, psz_parser ))
504                == NULL )
505         {
506             msg_Err( p_input, "cannot start stream output instance, aborting" );
507             free( psz_parser );
508             module_Unneed( p_input, p_input->p_access );
509             module_Unneed( p_input, p_input->p_demux );
510             return -1;
511         }
512
513         free( psz_parser );
514     }
515
516     return 0;
517 }
518
519 /*****************************************************************************
520  * ErrorThread: RunThread() error loop
521  *****************************************************************************
522  * This function is called when an error occured during thread main's loop.
523  *****************************************************************************/
524 static void ErrorThread( input_thread_t *p_input )
525 {
526     while( !p_input->b_die )
527     {
528         /* Sleep a while */
529         msleep( INPUT_IDLE_SLEEP );
530     }
531 }
532
533 /*****************************************************************************
534  * EndThread: end the input thread
535  *****************************************************************************/
536 static void EndThread( input_thread_t * p_input )
537 {
538 #ifdef HAVE_SYS_TIMES_H
539     /* Display statistics */
540     struct tms  cpu_usage;
541     times( &cpu_usage );
542
543     msg_Dbg( p_input, "%d loops consuming user: %d, system: %d",
544              p_input->c_loops, cpu_usage.tms_utime, cpu_usage.tms_stime );
545 #else
546     msg_Dbg( p_input, "%d loops", p_input->c_loops );
547 #endif
548
549     /* Free info structures */
550     msg_Dbg( p_input, "freeing info structures...");
551     input_DelInfo( p_input );
552
553     input_DumpStream( p_input );
554
555     /* Free all ES and destroy all decoder threads */
556     input_EndStream( p_input );
557
558     /* Close optional stream output instance */
559     if ( p_input->stream.p_sout != NULL )
560     {
561         sout_DeleteInstance( p_input->stream.p_sout );
562     }
563
564     /* Free demultiplexer's data */
565     module_Unneed( p_input, p_input->p_demux );
566
567     /* Close the access plug-in */
568     module_Unneed( p_input, p_input->p_access );
569
570     input_AccessEnd( p_input );
571
572     free( p_input->psz_source );
573
574     /* Tell we're dead */
575     p_input->b_dead = 1;
576 }
577