Reworked/improved the way sout-keep works. (VLM sout-keep does not
[vlc.git] / src / input / input.c
1 /*****************************************************************************
2  * input.c: input thread
3  *****************************************************************************
4  * Copyright (C) 1998-2004 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
8  *          Laurent Aimar <fenrir@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>
29 #include <ctype.h>
30
31 #include <vlc/vlc.h>
32
33 #include "input_internal.h"
34
35 #include <vlc_sout.h>
36 #include "../stream_output/stream_output.h"
37
38 #include <vlc_playlist.h>
39 #include <vlc_interface.h>
40 #include <vlc_url.h>
41 #include <vlc_demux.h>
42 #include <vlc_charset.h>
43
44 #ifdef HAVE_SYS_STAT_H
45 #   include <sys/stat.h>
46 #endif
47
48 /*****************************************************************************
49  * Local prototypes
50  *****************************************************************************/
51 static  int Run  ( input_thread_t *p_input );
52 static  int RunAndDestroy  ( input_thread_t *p_input );
53
54 static input_thread_t * Create  ( vlc_object_t *, input_item_t *,
55                                   const char *, vlc_bool_t, sout_instance_t * );
56 static  int             Init    ( input_thread_t *p_input );
57 static void             Error   ( input_thread_t *p_input );
58 static void             End     ( input_thread_t *p_input );
59 static void             MainLoop( input_thread_t *p_input );
60 static void             Destroy( input_thread_t *p_input, sout_instance_t **pp_sout );
61
62 static inline int ControlPopNoLock( input_thread_t *, int *, vlc_value_t * );
63 static void       ControlReduce( input_thread_t * );
64 static vlc_bool_t Control( input_thread_t *, int, vlc_value_t );
65
66 static int  UpdateFromAccess( input_thread_t * );
67 static int  UpdateFromDemux( input_thread_t * );
68 static int  UpdateMeta( input_thread_t * );
69
70 static void UpdateItemLength( input_thread_t *, int64_t i_length );
71
72 static void MRLSections( input_thread_t *, char *, int *, int *, int *, int *);
73
74 static input_source_t *InputSourceNew( input_thread_t *);
75 static int  InputSourceInit( input_thread_t *, input_source_t *,
76                              const char *, const char *psz_forced_demux );
77 static void InputSourceClean( input_thread_t *, input_source_t * );
78
79 static void SlaveDemux( input_thread_t *p_input );
80 static void SlaveSeek( input_thread_t *p_input );
81
82 static void InputMetaUser( input_thread_t *p_input );
83
84 static sout_instance_t *SoutFind( vlc_object_t *p_parent, input_item_t *p_item, vlc_bool_t * );
85 static void SoutKeep( sout_instance_t * );
86
87 /*****************************************************************************
88  * This function creates a new input, and returns a pointer
89  * to its description. On error, it returns NULL.
90  *
91  * Variables for _public_ use:
92  * * Get and Set:
93  *  - state
94  *  - rate,rate-slower, rate-faster
95  *  - position, position-offset
96  *  - time, time-offset
97  *  - title,title-next,title-prev
98  *  - chapter,chapter-next, chapter-prev
99  *  - program, audio-es, video-es, spu-es
100  *  - audio-delay, spu-delay
101  *  - bookmark
102  * * Get only:
103  *  - length
104  *  - bookmarks
105  *  - seekable (if you can seek, it doesn't say if 'bar display' has be shown or not, for that check position != 0.0)
106  * * For intf callback upon changes
107  *  - intf-change
108  * TODO explain when Callback is called
109  * TODO complete this list (?)
110  *****************************************************************************/
111 static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
112                                const char *psz_header, vlc_bool_t b_quick, sout_instance_t *p_sout )
113 {
114     input_thread_t *p_input = NULL;                 /* thread descriptor */
115     vlc_value_t val;
116     int i;
117
118     /* Allocate descriptor */
119     p_input = vlc_object_create( p_parent, VLC_OBJECT_INPUT );
120     if( p_input == NULL )
121     {
122         msg_Err( p_parent, "out of memory" );
123         return NULL;
124     }
125     MALLOC_NULL( p_input->p, input_thread_private_t );
126
127     /* One "randomly" selected input thread is responsible for computing
128      * the global stats. Check if there is already someone doing this */
129     if( p_input->p_libvlc->p_playlist->p_stats && !b_quick )
130     {
131         vlc_mutex_lock( &p_input->p_libvlc->p_playlist->p_stats->lock );
132         if( p_input->p_libvlc->p_playlist->p_stats_computer == NULL )
133         {
134             p_input->p_libvlc->p_playlist->p_stats_computer = p_input;
135         }
136         vlc_mutex_unlock( &p_input->p_libvlc->p_playlist->p_stats->lock );
137     }
138
139     p_input->b_preparsing = b_quick;
140     p_input->psz_header = psz_header ? strdup( psz_header ) : NULL;
141
142     /* Init Common fields */
143     p_input->b_eof = VLC_FALSE;
144     p_input->b_can_pace_control = VLC_TRUE;
145     p_input->p->i_start = 0;
146     p_input->i_time  = 0;
147     p_input->p->i_stop  = 0;
148     p_input->p->i_title = 0;
149     p_input->p->title   = NULL;
150     p_input->p->i_title_offset = p_input->p->i_seekpoint_offset = 0;
151     p_input->i_state = INIT_S;
152     p_input->p->i_rate  = INPUT_RATE_DEFAULT;
153     p_input->p->i_bookmark = 0;
154     p_input->p->bookmark = NULL;
155     p_input->p->p_meta  = NULL;
156     p_input->p->p_es_out = NULL;
157     p_input->p->p_sout  = NULL;
158     p_input->p->b_sout_keep  = VLC_FALSE;
159     p_input->p->b_out_pace_control = VLC_FALSE;
160     p_input->i_pts_delay = 0;
161
162     /* Init Input fields */
163     p_input->p->input.p_item = p_item;
164     p_input->p->input.p_access = NULL;
165     p_input->p->input.p_stream = NULL;
166     p_input->p->input.p_demux  = NULL;
167     p_input->p->input.b_title_demux = VLC_FALSE;
168     p_input->p->input.i_title  = 0;
169     p_input->p->input.title    = NULL;
170     p_input->p->input.i_title_offset = p_input->p->input.i_seekpoint_offset = 0;
171     p_input->p->input.b_can_pace_control = VLC_TRUE;
172     p_input->p->input.b_eof = VLC_FALSE;
173     p_input->p->input.i_cr_average = 0;
174
175     if( !p_input->p->input.p_item->p_meta )
176         p_input->p->input.p_item->p_meta = vlc_meta_New();
177
178     if( !p_item->p_stats )
179     {
180         p_item->p_stats = (input_stats_t*)malloc( sizeof( input_stats_t ) );
181         vlc_mutex_init( p_input, &p_item->p_stats->lock );
182         stats_ReinitInputStats( p_item->p_stats );
183     }
184
185     /* No slave */
186     p_input->p->i_slave = 0;
187     p_input->p->slave   = NULL;
188
189     /* Init control buffer */
190     vlc_mutex_init( p_input, &p_input->p->lock_control );
191     p_input->p->i_control = 0;
192
193     /* Parse input options */
194     vlc_mutex_lock( &p_item->lock );
195     for( i = 0; i < p_item->i_options; i++ )
196         var_OptionParse( p_input, p_item->ppsz_options[i] );
197     vlc_mutex_unlock( &p_item->lock );
198
199     /* Create Object Variables for private use only */
200     input_ConfigVarInit( p_input );
201
202     /* Create Objects variables for public Get and Set */
203     input_ControlVarInit( p_input );
204
205     p_input->p->input.i_cr_average = var_GetInteger( p_input, "cr-average" );
206
207     if( !p_input->b_preparsing )
208     {
209         var_Get( p_input, "bookmarks", &val );
210         if( val.psz_string )
211         {
212             /* FIXME: have a common cfg parsing routine used by sout and others */
213             char *psz_parser, *psz_start, *psz_end;
214             psz_parser = val.psz_string;
215             while( (psz_start = strchr( psz_parser, '{' ) ) )
216             {
217                  seekpoint_t *p_seekpoint = vlc_seekpoint_New();
218                  char backup;
219                  psz_start++;
220                  psz_end = strchr( psz_start, '}' );
221                  if( !psz_end ) break;
222                  psz_parser = psz_end + 1;
223                  backup = *psz_parser;
224                  *psz_parser = 0;
225                  *psz_end = ',';
226                  while( (psz_end = strchr( psz_start, ',' ) ) )
227                  {
228                      *psz_end = 0;
229                      if( !strncmp( psz_start, "name=", 5 ) )
230                      {
231                          p_seekpoint->psz_name = psz_start + 5;
232                      }
233                      else if( !strncmp( psz_start, "bytes=", 6 ) )
234                      {
235                          p_seekpoint->i_byte_offset = atoll(psz_start + 6);
236                      }
237                      else if( !strncmp( psz_start, "time=", 5 ) )
238                      {
239                          p_seekpoint->i_time_offset = atoll(psz_start + 5) *
240                                                         1000000;
241                      }
242                      psz_start = psz_end + 1;
243                 }
244                 msg_Dbg( p_input, "adding bookmark: %s, bytes="I64Fd", time="I64Fd,
245                                   p_seekpoint->psz_name, p_seekpoint->i_byte_offset,
246                                   p_seekpoint->i_time_offset );
247                 input_Control( p_input, INPUT_ADD_BOOKMARK, p_seekpoint );
248                 vlc_seekpoint_Delete( p_seekpoint );
249                 *psz_parser = backup;
250             }
251             free( val.psz_string );
252         }
253     }
254
255     /* Remove 'Now playing' info as it is probably outdated */
256     input_Control( p_input, INPUT_DEL_INFO, _(VLC_META_INFO_CAT),
257                    VLC_META_NOW_PLAYING );     /* ? Don't translate as it might has been copied ? */
258
259     /* */
260     if( p_input->b_preparsing )
261         p_input->i_flags |= OBJECT_FLAGS_QUIET | OBJECT_FLAGS_NOINTERACT;
262
263     /* */
264     if( p_sout )
265         p_input->p->p_sout = p_sout;
266
267     /* Attach only once we are ready */
268     vlc_object_attach( p_input, p_parent );
269
270     return p_input;
271 }
272
273 static void Destroy( input_thread_t *p_input, sout_instance_t **pp_sout )
274 {
275     vlc_object_detach( p_input );
276
277     if( pp_sout )
278         *pp_sout = NULL;
279     if( p_input->p->p_sout )
280     {
281         if( pp_sout )
282             *pp_sout = p_input->p->p_sout;
283         else if( p_input->p->b_sout_keep )
284             SoutKeep( p_input->p->p_sout );
285         else
286             sout_DeleteInstance( p_input->p->p_sout );
287     }
288
289     vlc_mutex_destroy( &p_input->p->lock_control );
290     free( p_input->p );
291
292     vlc_object_destroy( p_input );
293 }
294
295 /**
296  * Initialize an input thread and run it. You will need to monitor the
297  * thread to clean up after it is done
298  *
299  * \param p_parent a vlc_object
300  * \param p_item an input item
301  * \return a pointer to the spawned input thread
302  */
303 input_thread_t *__input_CreateThread( vlc_object_t *p_parent,
304                                       input_item_t *p_item )
305 {
306     vlc_bool_t b_sout_keep;
307     sout_instance_t *p_sout = SoutFind( p_parent, p_item, &b_sout_keep );
308     input_thread_t *p_input =  __input_CreateThreadExtended( p_parent, p_item, NULL, p_sout );
309
310     if( !p_input && p_sout )
311         SoutKeep( p_sout );
312
313     p_input->p->b_sout_keep = b_sout_keep;
314     return p_input;
315 }
316
317 /* */
318 input_thread_t *__input_CreateThreadExtended( vlc_object_t *p_parent,
319                                               input_item_t *p_item,
320                                               const char *psz_log, sout_instance_t *p_sout )
321 {
322     input_thread_t *p_input;
323
324     p_input = Create( p_parent, p_item, psz_log, VLC_FALSE, p_sout );
325     if( !p_input )
326         return NULL;
327
328     /* Create thread and wait for its readiness. */
329     if( vlc_thread_create( p_input, "input", Run,
330                            VLC_THREAD_PRIORITY_INPUT, VLC_TRUE ) )
331     {
332         input_ChangeState( p_input, ERROR_S );
333         msg_Err( p_input, "cannot create input thread" );
334         Destroy( p_input, &p_sout );
335         return NULL;
336     }
337
338     return p_input;
339 }
340
341 /**
342  * Initialize an input thread and run it. This thread will clean after himself,
343  * you can forget about it. It can work either in blocking or non-blocking mode
344  *
345  * \param p_parent a vlc_object
346  * \param p_item an input item
347  * \param b_block should we block until read is finished ?
348  * \return the input object id if non blocking, an error code else
349  */
350 int __input_Read( vlc_object_t *p_parent, input_item_t *p_item,
351                    vlc_bool_t b_block )
352 {
353     vlc_bool_t b_sout_keep;
354     sout_instance_t *p_sout = SoutFind( p_parent, p_item, &b_sout_keep );
355     input_thread_t *p_input;
356
357     p_input = Create( p_parent, p_item, NULL, VLC_FALSE, p_sout );
358     if( !p_input && p_sout )
359     {
360         SoutKeep( p_sout );
361         return VLC_EGENERIC;
362     }
363     p_input->p->b_sout_keep = b_sout_keep;
364
365     if( b_block )
366     {
367         RunAndDestroy( p_input );
368         return VLC_SUCCESS;
369     }
370     else
371     {
372         if( vlc_thread_create( p_input, "input", RunAndDestroy,
373                                VLC_THREAD_PRIORITY_INPUT, VLC_TRUE ) )
374         {
375             input_ChangeState( p_input, ERROR_S );
376             msg_Err( p_input, "cannot create input thread" );
377             Destroy( p_input, NULL );
378             return VLC_EGENERIC;
379         }
380     }
381     return p_input->i_object_id;
382 }
383
384 /**
385  * Initialize an input and initialize it to preparse the item
386  * This function is blocking. It will only accept to parse files
387  *
388  * \param p_parent a vlc_object_t
389  * \param p_item an input item
390  * \return VLC_SUCCESS or an error
391  */
392 int __input_Preparse( vlc_object_t *p_parent, input_item_t *p_item )
393 {
394     input_thread_t *p_input;
395
396     /* Allocate descriptor */
397     p_input = Create( p_parent, p_item, NULL, VLC_TRUE, NULL );
398     if( !p_input )
399         return VLC_EGENERIC;
400
401     Init( p_input );
402     End( p_input );
403
404     Destroy( p_input, NULL );
405
406     return VLC_SUCCESS;
407 }
408
409 /**
410  * Request a running input thread to stop and die
411  *
412  * \param the input thread to stop
413  */
414 void input_StopThread( input_thread_t *p_input )
415 {
416     vlc_list_t *p_list;
417     int i;
418
419     /* Set die for input */
420     p_input->b_die = VLC_TRUE;
421
422     /* We cannot touch p_input fields directly (we come from another thread),
423      * so use the vlc_object_find way, it's perfectly safe */
424
425     /* Set die for all access */
426     p_list = vlc_list_find( p_input, VLC_OBJECT_ACCESS, FIND_CHILD );
427     for( i = 0; i < p_list->i_count; i++ )
428     {
429         p_list->p_values[i].p_object->b_die = VLC_TRUE;
430     }
431     vlc_list_release( p_list );
432
433     /* Set die for all stream */
434     p_list = vlc_list_find( p_input, VLC_OBJECT_STREAM, FIND_CHILD );
435     for( i = 0; i < p_list->i_count; i++ )
436     {
437         p_list->p_values[i].p_object->b_die = VLC_TRUE;
438     }
439     vlc_list_release( p_list );
440
441     /* Set die for all demux */
442     p_list = vlc_list_find( p_input, VLC_OBJECT_DEMUX, FIND_CHILD );
443     for( i = 0; i < p_list->i_count; i++ )
444     {
445         p_list->p_values[i].p_object->b_die = VLC_TRUE;
446     }
447     vlc_list_release( p_list );
448
449     input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL );
450 }
451
452 /**
453  * Clean up a dead input thread
454  * This function does not return until the thread is effectively cancelled.
455  *
456  * \param the input thread to kill
457  */
458 void input_DestroyThread( input_thread_t *p_input )
459 {
460     input_DestroyThreadExtended( p_input, NULL );
461 }
462
463 void input_DestroyThreadExtended( input_thread_t *p_input, sout_instance_t **pp_sout )
464 {
465     /* Join the thread */
466     vlc_thread_join( p_input );
467
468     /* */
469     Destroy( p_input, pp_sout );
470 }
471
472 /*****************************************************************************
473  * Run: main thread loop
474  * This is the "normal" thread that spawns the input processing chain,
475  * reads the stream, cleans up and waits
476  *****************************************************************************/
477 static int Run( input_thread_t *p_input )
478 {
479     /* Signal that the thread is launched */
480     vlc_thread_ready( p_input );
481
482     if( Init( p_input ) )
483     {
484         /* If we failed, wait before we are killed, and exit */
485         p_input->b_error = VLC_TRUE;
486         playlist_Signal( pl_Get( p_input ) );
487
488         Error( p_input );
489
490         /* Tell we're dead */
491         p_input->b_dead = VLC_TRUE;
492
493         return 0;
494     }
495
496     MainLoop( p_input );
497
498     if( !p_input->b_eof && !p_input->b_error && p_input->p->input.b_eof )
499     {
500         /* We have finish to demux data but not to play them */
501         while( !p_input->b_die )
502         {
503             if( input_EsOutDecodersEmpty( p_input->p->p_es_out ) )
504                 break;
505
506             msg_Dbg( p_input, "waiting decoder fifos to empty" );
507
508             msleep( INPUT_IDLE_SLEEP );
509         }
510
511         /* We have finished */
512         p_input->b_eof = VLC_TRUE;
513         playlist_Signal( pl_Get( p_input ) );
514     }
515
516     /* Wait until we are asked to die */
517     if( !p_input->b_die )
518     {
519         Error( p_input );
520     }
521
522     /* Clean up */
523     End( p_input );
524
525     return 0;
526 }
527
528 /*****************************************************************************
529  * RunAndDestroy: main thread loop
530  * This is the "just forget me" thread that spawns the input processing chain,
531  * reads the stream, cleans up and releases memory
532  *****************************************************************************/
533 static int RunAndDestroy( input_thread_t *p_input )
534 {
535     /* Signal that the thread is launched */
536     vlc_thread_ready( p_input );
537
538     if( Init( p_input ) )
539         goto exit;
540
541     MainLoop( p_input );
542
543     if( !p_input->b_eof && !p_input->b_error && p_input->p->input.b_eof )
544     {
545         /* We have finished demuxing data but not playing it */
546         while( !p_input->b_die )
547         {
548             if( input_EsOutDecodersEmpty( p_input->p->p_es_out ) )
549                 break;
550
551             msg_Dbg( p_input, "waiting decoder fifos to empty" );
552
553             msleep( INPUT_IDLE_SLEEP );
554         }
555
556         /* We have finished */
557         p_input->b_eof = VLC_TRUE;
558     }
559
560     /* Clean up */
561     End( p_input );
562
563 exit:
564     /* Release memory */
565     Destroy( p_input, NULL );
566     return 0;
567 }
568
569 /*****************************************************************************
570  * Main loop: Fill buffers from access, and demux
571  *****************************************************************************/
572 static void MainLoop( input_thread_t *p_input )
573 {
574     int64_t i_intf_update = 0;
575     int i_updates = 0;
576
577     while( !p_input->b_die && !p_input->b_error && !p_input->p->input.b_eof )
578     {
579         vlc_bool_t b_force_update = VLC_FALSE;
580         int i_ret;
581         int i_type;
582         vlc_value_t val;
583
584         /* Do the read */
585         if( p_input->i_state != PAUSE_S  )
586         {
587             if( p_input->p->i_stop <= 0 || p_input->i_time < p_input->p->i_stop )
588                 i_ret=p_input->p->input.p_demux->pf_demux(p_input->p->input.p_demux);
589             else
590                 i_ret = 0;  /* EOF */
591
592             if( i_ret > 0 )
593             {
594                 /* TODO */
595                 if( p_input->p->input.b_title_demux &&
596                     p_input->p->input.p_demux->info.i_update )
597                 {
598                     i_ret = UpdateFromDemux( p_input );
599                     b_force_update = VLC_TRUE;
600                 }
601                 else if( !p_input->p->input.b_title_demux &&
602                           p_input->p->input.p_access &&
603                           p_input->p->input.p_access->info.i_update )
604                 {
605                     i_ret = UpdateFromAccess( p_input );
606                     b_force_update = VLC_TRUE;
607                 }
608             }
609
610             if( i_ret == 0 )    /* EOF */
611             {
612                 vlc_value_t repeat;
613
614                 var_Get( p_input, "input-repeat", &repeat );
615                 if( repeat.i_int == 0 )
616                 {
617                     /* End of file - we do not set b_die because only the
618                      * playlist is allowed to do so. */
619                     input_ChangeState( p_input, END_S );
620                     msg_Dbg( p_input, "EOF reached" );
621                     p_input->p->input.b_eof = VLC_TRUE;
622                 }
623                 else
624                 {
625                     msg_Dbg( p_input, "repeating the same input (%d)",
626                              repeat.i_int );
627                     if( repeat.i_int > 0 )
628                     {
629                         repeat.i_int--;
630                         var_Set( p_input, "input-repeat", repeat );
631                     }
632
633                     /* Seek to start title/seekpoint */
634                     val.i_int = p_input->p->input.i_title_start -
635                         p_input->p->input.i_title_offset;
636                     if( val.i_int < 0 || val.i_int >= p_input->p->input.i_title )
637                         val.i_int = 0;
638                     input_ControlPush( p_input,
639                                        INPUT_CONTROL_SET_TITLE, &val );
640
641                     val.i_int = p_input->p->input.i_seekpoint_start -
642                         p_input->p->input.i_seekpoint_offset;
643                     if( val.i_int > 0 /* TODO: check upper boundary */ )
644                         input_ControlPush( p_input,
645                                            INPUT_CONTROL_SET_SEEKPOINT, &val );
646
647                     /* Seek to start position */
648                     if( p_input->p->i_start > 0 )
649                     {
650                         val.i_time = p_input->p->i_start;
651                         input_ControlPush( p_input, INPUT_CONTROL_SET_TIME,
652                                            &val );
653                     }
654                     else
655                     {
656                         val.f_float = 0.0;
657                         input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION,
658                                            &val );
659                     }
660                 }
661             }
662             else if( i_ret < 0 )
663             {
664                 p_input->b_error = VLC_TRUE;
665             }
666
667             if( i_ret > 0 && p_input->p->i_slave > 0 )
668             {
669                 SlaveDemux( p_input );
670             }
671         }
672         else
673         {
674             /* Small wait */
675             msleep( 10*1000 );
676         }
677
678         /* Handle control */
679         vlc_mutex_lock( &p_input->p->lock_control );
680         ControlReduce( p_input );
681         while( !ControlPopNoLock( p_input, &i_type, &val ) )
682         {
683             msg_Dbg( p_input, "control type=%d", i_type );
684             if( Control( p_input, i_type, val ) )
685                 b_force_update = VLC_TRUE;
686         }
687         vlc_mutex_unlock( &p_input->p->lock_control );
688
689         if( b_force_update || i_intf_update < mdate() )
690         {
691             vlc_value_t val;
692             double f_pos;
693             int64_t i_time, i_length;
694             /* update input status variables */
695             if( !demux2_Control( p_input->p->input.p_demux,
696                                  DEMUX_GET_POSITION, &f_pos ) )
697             {
698                 val.f_float = (float)f_pos;
699                 var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL );
700             }
701             if( !demux2_Control( p_input->p->input.p_demux,
702                                  DEMUX_GET_TIME, &i_time ) )
703             {
704                 p_input->i_time = i_time;
705                 val.i_time = i_time;
706                 var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL );
707             }
708             if( !demux2_Control( p_input->p->input.p_demux,
709                                  DEMUX_GET_LENGTH, &i_length ) )
710             {
711                 vlc_value_t old_val;
712                 var_Get( p_input, "length", &old_val );
713                 val.i_time = i_length;
714                 var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL );
715
716                 if( old_val.i_time != val.i_time )
717                 {
718                     UpdateItemLength( p_input, i_length );
719                 }
720             }
721
722             var_SetBool( p_input, "intf-change", VLC_TRUE );
723             i_intf_update = mdate() + I64C(150000);
724         }
725         /* 150ms * 8 = ~ 1 second */
726         if( ++i_updates % 8 == 0 )
727         {
728             stats_ComputeInputStats( p_input, p_input->p->input.p_item->p_stats );
729             /* Are we the thread responsible for computing global stats ? */
730             if( p_input->p_libvlc->p_playlist->p_stats_computer == p_input )
731             {
732                 stats_ComputeGlobalStats( p_input->p_libvlc->p_playlist,
733                                      p_input->p_libvlc->p_playlist->p_stats );
734             }
735         }
736     }
737 }
738
739 static int Init( input_thread_t * p_input )
740 {
741     char *psz;
742     char *psz_subtitle;
743     vlc_value_t val;
744     double f_fps;
745     vlc_meta_t *p_meta;
746     int i_es_out_mode;
747     int i, i_delay;
748
749     /* Initialize optional stream output. (before access/demuxer)
750      * XXX: we add a special case if the uri starts by vlc.
751      * else 'vlc in.file --sout "" vlc:quit'  cannot work (the output will
752      * be destroyed in case of a file).
753      * (this will break playing of file starting by 'vlc:' but I don't
754      * want to add more logic, just force file by file:// or code it ;)
755      */
756     memset( &p_input->p->counters, 0, sizeof( p_input->p->counters ) );
757     vlc_mutex_init( p_input, &p_input->p->counters.counters_lock );
758
759     if( !p_input->b_preparsing )
760     {
761         /* Prepare statistics */
762 #define INIT_COUNTER( c, type, compute ) p_input->p->counters.p_##c = \
763      stats_CounterCreate( p_input, VLC_VAR_##type, STATS_##compute);
764         if( p_input->p_libvlc->b_stats )
765         {
766             INIT_COUNTER( read_bytes, INTEGER, COUNTER );
767             INIT_COUNTER( read_packets, INTEGER, COUNTER );
768             INIT_COUNTER( demux_read, INTEGER, COUNTER );
769             INIT_COUNTER( input_bitrate, FLOAT, DERIVATIVE );
770             INIT_COUNTER( demux_bitrate, FLOAT, DERIVATIVE );
771             INIT_COUNTER( played_abuffers, INTEGER, COUNTER );
772             INIT_COUNTER( lost_abuffers, INTEGER, COUNTER );
773             INIT_COUNTER( displayed_pictures, INTEGER, COUNTER );
774             INIT_COUNTER( lost_pictures, INTEGER, COUNTER );
775             INIT_COUNTER( decoded_audio, INTEGER, COUNTER );
776             INIT_COUNTER( decoded_video, INTEGER, COUNTER );
777             INIT_COUNTER( decoded_sub, INTEGER, COUNTER );
778             p_input->p->counters.p_sout_send_bitrate = NULL;
779             p_input->p->counters.p_sout_sent_packets = NULL;
780             p_input->p->counters.p_sout_sent_bytes = NULL;
781             if( p_input->p->counters.p_demux_bitrate )
782                 p_input->p->counters.p_demux_bitrate->update_interval = 1000000;
783             if( p_input->p->counters.p_input_bitrate )
784                 p_input->p->counters.p_input_bitrate->update_interval = 1000000;
785         }
786
787         /* Find a usable sout and attach it to p_input */
788         psz = var_GetString( p_input, "sout" );
789         if( *psz && strncasecmp( p_input->p->input.p_item->psz_uri, "vlc:", 4 ) )
790         {
791             /* Check the validity of the provided sout */
792             if( p_input->p->p_sout )
793             {
794                 if( strcmp( p_input->p->p_sout->psz_sout, psz ) )
795                 {
796                     msg_Dbg( p_input, "destroying unusable sout" );
797
798                     sout_DeleteInstance( p_input->p->p_sout );
799                     p_input->p->p_sout = NULL;
800                 }
801             }
802
803             if( p_input->p->p_sout )
804             {
805                 /* Reuse it */
806                 msg_Dbg( p_input, "sout keep: reusing sout" );
807                 msg_Dbg( p_input, "sout keep: you probably want to use "
808                                   "gather stream_out" );
809                 vlc_object_attach( p_input->p->p_sout, p_input );
810             }
811             else
812             {
813                 /* Create a new one */
814                 p_input->p->p_sout = sout_NewInstance( p_input, psz );
815
816                 if( !p_input->p->p_sout )
817                 {
818                     input_ChangeState( p_input, ERROR_S );
819                     msg_Err( p_input, "cannot start stream output instance, " \
820                                       "aborting" );
821                     free( psz );
822                     return VLC_EGENERIC;
823                 }
824             }
825
826             if( p_input->p_libvlc->b_stats )
827             {
828                 INIT_COUNTER( sout_sent_packets, INTEGER, COUNTER );
829                 INIT_COUNTER (sout_sent_bytes, INTEGER, COUNTER );
830                 INIT_COUNTER( sout_send_bitrate, FLOAT, DERIVATIVE );
831                 if( p_input->p->counters.p_sout_send_bitrate )
832                      p_input->p->counters.p_sout_send_bitrate->update_interval =
833                              1000000;
834             }
835         }
836         else if( p_input->p->p_sout )
837         {
838             msg_Dbg( p_input, "destroying useless sout" );
839
840             sout_DeleteInstance( p_input->p->p_sout );
841             p_input->p->p_sout = NULL;
842         }
843         free( psz );
844     }
845
846     /* Create es out */
847     p_input->p->p_es_out = input_EsOutNew( p_input );
848     es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ACTIVE, VLC_FALSE );
849     es_out_Control( p_input->p->p_es_out, ES_OUT_SET_MODE, ES_OUT_MODE_NONE );
850
851     var_Create( p_input, "bit-rate", VLC_VAR_INTEGER );
852     var_Create( p_input, "sample-rate", VLC_VAR_INTEGER );
853
854     if( InputSourceInit( p_input, &p_input->p->input,
855                          p_input->p->input.p_item->psz_uri, NULL ) )
856     {
857         goto error;
858     }
859
860     /* Create global title (from master) */
861     if( !p_input->b_preparsing )
862     {
863         p_input->p->i_title = p_input->p->input.i_title;
864         p_input->p->title   = p_input->p->input.title;
865         p_input->p->i_title_offset = p_input->p->input.i_title_offset;
866         p_input->p->i_seekpoint_offset = p_input->p->input.i_seekpoint_offset;
867         if( p_input->p->i_title > 0 )
868         {
869             /* Setup variables */
870             input_ControlVarNavigation( p_input );
871             input_ControlVarTitle( p_input, 0 );
872         }
873
874         /* Global flag */
875         p_input->b_can_pace_control = p_input->p->input.b_can_pace_control;
876         p_input->p->b_can_pause        = p_input->p->input.b_can_pause;
877
878         /* Fix pts delay */
879         if( p_input->i_pts_delay < 0 )
880             p_input->i_pts_delay = 0;
881
882         /* If the desynchronisation requested by the user is < 0, we need to
883          * cache more data. */
884         var_Get( p_input, "audio-desync", &val );
885         if( val.i_int < 0 ) p_input->i_pts_delay -= (val.i_int * 1000);
886
887         /* Update cr_average depending on the caching */
888         p_input->p->input.i_cr_average *= (10 * p_input->i_pts_delay / 200000);
889         p_input->p->input.i_cr_average /= 10;
890         if( p_input->p->input.i_cr_average < 10 ) p_input->p->input.i_cr_average = 10;
891     }
892
893     /* Load master infos */
894     /* Init length */
895     if( !demux2_Control( p_input->p->input.p_demux, DEMUX_GET_LENGTH,
896                          &val.i_time ) && val.i_time > 0 )
897     {
898         var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL );
899         UpdateItemLength( p_input, val.i_time );
900         p_input->p->input.p_item->i_duration = val.i_time;
901     }
902
903     /* Start title/chapter */
904     if( !p_input->b_preparsing )
905     {
906         val.i_int = p_input->p->input.i_title_start -
907                     p_input->p->input.i_title_offset;
908         if( val.i_int > 0 && val.i_int < p_input->p->input.i_title )
909             input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE, &val );
910         val.i_int = p_input->p->input.i_seekpoint_start -
911                     p_input->p->input.i_seekpoint_offset;
912         if( val.i_int > 0 /* TODO: check upper boundary */ )
913             input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT, &val );
914
915         /* Start time*/
916         /* Set start time */
917         p_input->p->i_start = (int64_t)var_GetInteger( p_input, "start-time" ) *
918                            I64C(1000000);
919         p_input->p->i_stop  = (int64_t)var_GetInteger( p_input, "stop-time" ) *
920                            I64C(1000000);
921
922         if( p_input->p->i_start > 0 )
923         {
924             if( p_input->p->i_start >= val.i_time )
925             {
926                 msg_Warn( p_input, "invalid start-time ignored" );
927             }
928             else
929             {
930                 vlc_value_t s;
931
932                 msg_Dbg( p_input, "starting at time: %ds",
933                                   (int)( p_input->p->i_start / I64C(1000000) ) );
934
935                 s.i_time = p_input->p->i_start;
936                 input_ControlPush( p_input, INPUT_CONTROL_SET_TIME, &s );
937             }
938         }
939         if( p_input->p->i_stop > 0 && p_input->p->i_stop <= p_input->p->i_start )
940         {
941             msg_Warn( p_input, "invalid stop-time ignored" );
942             p_input->p->i_stop = 0;
943         }
944
945         /* Load subtitles */
946         /* Get fps and set it if not already set */
947         if( !demux2_Control( p_input->p->input.p_demux, DEMUX_GET_FPS, &f_fps ) &&
948             f_fps > 1.0 )
949         {
950             float f_requested_fps;
951
952             var_Create( p_input, "sub-original-fps", VLC_VAR_FLOAT );
953             var_SetFloat( p_input, "sub-original-fps", f_fps );
954
955             f_requested_fps = var_CreateGetFloat( p_input, "sub-fps" );
956             if( f_requested_fps != f_fps )
957             {
958                 var_Create( p_input, "sub-fps", VLC_VAR_FLOAT|
959                                                 VLC_VAR_DOINHERIT );
960                 var_SetFloat( p_input, "sub-fps", f_requested_fps );
961             }
962         }
963
964         i_delay = var_CreateGetInteger( p_input, "sub-delay" );
965         if( i_delay != 0 )
966         {
967             var_SetTime( p_input, "spu-delay", (mtime_t)i_delay * 100000 );
968         }
969
970         /* Look for and add subtitle files */
971         psz_subtitle = var_GetString( p_input, "sub-file" );
972         if( *psz_subtitle )
973         {
974             msg_Dbg( p_input, "forced subtitle: %s", psz_subtitle );
975             input_AddSubtitles( p_input, psz_subtitle, VLC_FALSE );
976         }
977
978         var_Get( p_input, "sub-autodetect-file", &val );
979         if( val.b_bool )
980         {
981             char *psz_autopath = var_GetString( p_input, "sub-autodetect-path" );
982             char **subs = subtitles_Detect( p_input, psz_autopath,
983                                             p_input->p->input.p_item->psz_uri );
984             input_source_t *sub;
985             i = 0;
986
987             /* Try to autoselect the first autodetected subtitles file
988              * if no subtitles file was specified */
989             if( *psz_subtitle == 0 && subs && subs[0] )
990             {
991                 input_AddSubtitles( p_input, subs[0], VLC_FALSE );
992                 free( subs[0] );
993                 i = 1;
994             }
995
996             /* Then, just add the following subtitles files */
997             for( ; subs && subs[i]; i++ )
998             {
999                 if( strcmp( psz_subtitle, subs[i] ) )
1000                 {
1001                     sub = InputSourceNew( p_input );
1002                     if( !InputSourceInit( p_input, sub, subs[i], "subtitle" ) )
1003                     {
1004                         TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub );
1005                     }
1006                     else free( sub );
1007                 }
1008                 free( subs[i] );
1009             }
1010             if( subs ) free( subs );
1011             if( psz_autopath ) free( psz_autopath );
1012         }
1013         free( psz_subtitle );
1014
1015         /* Look for slave */
1016         psz = var_GetString( p_input, "input-slave" );
1017         if( *psz )
1018         {
1019             char *psz_delim;
1020             input_source_t *slave;
1021             while( psz && *psz )
1022             {
1023                 while( *psz == ' ' || *psz == '#' )
1024                 {
1025                     psz++;
1026                 }
1027                 if( ( psz_delim = strchr( psz, '#' ) ) )
1028                 {
1029                     *psz_delim++ = '\0';
1030                 }
1031                 if( *psz == 0 )
1032                 {
1033                     break;
1034                 }
1035
1036                 msg_Dbg( p_input, "adding slave input '%s'", psz );
1037                 slave = InputSourceNew( p_input );
1038                 if( !InputSourceInit( p_input, slave, psz, NULL ) )
1039                 {
1040                     TAB_APPEND( p_input->p->i_slave, p_input->p->slave, slave );
1041                 }
1042                 else free( slave );
1043                 psz = psz_delim;
1044             }
1045         }
1046         if( psz ) free( psz );
1047     }
1048     else
1049     {
1050         p_input->p->i_start = 0;
1051         p_input->p->i_start = 0;
1052     }
1053
1054     /* Set up es_out */
1055     if( !p_input->b_preparsing )
1056     {
1057         es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ACTIVE, VLC_TRUE );
1058         i_es_out_mode = ES_OUT_MODE_AUTO;
1059         val.p_list = NULL;
1060         if( p_input->p->p_sout )
1061         {
1062             var_Get( p_input, "sout-all", &val );
1063             if ( val.b_bool )
1064             {
1065                 i_es_out_mode = ES_OUT_MODE_ALL;
1066                 val.p_list = NULL;
1067             }
1068             else
1069             {
1070                 var_Get( p_input, "programs", &val );
1071                 if ( val.p_list && val.p_list->i_count )
1072                 {
1073                     i_es_out_mode = ES_OUT_MODE_PARTIAL;
1074                     /* Note : we should remove the "program" callback. */
1075                 }
1076                 else
1077                     var_Change( p_input, "programs", VLC_VAR_FREELIST, &val,
1078                                 NULL );
1079             }
1080         }
1081         es_out_Control( p_input->p->p_es_out, ES_OUT_SET_MODE, i_es_out_mode );
1082
1083         /* Inform the demuxer about waited group (needed only for DVB) */
1084         if( i_es_out_mode == ES_OUT_MODE_ALL )
1085         {
1086             demux2_Control( p_input->p->input.p_demux, DEMUX_SET_GROUP, -1, NULL );
1087         }
1088         else if( i_es_out_mode == ES_OUT_MODE_PARTIAL )
1089         {
1090             demux2_Control( p_input->p->input.p_demux, DEMUX_SET_GROUP, -1,
1091                             val.p_list );
1092         }
1093         else
1094         {
1095             demux2_Control( p_input->p->input.p_demux, DEMUX_SET_GROUP,
1096                            (int) var_GetInteger( p_input, "program" ), NULL );
1097         }
1098
1099         if( p_input->p->p_sout )
1100         {
1101             if( p_input->p->p_sout->i_out_pace_nocontrol > 0 )
1102             {
1103                 p_input->p->b_out_pace_control = VLC_FALSE;
1104             }
1105             else
1106             {
1107                 p_input->p->b_out_pace_control = VLC_TRUE;
1108             }
1109
1110             if( p_input->b_can_pace_control && p_input->p->b_out_pace_control )
1111             {
1112                 /* We don't want a high input priority here or we'll
1113                  * end-up sucking up all the CPU time */
1114                 vlc_thread_set_priority( p_input, VLC_THREAD_PRIORITY_LOW );
1115             }
1116
1117             msg_Dbg( p_input, "starting in %s mode",
1118                      p_input->p->b_out_pace_control ? "async" : "sync" );
1119         }
1120     }
1121
1122     p_meta = p_input->p->input.p_item->p_meta;
1123     /* Get meta data from users */
1124     InputMetaUser( p_input );
1125     /* Get meta data from master input */
1126     demux2_Control( p_input->p->input.p_demux, DEMUX_GET_META, p_meta );
1127
1128     /* Access_file does not give any meta, and there are no slave */
1129     if( !p_input->b_preparsing )
1130     {
1131         if( p_input->p->input.p_access )
1132             access2_Control( p_input->p->input.p_access, ACCESS_GET_META,
1133                              p_meta );
1134
1135         /* Get meta data from slave input */
1136         for( i = 0; i < p_input->p->i_slave; i++ )
1137         {
1138             demux2_Control( p_input->p->slave[i]->p_demux,
1139                             DEMUX_GET_META, p_meta );
1140             if( p_input->p->slave[i]->p_access )
1141             {
1142                 access2_Control( p_input->p->slave[i]->p_access,
1143                                  ACCESS_GET_META, p_meta );
1144             }
1145         }
1146     }
1147
1148     UpdateMeta( p_input );
1149
1150     if( !p_input->b_preparsing )
1151     {
1152         msg_Dbg( p_input, "`%s' successfully opened",
1153                  p_input->p->input.p_item->psz_uri );
1154
1155     }
1156
1157     /* initialization is complete */
1158     input_ChangeState( p_input, PLAYING_S );
1159
1160     return VLC_SUCCESS;
1161
1162 error:
1163     input_ChangeState( p_input, ERROR_S );
1164
1165     if( p_input->p->p_es_out )
1166         input_EsOutDelete( p_input->p->p_es_out );
1167
1168     if( p_input->p->p_sout )
1169         vlc_object_detach( p_input->p->p_sout );
1170
1171     /* Mark them deleted */
1172     p_input->p->input.p_demux = NULL;
1173     p_input->p->input.p_stream = NULL;
1174     p_input->p->input.p_access = NULL;
1175     p_input->p->p_es_out = NULL;
1176     p_input->p->p_sout = NULL;
1177
1178     return VLC_EGENERIC;
1179 }
1180
1181 /*****************************************************************************
1182  * Error: RunThread() error loop
1183  *****************************************************************************
1184  * This function is called when an error occurred during thread main's loop.
1185  *****************************************************************************/
1186 static void Error( input_thread_t *p_input )
1187 {
1188     while( !p_input->b_die )
1189     {
1190         /* Sleep a while */
1191         input_ChangeState( p_input, ERROR_S );
1192         msleep( INPUT_IDLE_SLEEP );
1193     }
1194 }
1195
1196 /*****************************************************************************
1197  * End: end the input thread
1198  *****************************************************************************/
1199 static void End( input_thread_t * p_input )
1200 {
1201     int i;
1202
1203     /* We are at the end */
1204     input_ChangeState( p_input, END_S );
1205
1206     /* Clean control variables */
1207     input_ControlVarClean( p_input );
1208
1209     /* Clean up master */
1210     InputSourceClean( p_input, &p_input->p->input );
1211
1212     /* Delete slave */
1213     for( i = 0; i < p_input->p->i_slave; i++ )
1214     {
1215         InputSourceClean( p_input, p_input->p->slave[i] );
1216         free( p_input->p->slave[i] );
1217     }
1218     if( p_input->p->slave ) free( p_input->p->slave );
1219
1220     /* Unload all modules */
1221     if( p_input->p->p_es_out )
1222         input_EsOutDelete( p_input->p->p_es_out );
1223
1224     if( !p_input->b_preparsing )
1225     {
1226 #define CL_CO( c ) stats_CounterClean( p_input->p->counters.p_##c ); p_input->p->counters.p_##c = NULL;
1227         if( p_input->p_libvlc->b_stats )
1228         {
1229             /* make sure we are up to date */
1230             stats_ComputeInputStats( p_input, p_input->p->input.p_item->p_stats );
1231             if( p_input->p_libvlc->p_playlist->p_stats_computer == p_input )
1232             {
1233                 stats_ComputeGlobalStats( p_input->p_libvlc->p_playlist,
1234                                           p_input->p_libvlc->p_playlist->p_stats );
1235                 p_input->p_libvlc->p_playlist->p_stats_computer = NULL;
1236             }
1237             CL_CO( read_bytes );
1238             CL_CO( read_packets );
1239             CL_CO( demux_read );
1240             CL_CO( input_bitrate );
1241             CL_CO( demux_bitrate );
1242             CL_CO( played_abuffers );
1243             CL_CO( lost_abuffers );
1244             CL_CO( displayed_pictures );
1245             CL_CO( lost_pictures );
1246             CL_CO( decoded_audio) ;
1247             CL_CO( decoded_video );
1248             CL_CO( decoded_sub) ;
1249         }
1250
1251         /* Close optional stream output instance */
1252         if( p_input->p->p_sout )
1253         {
1254             CL_CO( sout_sent_packets );
1255             CL_CO( sout_sent_bytes );
1256             CL_CO( sout_send_bitrate );
1257
1258             vlc_object_detach( p_input->p->p_sout );
1259         }
1260 #undef CL_CO
1261     }
1262
1263     vlc_mutex_destroy( &p_input->p->counters.counters_lock );
1264
1265     /* Tell we're dead */
1266     p_input->b_dead = VLC_TRUE;
1267 }
1268
1269 static sout_instance_t *SoutFind( vlc_object_t *p_parent, input_item_t *p_item, vlc_bool_t *pb_sout_keep )
1270 {
1271     vlc_bool_t b_keep_sout = var_CreateGetBool( p_parent, "sout-keep" );
1272     sout_instance_t *p_sout = NULL;
1273     int i;
1274
1275     /* Search sout-keep options
1276      * XXX it has to be done here, but it is duplicated work :( */
1277     vlc_mutex_lock( &p_item->lock );
1278     for( i = 0; i < p_item->i_options; i++ )
1279     {
1280         const char *psz_option = p_item->ppsz_options[i];
1281         if( !psz_option )
1282             continue;
1283         if( *psz_option == ':' )
1284             psz_option++;
1285
1286         if( !strcmp( psz_option, "sout-keep" ) )
1287             b_keep_sout = VLC_TRUE;
1288         else if( !strcmp( psz_option, "no-sout-keep" ) || !strcmp( psz_option, "nosout-keep" ) )
1289             b_keep_sout = VLC_FALSE;
1290     }
1291     vlc_mutex_unlock( &p_item->lock );
1292
1293     /* Find a potential sout to reuse
1294      * XXX it might be unusable but this will be checked later */
1295     if( b_keep_sout )
1296     {
1297         /* Remove the sout from the playlist garbage collector */
1298         playlist_t *p_playlist = pl_Yield( p_parent );
1299
1300         vlc_mutex_lock( &p_playlist->gc_lock );
1301         p_sout = vlc_object_find( p_playlist, VLC_OBJECT_SOUT, FIND_CHILD );
1302         if( p_sout )
1303         {
1304             if( p_sout->p_parent != VLC_OBJECT(p_playlist) )
1305             {
1306                 vlc_object_release( p_sout );
1307                 p_sout = NULL;
1308             }
1309             else
1310             {
1311                 vlc_object_detach( p_sout );    /* Remove it from the GC */
1312
1313                 vlc_object_release( p_sout );
1314             }
1315         }
1316         vlc_mutex_unlock( &p_playlist->gc_lock );
1317
1318         pl_Release( p_parent );
1319     }
1320
1321     if( pb_sout_keep )
1322         *pb_sout_keep = b_keep_sout;
1323
1324     return p_sout;
1325 }
1326 static void SoutKeep( sout_instance_t *p_sout )
1327 {
1328     /* attach sout to the playlist */
1329     playlist_t  *p_playlist = pl_Yield( p_sout );
1330
1331     msg_Dbg( p_sout, "sout has been kept" );
1332     vlc_object_attach( p_sout, p_playlist );
1333
1334     pl_Release( p_sout );
1335 }
1336
1337 /*****************************************************************************
1338  * Control
1339  *****************************************************************************/
1340 static inline int ControlPopNoLock( input_thread_t *p_input,
1341                                     int *pi_type, vlc_value_t *p_val )
1342 {
1343     if( p_input->p->i_control <= 0 )
1344     {
1345         return VLC_EGENERIC;
1346     }
1347
1348     *pi_type = p_input->p->control[0].i_type;
1349     *p_val   = p_input->p->control[0].val;
1350
1351     p_input->p->i_control--;
1352     if( p_input->p->i_control > 0 )
1353     {
1354         int i;
1355
1356         for( i = 0; i < p_input->p->i_control; i++ )
1357         {
1358             p_input->p->control[i].i_type = p_input->p->control[i+1].i_type;
1359             p_input->p->control[i].val    = p_input->p->control[i+1].val;
1360         }
1361     }
1362
1363     return VLC_SUCCESS;
1364 }
1365
1366 static void ControlReduce( input_thread_t *p_input )
1367 {
1368     int i;
1369
1370     if( !p_input )
1371         return;
1372
1373     for( i = 1; i < p_input->p->i_control; i++ )
1374     {
1375         const int i_lt = p_input->p->control[i-1].i_type;
1376         const int i_ct = p_input->p->control[i].i_type;
1377
1378         /* XXX We can't merge INPUT_CONTROL_SET_ES */
1379 /*        msg_Dbg( p_input, "[%d/%d] l=%d c=%d", i, p_input->p->i_control,
1380                  i_lt, i_ct );
1381 */
1382         if( i_lt == i_ct &&
1383             ( i_ct == INPUT_CONTROL_SET_STATE ||
1384               i_ct == INPUT_CONTROL_SET_RATE ||
1385               i_ct == INPUT_CONTROL_SET_POSITION ||
1386               i_ct == INPUT_CONTROL_SET_TIME ||
1387               i_ct == INPUT_CONTROL_SET_PROGRAM ||
1388               i_ct == INPUT_CONTROL_SET_TITLE ||
1389               i_ct == INPUT_CONTROL_SET_SEEKPOINT ||
1390               i_ct == INPUT_CONTROL_SET_BOOKMARK ) )
1391         {
1392             int j;
1393 //            msg_Dbg( p_input, "merged at %d", i );
1394             /* Remove the i-1 */
1395             for( j = i; j <  p_input->p->i_control; j++ )
1396                 p_input->p->control[j-1] = p_input->p->control[j];
1397             p_input->p->i_control--;
1398         }
1399         else
1400         {
1401             /* TODO but that's not that important
1402                 - merge SET_X with SET_X_CMD
1403                 - remove SET_SEEKPOINT/SET_POSITION/SET_TIME before a SET_TITLE
1404                 - remove SET_SEEKPOINT/SET_POSITION/SET_TIME before another among them
1405                 - ?
1406                 */
1407         }
1408     }
1409 }
1410
1411 static vlc_bool_t Control( input_thread_t *p_input, int i_type,
1412                            vlc_value_t val )
1413 {
1414     vlc_bool_t b_force_update = VLC_FALSE;
1415
1416     if( !p_input ) return b_force_update;
1417
1418     switch( i_type )
1419     {
1420         case INPUT_CONTROL_SET_DIE:
1421             msg_Dbg( p_input, "control: stopping input" );
1422             /* Mark all submodules to die */
1423             if( p_input->p->input.p_access )
1424                 p_input->p->input.p_access->b_die = VLC_TRUE;
1425             if( p_input->p->input.p_stream )
1426                 p_input->p->input.p_stream->b_die = VLC_TRUE;
1427             p_input->p->input.p_demux->b_die = VLC_TRUE;
1428
1429             p_input->b_die = VLC_TRUE;
1430             break;
1431
1432         case INPUT_CONTROL_SET_POSITION:
1433         case INPUT_CONTROL_SET_POSITION_OFFSET:
1434         {
1435             double f_pos;
1436             if( i_type == INPUT_CONTROL_SET_POSITION )
1437             {
1438                 f_pos = val.f_float;
1439             }
1440             else
1441             {
1442                 /* Should not fail */
1443                 demux2_Control( p_input->p->input.p_demux,
1444                                 DEMUX_GET_POSITION, &f_pos );
1445                 f_pos += val.f_float;
1446             }
1447             if( f_pos < 0.0 ) f_pos = 0.0;
1448             if( f_pos > 1.0 ) f_pos = 1.0;
1449             /* Reset the decoders states and clock sync (before calling the demuxer */
1450             es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1451             input_EsOutDiscontinuity( p_input->p->p_es_out, VLC_FALSE );
1452             if( demux2_Control( p_input->p->input.p_demux, DEMUX_SET_POSITION,
1453                                 f_pos ) )
1454             {
1455                 msg_Err( p_input, "INPUT_CONTROL_SET_POSITION(_OFFSET) "
1456                          "%2.1f%% failed", f_pos * 100 );
1457             }
1458             else
1459             {
1460                 if( p_input->p->i_slave > 0 )
1461                     SlaveSeek( p_input );
1462
1463                 b_force_update = VLC_TRUE;
1464             }
1465             break;
1466         }
1467
1468         case INPUT_CONTROL_SET_TIME:
1469         case INPUT_CONTROL_SET_TIME_OFFSET:
1470         {
1471             int64_t i_time;
1472             int i_ret;
1473
1474             if( i_type == INPUT_CONTROL_SET_TIME )
1475             {
1476                 i_time = val.i_time;
1477             }
1478             else
1479             {
1480                 /* Should not fail */
1481                 demux2_Control( p_input->p->input.p_demux,
1482                                 DEMUX_GET_TIME, &i_time );
1483                 i_time += val.i_time;
1484             }
1485             if( i_time < 0 ) i_time = 0;
1486
1487             /* Reset the decoders states and clock sync (before calling the demuxer */
1488             es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1489             input_EsOutDiscontinuity( p_input->p->p_es_out, VLC_FALSE );
1490
1491             i_ret = demux2_Control( p_input->p->input.p_demux,
1492                                     DEMUX_SET_TIME, i_time );
1493             if( i_ret )
1494             {
1495                 int64_t i_length;
1496
1497                 /* Emulate it with a SET_POS */
1498                 demux2_Control( p_input->p->input.p_demux,
1499                                 DEMUX_GET_LENGTH, &i_length );
1500                 if( i_length > 0 )
1501                 {
1502                     double f_pos = (double)i_time / (double)i_length;
1503                     i_ret = demux2_Control( p_input->p->input.p_demux,
1504                                             DEMUX_SET_POSITION, f_pos );
1505                 }
1506             }
1507             if( i_ret )
1508             {
1509                 msg_Warn( p_input, "INPUT_CONTROL_SET_TIME(_OFFSET) "I64Fd
1510                          " failed or not possible", i_time );
1511             }
1512             else
1513             {
1514                 if( p_input->p->i_slave > 0 )
1515                     SlaveSeek( p_input );
1516
1517                 b_force_update = VLC_TRUE;
1518             }
1519             break;
1520         }
1521
1522         case INPUT_CONTROL_SET_STATE:
1523             if( ( val.i_int == PLAYING_S && p_input->i_state == PAUSE_S ) ||
1524                 ( val.i_int == PAUSE_S && p_input->i_state == PAUSE_S ) )
1525             {
1526                 int i_ret;
1527                 if( p_input->p->input.p_access )
1528                     i_ret = access2_Control( p_input->p->input.p_access,
1529                                              ACCESS_SET_PAUSE_STATE, VLC_FALSE );
1530                 else
1531                     i_ret = demux2_Control( p_input->p->input.p_demux,
1532                                             DEMUX_SET_PAUSE_STATE, VLC_FALSE );
1533
1534                 if( i_ret )
1535                 {
1536                     /* FIXME What to do ? */
1537                     msg_Warn( p_input, "cannot unset pause -> EOF" );
1538                     vlc_mutex_unlock( &p_input->p->lock_control );
1539                     input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL );
1540                     vlc_mutex_lock( &p_input->p->lock_control );
1541                 }
1542
1543                 b_force_update = VLC_TRUE;
1544
1545                 /* Switch to play */
1546                 p_input->i_state = PLAYING_S;
1547                 val.i_int = PLAYING_S;
1548                 var_Change( p_input, "state", VLC_VAR_SETVALUE, &val, NULL );
1549
1550                 /* Reset clock */
1551                 es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1552                 input_EsOutDiscontinuity( p_input->p->p_es_out, VLC_FALSE );
1553             }
1554             else if( val.i_int == PAUSE_S && p_input->i_state == PLAYING_S &&
1555                      p_input->p->b_can_pause )
1556             {
1557                 int i_ret;
1558                 if( p_input->p->input.p_access )
1559                     i_ret = access2_Control( p_input->p->input.p_access,
1560                                              ACCESS_SET_PAUSE_STATE, VLC_TRUE );
1561                 else
1562                     i_ret = demux2_Control( p_input->p->input.p_demux,
1563                                             DEMUX_SET_PAUSE_STATE, VLC_TRUE );
1564
1565                 b_force_update = VLC_TRUE;
1566
1567                 if( i_ret )
1568                 {
1569                     msg_Warn( p_input, "cannot set pause state" );
1570                     val.i_int = p_input->i_state;
1571                 }
1572                 else
1573                 {
1574                     val.i_int = PAUSE_S;
1575                 }
1576
1577                 /* Switch to new state */
1578                 p_input->i_state = val.i_int;
1579                 var_Change( p_input, "state", VLC_VAR_SETVALUE, &val, NULL );
1580             }
1581             else if( val.i_int == PAUSE_S && !p_input->p->b_can_pause )
1582             {
1583                 b_force_update = VLC_TRUE;
1584
1585                 /* Correct "state" value */
1586                 val.i_int = p_input->i_state;
1587                 var_Change( p_input, "state", VLC_VAR_SETVALUE, &val, NULL );
1588             }
1589             else if( val.i_int != PLAYING_S && val.i_int != PAUSE_S )
1590             {
1591                 msg_Err( p_input, "invalid state in INPUT_CONTROL_SET_STATE" );
1592             }
1593             break;
1594
1595         case INPUT_CONTROL_SET_RATE:
1596         case INPUT_CONTROL_SET_RATE_SLOWER:
1597         case INPUT_CONTROL_SET_RATE_FASTER:
1598         {
1599             int i_rate;
1600
1601             if( i_type == INPUT_CONTROL_SET_RATE_SLOWER )
1602                 i_rate = p_input->p->i_rate * 2;
1603             else if( i_type == INPUT_CONTROL_SET_RATE_FASTER )
1604                 i_rate = p_input->p->i_rate / 2;
1605             else
1606                 i_rate = val.i_int;
1607
1608             if( i_rate < INPUT_RATE_MIN )
1609             {
1610                 msg_Dbg( p_input, "cannot set rate faster" );
1611                 i_rate = INPUT_RATE_MIN;
1612             }
1613             else if( i_rate > INPUT_RATE_MAX )
1614             {
1615                 msg_Dbg( p_input, "cannot set rate slower" );
1616                 i_rate = INPUT_RATE_MAX;
1617             }
1618             if( i_rate != INPUT_RATE_DEFAULT &&
1619                 ( !p_input->b_can_pace_control ||
1620                   ( p_input->p->p_sout && !p_input->p->b_out_pace_control ) ) )
1621             {
1622                 msg_Dbg( p_input, "cannot change rate" );
1623                 i_rate = INPUT_RATE_DEFAULT;
1624             }
1625             if( i_rate != p_input->p->i_rate )
1626             {
1627                 p_input->p->i_rate  = i_rate;
1628                 val.i_int = i_rate;
1629                 var_Change( p_input, "rate", VLC_VAR_SETVALUE, &val, NULL );
1630
1631                 /* We haven't send data to decoder when rate != default */
1632                 if( i_rate == INPUT_RATE_DEFAULT )
1633                     input_EsOutDiscontinuity( p_input->p->p_es_out, VLC_TRUE );
1634
1635                 /* Reset clock */
1636                 es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1637
1638                 b_force_update = VLC_TRUE;
1639             }
1640             break;
1641         }
1642
1643         case INPUT_CONTROL_SET_PROGRAM:
1644             /* No need to force update, es_out does it if needed */
1645             es_out_Control( p_input->p->p_es_out,
1646                             ES_OUT_SET_GROUP, val.i_int );
1647
1648             demux2_Control( p_input->p->input.p_demux, DEMUX_SET_GROUP, val.i_int,
1649                             NULL );
1650             break;
1651
1652         case INPUT_CONTROL_SET_ES:
1653             /* No need to force update, es_out does it if needed */
1654             es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ES,
1655                             input_EsOutGetFromID( p_input->p->p_es_out,
1656                                                   val.i_int ) );
1657             break;
1658
1659         case INPUT_CONTROL_SET_AUDIO_DELAY:
1660             input_EsOutSetDelay( p_input->p->p_es_out,
1661                                  AUDIO_ES, val.i_time );
1662             var_Change( p_input, "audio-delay", VLC_VAR_SETVALUE, &val, NULL );
1663             break;
1664
1665         case INPUT_CONTROL_SET_SPU_DELAY:
1666             input_EsOutSetDelay( p_input->p->p_es_out,
1667                                  SPU_ES, val.i_time );
1668             var_Change( p_input, "spu-delay", VLC_VAR_SETVALUE, &val, NULL );
1669             break;
1670
1671         case INPUT_CONTROL_SET_TITLE:
1672         case INPUT_CONTROL_SET_TITLE_NEXT:
1673         case INPUT_CONTROL_SET_TITLE_PREV:
1674             if( p_input->p->input.b_title_demux &&
1675                 p_input->p->input.i_title > 0 )
1676             {
1677                 /* TODO */
1678                 /* FIXME handle demux title */
1679                 demux_t *p_demux = p_input->p->input.p_demux;
1680                 int i_title;
1681
1682                 if( i_type == INPUT_CONTROL_SET_TITLE_PREV )
1683                     i_title = p_demux->info.i_title - 1;
1684                 else if( i_type == INPUT_CONTROL_SET_TITLE_NEXT )
1685                     i_title = p_demux->info.i_title + 1;
1686                 else
1687                     i_title = val.i_int;
1688
1689                 if( i_title >= 0 && i_title < p_input->p->input.i_title )
1690                 {
1691                     input_EsOutDiscontinuity( p_input->p->p_es_out, VLC_FALSE );
1692                     es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1693
1694                     demux2_Control( p_demux, DEMUX_SET_TITLE, i_title );
1695                     input_ControlVarTitle( p_input, i_title );
1696                 }
1697             }
1698             else if( p_input->p->input.i_title > 0 )
1699             {
1700                 access_t *p_access = p_input->p->input.p_access;
1701                 int i_title;
1702
1703                 if( i_type == INPUT_CONTROL_SET_TITLE_PREV )
1704                     i_title = p_access->info.i_title - 1;
1705                 else if( i_type == INPUT_CONTROL_SET_TITLE_NEXT )
1706                     i_title = p_access->info.i_title + 1;
1707                 else
1708                     i_title = val.i_int;
1709
1710                 if( i_title >= 0 && i_title < p_input->p->input.i_title )
1711                 {
1712                     input_EsOutDiscontinuity( p_input->p->p_es_out, VLC_FALSE );
1713                     es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1714
1715                     access2_Control( p_access, ACCESS_SET_TITLE, i_title );
1716                     stream_AccessReset( p_input->p->input.p_stream );
1717                 }
1718             }
1719             break;
1720         case INPUT_CONTROL_SET_SEEKPOINT:
1721         case INPUT_CONTROL_SET_SEEKPOINT_NEXT:
1722         case INPUT_CONTROL_SET_SEEKPOINT_PREV:
1723             if( p_input->p->input.b_title_demux &&
1724                 p_input->p->input.i_title > 0 )
1725             {
1726                 demux_t *p_demux = p_input->p->input.p_demux;
1727                 int i_seekpoint;
1728                 int64_t i_input_time;
1729                 int64_t i_seekpoint_time;
1730
1731                 if( i_type == INPUT_CONTROL_SET_SEEKPOINT_PREV )
1732                 {
1733                     i_seekpoint = p_demux->info.i_seekpoint;
1734                     i_seekpoint_time = p_input->p->input.title[p_demux->info.i_title]->seekpoint[i_seekpoint]->i_time_offset;
1735                     if( i_seekpoint_time >= 0 &&
1736                          !demux2_Control( p_demux,
1737                                           DEMUX_GET_TIME, &i_input_time ) )
1738                     {
1739                         if ( i_input_time < i_seekpoint_time + 3000000 )
1740                             i_seekpoint--;
1741                     }
1742                     else
1743                         i_seekpoint--;
1744                 }
1745                 else if( i_type == INPUT_CONTROL_SET_SEEKPOINT_NEXT )
1746                     i_seekpoint = p_demux->info.i_seekpoint + 1;
1747                 else
1748                     i_seekpoint = val.i_int;
1749
1750                 if( i_seekpoint >= 0 && i_seekpoint <
1751                     p_input->p->input.title[p_demux->info.i_title]->i_seekpoint )
1752                 {
1753                     input_EsOutDiscontinuity( p_input->p->p_es_out, VLC_FALSE );
1754                     es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1755
1756                     demux2_Control( p_demux, DEMUX_SET_SEEKPOINT, i_seekpoint );
1757                 }
1758             }
1759             else if( p_input->p->input.i_title > 0 )
1760             {
1761                 demux_t *p_demux = p_input->p->input.p_demux;
1762                 access_t *p_access = p_input->p->input.p_access;
1763                 int i_seekpoint;
1764                 int64_t i_input_time;
1765                 int64_t i_seekpoint_time;
1766
1767                 if( i_type == INPUT_CONTROL_SET_SEEKPOINT_PREV )
1768                 {
1769                     i_seekpoint = p_access->info.i_seekpoint;
1770                     i_seekpoint_time = p_input->p->input.title[p_access->info.i_title]->seekpoint[i_seekpoint]->i_time_offset;
1771                     if( i_seekpoint_time >= 0 &&
1772                         demux2_Control( p_demux,
1773                                         DEMUX_GET_TIME, &i_input_time ) )
1774                     {
1775                         if ( i_input_time < i_seekpoint_time + 3000000 )
1776                             i_seekpoint--;
1777                     }
1778                     else
1779                         i_seekpoint--;
1780                 }
1781                 else if( i_type == INPUT_CONTROL_SET_SEEKPOINT_NEXT ) 
1782                     i_seekpoint = p_access->info.i_seekpoint + 1;
1783                 else
1784                     i_seekpoint = val.i_int;
1785
1786                 if( i_seekpoint >= 0 && i_seekpoint <
1787                     p_input->p->input.title[p_access->info.i_title]->i_seekpoint )
1788                 {
1789                     input_EsOutDiscontinuity( p_input->p->p_es_out, VLC_FALSE );
1790                     es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1791
1792                     access2_Control( p_access, ACCESS_SET_SEEKPOINT,
1793                                     i_seekpoint );
1794                     stream_AccessReset( p_input->p->input.p_stream );
1795                 }
1796             }
1797             break;
1798
1799         case INPUT_CONTROL_ADD_SLAVE:
1800             if( val.psz_string )
1801             {
1802                 input_source_t *slave = InputSourceNew( p_input );
1803
1804                 if( !InputSourceInit( p_input, slave, val.psz_string, NULL ) )
1805                 {
1806                     vlc_meta_t *p_meta = p_input->p->input.p_item->p_meta;
1807                     int64_t i_time;
1808
1809                     /* Add the slave */
1810                     msg_Dbg( p_input, "adding %s as slave on the fly",
1811                              val.psz_string );
1812
1813                     /* Set position */
1814                     if( demux2_Control( p_input->p->input.p_demux,
1815                                         DEMUX_GET_TIME, &i_time ) )
1816                     {
1817                         msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" );
1818                         InputSourceClean( p_input, slave );
1819                         free( slave );
1820                         break;
1821                     }
1822                     if( demux2_Control( slave->p_demux,
1823                                         DEMUX_SET_TIME, i_time ) )
1824                     {
1825                         msg_Err( p_input, "seek failed for new slave" );
1826                         InputSourceClean( p_input, slave );
1827                         free( slave );
1828                         break;
1829                     }
1830
1831                     /* Get meta (access and demux) */
1832                     access2_Control( slave->p_access, ACCESS_GET_META,
1833                                      p_meta );
1834                     demux2_Control( slave->p_demux, DEMUX_GET_META, p_meta );
1835                     UpdateMeta( p_input );
1836
1837                     TAB_APPEND( p_input->p->i_slave, p_input->p->slave, slave );
1838                 }
1839                 else
1840                 {
1841                     free( slave );
1842                     msg_Warn( p_input, "failed to add %s as slave",
1843                               val.psz_string );
1844                 }
1845
1846                 free( val.psz_string );
1847             }
1848             break;
1849
1850         case INPUT_CONTROL_SET_BOOKMARK:
1851         default:
1852             msg_Err( p_input, "not yet implemented" );
1853             break;
1854     }
1855
1856     return b_force_update;
1857 }
1858
1859 /*****************************************************************************
1860  * UpdateFromDemux:
1861  *****************************************************************************/
1862 static int UpdateFromDemux( input_thread_t *p_input )
1863 {
1864     demux_t *p_demux = p_input->p->input.p_demux;
1865     vlc_value_t v;
1866
1867     if( p_demux->info.i_update & INPUT_UPDATE_TITLE )
1868     {
1869         v.i_int = p_demux->info.i_title;
1870         var_Change( p_input, "title", VLC_VAR_SETVALUE, &v, NULL );
1871
1872         input_ControlVarTitle( p_input, p_demux->info.i_title );
1873
1874         p_demux->info.i_update &= ~INPUT_UPDATE_TITLE;
1875     }
1876     if( p_demux->info.i_update & INPUT_UPDATE_SEEKPOINT )
1877     {
1878         v.i_int = p_demux->info.i_seekpoint;
1879         var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &v, NULL);
1880
1881         p_demux->info.i_update &= ~INPUT_UPDATE_SEEKPOINT;
1882     }
1883     p_demux->info.i_update &= ~INPUT_UPDATE_SIZE;
1884
1885     /* Hmmm only works with master input */
1886     if( p_input->p->input.p_demux == p_demux )
1887     {
1888         int i_title_end = p_input->p->input.i_title_end -
1889             p_input->p->input.i_title_offset;
1890         int i_seekpoint_end = p_input->p->input.i_seekpoint_end -
1891             p_input->p->input.i_seekpoint_offset;
1892
1893         if( i_title_end >= 0 && i_seekpoint_end >= 0 )
1894         {
1895             if( p_demux->info.i_title > i_title_end ||
1896                 ( p_demux->info.i_title == i_title_end &&
1897                   p_demux->info.i_seekpoint > i_seekpoint_end ) ) return 0;
1898         }
1899         else if( i_seekpoint_end >=0 )
1900         {
1901             if( p_demux->info.i_seekpoint > i_seekpoint_end ) return 0;
1902         }
1903         else if( i_title_end >= 0 )
1904         {
1905             if( p_demux->info.i_title > i_title_end ) return 0;
1906         }
1907     }
1908
1909     return 1;
1910 }
1911
1912 /*****************************************************************************
1913  * UpdateFromAccess:
1914  *****************************************************************************/
1915 static int UpdateFromAccess( input_thread_t *p_input )
1916 {
1917     access_t *p_access = p_input->p->input.p_access;
1918     vlc_value_t v;
1919
1920     if( p_access->info.i_update & INPUT_UPDATE_TITLE )
1921     {
1922         v.i_int = p_access->info.i_title;
1923         var_Change( p_input, "title", VLC_VAR_SETVALUE, &v, NULL );
1924
1925         input_ControlVarTitle( p_input, p_access->info.i_title );
1926
1927         stream_AccessUpdate( p_input->p->input.p_stream );
1928
1929         p_access->info.i_update &= ~INPUT_UPDATE_TITLE;
1930     }
1931     if( p_access->info.i_update & INPUT_UPDATE_SEEKPOINT )
1932     {
1933         v.i_int = p_access->info.i_seekpoint;
1934         var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &v, NULL);
1935         p_access->info.i_update &= ~INPUT_UPDATE_SEEKPOINT;
1936     }
1937     if( p_access->info.i_update & INPUT_UPDATE_META )
1938     {
1939         /* TODO maybe multi - access ? */
1940         vlc_meta_t *p_meta = p_input->p->input.p_item->p_meta;
1941         access2_Control( p_input->p->input.p_access,ACCESS_GET_META, p_meta );
1942         UpdateMeta( p_input );
1943         var_SetBool( p_input, "item-change", p_input->p->input.p_item->i_id );
1944         p_access->info.i_update &= ~INPUT_UPDATE_META;
1945     }
1946
1947     p_access->info.i_update &= ~INPUT_UPDATE_SIZE;
1948
1949     /* Hmmm only works with master input */
1950     if( p_input->p->input.p_access == p_access )
1951     {
1952         int i_title_end = p_input->p->input.i_title_end -
1953             p_input->p->input.i_title_offset;
1954         int i_seekpoint_end = p_input->p->input.i_seekpoint_end -
1955             p_input->p->input.i_seekpoint_offset;
1956
1957         if( i_title_end >= 0 && i_seekpoint_end >=0 )
1958         {
1959             if( p_access->info.i_title > i_title_end ||
1960                 ( p_access->info.i_title == i_title_end &&
1961                   p_access->info.i_seekpoint > i_seekpoint_end ) ) return 0;
1962         }
1963         else if( i_seekpoint_end >=0 )
1964         {
1965             if( p_access->info.i_seekpoint > i_seekpoint_end ) return 0;
1966         }
1967         else if( i_title_end >= 0 )
1968         {
1969             if( p_access->info.i_title > i_title_end ) return 0;
1970         }
1971     }
1972
1973     return 1;
1974 }
1975
1976 /*****************************************************************************
1977  * UpdateMeta:
1978  *****************************************************************************/
1979 static int  UpdateMeta( input_thread_t *p_input )
1980 {
1981     vlc_meta_t *p_meta = p_input->p->input.p_item->p_meta;
1982     if( !p_meta )
1983         return VLC_SUCCESS;
1984
1985     if( p_meta->psz_title && !p_input->p->input.p_item->b_fixed_name )
1986         input_Control( p_input, INPUT_SET_NAME, p_meta->psz_title );
1987
1988     /** \todo handle sout meta */
1989
1990     return VLC_SUCCESS;
1991 }
1992
1993 /*****************************************************************************
1994  * UpdateItemLength:
1995  *****************************************************************************/
1996 static void UpdateItemLength( input_thread_t *p_input, int64_t i_length )
1997 {
1998     vlc_mutex_lock( &p_input->p->input.p_item->lock );
1999     p_input->p->input.p_item->i_duration = i_length;
2000     vlc_mutex_unlock( &p_input->p->input.p_item->lock );
2001
2002     if( !p_input->b_preparsing )
2003     {
2004         pl_Yield( p_input );
2005         var_SetInteger( pl_Get( p_input ), "item-change",
2006                         p_input->p->input.p_item->i_id );
2007         pl_Release( p_input )
2008     }
2009 }
2010
2011 /*****************************************************************************
2012  * InputSourceNew:
2013  *****************************************************************************/
2014 static input_source_t *InputSourceNew( input_thread_t *p_input )
2015 {
2016     input_source_t *in = (input_source_t*) malloc( sizeof( input_source_t ) );
2017
2018     if( !in )
2019     {
2020         msg_Err( p_input, "out of memory for new input source" );
2021         return NULL;
2022     }
2023
2024     in->p_item   = NULL;
2025     in->p_access = NULL;
2026     in->p_stream = NULL;
2027     in->p_demux  = NULL;
2028     in->b_title_demux = VLC_FALSE;
2029     in->i_title  = 0;
2030     in->title    = NULL;
2031     in->b_can_pace_control = VLC_TRUE;
2032     in->b_eof = VLC_FALSE;
2033     in->i_cr_average = 0;
2034
2035     return in;
2036 }
2037
2038 /*****************************************************************************
2039  * InputSourceInit:
2040  *****************************************************************************/
2041 static int InputSourceInit( input_thread_t *p_input,
2042                             input_source_t *in, const char *psz_mrl,
2043                             const char *psz_forced_demux )
2044 {
2045     char psz_dup[strlen (psz_mrl) + 1];
2046     const char *psz_access;
2047     const char *psz_demux;
2048     char *psz_path;
2049     char *psz_tmp;
2050     char *psz;
2051     vlc_value_t val;
2052
2053     strcpy (psz_dup, psz_mrl);
2054
2055     if( !in ) return VLC_EGENERIC;
2056     if( !p_input ) return VLC_EGENERIC;
2057
2058     /* Split uri */
2059     if( !p_input->b_preparsing )
2060     {
2061         MRLSplit( VLC_OBJECT(p_input), psz_dup,
2062                   &psz_access, &psz_demux, &psz_path );
2063
2064         msg_Dbg( p_input, "`%s' gives access `%s' demux `%s' path `%s'",
2065                  psz_mrl, psz_access, psz_demux, psz_path );
2066
2067         /* Hack to allow udp://@:port syntax */
2068         if( !psz_access ||
2069             (strncmp( psz_access, "udp", 3 ) &&
2070              strncmp( psz_access, "rtp", 3 )) )
2071
2072         /* Find optional titles and seekpoints */
2073         MRLSections( p_input, psz_path, &in->i_title_start, &in->i_title_end,
2074                      &in->i_seekpoint_start, &in->i_seekpoint_end );
2075
2076         if( psz_forced_demux && *psz_forced_demux )
2077         {
2078             psz_demux = psz_forced_demux;
2079         }
2080         else if( !psz_demux || *psz_demux == '\0' )
2081         {
2082             /* special hack for forcing a demuxer with --demux=module
2083              * (and do nothing with a list) */
2084             char *psz_var_demux = var_GetString( p_input, "demux" );
2085
2086             if( *psz_var_demux != '\0' &&
2087                 !strchr(psz_var_demux, ',' ) &&
2088                 !strchr(psz_var_demux, ':' ) )
2089             {
2090                 psz_demux = psz_var_demux;
2091
2092                 msg_Dbg( p_input, "enforced demux ` %s'", psz_demux );
2093             }
2094             else if( psz_var_demux )
2095             {
2096                 free( psz_var_demux );
2097             }
2098         }
2099
2100         /* Try access_demux if no demux given */
2101         if( *psz_demux == '\0' )
2102         {
2103             in->p_demux = demux2_New( p_input, psz_access, psz_demux, psz_path,
2104                                       NULL, p_input->p->p_es_out, VLC_FALSE );
2105         }
2106     }
2107     else
2108     {
2109         psz_path = psz_dup;
2110         if( !strncmp( psz_path, "file://", 7 ) )
2111             psz_path += 7;
2112         msg_Dbg( p_input, "trying to pre-parse %s",  psz_path );
2113         psz_demux = "";
2114         psz_access = "file";
2115     }
2116
2117     if( in->p_demux )
2118     {
2119         int64_t i_pts_delay;
2120
2121         /* Get infos from access_demux */
2122         demux2_Control( in->p_demux,
2123                         DEMUX_GET_PTS_DELAY, &i_pts_delay );
2124         p_input->i_pts_delay = __MAX( p_input->i_pts_delay, i_pts_delay );
2125
2126         in->b_title_demux = VLC_TRUE;
2127         if( demux2_Control( in->p_demux, DEMUX_GET_TITLE_INFO,
2128                             &in->title, &in->i_title,
2129                             &in->i_title_offset, &in->i_seekpoint_offset ) )
2130         {
2131             in->i_title = 0;
2132             in->title   = NULL;
2133         }
2134         demux2_Control( in->p_demux, DEMUX_CAN_CONTROL_PACE,
2135                         &in->b_can_pace_control );
2136         demux2_Control( in->p_demux, DEMUX_CAN_PAUSE,
2137                         &in->b_can_pause );
2138
2139         /* FIXME todo
2140         demux2_Control( in->p_demux, DEMUX_CAN_SEEK,
2141                         &val.b_bool );
2142         */
2143     }
2144     else
2145     {
2146         int64_t i_pts_delay;
2147
2148         input_ChangeState( p_input, OPENING_S );
2149
2150         /* Now try a real access */
2151         in->p_access = access2_New( p_input, psz_access, psz_demux, psz_path,
2152                                     p_input->b_preparsing );
2153
2154         /* Access failed, URL encoded ? */
2155         if( in->p_access == NULL && strchr( psz_path, '%' ) )
2156         {
2157             decode_URI( psz_path );
2158
2159             msg_Dbg( p_input, "retrying with access `%s' demux `%s' path `%s'",
2160                      psz_access, psz_demux, psz_path );
2161
2162             in->p_access = access2_New( p_input,
2163                                         psz_access, psz_demux, psz_path,
2164                                         p_input->b_preparsing );
2165         }
2166
2167         if( in->p_access == NULL )
2168         {
2169             msg_Err( p_input, "open of `%s' failed: %s", psz_mrl,
2170                                                          msg_StackMsg() );
2171             intf_UserFatal( VLC_OBJECT( p_input), VLC_FALSE,
2172                             _("Your input can't be opened"),
2173                             _("VLC is unable to open the MRL '%s'."
2174                             " Check the log for details."), psz_mrl );
2175             goto error;
2176         }
2177
2178         /* */
2179         psz_tmp = psz = var_GetString( p_input, "access-filter" );
2180         while( psz && *psz )
2181         {
2182             access_t *p_access = in->p_access;
2183             char *end = strchr( psz, ':' );
2184
2185             if( end )
2186                 *end++ = '\0';
2187
2188             in->p_access = access2_FilterNew( in->p_access, psz );
2189             if( in->p_access == NULL )
2190             {
2191                 in->p_access = p_access;
2192                 msg_Warn( p_input, "failed to insert access filter %s",
2193                           psz );
2194             }
2195
2196             psz = end;
2197         }
2198         if( psz_tmp ) free( psz_tmp );
2199
2200         /* Get infos from access */
2201         if( !p_input->b_preparsing )
2202         {
2203             access2_Control( in->p_access,
2204                              ACCESS_GET_PTS_DELAY, &i_pts_delay );
2205             p_input->i_pts_delay = __MAX( p_input->i_pts_delay, i_pts_delay );
2206
2207             in->b_title_demux = VLC_FALSE;
2208             if( access2_Control( in->p_access, ACCESS_GET_TITLE_INFO,
2209                                  &in->title, &in->i_title,
2210                                 &in->i_title_offset, &in->i_seekpoint_offset ) )
2211
2212             {
2213                 in->i_title = 0;
2214                 in->title   = NULL;
2215             }
2216             access2_Control( in->p_access, ACCESS_CAN_CONTROL_PACE,
2217                              &in->b_can_pace_control );
2218             access2_Control( in->p_access, ACCESS_CAN_PAUSE,
2219                              &in->b_can_pause );
2220             access2_Control( in->p_access, ACCESS_CAN_SEEK,
2221                              &val.b_bool );
2222             var_Set( p_input, "seekable", val );
2223         }
2224
2225         input_ChangeState( p_input, BUFFERING_S );
2226
2227         /* Create the stream_t */
2228         in->p_stream = stream_AccessNew( in->p_access, p_input->b_preparsing );
2229         if( in->p_stream == NULL )
2230         {
2231             msg_Warn( p_input, "cannot create a stream_t from access" );
2232             goto error;
2233         }
2234
2235         /* Open a demuxer */
2236         if( *psz_demux == '\0' && *in->p_access->psz_demux )
2237         {
2238             psz_demux = in->p_access->psz_demux;
2239         }
2240         in->p_demux = demux2_New( p_input, psz_access, psz_demux, psz_path,
2241                                   in->p_stream, p_input->p->p_es_out,
2242                                   p_input->b_preparsing );
2243         if( in->p_demux == NULL )
2244         {
2245             msg_Err( p_input, "no suitable demux module for `%s/%s://%s'",
2246                      psz_access, psz_demux, psz_path );
2247             intf_UserFatal( VLC_OBJECT( p_input), VLC_FALSE, 
2248                             _("Can't recognize the input's format"),
2249                             _("The format of '%s' can't be detected. "
2250                             "Have a look the log for details."), psz_mrl );
2251             goto error;
2252         }
2253
2254         /* TODO get title from demux */
2255         if( !p_input->b_preparsing && in->i_title <= 0 )
2256         {
2257             if( demux2_Control( in->p_demux, DEMUX_GET_TITLE_INFO,
2258                                 &in->title, &in->i_title,
2259                                 &in->i_title_offset, &in->i_seekpoint_offset ))
2260             {
2261                 in->i_title = 0;
2262                 in->title   = NULL;
2263             }
2264             else
2265             {
2266                 in->b_title_demux = VLC_TRUE;
2267             }
2268         }
2269     }
2270
2271     if( var_GetInteger( p_input, "clock-synchro" ) != -1 )
2272         in->b_can_pace_control = !var_GetInteger( p_input, "clock-synchro" );
2273
2274     return VLC_SUCCESS;
2275
2276 error:
2277     input_ChangeState( p_input, ERROR_S );
2278
2279     if( in->p_demux )
2280         demux2_Delete( in->p_demux );
2281
2282     if( in->p_stream )
2283         stream_Delete( in->p_stream );
2284
2285     if( in->p_access )
2286         access2_Delete( in->p_access );
2287
2288     return VLC_EGENERIC;
2289 }
2290
2291 /*****************************************************************************
2292  * InputSourceClean:
2293  *****************************************************************************/
2294 static void InputSourceClean( input_thread_t *p_input, input_source_t *in )
2295 {
2296     if( in->p_demux )
2297         demux2_Delete( in->p_demux );
2298
2299     if( in->p_stream )
2300         stream_Delete( in->p_stream );
2301
2302     if( in->p_access )
2303         access2_Delete( in->p_access );
2304
2305     if( in->i_title > 0 )
2306     {
2307         int i;
2308         for( i = 0; i < in->i_title; i++ )
2309         {
2310             vlc_input_title_Delete( in->title[i] );
2311         }
2312         free( in->title );
2313     }
2314 }
2315
2316 static void SlaveDemux( input_thread_t *p_input )
2317 {
2318     int64_t i_time;
2319     int i;
2320
2321     if( demux2_Control( p_input->p->input.p_demux, DEMUX_GET_TIME, &i_time ) )
2322     {
2323         msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" );
2324         return;
2325     }
2326
2327     for( i = 0; i < p_input->p->i_slave; i++ )
2328     {
2329         input_source_t *in = p_input->p->slave[i];
2330         int i_ret = 1;
2331
2332         if( in->b_eof )
2333             continue;
2334
2335         if( demux2_Control( in->p_demux, DEMUX_SET_NEXT_DEMUX_TIME, i_time ) )
2336         {
2337             for( ;; )
2338             {
2339                 int64_t i_stime;
2340                 if( demux2_Control( in->p_demux, DEMUX_GET_TIME, &i_stime ) )
2341                 {
2342                     msg_Err( p_input, "slave[%d] doesn't like "
2343                              "DEMUX_GET_TIME -> EOF", i );
2344                     i_ret = 0;
2345                     break;
2346                 }
2347
2348                 if( i_stime >= i_time )
2349                     break;
2350
2351                 if( ( i_ret = in->p_demux->pf_demux( in->p_demux ) ) <= 0 )
2352                     break;
2353             }
2354         }
2355         else
2356         {
2357             i_ret = in->p_demux->pf_demux( in->p_demux );
2358         }
2359
2360         if( i_ret <= 0 )
2361         {
2362             msg_Dbg( p_input, "slave %d EOF", i );
2363             in->b_eof = VLC_TRUE;
2364         }
2365     }
2366 }
2367
2368 static void SlaveSeek( input_thread_t *p_input )
2369 {
2370     int64_t i_time;
2371     int i;
2372
2373     if( !p_input ) return;
2374
2375     if( demux2_Control( p_input->p->input.p_demux, DEMUX_GET_TIME, &i_time ) )
2376     {
2377         msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" );
2378         return;
2379     }
2380
2381     for( i = 0; i < p_input->p->i_slave; i++ )
2382     {
2383         input_source_t *in = p_input->p->slave[i];
2384
2385         if( demux2_Control( in->p_demux, DEMUX_SET_TIME, i_time ) )
2386         {
2387             msg_Err( p_input, "seek failed for slave %d -> EOF", i );
2388             in->b_eof = VLC_TRUE;
2389         }
2390     }
2391 }
2392
2393 /*****************************************************************************
2394  * InputMetaUser:
2395  *****************************************************************************/
2396 static void InputMetaUser( input_thread_t *p_input )
2397 {
2398     vlc_meta_t *p_meta = p_input->p->input.p_item->p_meta;
2399     vlc_value_t val;
2400
2401     if( !p_meta ) return;
2402
2403     /* Get meta information from user */
2404 #define GET_META( field, s ) \
2405     var_Get( p_input, (s), &val );  \
2406     if( *val.psz_string ) { \
2407         if( p_meta->psz_ ## field ) free ( p_meta->psz_ ## field ); \
2408         p_meta->psz_ ## field = strdup( val.psz_string ); \
2409     } \
2410     free( val.psz_string )
2411
2412     GET_META( title, "meta-title" );
2413     GET_META( artist, "meta-artist" );
2414     GET_META( genre, "meta-genre" );
2415     GET_META( copyright, "meta-copyright" );
2416     GET_META( description, "meta-description" );
2417     GET_META( date, "meta-date" );
2418     GET_META( url, "meta-url" );
2419 #undef GET_META
2420 }
2421
2422 /*****************************************************************************
2423  * MRLSplit: parse the access, demux and url part of the
2424  *           Media Resource Locator.
2425  *****************************************************************************/
2426 void MRLSplit( vlc_object_t *p_input, char *psz_dup,
2427                const char **ppsz_access, const char **ppsz_demux,
2428                char **ppsz_path )
2429 {
2430     const char *psz_access = "";
2431     const char *psz_demux  = "";
2432     char *psz_path;
2433     char *psz, *psz_check;
2434
2435     psz = strchr( psz_dup, ':' );
2436
2437     /* '@' not allowed in access/demux part */
2438     psz_check = strchr( psz_dup, '@' );
2439     if( psz_check && psz_check < psz ) psz = 0;
2440
2441 #if defined( WIN32 ) || defined( UNDER_CE )
2442     if( psz - psz_dup == 1 )
2443     {
2444         msg_Dbg( p_input, "drive letter %c: found in source", *psz_dup );
2445         psz_path = psz_dup;
2446     }
2447     else
2448 #endif
2449
2450     if( psz )
2451     {
2452         *psz++ = '\0';
2453         if( psz[0] == '/' && psz[1] == '/' ) psz += 2;
2454
2455         psz_path = psz;
2456
2457         psz = strchr( psz_dup, '/' );
2458         if( psz )
2459         {
2460             *psz++ = '\0';
2461             psz_demux = psz;
2462         }
2463
2464         psz_access = psz_dup;
2465     }
2466     else
2467     {
2468         psz_path = psz_dup;
2469     }
2470
2471     *ppsz_access = psz_access;
2472     *ppsz_demux = psz_demux;
2473     *ppsz_path = psz_path;
2474 }
2475
2476 /*****************************************************************************
2477  * MRLSections: parse title and seekpoint info from the Media Resource Locator.
2478  *
2479  * Syntax:
2480  * [url][@[title-start][:chapter-start][-[title-end][:chapter-end]]]
2481  *****************************************************************************/
2482 static void MRLSections( input_thread_t *p_input, char *psz_source,
2483                          int *pi_title_start, int *pi_title_end,
2484                          int *pi_chapter_start, int *pi_chapter_end )
2485 {
2486     char *psz, *psz_end, *psz_next, *psz_check;
2487
2488     *pi_title_start = *pi_title_end = -1;
2489     *pi_chapter_start = *pi_chapter_end = -1;
2490
2491     /* Start by parsing titles and chapters */
2492     if( !psz_source || !( psz = strrchr( psz_source, '@' ) ) ) return;
2493
2494     /* Check we are really dealing with a title/chapter section */
2495     psz_check = psz + 1;
2496     if( !*psz_check ) return;
2497     if( isdigit(*psz_check) ) strtol( psz_check, &psz_check, 0 );
2498     if( *psz_check != ':' && *psz_check != '-' && *psz_check ) return;
2499     if( *psz_check == ':' && ++psz_check )
2500         if( isdigit(*psz_check) ) strtol( psz_check, &psz_check, 0 );
2501     if( *psz_check != '-' && *psz_check ) return;
2502     if( *psz_check == '-' && ++psz_check )
2503         if( isdigit(*psz_check) ) strtol( psz_check, &psz_check, 0 );
2504     if( *psz_check != ':' && *psz_check ) return;
2505     if( *psz_check == ':' && ++psz_check )
2506         if( isdigit(*psz_check) ) strtol( psz_check, &psz_check, 0 );
2507     if( *psz_check ) return;
2508
2509     /* Separate start and end */
2510     *psz++ = 0;
2511     if( ( psz_end = strchr( psz, '-' ) ) ) *psz_end++ = 0;
2512
2513     /* Look for the start title */
2514     *pi_title_start = strtol( psz, &psz_next, 0 );
2515     if( !*pi_title_start && psz == psz_next ) *pi_title_start = -1;
2516     *pi_title_end = *pi_title_start;
2517     psz = psz_next;
2518
2519     /* Look for the start chapter */
2520     if( *psz ) psz++;
2521     *pi_chapter_start = strtol( psz, &psz_next, 0 );
2522     if( !*pi_chapter_start && psz == psz_next ) *pi_chapter_start = -1;
2523     *pi_chapter_end = *pi_chapter_start;
2524
2525     if( psz_end )
2526     {
2527         /* Look for the end title */
2528         *pi_title_end = strtol( psz_end, &psz_next, 0 );
2529         if( !*pi_title_end && psz_end == psz_next ) *pi_title_end = -1;
2530         psz_end = psz_next;
2531
2532         /* Look for the end chapter */
2533         if( *psz_end ) psz_end++;
2534         *pi_chapter_end = strtol( psz_end, &psz_next, 0 );
2535         if( !*pi_chapter_end && psz_end == psz_next ) *pi_chapter_end = -1;
2536     }
2537
2538     msg_Dbg( p_input, "source=`%s' title=%d/%d seekpoint=%d/%d",
2539              psz_source, *pi_title_start, *pi_chapter_start,
2540              *pi_title_end, *pi_chapter_end );
2541 }
2542
2543 /*****************************************************************************
2544  * input_AddSubtitles: add a subtitles file and enable it
2545  *****************************************************************************/
2546 vlc_bool_t input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle,
2547                                vlc_bool_t b_check_extension )
2548 {
2549     input_source_t *sub;
2550     vlc_value_t count;
2551     vlc_value_t list;
2552     char *psz_path, *psz_extension;
2553
2554     if( b_check_extension && !subtitles_Filter( psz_subtitle ) )
2555     {
2556         return VLC_FALSE;
2557     }
2558
2559     /* if we are provided a subtitle.sub file,
2560      * see if we don't have a subtitle.idx and use it instead */
2561     psz_path = strdup( psz_subtitle );
2562     if( psz_path )
2563     {
2564         psz_extension = strrchr( psz_path, '.');
2565         if( psz_extension && strcmp( psz_extension, ".sub" ) == 0 )
2566         {
2567             FILE *f;
2568
2569             strcpy( psz_extension, ".idx" );
2570             /* FIXME: a portable wrapper for stat() or access() would be more suited */
2571             if( ( f = utf8_fopen( psz_path, "rt" ) ) )
2572             {
2573                 fclose( f );
2574                 msg_Dbg( p_input, "using %s subtitles file instead of %s",
2575                          psz_path, psz_subtitle );
2576                 strcpy( psz_subtitle, psz_path );
2577             }
2578         }
2579         free( psz_path );
2580     }
2581
2582     var_Change( p_input, "spu-es", VLC_VAR_CHOICESCOUNT, &count, NULL );
2583
2584     sub = InputSourceNew( p_input );
2585     if( !InputSourceInit( p_input, sub, psz_subtitle, "subtitle" ) )
2586     {
2587         TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub );
2588
2589         /* Select the ES */
2590         if( !var_Change( p_input, "spu-es", VLC_VAR_GETLIST, &list, NULL ) )
2591         {
2592             if( count.i_int == 0 )
2593                 count.i_int++;
2594             /* if it was first one, there is disable too */
2595
2596             if( count.i_int < list.p_list->i_count )
2597             {
2598                 input_ControlPush( p_input, INPUT_CONTROL_SET_ES,
2599                                    &list.p_list->p_values[count.i_int] );
2600             }
2601             var_Change( p_input, "spu-es", VLC_VAR_FREELIST, &list, NULL );
2602         }
2603     }
2604     else free( sub );
2605
2606     return VLC_TRUE;
2607 }