?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pass 2nd variable 0 1 to distinguish a 2nd es
[vlc/multisubs.git] / src / input / input.c
blobce9614a0dce2fde2d8908cc8382007f995ea40c0
1 /*****************************************************************************
2 * input.c: input thread
3 *****************************************************************************
4 * Copyright (C) 1998-2007 VLC authors and VideoLAN
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 it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33
34 #include <limits.h>
35 #include <assert.h>
36 #include <errno.h>
37 #include <math.h>
38 #include <sys/stat.h>
39
40 #include "input_internal.h"
41 #include "event.h"
42 #include "es_out.h"
43 #include "es_out_timeshift.h"
44 #include "access.h"
45 #include "demux.h"
46 #include "stream.h"
47 #include "item.h"
48 #include "resource.h"
49
50 #include <vlc_sout.h>
51 #include <vlc_dialog.h>
52 #include <vlc_url.h>
53 #include <vlc_charset.h>
54 #include <vlc_fs.h>
55 #include <vlc_strings.h>
56 #include <vlc_modules.h>
57
58 /*****************************************************************************
59 * Local prototypes
60 *****************************************************************************/
61 static void *Run ( void * );
62
63 static input_thread_t * Create ( vlc_object_t *, input_item_t *,
64 const char *, bool, input_resource_t * );
65 static int Init ( input_thread_t *p_input );
66 static void End ( input_thread_t *p_input );
67 static void MainLoop( input_thread_t *p_input, bool b_interactive );
68
69 static inline int ControlPop( input_thread_t *, int *, vlc_value_t *, mtime_t i_deadline, bool b_postpone_seek );
70 static void ControlRelease( int i_type, vlc_value_t val );
71 static bool ControlIsSeekRequest( int i_type );
72 static bool Control( input_thread_t *, int, vlc_value_t );
73 static void ControlPause( input_thread_t *, mtime_t );
74
75 static int UpdateTitleSeekpointFromDemux( input_thread_t * );
76 static void UpdateGenericFromDemux( input_thread_t * );
77 static void UpdateTitleListfromDemux( input_thread_t * );
78
79 static void MRLSections( const char *, int *, int *, int *, int *);
80
81 static input_source_t *InputSourceNew( input_thread_t *);
82 static int InputSourceInit( input_thread_t *, input_source_t *,
83 const char *, const char *psz_forced_demux,
84 bool b_in_can_fail );
85 static void InputSourceClean( input_source_t * );
86 static void InputSourceMeta( input_thread_t *, input_source_t *, vlc_meta_t * );
87
88 /* TODO */
89 //static void InputGetAttachments( input_thread_t *, input_source_t * );
90 static void SlaveDemux( input_thread_t *p_input );
91 static void SlaveSeek( input_thread_t *p_input );
92
93 static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta );
94 static void InputUpdateMeta( input_thread_t *p_input, demux_t *p_demux );
95 static void InputGetExtraFiles( input_thread_t *p_input,
96 int *pi_list, char ***pppsz_list,
97 const char *psz_access, const char *psz_path );
98
99 static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_attachment, demux_t ***ppp_attachment_demux,
100 int i_new, input_attachment_t **pp_new, demux_t *p_demux );
101
102 enum {
103 SUB_NOFLAG = 0x00,
104 SUB_FORCED = 0x01,
105 SUB_CANFAIL = 0x02,
106 };
107
108 static void input_SubtitleAdd( input_thread_t *, const char *, unsigned );
109 static void input_SubtitleFileAdd( input_thread_t *, char *, unsigned );
110 static void input_ChangeState( input_thread_t *p_input, int i_state ); /* TODO fix name */
111
112 #undef input_Create
113 /**
114 * Create a new input_thread_t.
115 *
116 * You need to call input_Start on it when you are done
117 * adding callback on the variables/events you want to monitor.
118 *
119 * \param p_parent a vlc_object
120 * \param p_item an input item
121 * \param psz_log an optional prefix for this input logs
122 * \param p_resource an optional input ressource
123 * \return a pointer to the spawned input thread
124 */
125 input_thread_t *input_Create( vlc_object_t *p_parent,
126 input_item_t *p_item,
127 const char *psz_log, input_resource_t *p_resource )
128 {
129 return Create( p_parent, p_item, psz_log, false, p_resource );
130 }
131
132 #undef input_Read
133 /**
134 * Initialize an input thread and run it until it stops by itself.
135 *
136 * \param p_parent a vlc_object
137 * \param p_item an input item
138 * \return an error code, VLC_SUCCESS on success
139 */
140 int input_Read( vlc_object_t *p_parent, input_item_t *p_item )
141 {
142 input_thread_t *p_input = Create( p_parent, p_item, NULL, false, NULL );
143 if( !p_input )
144 return VLC_EGENERIC;
145
146 if( !Init( p_input ) )
147 {
148 MainLoop( p_input, false );
149 End( p_input );
150 }
151
152 vlc_object_release( p_input );
153 return VLC_SUCCESS;
154 }
155
156 /**
157 * Initialize an input and initialize it to preparse the item
158 * This function is blocking. It will only accept parsing regular files.
159 *
160 * \param p_parent a vlc_object_t
161 * \param p_item an input item
162 * \return VLC_SUCCESS or an error
163 */
164 int input_Preparse( vlc_object_t *p_parent, input_item_t *p_item )
165 {
166 input_thread_t *p_input;
167
168 /* Allocate descriptor */
169 p_input = Create( p_parent, p_item, NULL, true, NULL );
170 if( !p_input )
171 return VLC_EGENERIC;
172
173 if( !Init( p_input ) ) {
174 /* if the demux is a playlist, call Mainloop that will call
175 * demux_Demux in order to fetch sub items */
176 bool b_is_playlist = false;
177
178 if ( input_item_ShouldPreparseSubItems( p_item )
179 && demux_Control( p_input->p->input.p_demux,
180 DEMUX_IS_PLAYLIST,
181 &b_is_playlist ) )
182 b_is_playlist = false;
183 if( b_is_playlist )
184 MainLoop( p_input, false );
185 End( p_input );
186 }
187
188 vlc_object_release( p_input );
189
190 return VLC_SUCCESS;
191 }
192
193 /**
194 * Start a input_thread_t created by input_Create.
195 *
196 * You must not start an already running input_thread_t.
197 *
198 * \param the input thread to start
199 */
200 int input_Start( input_thread_t *p_input )
201 {
202 assert( !p_input->p->is_running );
203 /* Create thread and wait for its readiness. */
204 p_input->p->is_running = !vlc_clone( &p_input->p->thread,
205 Run, p_input, VLC_THREAD_PRIORITY_INPUT );
206 if( !p_input->p->is_running )
207 {
208 input_ChangeState( p_input, ERROR_S );
209 msg_Err( p_input, "cannot create input thread" );
210 return VLC_EGENERIC;
211 }
212 return VLC_SUCCESS;
213 }
214
215 /**
216 * Request a running input thread to stop and die
217 *
218 * \param p_input the input thread to stop
219 */
220 void input_Stop( input_thread_t *p_input )
221 {
222 input_thread_private_t *sys = p_input->p;
223
224 vlc_mutex_lock( &sys->lock_control );
225 /* Discard all pending controls */
226 for( int i = 0; i < sys->i_control; i++ )
227 {
228 input_control_t *ctrl = &sys->control[i];
229 ControlRelease( ctrl->i_type, ctrl->val );
230 }
231 sys->i_control = 0;
232 sys->is_stopped = true;
233 vlc_cond_signal( &sys->wait_control );
234 vlc_mutex_unlock( &sys->lock_control );
235 vlc_interrupt_kill( &sys->interrupt );
236 }
237
238 /**
239 * Close an input
240 *
241 * It does not call input_Stop itself.
242 */
243 void input_Close( input_thread_t *p_input )
244 {
245 if( p_input->p->is_running )
246 vlc_join( p_input->p->thread, NULL );
247 vlc_interrupt_deinit( &p_input->p->interrupt );
248 vlc_object_release( p_input );
249 }
250
251 /**
252 * Input destructor (called when the object's refcount reaches 0).
253 */
254 static void input_Destructor( vlc_object_t *obj )
255 {
256 input_thread_t *p_input = (input_thread_t *)obj;
257 #ifndef NDEBUG
258 char * psz_name = input_item_GetName( p_input->p->p_item );
259 msg_Dbg( p_input, "Destroying the input for '%s'", psz_name);
260 free( psz_name );
261 #endif
262
263 if( p_input->p->p_es_out_display )
264 es_out_Delete( p_input->p->p_es_out_display );
265
266 if( p_input->p->p_resource )
267 input_resource_Release( p_input->p->p_resource );
268 if( p_input->p->p_resource_private )
269 input_resource_Release( p_input->p->p_resource_private );
270
271 vlc_gc_decref( p_input->p->p_item );
272
273 vlc_mutex_destroy( &p_input->p->counters.counters_lock );
274
275 for( int i = 0; i < p_input->p->i_control; i++ )
276 {
277 input_control_t *p_ctrl = &p_input->p->control[i];
278 ControlRelease( p_ctrl->i_type, p_ctrl->val );
279 }
280
281 vlc_cond_destroy( &p_input->p->wait_control );
282 vlc_mutex_destroy( &p_input->p->lock_control );
283 free( p_input->p );
284 }
285
286 /**
287 * Get the item from an input thread
288 * FIXME it does not increase ref count of the item.
289 * if it is used after p_input is destroyed nothing prevent it from
290 * being freed.
291 */
292 input_item_t *input_GetItem( input_thread_t *p_input )
293 {
294 assert( p_input && p_input->p );
295 return p_input->p->p_item;
296 }
297
298 /*****************************************************************************
299 * This function creates a new input, and returns a pointer
300 * to its description. On error, it returns NULL.
301 *
302 * XXX Do not forget to update vlc_input.h if you add new variables.
303 *****************************************************************************/
304 static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
305 const char *psz_header, bool b_quick,
306 input_resource_t *p_resource )
307 {
308 input_thread_t *p_input = NULL; /* thread descriptor */
309
310 /* Allocate descriptor */
311 p_input = vlc_custom_create( p_parent, sizeof( *p_input ), "input" );
312 if( p_input == NULL )
313 return NULL;
314
315 /* Construct a nice name for the input timer */
316 char psz_timer_name[255];
317 char * psz_name = input_item_GetName( p_item );
318 snprintf( psz_timer_name, sizeof(psz_timer_name),
319 "input launching for '%s'", psz_name );
320
321 msg_Dbg( p_input, "Creating an input for '%s'", psz_name);
322
323 free( psz_name );
324
325 p_input->p = calloc( 1, sizeof( input_thread_private_t ) );
326 if( !p_input->p )
327 {
328 vlc_object_release( p_input );
329 return NULL;
330 }
331
332 /* Parse input options */
333 input_item_ApplyOptions( VLC_OBJECT(p_input), p_item );
334
335 p_input->b_preparsing = b_quick;
336 p_input->psz_header = psz_header ? strdup( psz_header ) : NULL;
337
338 /* Init Common fields */
339 p_input->p->b_can_pace_control = true;
340 p_input->p->i_start = 0;
341 p_input->p->i_time = 0;
342 p_input->p->i_stop = 0;
343 p_input->p->i_run = 0;
344 p_input->p->i_title = 0;
345 p_input->p->title = NULL;
346 p_input->p->i_title_offset = p_input->p->i_seekpoint_offset = 0;
347 p_input->p->i_state = INIT_S;
348 p_input->p->is_running = false;
349 p_input->p->is_stopped = false;
350 p_input->p->b_recording = false;
351 p_input->p->i_rate = INPUT_RATE_DEFAULT;
352 memset( &p_input->p->bookmark, 0, sizeof(p_input->p->bookmark) );
353 TAB_INIT( p_input->p->i_bookmark, p_input->p->pp_bookmark );
354 TAB_INIT( p_input->p->i_attachment, p_input->p->attachment );
355 p_input->p->attachment_demux = NULL;
356 p_input->p->p_sout = NULL;
357 p_input->p->b_out_pace_control = false;
358
359 vlc_gc_incref( p_item ); /* Released in Destructor() */
360 p_input->p->p_item = p_item;
361
362 /* Init Input fields */
363 p_input->p->input.p_demux = NULL;
364 p_input->p->input.b_title_demux = false;
365 p_input->p->input.i_title = 0;
366 p_input->p->input.title = NULL;
367 p_input->p->input.i_title_offset = p_input->p->input.i_seekpoint_offset = 0;
368 p_input->p->input.b_can_pace_control = true;
369 p_input->p->input.b_can_rate_control = true;
370 p_input->p->input.b_rescale_ts = true;
371 p_input->p->input.b_eof = false;
372
373 vlc_mutex_lock( &p_item->lock );
374
375 if( !p_item->p_stats )
376 p_item->p_stats = stats_NewInputStats( p_input );
377
378 /* setup the preparse depth of the item
379 * if we are preparsing, use the i_preparse_depth of the parent item */
380 if( !p_input->b_preparsing )
381 {
382 char *psz_rec = var_InheritString( p_parent, "recursive" );
383
384 if( psz_rec != NULL )
385 {
386 if ( !strcasecmp( psz_rec, "none" ) )
387 p_item->i_preparse_depth = 0;
388 else if ( !strcasecmp( psz_rec, "collapse" ) )
389 p_item->i_preparse_depth = 1;
390 else
391 p_item->i_preparse_depth = -1; /* default is expand */
392 free (psz_rec);
393 } else
394 p_item->i_preparse_depth = -1;
395 }
396
397 vlc_mutex_unlock( &p_item->lock );
398
399 /* No slave */
400 p_input->p->i_slave = 0;
401 p_input->p->slave = NULL;
402
403 /* */
404 if( p_resource )
405 {
406 p_input->p->p_resource_private = NULL;
407 p_input->p->p_resource = input_resource_Hold( p_resource );
408 }
409 else
410 {
411 p_input->p->p_resource_private = input_resource_New( VLC_OBJECT( p_input ) );
412 p_input->p->p_resource = input_resource_Hold( p_input->p->p_resource_private );
413 }
414 input_resource_SetInput( p_input->p->p_resource, p_input );
415
416 /* Init control buffer */
417 vlc_mutex_init( &p_input->p->lock_control );
418 vlc_cond_init( &p_input->p->wait_control );
419 p_input->p->i_control = 0;
420 vlc_interrupt_init(&p_input->p->interrupt);
421
422 /* Create Object Variables for private use only */
423 input_ConfigVarInit( p_input );
424
425 /* Create Objects variables for public Get and Set */
426 input_ControlVarInit( p_input );
427
428 /* */
429 if( !p_input->b_preparsing )
430 {
431 char *psz_bookmarks = var_GetNonEmptyString( p_input, "bookmarks" );
432 if( psz_bookmarks )
433 {
434 /* FIXME: have a common cfg parsing routine used by sout and others */
435 char *psz_parser, *psz_start, *psz_end;
436 psz_parser = psz_bookmarks;
437 while( (psz_start = strchr( psz_parser, '{' ) ) )
438 {
439 seekpoint_t *p_seekpoint;
440 char backup;
441 psz_start++;
442 psz_end = strchr( psz_start, '}' );
443 if( !psz_end ) break;
444 psz_parser = psz_end + 1;
445 backup = *psz_parser;
446 *psz_parser = 0;
447 *psz_end = ',';
448
449 p_seekpoint = vlc_seekpoint_New();
450 while( (psz_end = strchr( psz_start, ',' ) ) )
451 {
452 *psz_end = 0;
453 if( !strncmp( psz_start, "name=", 5 ) )
454 {
455 p_seekpoint->psz_name = strdup(psz_start + 5);
456 }
457 else if( !strncmp( psz_start, "bytes=", 6 ) )
458 {
459 p_seekpoint->i_byte_offset = atoll(psz_start + 6);
460 }
461 else if( !strncmp( psz_start, "time=", 5 ) )
462 {
463 p_seekpoint->i_time_offset = atoll(psz_start + 5) *
464 CLOCK_FREQ;
465 }
466 psz_start = psz_end + 1;
467 }
468 msg_Dbg( p_input, "adding bookmark: %s, bytes=%"PRId64", time=%"PRId64,
469 p_seekpoint->psz_name, p_seekpoint->i_byte_offset,
470 p_seekpoint->i_time_offset );
471 input_Control( p_input, INPUT_ADD_BOOKMARK, p_seekpoint );
472 vlc_seekpoint_Delete( p_seekpoint );
473 *psz_parser = backup;
474 }
475 free( psz_bookmarks );
476 }
477 }
478
479 /* Remove 'Now playing' info as it is probably outdated */
480 input_item_SetNowPlaying( p_item, NULL );
481 input_item_SetESNowPlaying( p_item, NULL );
482 input_SendEventMeta( p_input );
483
484 /* */
485 if( p_input->b_preparsing )
486 p_input->i_flags |= OBJECT_FLAGS_QUIET | OBJECT_FLAGS_NOINTERACT;
487
488 /* Make sure the interaction option is honored */
489 if( !var_InheritBool( p_input, "interact" ) )
490 p_input->i_flags |= OBJECT_FLAGS_NOINTERACT;
491
492 /* */
493 memset( &p_input->p->counters, 0, sizeof( p_input->p->counters ) );
494 vlc_mutex_init( &p_input->p->counters.counters_lock );
495
496 p_input->p->p_es_out_display = input_EsOutNew( p_input, p_input->p->i_rate );
497 p_input->p->p_es_out = NULL;
498
499 /* Set the destructor when we are sure we are initialized */
500 vlc_object_set_destructor( p_input, input_Destructor );
501
502 return p_input;
503 }
504
505 /*****************************************************************************
506 * Run: main thread loop
507 * This is the "normal" thread that spawns the input processing chain,
508 * reads the stream, cleans up and waits
509 *****************************************************************************/
510 static void *Run( void *obj )
511 {
512 input_thread_t *p_input = (input_thread_t *)obj;
513
514 vlc_interrupt_set(&p_input->p->interrupt);
515
516 if( !Init( p_input ) )
517 {
518 MainLoop( p_input, true ); /* FIXME it can be wrong (like with VLM) */
519
520 /* Clean up */
521 End( p_input );
522 }
523
524 input_SendEventDead( p_input );
525 return NULL;
526 }
527
528 bool input_Stopped( input_thread_t *input )
529 {
530 input_thread_private_t *sys = input->p;
531 bool ret;
532
533 vlc_mutex_lock( &sys->lock_control );
534 ret = sys->is_stopped;
535 vlc_mutex_unlock( &sys->lock_control );
536 return ret;
537 }
538
539 /*****************************************************************************
540 * Main loop: Fill buffers from access, and demux
541 *****************************************************************************/
542
543 /**
544 * MainLoopDemux
545 * It asks the demuxer to demux some data
546 */
547 static void MainLoopDemux( input_thread_t *p_input, bool *pb_changed, mtime_t i_start_mdate )
548 {
549 int i_ret;
550
551 *pb_changed = false;
552
553 if( ( p_input->p->i_stop > 0 && p_input->p->i_time >= p_input->p->i_stop ) ||
554 ( p_input->p->i_run > 0 && i_start_mdate+p_input->p->i_run < mdate() ) )
555 i_ret = 0; /* EOF */
556 else
557 i_ret = demux_Demux( p_input->p->input.p_demux );
558
559 if( i_ret > 0 )
560 {
561 if( p_input->p->input.p_demux->info.i_update )
562 {
563 if( p_input->p->input.p_demux->info.i_update & INPUT_UPDATE_TITLE_LIST )
564 {
565 UpdateTitleListfromDemux( p_input );
566 p_input->p->input.p_demux->info.i_update &= ~INPUT_UPDATE_TITLE_LIST;
567 }
568 if( p_input->p->input.b_title_demux )
569 {
570 i_ret = UpdateTitleSeekpointFromDemux( p_input );
571 *pb_changed = true;
572 }
573 UpdateGenericFromDemux( p_input );
574 }
575 }
576
577 if( i_ret == 0 ) /* EOF */
578 {
579 msg_Dbg( p_input, "EOF reached" );
580 p_input->p->input.b_eof = true;
581 es_out_Eos(p_input->p->p_es_out);
582 }
583 else if( i_ret < 0 )
584 {
585 input_ChangeState( p_input, ERROR_S );
586 }
587
588 if( i_ret > 0 && p_input->p->i_slave > 0 )
589 SlaveDemux( p_input );
590 }
591
592 static int MainLoopTryRepeat( input_thread_t *p_input, mtime_t *pi_start_mdate )
593 {
594 int i_repeat = var_GetInteger( p_input, "input-repeat" );
595 if( i_repeat <= 0 )
596 return VLC_EGENERIC;
597
598 vlc_value_t val;
599
600 msg_Dbg( p_input, "repeating the same input (%d)", i_repeat );
601 if( i_repeat > 0 )
602 {
603 i_repeat--;
604 var_SetInteger( p_input, "input-repeat", i_repeat );
605 }
606
607 /* Seek to start title/seekpoint */
608 val.i_int = p_input->p->input.i_title_start -
609 p_input->p->input.i_title_offset;
610 if( val.i_int < 0 || val.i_int >= p_input->p->input.i_title )
611 val.i_int = 0;
612 input_ControlPush( p_input,
613 INPUT_CONTROL_SET_TITLE, &val );
614
615 val.i_int = p_input->p->input.i_seekpoint_start -
616 p_input->p->input.i_seekpoint_offset;
617 if( val.i_int > 0 /* TODO: check upper boundary */ )
618 input_ControlPush( p_input,
619 INPUT_CONTROL_SET_SEEKPOINT, &val );
620
621 /* Seek to start position */
622 if( p_input->p->i_start > 0 )
623 {
624 val.i_int = p_input->p->i_start;
625 input_ControlPush( p_input, INPUT_CONTROL_SET_TIME, &val );
626 }
627 else
628 {
629 val.f_float = 0.f;
630 input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION, &val );
631 }
632
633 /* */
634 *pi_start_mdate = mdate();
635 return VLC_SUCCESS;
636 }
637
638 /**
639 * Update timing infos and statistics.
640 */
641 static void MainLoopStatistics( input_thread_t *p_input )
642 {
643 double f_position = 0.0;
644 mtime_t i_time = 0;
645 mtime_t i_length = 0;
646
647 /* update input status variables */
648 if( demux_Control( p_input->p->input.p_demux,
649 DEMUX_GET_POSITION, &f_position ) )
650 f_position = 0.0;
651
652 if( demux_Control( p_input->p->input.p_demux,
653 DEMUX_GET_TIME, &i_time ) )
654 i_time = 0;
655 p_input->p->i_time = i_time;
656
657 if( demux_Control( p_input->p->input.p_demux,
658 DEMUX_GET_LENGTH, &i_length ) )
659 i_length = 0;
660
661 es_out_SetTimes( p_input->p->p_es_out, f_position, i_time, i_length );
662
663 /* update current bookmark */
664 vlc_mutex_lock( &p_input->p->p_item->lock );
665 p_input->p->bookmark.i_time_offset = i_time;
666 p_input->p->bookmark.i_byte_offset = -1;
667 vlc_mutex_unlock( &p_input->p->p_item->lock );
668
669 stats_ComputeInputStats( p_input, p_input->p->p_item->p_stats );
670 input_SendEventStatistics( p_input );
671 }
672
673 /**
674 * MainLoop
675 * The main input loop.
676 */
677 static void MainLoop( input_thread_t *p_input, bool b_interactive )
678 {
679 mtime_t i_start_mdate = mdate();
680 mtime_t i_intf_update = 0;
681 mtime_t i_last_seek_mdate = 0;
682
683 if( b_interactive && var_InheritBool( p_input, "start-paused" ) )
684 ControlPause( p_input, i_start_mdate );
685
686 bool b_pause_after_eof = b_interactive &&
687 var_InheritBool( p_input, "play-and-pause" );
688
689 while( !input_Stopped( p_input ) && p_input->p->i_state != ERROR_S )
690 {
691 mtime_t i_wakeup = -1;
692 bool b_paused = p_input->p->i_state == PAUSE_S;
693 /* FIXME if p_input->p->i_state == PAUSE_S the access/access_demux
694 * is paused -> this may cause problem with some of them
695 * The same problem can be seen when seeking while paused */
696 if( b_paused )
697 b_paused = !es_out_GetBuffering( p_input->p->p_es_out ) || p_input->p->input.b_eof;
698
699 if( !b_paused )
700 {
701 if( !p_input->p->input.b_eof )
702 {
703 bool b_force_update = false;
704
705 MainLoopDemux( p_input, &b_force_update, i_start_mdate );
706 i_wakeup = es_out_GetWakeup( p_input->p->p_es_out );
707
708 if( b_force_update )
709 i_intf_update = 0;
710 }
711 else if( !es_out_GetEmpty( p_input->p->p_es_out ) )
712 {
713 msg_Dbg( p_input, "waiting decoder fifos to empty" );
714 i_wakeup = mdate() + INPUT_IDLE_SLEEP;
715 }
716 /* Pause after eof only if the input is pausable.
717 * This way we won't trigger timeshifting for nothing */
718 else if( b_pause_after_eof && p_input->p->b_can_pause )
719 {
720 vlc_value_t val = { .i_int = PAUSE_S };
721
722 msg_Dbg( p_input, "pausing at EOF (pause after each)");
723 Control( p_input, INPUT_CONTROL_SET_STATE, val );
724
725 b_paused = true;
726 }
727 else
728 {
729 if( MainLoopTryRepeat( p_input, &i_start_mdate ) )
730 break;
731 }
732
733 /* Update interface and statistics */
734 mtime_t now = mdate();
735 if( now >= i_intf_update )
736 {
737 MainLoopStatistics( p_input );
738 i_intf_update = now + INT64_C(250000);
739 }
740 }
741
742 /* Handle control */
743 for( ;; )
744 {
745 mtime_t i_deadline = i_wakeup;
746
747 /* Postpone seeking until ES buffering is complete or at most
748 * 125 ms. */
749 bool b_postpone = es_out_GetBuffering( p_input->p->p_es_out )
750 && !p_input->p->input.b_eof;
751 if( b_postpone )
752 {
753 mtime_t now = mdate();
754
755 /* Recheck ES buffer level every 20 ms when seeking */
756 if( now < i_last_seek_mdate + INT64_C(125000)
757 && (i_deadline < 0 || i_deadline > now + INT64_C(20000)) )
758 i_deadline = now + INT64_C(20000);
759 else
760 b_postpone = false;
761 }
762
763 int i_type;
764 vlc_value_t val;
765
766 if( ControlPop( p_input, &i_type, &val, i_deadline, b_postpone ) )
767 {
768 if( b_postpone )
769 continue;
770 break; /* Wake-up time reached */
771 }
772
773 #ifndef NDEBUG
774 msg_Dbg( p_input, "control type=%d", i_type );
775 #endif
776 if( Control( p_input, i_type, val ) )
777 {
778 if( ControlIsSeekRequest( i_type ) )
779 i_last_seek_mdate = mdate();
780 i_intf_update = 0;
781 }
782
783 /* Update the wakeup time */
784 if( i_wakeup != 0 )
785 i_wakeup = es_out_GetWakeup( p_input->p->p_es_out );
786 }
787 }
788 }
789
790 static void InitStatistics( input_thread_t * p_input )
791 {
792 if( p_input->b_preparsing ) return;
793
794 /* Prepare statistics */
795 #define INIT_COUNTER( c, compute ) p_input->p->counters.p_##c = \
796 stats_CounterCreate( STATS_##compute);
797 if( libvlc_stats( p_input ) )
798 {
799 INIT_COUNTER( read_bytes, COUNTER );
800 INIT_COUNTER( read_packets, COUNTER );
801 INIT_COUNTER( demux_read, COUNTER );
802 INIT_COUNTER( input_bitrate, DERIVATIVE );
803 INIT_COUNTER( demux_bitrate, DERIVATIVE );
804 INIT_COUNTER( demux_corrupted, COUNTER );
805 INIT_COUNTER( demux_discontinuity, COUNTER );
806 INIT_COUNTER( played_abuffers, COUNTER );
807 INIT_COUNTER( lost_abuffers, COUNTER );
808 INIT_COUNTER( displayed_pictures, COUNTER );
809 INIT_COUNTER( lost_pictures, COUNTER );
810 INIT_COUNTER( decoded_audio, COUNTER );
811 INIT_COUNTER( decoded_video, COUNTER );
812 INIT_COUNTER( decoded_sub, COUNTER );
813 p_input->p->counters.p_sout_send_bitrate = NULL;
814 p_input->p->counters.p_sout_sent_packets = NULL;
815 p_input->p->counters.p_sout_sent_bytes = NULL;
816 }
817 }
818
819 #ifdef ENABLE_SOUT
820 static int InitSout( input_thread_t * p_input )
821 {
822 if( p_input->b_preparsing )
823 return VLC_SUCCESS;
824
825 /* Find a usable sout and attach it to p_input */
826 char *psz = var_GetNonEmptyString( p_input, "sout" );
827 if( psz && strncasecmp( p_input->p->p_item->psz_uri, "vlc:", 4 ) )
828 {
829 p_input->p->p_sout = input_resource_RequestSout( p_input->p->p_resource, NULL, psz );
830 if( !p_input->p->p_sout )
831 {
832 input_ChangeState( p_input, ERROR_S );
833 msg_Err( p_input, "cannot start stream output instance, " \
834 "aborting" );
835 free( psz );
836 return VLC_EGENERIC;
837 }
838 if( libvlc_stats( p_input ) )
839 {
840 INIT_COUNTER( sout_sent_packets, COUNTER );
841 INIT_COUNTER( sout_sent_bytes, COUNTER );
842 INIT_COUNTER( sout_send_bitrate, DERIVATIVE );
843 }
844 }
845 else
846 {
847 input_resource_RequestSout( p_input->p->p_resource, NULL, NULL );
848 }
849 free( psz );
850
851 return VLC_SUCCESS;
852 }
853 #endif
854
855 static void InitTitle( input_thread_t * p_input )
856 {
857 input_source_t *p_master = &p_input->p->input;
858
859 if( p_input->b_preparsing )
860 return;
861
862 vlc_mutex_lock( &p_input->p->p_item->lock );
863 /* Create global title (from master) */
864 p_input->p->i_title = p_master->i_title;
865 p_input->p->title = p_master->title;
866 p_input->p->i_title_offset = p_master->i_title_offset;
867 p_input->p->i_seekpoint_offset = p_master->i_seekpoint_offset;
868 if( p_input->p->i_title > 0 )
869 {
870 /* Setup variables */
871 input_ControlVarNavigation( p_input );
872 input_SendEventTitle( p_input, 0 );
873 }
874
875 /* Global flag */
876 p_input->p->b_can_pace_control = p_master->b_can_pace_control;
877 p_input->p->b_can_pause = p_master->b_can_pause;
878 p_input->p->b_can_rate_control = p_master->b_can_rate_control;
879 vlc_mutex_unlock( &p_input->p->p_item->lock );
880 }
881
882 static void StartTitle( input_thread_t * p_input )
883 {
884 vlc_value_t val;
885
886 /* Start title/chapter */
887 val.i_int = p_input->p->input.i_title_start -
888 p_input->p->input.i_title_offset;
889 if( val.i_int > 0 && val.i_int < p_input->p->input.i_title )
890 input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE, &val );
891
892 val.i_int = p_input->p->input.i_seekpoint_start -
893 p_input->p->input.i_seekpoint_offset;
894 if( val.i_int > 0 /* TODO: check upper boundary */ )
895 input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT, &val );
896
897 /* Start/stop/run time */
898 p_input->p->i_start = llroundf(1000000.f
899 * var_GetFloat( p_input, "start-time" ));
900 p_input->p->i_stop = llroundf(1000000.f
901 * var_GetFloat( p_input, "stop-time" ));
902 p_input->p->i_run = llroundf(1000000.f
903 * var_GetFloat( p_input, "run-time" ));
904 if( p_input->p->i_run < 0 )
905 {
906 msg_Warn( p_input, "invalid run-time ignored" );
907 p_input->p->i_run = 0;
908 }
909
910 if( p_input->p->i_start > 0 )
911 {
912 vlc_value_t s;
913
914 msg_Dbg( p_input, "starting at time: %ds",
915 (int)( p_input->p->i_start / CLOCK_FREQ ) );
916
917 s.i_int = p_input->p->i_start;
918 input_ControlPush( p_input, INPUT_CONTROL_SET_TIME, &s );
919 }
920 if( p_input->p->i_stop > 0 && p_input->p->i_stop <= p_input->p->i_start )
921 {
922 msg_Warn( p_input, "invalid stop-time ignored" );
923 p_input->p->i_stop = 0;
924 }
925 p_input->p->b_fast_seek = var_GetBool( p_input, "input-fast-seek" );
926 }
927
928 static void LoadSubtitles( input_thread_t *p_input )
929 {
930 /* Load subtitles */
931 /* Get fps and set it if not already set */
932 const float f_fps = p_input->p->f_fps;
933 if( f_fps > 1.f )
934 {
935 var_Create( p_input, "sub-original-fps", VLC_VAR_FLOAT );
936 var_SetFloat( p_input, "sub-original-fps", f_fps );
937
938 float f_requested_fps = var_CreateGetFloat( p_input, "sub-fps" );
939 if( f_requested_fps != f_fps )
940 {
941 var_Create( p_input, "sub-fps", VLC_VAR_FLOAT|
942 VLC_VAR_DOINHERIT );
943 var_SetFloat( p_input, "sub-fps", f_requested_fps );
944 }
945 }
946
947 const int i_delay = var_CreateGetInteger( p_input, "sub-delay" );
948 if( i_delay != 0 )
949 var_SetInteger( p_input, "spu-delay", (mtime_t)i_delay * 100000 );
950
951 /* Look for and add subtitle files */
952 unsigned i_flags = SUB_FORCED;
953
954 char *psz_subtitle = var_GetNonEmptyString( p_input, "sub-file" );
955 if( psz_subtitle != NULL )
956 {
957 msg_Dbg( p_input, "forced subtitle: %s", psz_subtitle );
958 input_SubtitleFileAdd( p_input, psz_subtitle, i_flags );
959 i_flags = SUB_NOFLAG;
960 }
961
962 if( var_GetBool( p_input, "sub-autodetect-file" ) )
963 {
964 char *psz_autopath = var_GetNonEmptyString( p_input, "sub-autodetect-path" );
965 char **ppsz_subs = subtitles_Detect( p_input, psz_autopath,
966 p_input->p->p_item->psz_uri );
967 free( psz_autopath );
968
969 for( int i = 0; ppsz_subs && ppsz_subs[i]; i++ )
970 {
971 if( !psz_subtitle || strcmp( psz_subtitle, ppsz_subs[i] ) )
972 {
973 i_flags |= SUB_CANFAIL;
974 input_SubtitleFileAdd( p_input, ppsz_subs[i], i_flags );
975 i_flags = SUB_NOFLAG;
976 }
977
978 free( ppsz_subs[i] );
979 }
980 free( ppsz_subs );
981 }
982 free( psz_subtitle );
983
984 /* Load subtitles from attachments */
985 int i_attachment = 0;
986 input_attachment_t **pp_attachment = NULL;
987
988 vlc_mutex_lock( &p_input->p->p_item->lock );
989 for( int i = 0; i < p_input->p->i_attachment; i++ )
990 {
991 const input_attachment_t *a = p_input->p->attachment[i];
992 if( !strcmp( a->psz_mime, "application/x-srt" ) )
993 TAB_APPEND( i_attachment, pp_attachment,
994 vlc_input_attachment_New( a->psz_name, NULL,
995 a->psz_description, NULL, 0 ) );
996 }
997 vlc_mutex_unlock( &p_input->p->p_item->lock );
998
999 if( i_attachment > 0 )
1000 var_Create( p_input, "sub-description", VLC_VAR_STRING );
1001 for( int i = 0; i < i_attachment; i++ )
1002 {
1003 input_attachment_t *a = pp_attachment[i];
1004 if( !a )
1005 continue;
1006 char *psz_mrl;
1007 if( a->psz_name[i] &&
1008 asprintf( &psz_mrl, "attachment://%s", a->psz_name ) >= 0 )
1009 {
1010 var_SetString( p_input, "sub-description", a->psz_description ? a->psz_description : "");
1011
1012 input_SubtitleAdd( p_input, psz_mrl, i_flags );
1013
1014 i_flags = SUB_NOFLAG;
1015 free( psz_mrl );
1016 }
1017 vlc_input_attachment_Delete( a );
1018 }
1019 free( pp_attachment );
1020 if( i_attachment > 0 )
1021 var_Destroy( p_input, "sub-description" );
1022 }
1023
1024 static void LoadSlaves( input_thread_t *p_input )
1025 {
1026 char *psz = var_GetNonEmptyString( p_input, "input-slave" );
1027 if( !psz )
1028 return;
1029
1030 char *psz_org = psz;
1031 while( psz && *psz )
1032 {
1033 while( *psz == ' ' || *psz == '#' )
1034 psz++;
1035
1036 char *psz_delim = strchr( psz, '#' );
1037 if( psz_delim )
1038 *psz_delim++ = '\0';
1039
1040 if( *psz == 0 )
1041 break;
1042
1043 char *uri = strstr(psz, "://")
1044 ? strdup( psz ) : vlc_path2uri( psz, NULL );
1045 psz = psz_delim;
1046 if( uri == NULL )
1047 continue;
1048 msg_Dbg( p_input, "adding slave input '%s'", uri );
1049
1050 input_source_t *p_slave = InputSourceNew( p_input );
1051 if( p_slave && !InputSourceInit( p_input, p_slave, uri, NULL, false ) )
1052 TAB_APPEND( p_input->p->i_slave, p_input->p->slave, p_slave );
1053 else
1054 free( p_slave );
1055 free( uri );
1056 }
1057 free( psz_org );
1058 }
1059
1060 static void UpdatePtsDelay( input_thread_t *p_input )
1061 {
1062 input_thread_private_t *p_sys = p_input->p;
1063
1064 /* Get max pts delay from input source */
1065 mtime_t i_pts_delay = p_sys->input.i_pts_delay;
1066 for( int i = 0; i < p_sys->i_slave; i++ )
1067 i_pts_delay = __MAX( i_pts_delay, p_sys->slave[i]->i_pts_delay );
1068
1069 if( i_pts_delay < 0 )
1070 i_pts_delay = 0;
1071
1072 /* Take care of audio/spu delay */
1073 const mtime_t i_audio_delay = var_GetInteger( p_input, "audio-delay" );
1074 const mtime_t i_spu_delay = var_GetInteger( p_input, "spu-delay" );
1075 const mtime_t i_extra_delay = __MIN( i_audio_delay, i_spu_delay );
1076 if( i_extra_delay < 0 )
1077 i_pts_delay -= i_extra_delay;
1078
1079 /* Update cr_average depending on the caching */
1080 const int i_cr_average = var_GetInteger( p_input, "cr-average" ) * i_pts_delay / DEFAULT_PTS_DELAY;
1081
1082 /* */
1083 es_out_SetDelay( p_input->p->p_es_out_display, AUDIO_ES, i_audio_delay );
1084 es_out_SetDelay( p_input->p->p_es_out_display, SPU_ES, i_spu_delay );
1085 es_out_SetJitter( p_input->p->p_es_out, i_pts_delay, 0, i_cr_average );
1086 }
1087
1088 static void InitPrograms( input_thread_t * p_input )
1089 {
1090 int i_es_out_mode;
1091 vlc_list_t list;
1092
1093 /* Compute correct pts_delay */
1094 UpdatePtsDelay( p_input );
1095
1096 /* Set up es_out */
1097 i_es_out_mode = ES_OUT_MODE_AUTO;
1098 if( p_input->p->p_sout )
1099 {
1100 char *prgms;
1101
1102 if( (prgms = var_GetNonEmptyString( p_input, "programs" )) != NULL )
1103 {
1104 char *buf;
1105
1106 TAB_INIT( list.i_count, list.p_values );
1107 for( const char *prgm = strtok_r( prgms, ",", &buf );
1108 prgm != NULL;
1109 prgm = strtok_r( NULL, ",", &buf ) )
1110 {
1111 vlc_value_t val = { .i_int = atoi( prgm ) };
1112 INSERT_ELEM( list.p_values, list.i_count, list.i_count, val );
1113 }
1114
1115 if( list.i_count > 0 )
1116 i_es_out_mode = ES_OUT_MODE_PARTIAL;
1117 /* Note : we should remove the "program" callback. */
1118
1119 free( prgms );
1120 }
1121 else if( var_GetBool( p_input, "sout-all" ) )
1122 {
1123 i_es_out_mode = ES_OUT_MODE_ALL;
1124 }
1125 }
1126 es_out_SetMode( p_input->p->p_es_out, i_es_out_mode );
1127
1128 /* Inform the demuxer about waited group (needed only for DVB) */
1129 if( i_es_out_mode == ES_OUT_MODE_ALL )
1130 {
1131 demux_Control( p_input->p->input.p_demux, DEMUX_SET_GROUP, -1, NULL );
1132 }
1133 else if( i_es_out_mode == ES_OUT_MODE_PARTIAL )
1134 {
1135 demux_Control( p_input->p->input.p_demux, DEMUX_SET_GROUP, -1,
1136 &list );
1137 TAB_CLEAN( list.i_count, list.p_values );
1138 }
1139 else
1140 {
1141 demux_Control( p_input->p->input.p_demux, DEMUX_SET_GROUP,
1142 es_out_GetGroupForced( p_input->p->p_es_out ), NULL );
1143 }
1144 }
1145
1146 static int Init( input_thread_t * p_input )
1147 {
1148 for( int i = 0; i < p_input->p->p_item->i_options; i++ )
1149 {
1150 if( !strncmp( p_input->p->p_item->ppsz_options[i], "meta-file", 9 ) )
1151 {
1152 msg_Dbg( p_input, "Input is a meta file: disabling unneeded options" );
1153 var_SetString( p_input, "sout", "" );
1154 var_SetBool( p_input, "sout-all", false );
1155 var_SetString( p_input, "input-slave", "" );
1156 var_SetInteger( p_input, "input-repeat", 0 );
1157 var_SetString( p_input, "sub-file", "" );
1158 var_SetBool( p_input, "sub-autodetect-file", false );
1159 }
1160 }
1161
1162 InitStatistics( p_input );
1163 #ifdef ENABLE_SOUT
1164 if( InitSout( p_input ) )
1165 goto error;
1166 #endif
1167
1168 /* Create es out */
1169 p_input->p->p_es_out = input_EsOutTimeshiftNew( p_input, p_input->p->p_es_out_display, p_input->p->i_rate );
1170
1171 /* */
1172 input_ChangeState( p_input, OPENING_S );
1173 input_SendEventCache( p_input, 0.0 );
1174
1175 /* */
1176 if( InputSourceInit( p_input, &p_input->p->input,
1177 p_input->p->p_item->psz_uri, NULL, false ) )
1178 {
1179 goto error;
1180 }
1181
1182 InitTitle( p_input );
1183
1184 /* Load master infos */
1185 /* Init length */
1186 mtime_t i_length;
1187 if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_LENGTH,
1188 &i_length ) )
1189 i_length = 0;
1190 if( i_length <= 0 )
1191 i_length = input_item_GetDuration( p_input->p->p_item );
1192 input_SendEventLength( p_input, i_length );
1193
1194 input_SendEventPosition( p_input, 0.0, 0 );
1195
1196 if( !p_input->b_preparsing )
1197 {
1198 StartTitle( p_input );
1199 LoadSubtitles( p_input );
1200 LoadSlaves( p_input );
1201 InitPrograms( p_input );
1202
1203 double f_rate = var_InheritFloat( p_input, "rate" );
1204 if( f_rate != 0.0 && f_rate != 1.0 )
1205 {
1206 vlc_value_t val = { .i_int = INPUT_RATE_DEFAULT / f_rate };
1207 input_ControlPush( p_input, INPUT_CONTROL_SET_RATE, &val );
1208 }
1209 }
1210
1211 if( !p_input->b_preparsing && p_input->p->p_sout )
1212 {
1213 p_input->p->b_out_pace_control = (p_input->p->p_sout->i_out_pace_nocontrol > 0);
1214
1215 if( p_input->p->b_can_pace_control && p_input->p->b_out_pace_control )
1216 {
1217 /* We don't want a high input priority here or we'll
1218 * end-up sucking up all the CPU time */
1219 vlc_set_priority( p_input->p->thread, VLC_THREAD_PRIORITY_LOW );
1220 }
1221
1222 msg_Dbg( p_input, "starting in %s mode",
1223 p_input->p->b_out_pace_control ? "async" : "sync" );
1224 }
1225
1226 vlc_meta_t *p_meta = vlc_meta_New();
1227 if( p_meta != NULL )
1228 {
1229 /* Get meta data from users */
1230 InputMetaUser( p_input, p_meta );
1231
1232 /* Get meta data from master input */
1233 InputSourceMeta( p_input, &p_input->p->input, p_meta );
1234
1235 /* And from slave */
1236 for( int i = 0; i < p_input->p->i_slave; i++ )
1237 InputSourceMeta( p_input, p_input->p->slave[i], p_meta );
1238
1239 es_out_ControlSetMeta( p_input->p->p_es_out, p_meta );
1240 vlc_meta_Delete( p_meta );
1241 }
1242
1243 msg_Dbg( p_input, "`%s' successfully opened",
1244 p_input->p->p_item->psz_uri );
1245
1246 /* initialization is complete */
1247 input_ChangeState( p_input, PLAYING_S );
1248
1249 return VLC_SUCCESS;
1250
1251 error:
1252 input_ChangeState( p_input, ERROR_S );
1253
1254 if( p_input->p->p_es_out )
1255 es_out_Delete( p_input->p->p_es_out );
1256 es_out_SetMode( p_input->p->p_es_out_display, ES_OUT_MODE_END );
1257 if( p_input->p->p_resource )
1258 {
1259 if( p_input->p->p_sout )
1260 input_resource_RequestSout( p_input->p->p_resource,
1261 p_input->p->p_sout, NULL );
1262 input_resource_SetInput( p_input->p->p_resource, NULL );
1263 if( p_input->p->p_resource_private )
1264 input_resource_Terminate( p_input->p->p_resource_private );
1265 }
1266
1267 if( !p_input->b_preparsing && libvlc_stats( p_input ) )
1268 {
1269 #define EXIT_COUNTER( c ) do { if( p_input->p->counters.p_##c ) \
1270 stats_CounterClean( p_input->p->counters.p_##c );\
1271 p_input->p->counters.p_##c = NULL; } while(0)
1272 EXIT_COUNTER( read_bytes );
1273 EXIT_COUNTER( read_packets );
1274 EXIT_COUNTER( demux_read );
1275 EXIT_COUNTER( input_bitrate );
1276 EXIT_COUNTER( demux_bitrate );
1277 EXIT_COUNTER( demux_corrupted );
1278 EXIT_COUNTER( demux_discontinuity );
1279 EXIT_COUNTER( played_abuffers );
1280 EXIT_COUNTER( lost_abuffers );
1281 EXIT_COUNTER( displayed_pictures );
1282 EXIT_COUNTER( lost_pictures );
1283 EXIT_COUNTER( decoded_audio );
1284 EXIT_COUNTER( decoded_video );
1285 EXIT_COUNTER( decoded_sub );
1286
1287 if( p_input->p->p_sout )
1288 {
1289 EXIT_COUNTER( sout_sent_packets );
1290 EXIT_COUNTER( sout_sent_bytes );
1291 EXIT_COUNTER( sout_send_bitrate );
1292 }
1293 #undef EXIT_COUNTER
1294 }
1295
1296 /* Mark them deleted */
1297 p_input->p->input.p_demux = NULL;
1298 p_input->p->p_es_out = NULL;
1299 p_input->p->p_sout = NULL;
1300
1301 return VLC_EGENERIC;
1302 }
1303
1304 /*****************************************************************************
1305 * End: end the input thread
1306 *****************************************************************************/
1307 static void End( input_thread_t * p_input )
1308 {
1309 int i;
1310
1311 /* We are at the end */
1312 input_ChangeState( p_input, END_S );
1313
1314 /* Clean control variables */
1315 input_ControlVarStop( p_input );
1316
1317 /* Stop es out activity */
1318 es_out_SetMode( p_input->p->p_es_out, ES_OUT_MODE_NONE );
1319
1320 /* Clean up master */
1321 InputSourceClean( &p_input->p->input );
1322
1323 /* Delete slave */
1324 for( i = 0; i < p_input->p->i_slave; i++ )
1325 {
1326 InputSourceClean( p_input->p->slave[i] );
1327 free( p_input->p->slave[i] );
1328 }
1329 free( p_input->p->slave );
1330
1331 /* Unload all modules */
1332 if( p_input->p->p_es_out )
1333 es_out_Delete( p_input->p->p_es_out );
1334 es_out_SetMode( p_input->p->p_es_out_display, ES_OUT_MODE_END );
1335
1336 if( !p_input->b_preparsing )
1337 {
1338 #define CL_CO( c ) stats_CounterClean( p_input->p->counters.p_##c ); p_input->p->counters.p_##c = NULL;
1339 if( libvlc_stats( p_input ) )
1340 {
1341 /* make sure we are up to date */
1342 stats_ComputeInputStats( p_input, p_input->p->p_item->p_stats );
1343 CL_CO( read_bytes );
1344 CL_CO( read_packets );
1345 CL_CO( demux_read );
1346 CL_CO( input_bitrate );
1347 CL_CO( demux_bitrate );
1348 CL_CO( demux_corrupted );
1349 CL_CO( demux_discontinuity );
1350 CL_CO( played_abuffers );
1351 CL_CO( lost_abuffers );
1352 CL_CO( displayed_pictures );
1353 CL_CO( lost_pictures );
1354 CL_CO( decoded_audio) ;
1355 CL_CO( decoded_video );
1356 CL_CO( decoded_sub) ;
1357 }
1358
1359 /* Close optional stream output instance */
1360 if( p_input->p->p_sout )
1361 {
1362 CL_CO( sout_sent_packets );
1363 CL_CO( sout_sent_bytes );
1364 CL_CO( sout_send_bitrate );
1365 }
1366 #undef CL_CO
1367 }
1368
1369 vlc_mutex_lock( &p_input->p->p_item->lock );
1370 if( p_input->p->i_attachment > 0 )
1371 {
1372 for( i = 0; i < p_input->p->i_attachment; i++ )
1373 vlc_input_attachment_Delete( p_input->p->attachment[i] );
1374 TAB_CLEAN( p_input->p->i_attachment, p_input->p->attachment );
1375 free( p_input->p->attachment_demux);
1376 p_input->p->attachment_demux = NULL;
1377 }
1378 vlc_mutex_unlock( &p_input->p->p_item->lock );
1379
1380 /* */
1381 input_resource_RequestSout( p_input->p->p_resource,
1382 p_input->p->p_sout, NULL );
1383 input_resource_SetInput( p_input->p->p_resource, NULL );
1384 if( p_input->p->p_resource_private )
1385 input_resource_Terminate( p_input->p->p_resource_private );
1386 }
1387
1388 /*****************************************************************************
1389 * Control
1390 *****************************************************************************/
1391 void input_ControlPush( input_thread_t *p_input,
1392 int i_type, vlc_value_t *p_val )
1393 {
1394 input_thread_private_t *sys = p_input->p;
1395
1396 vlc_mutex_lock( &sys->lock_control );
1397 if( sys->is_stopped )
1398 ;
1399 else if( sys->i_control >= INPUT_CONTROL_FIFO_SIZE )
1400 {
1401 msg_Err( p_input, "input control fifo overflow, trashing type=%d",
1402 i_type );
1403 if( p_val )
1404 ControlRelease( i_type, *p_val );
1405 }
1406 else
1407 {
1408 input_control_t c;
1409 c.i_type = i_type;
1410 if( p_val )
1411 c.val = *p_val;
1412 else
1413 memset( &c.val, 0, sizeof(c.val) );
1414
1415 sys->control[sys->i_control++] = c;
1416 }
1417 vlc_cond_signal( &sys->wait_control );
1418 vlc_mutex_unlock( &sys->lock_control );
1419 }
1420
1421 static int ControlGetReducedIndexLocked( input_thread_t *p_input )
1422 {
1423 const int i_lt = p_input->p->control[0].i_type;
1424 int i;
1425 for( i = 1; i < p_input->p->i_control; i++ )
1426 {
1427 const int i_ct = p_input->p->control[i].i_type;
1428
1429 if( i_lt == i_ct &&
1430 ( i_ct == INPUT_CONTROL_SET_STATE ||
1431 i_ct == INPUT_CONTROL_SET_RATE ||
1432 i_ct == INPUT_CONTROL_SET_POSITION ||
1433 i_ct == INPUT_CONTROL_SET_TIME ||
1434 i_ct == INPUT_CONTROL_SET_PROGRAM ||
1435 i_ct == INPUT_CONTROL_SET_TITLE ||
1436 i_ct == INPUT_CONTROL_SET_SEEKPOINT ||
1437 i_ct == INPUT_CONTROL_SET_BOOKMARK ) )
1438 {
1439 continue;
1440 }
1441 else
1442 {
1443 /* TODO but that's not that important
1444 - merge SET_X with SET_X_CMD
1445 - ignore SET_SEEKPOINT/SET_POSITION/SET_TIME before a SET_TITLE
1446 - ignore SET_SEEKPOINT/SET_POSITION/SET_TIME before another among them
1447 - ?
1448 */
1449 break;
1450 }
1451 }
1452 return i - 1;
1453 }
1454
1455
1456 static inline int ControlPop( input_thread_t *p_input,
1457 int *pi_type, vlc_value_t *p_val,
1458 mtime_t i_deadline, bool b_postpone_seek )
1459 {
1460 input_thread_private_t *p_sys = p_input->p;
1461
1462 vlc_mutex_lock( &p_sys->lock_control );
1463 while( p_sys->i_control <= 0 ||
1464 ( b_postpone_seek && ControlIsSeekRequest( p_sys->control[0].i_type ) ) )
1465 {
1466 if( p_sys->is_stopped )
1467 {
1468 vlc_mutex_unlock( &p_sys->lock_control );
1469 return VLC_EGENERIC;
1470 }
1471
1472 if( i_deadline >= 0 )
1473 {
1474 if( vlc_cond_timedwait( &p_sys->wait_control, &p_sys->lock_control,
1475 i_deadline ) )
1476 {
1477 vlc_mutex_unlock( &p_sys->lock_control );
1478 return VLC_EGENERIC;
1479 }
1480 }
1481 else
1482 vlc_cond_wait( &p_sys->wait_control, &p_sys->lock_control );
1483 }
1484
1485 /* */
1486 const int i_index = ControlGetReducedIndexLocked( p_input );
1487
1488 /* */
1489 *pi_type = p_sys->control[i_index].i_type;
1490 *p_val = p_sys->control[i_index].val;
1491
1492 p_sys->i_control -= i_index + 1;
1493 if( p_sys->i_control > 0 )
1494 memmove( &p_sys->control[0], &p_sys->control[i_index+1],
1495 sizeof(*p_sys->control) * p_sys->i_control );
1496 vlc_mutex_unlock( &p_sys->lock_control );
1497
1498 return VLC_SUCCESS;
1499 }
1500 static bool ControlIsSeekRequest( int i_type )
1501 {
1502 switch( i_type )
1503 {
1504 case INPUT_CONTROL_SET_POSITION:
1505 case INPUT_CONTROL_SET_TIME:
1506 case INPUT_CONTROL_SET_TITLE:
1507 case INPUT_CONTROL_SET_TITLE_NEXT:
1508 case INPUT_CONTROL_SET_TITLE_PREV:
1509 case INPUT_CONTROL_SET_SEEKPOINT:
1510 case INPUT_CONTROL_SET_SEEKPOINT_NEXT:
1511 case INPUT_CONTROL_SET_SEEKPOINT_PREV:
1512 case INPUT_CONTROL_SET_BOOKMARK:
1513 case INPUT_CONTROL_NAV_ACTIVATE:
1514 case INPUT_CONTROL_NAV_UP:
1515 case INPUT_CONTROL_NAV_DOWN:
1516 case INPUT_CONTROL_NAV_LEFT:
1517 case INPUT_CONTROL_NAV_RIGHT:
1518 return true;
1519 default:
1520 return false;
1521 }
1522 }
1523
1524 static void ControlRelease( int i_type, vlc_value_t val )
1525 {
1526 switch( i_type )
1527 {
1528 case INPUT_CONTROL_ADD_SUBTITLE:
1529 case INPUT_CONTROL_ADD_SLAVE:
1530 free( val.psz_string );
1531 break;
1532
1533 default:
1534 break;
1535 }
1536 }
1537
1538 /* Pause input */
1539 static void ControlPause( input_thread_t *p_input, mtime_t i_control_date )
1540 {
1541 int i_ret = VLC_SUCCESS;
1542 int i_state = PAUSE_S;
1543
1544 if( p_input->p->b_can_pause )
1545 {
1546 demux_t *p_demux = p_input->p->input.p_demux;
1547
1548 if( p_demux->s != NULL )
1549 i_ret = stream_Control( p_demux->s, STREAM_SET_PAUSE_STATE, true );
1550 else
1551 i_ret = demux_Control( p_demux, DEMUX_SET_PAUSE_STATE, true );
1552
1553 if( i_ret )
1554 {
1555 msg_Warn( p_input, "cannot set pause state" );
1556 return;
1557 }
1558 }
1559
1560 /* */
1561 i_ret = es_out_SetPauseState( p_input->p->p_es_out,
1562 p_input->p->b_can_pause, true,
1563 i_control_date );
1564 if( i_ret )
1565 {
1566 msg_Warn( p_input, "cannot set pause state at es_out level" );
1567 return;
1568 }
1569
1570 /* Switch to new state */
1571 input_ChangeState( p_input, i_state );
1572 }
1573
1574 static void ControlUnpause( input_thread_t *p_input, mtime_t i_control_date )
1575 {
1576 if( p_input->p->b_can_pause )
1577 {
1578 demux_t *p_demux = p_input->p->input.p_demux;
1579 int ret;
1580
1581 if( p_demux->s != NULL )
1582 ret = stream_Control( p_demux->s, STREAM_SET_PAUSE_STATE, false );
1583 else
1584 ret = demux_Control( p_demux, DEMUX_SET_PAUSE_STATE, false );
1585 if( ret != VLC_SUCCESS )
1586 {
1587 msg_Err( p_input, "cannot resume" );
1588 input_ChangeState( p_input, ERROR_S );
1589 return;
1590 }
1591 }
1592
1593 /* Switch to play */
1594 input_ChangeState( p_input, PLAYING_S );
1595 es_out_SetPauseState( p_input->p->p_es_out, false, false, i_control_date );
1596 }
1597
1598 static bool Control( input_thread_t *p_input,
1599 int i_type, vlc_value_t val )
1600 {
1601 const mtime_t i_control_date = mdate();
1602 /* FIXME b_force_update is abused, it should be carefully checked */
1603 bool b_force_update = false;
1604
1605 if( !p_input )
1606 return b_force_update;
1607
1608 switch( i_type )
1609 {
1610 case INPUT_CONTROL_SET_POSITION:
1611 {
1612 if( p_input->p->b_recording )
1613 {
1614 msg_Err( p_input, "INPUT_CONTROL_SET_POSITION(_OFFSET) ignored while recording" );
1615 break;
1616 }
1617
1618 float f_pos = val.f_float;
1619 if( f_pos < 0.f )
1620 f_pos = 0.f;
1621 else if( f_pos > 1.f )
1622 f_pos = 1.f;
1623 /* Reset the decoders states and clock sync (before calling the demuxer */
1624 es_out_SetTime( p_input->p->p_es_out, -1 );
1625 if( demux_Control( p_input->p->input.p_demux, DEMUX_SET_POSITION,
1626 (double) f_pos, !p_input->p->b_fast_seek ) )
1627 {
1628 msg_Err( p_input, "INPUT_CONTROL_SET_POSITION(_OFFSET) "
1629 "%2.1f%% failed", (double)(f_pos * 100.f) );
1630 }
1631 else
1632 {
1633 if( p_input->p->i_slave > 0 )
1634 SlaveSeek( p_input );
1635 p_input->p->input.b_eof = false;
1636
1637 b_force_update = true;
1638 }
1639 break;
1640 }
1641
1642 case INPUT_CONTROL_SET_TIME:
1643 {
1644 int64_t i_time;
1645 int i_ret;
1646
1647 if( p_input->p->b_recording )
1648 {
1649 msg_Err( p_input, "INPUT_CONTROL_SET_TIME(_OFFSET) ignored while recording" );
1650 break;
1651 }
1652
1653 i_time = val.i_int;
1654 if( i_time < 0 )
1655 i_time = 0;
1656
1657 /* Reset the decoders states and clock sync (before calling the demuxer */
1658 es_out_SetTime( p_input->p->p_es_out, -1 );
1659
1660 i_ret = demux_Control( p_input->p->input.p_demux,
1661 DEMUX_SET_TIME, i_time,
1662 !p_input->p->b_fast_seek );
1663 if( i_ret )
1664 {
1665 int64_t i_length;
1666
1667 /* Emulate it with a SET_POS */
1668 if( !demux_Control( p_input->p->input.p_demux,
1669 DEMUX_GET_LENGTH, &i_length ) && i_length > 0 )
1670 {
1671 double f_pos = (double)i_time / (double)i_length;
1672 i_ret = demux_Control( p_input->p->input.p_demux,
1673 DEMUX_SET_POSITION, f_pos,
1674 !p_input->p->b_fast_seek );
1675 }
1676 }
1677 if( i_ret )
1678 {
1679 msg_Warn( p_input, "INPUT_CONTROL_SET_TIME(_OFFSET) %"PRId64
1680 " failed or not possible", i_time );
1681 }
1682 else
1683 {
1684 if( p_input->p->i_slave > 0 )
1685 SlaveSeek( p_input );
1686 p_input->p->input.b_eof = false;
1687
1688 b_force_update = true;
1689 }
1690 break;
1691 }
1692
1693 case INPUT_CONTROL_SET_STATE:
1694 switch( val.i_int )
1695 {
1696 case PLAYING_S:
1697 if( p_input->p->i_state == PAUSE_S )
1698 {
1699 ControlUnpause( p_input, i_control_date );
1700 b_force_update = true;
1701 }
1702 break;
1703 case PAUSE_S:
1704 if( p_input->p->i_state == PLAYING_S )
1705 {
1706 ControlPause( p_input, i_control_date );
1707 b_force_update = true;
1708 }
1709 break;
1710 default:
1711 msg_Err( p_input, "invalid INPUT_CONTROL_SET_STATE" );
1712 }
1713 break;
1714
1715 case INPUT_CONTROL_SET_RATE:
1716 {
1717 /* Get rate and direction */
1718 int i_rate = abs( val.i_int );
1719 int i_rate_sign = val.i_int < 0 ? -1 : 1;
1720
1721 /* Check rate bound */
1722 if( i_rate < INPUT_RATE_MIN )
1723 {
1724 msg_Dbg( p_input, "cannot set rate faster" );
1725 i_rate = INPUT_RATE_MIN;
1726 }
1727 else if( i_rate > INPUT_RATE_MAX )
1728 {
1729 msg_Dbg( p_input, "cannot set rate slower" );
1730 i_rate = INPUT_RATE_MAX;
1731 }
1732
1733 /* Apply direction */
1734 if( i_rate_sign < 0 )
1735 {
1736 if( p_input->p->input.b_rescale_ts )
1737 {
1738 msg_Dbg( p_input, "cannot set negative rate" );
1739 i_rate = p_input->p->i_rate;
1740 assert( i_rate > 0 );
1741 }
1742 else
1743 {
1744 i_rate *= i_rate_sign;
1745 }
1746 }
1747
1748 if( i_rate != INPUT_RATE_DEFAULT &&
1749 ( ( !p_input->p->b_can_rate_control && !p_input->p->input.b_rescale_ts ) ||
1750 ( p_input->p->p_sout && !p_input->p->b_out_pace_control ) ) )
1751 {
1752 msg_Dbg( p_input, "cannot change rate" );
1753 i_rate = INPUT_RATE_DEFAULT;
1754 }
1755 if( i_rate != p_input->p->i_rate &&
1756 !p_input->p->b_can_pace_control && p_input->p->b_can_rate_control )
1757 {
1758 demux_t *p_demux = p_input->p->input.p_demux;
1759 int i_ret = VLC_EGENERIC;
1760
1761 if( p_demux->s == NULL )
1762 {
1763 if( !p_input->p->input.b_rescale_ts )
1764 es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR );
1765
1766 i_ret = demux_Control( p_input->p->input.p_demux,
1767 DEMUX_SET_RATE, &i_rate );
1768 }
1769 if( i_ret )
1770 {
1771 msg_Warn( p_input, "ACCESS/DEMUX_SET_RATE failed" );
1772 i_rate = p_input->p->i_rate;
1773 }
1774 }
1775
1776 /* */
1777 if( i_rate != p_input->p->i_rate )
1778 {
1779 p_input->p->i_rate = i_rate;
1780 input_SendEventRate( p_input, i_rate );
1781
1782 if( p_input->p->input.b_rescale_ts )
1783 {
1784 const int i_rate_source = (p_input->p->b_can_pace_control || p_input->p->b_can_rate_control ) ? i_rate : INPUT_RATE_DEFAULT;
1785 es_out_SetRate( p_input->p->p_es_out, i_rate_source, i_rate );
1786 }
1787
1788 b_force_update = true;
1789 }
1790 break;
1791 }
1792
1793 case INPUT_CONTROL_SET_PROGRAM:
1794 /* No need to force update, es_out does it if needed */
1795 es_out_Control( p_input->p->p_es_out,
1796 ES_OUT_SET_GROUP, val.i_int );
1797
1798 demux_Control( p_input->p->input.p_demux, DEMUX_SET_GROUP, val.i_int,
1799 NULL );
1800 break;
1801
1802 case INPUT_CONTROL_SET_ES:
1803 /* No need to force update, es_out does it if needed */
1804 es_out_Control( p_input->p->p_es_out_display,
1805 ES_OUT_SET_ES_BY_ID, (int)val.i_int, 0);
1806
1807 demux_Control( p_input->p->input.p_demux, DEMUX_SET_ES, (int)val.i_int);
1808 break;
1809 case INPUT_CONTROL_SET_ES2:
1810 es_out_Control( p_input->p->p_es_out_display,
1811 ES_OUT_SET_ES_BY_ID, (int)val.i_int, 1);
1812
1813 demux_Control( p_input->p->input.p_demux, DEMUX_SET_ES, (int)val.i_int );
1814 break;
1815
1816 case INPUT_CONTROL_RESTART_ES:
1817 es_out_Control( p_input->p->p_es_out_display,
1818 ES_OUT_RESTART_ES_BY_ID, (int)val.i_int, 0);
1819 break;
1820 case INPUT_CONTROL_RESTART_ES2:
1821 es_out_Control( p_input->p->p_es_out_display,
1822 ES_OUT_RESTART_ES_BY_ID, (int)val.i_int, 1);
1823 break;
1824
1825 case INPUT_CONTROL_SET_AUDIO_DELAY:
1826 input_SendEventAudioDelay( p_input, val.i_int );
1827 UpdatePtsDelay( p_input );
1828 break;
1829
1830 case INPUT_CONTROL_SET_SPU_DELAY:
1831 input_SendEventSubtitleDelay( p_input, val.i_int );
1832 UpdatePtsDelay( p_input );
1833 break;
1834
1835 case INPUT_CONTROL_SET_TITLE:
1836 case INPUT_CONTROL_SET_TITLE_NEXT:
1837 case INPUT_CONTROL_SET_TITLE_PREV:
1838 {
1839 if( p_input->p->b_recording )
1840 {
1841 msg_Err( p_input, "INPUT_CONTROL_SET_TITLE(*) ignored while recording" );
1842 break;
1843 }
1844 if( p_input->p->input.i_title <= 0 )
1845 break;
1846
1847 int i_title = p_input->p->input.p_demux->info.i_title;
1848 if( i_type == INPUT_CONTROL_SET_TITLE_PREV )
1849 i_title--;
1850 else if( i_type == INPUT_CONTROL_SET_TITLE_NEXT )
1851 i_title++;
1852 else
1853 i_title = val.i_int;
1854 if( i_title < 0 || i_title >= p_input->p->input.i_title )
1855 break;
1856
1857 es_out_SetTime( p_input->p->p_es_out, -1 );
1858 demux_Control( p_input->p->input.p_demux,
1859 DEMUX_SET_TITLE, i_title );
1860 input_SendEventTitle( p_input, i_title );
1861 break;
1862 }
1863 case INPUT_CONTROL_SET_SEEKPOINT:
1864 case INPUT_CONTROL_SET_SEEKPOINT_NEXT:
1865 case INPUT_CONTROL_SET_SEEKPOINT_PREV:
1866 {
1867 if( p_input->p->b_recording )
1868 {
1869 msg_Err( p_input, "INPUT_CONTROL_SET_SEEKPOINT(*) ignored while recording" );
1870 break;
1871 }
1872 if( p_input->p->input.i_title <= 0 )
1873 break;
1874
1875 demux_t *p_demux = p_input->p->input.p_demux;
1876
1877 int i_title = p_demux->info.i_title;
1878 int i_seekpoint = p_demux->info.i_seekpoint;
1879
1880 if( i_type == INPUT_CONTROL_SET_SEEKPOINT_PREV )
1881 {
1882 int64_t i_seekpoint_time = p_input->p->input.title[i_title]->seekpoint[i_seekpoint]->i_time_offset;
1883 int64_t i_input_time = var_GetInteger( p_input, "time" );
1884 if( i_seekpoint_time >= 0 && i_input_time >= 0 )
1885 {
1886 if( i_input_time < i_seekpoint_time + 3000000 )
1887 i_seekpoint--;
1888 }
1889 else
1890 i_seekpoint--;
1891 }
1892 else if( i_type == INPUT_CONTROL_SET_SEEKPOINT_NEXT )
1893 i_seekpoint++;
1894 else
1895 i_seekpoint = val.i_int;
1896 if( i_seekpoint < 0
1897 || i_seekpoint >= p_input->p->input.title[i_title]->i_seekpoint )
1898 break;
1899
1900 es_out_SetTime( p_input->p->p_es_out, -1 );
1901 demux_Control( p_input->p->input.p_demux,
1902 DEMUX_SET_SEEKPOINT, i_seekpoint );
1903 input_SendEventSeekpoint( p_input, i_title, i_seekpoint );
1904 break;
1905 }
1906
1907 case INPUT_CONTROL_ADD_SUBTITLE:
1908 if( val.psz_string )
1909 input_SubtitleFileAdd( p_input, val.psz_string, true );
1910 break;
1911
1912 case INPUT_CONTROL_ADD_SLAVE:
1913 if( val.psz_string )
1914 {
1915 const char *uri = val.psz_string;
1916 input_source_t *slave = InputSourceNew( p_input );
1917
1918 if( slave && !InputSourceInit( p_input, slave, uri, NULL, false ) )
1919 {
1920 int64_t i_time;
1921
1922 /* Add the slave */
1923 msg_Dbg( p_input, "adding %s as slave on the fly", uri );
1924
1925 /* Set position */
1926 if( demux_Control( p_input->p->input.p_demux,
1927 DEMUX_GET_TIME, &i_time ) )
1928 {
1929 msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" );
1930 InputSourceClean( slave );
1931 free( slave );
1932 break;
1933 }
1934 if( demux_Control( slave->p_demux,
1935 DEMUX_SET_TIME, i_time, true ) )
1936 {
1937 msg_Err( p_input, "seek failed for new slave" );
1938 InputSourceClean( slave );
1939 free( slave );
1940 break;
1941 }
1942
1943 /* Get meta (access and demux) */
1944 InputUpdateMeta( p_input, slave->p_demux );
1945
1946 TAB_APPEND( p_input->p->i_slave, p_input->p->slave, slave );
1947 }
1948 else
1949 {
1950 free( slave );
1951 msg_Warn( p_input, "failed to add %s as slave", uri );
1952 }
1953 }
1954 break;
1955
1956 case INPUT_CONTROL_SET_RECORD_STATE:
1957 if( !!p_input->p->b_recording != !!val.b_bool )
1958 {
1959 if( p_input->p->input.b_can_stream_record )
1960 {
1961 if( demux_Control( p_input->p->input.p_demux,
1962 DEMUX_SET_RECORD_STATE, val.b_bool ) )
1963 val.b_bool = false;
1964 }
1965 else
1966 {
1967 if( es_out_SetRecordState( p_input->p->p_es_out_display, val.b_bool ) )
1968 val.b_bool = false;
1969 }
1970 p_input->p->b_recording = val.b_bool;
1971
1972 input_SendEventRecord( p_input, val.b_bool );
1973
1974 b_force_update = true;
1975 }
1976 break;
1977
1978 case INPUT_CONTROL_SET_FRAME_NEXT:
1979 if( p_input->p->i_state == PAUSE_S )
1980 {
1981 es_out_SetFrameNext( p_input->p->p_es_out );
1982 }
1983 else if( p_input->p->i_state == PLAYING_S )
1984 {
1985 ControlPause( p_input, i_control_date );
1986 }
1987 else
1988 {
1989 msg_Err( p_input, "invalid state for frame next" );
1990 }
1991 b_force_update = true;
1992 break;
1993
1994 case INPUT_CONTROL_SET_BOOKMARK:
1995 {
1996 mtime_t time_offset = -1;
1997
1998 vlc_mutex_lock( &p_input->p->p_item->lock );
1999 if( val.i_int >= 0 && val.i_int < p_input->p->i_bookmark )
2000 {
2001 const seekpoint_t *p_bookmark = p_input->p->pp_bookmark[val.i_int];
2002 time_offset = p_bookmark->i_time_offset;
2003 }
2004 vlc_mutex_unlock( &p_input->p->p_item->lock );
2005
2006 if( time_offset < 0 )
2007 {
2008 msg_Err( p_input, "invalid bookmark %"PRId64, val.i_int );
2009 break;
2010 }
2011
2012 val.i_int = time_offset;
2013 b_force_update = Control( p_input, INPUT_CONTROL_SET_TIME, val );
2014 break;
2015 }
2016
2017 case INPUT_CONTROL_NAV_ACTIVATE:
2018 case INPUT_CONTROL_NAV_UP:
2019 case INPUT_CONTROL_NAV_DOWN:
2020 case INPUT_CONTROL_NAV_LEFT:
2021 case INPUT_CONTROL_NAV_RIGHT:
2022 demux_Control( p_input->p->input.p_demux, i_type
2023 - INPUT_CONTROL_NAV_ACTIVATE + DEMUX_NAV_ACTIVATE );
2024 break;
2025
2026 default:
2027 msg_Err( p_input, "not yet implemented" );
2028 break;
2029 }
2030
2031 ControlRelease( i_type, val );
2032 return b_force_update;
2033 }
2034
2035 /*****************************************************************************
2036 * UpdateTitleSeekpoint
2037 *****************************************************************************/
2038 static int UpdateTitleSeekpoint( input_thread_t *p_input,
2039 int i_title, int i_seekpoint )
2040 {
2041 int i_title_end = p_input->p->input.i_title_end -
2042 p_input->p->input.i_title_offset;
2043 int i_seekpoint_end = p_input->p->input.i_seekpoint_end -
2044 p_input->p->input.i_seekpoint_offset;
2045
2046 if( i_title_end >= 0 && i_seekpoint_end >= 0 )
2047 {
2048 if( i_title > i_title_end ||
2049 ( i_title == i_title_end && i_seekpoint > i_seekpoint_end ) )
2050 return 0;
2051 }
2052 else if( i_seekpoint_end >= 0 )
2053 {
2054 if( i_seekpoint > i_seekpoint_end )
2055 return 0;
2056 }
2057 else if( i_title_end >= 0 )
2058 {
2059 if( i_title > i_title_end )
2060 return 0;
2061 }
2062 return 1;
2063 }
2064 /*****************************************************************************
2065 * Update*FromDemux:
2066 *****************************************************************************/
2067 static int UpdateTitleSeekpointFromDemux( input_thread_t *p_input )
2068 {
2069 demux_t *p_demux = p_input->p->input.p_demux;
2070
2071 /* TODO event-like */
2072 if( p_demux->info.i_update & INPUT_UPDATE_TITLE )
2073 {
2074 input_SendEventTitle( p_input, p_demux->info.i_title );
2075
2076 p_demux->info.i_update &= ~INPUT_UPDATE_TITLE;
2077 }
2078 if( p_demux->info.i_update & INPUT_UPDATE_SEEKPOINT )
2079 {
2080 input_SendEventSeekpoint( p_input,
2081 p_demux->info.i_title, p_demux->info.i_seekpoint );
2082
2083 p_demux->info.i_update &= ~INPUT_UPDATE_SEEKPOINT;
2084 }
2085
2086 /* Hmmm only works with master input */
2087 if( p_input->p->input.p_demux == p_demux )
2088 return UpdateTitleSeekpoint( p_input,
2089 p_demux->info.i_title,
2090 p_demux->info.i_seekpoint );
2091 return 1;
2092 }
2093
2094 static void UpdateGenericFromDemux( input_thread_t *p_input )
2095 {
2096 demux_t *p_demux = p_input->p->input.p_demux;
2097
2098 if( p_demux->info.i_update & INPUT_UPDATE_META )
2099 {
2100 InputUpdateMeta( p_input, p_demux );
2101 p_demux->info.i_update &= ~INPUT_UPDATE_META;
2102 }
2103 {
2104 double quality;
2105 double strength;
2106
2107 if( !demux_Control( p_demux, DEMUX_GET_SIGNAL, &quality, &strength ) )
2108 input_SendEventSignal( p_input, quality, strength );
2109 }
2110 }
2111
2112 static void UpdateTitleListfromDemux( input_thread_t *p_input )
2113 {
2114 input_source_t *in = &p_input->p->input;
2115
2116 /* Delete the preexisting titles */
2117 if( in->i_title > 0 )
2118 {
2119 for( int i = 0; i < in->i_title; i++ )
2120 vlc_input_title_Delete( in->title[i] );
2121 TAB_CLEAN( in->i_title, in->title );
2122 in->b_title_demux = false;
2123 }
2124
2125 /* Get the new title list */
2126 if( demux_Control( in->p_demux, DEMUX_GET_TITLE_INFO,
2127 &in->title, &in->i_title,
2128 &in->i_title_offset, &in->i_seekpoint_offset ) )
2129 TAB_INIT( in->i_title, in->title );
2130 else
2131 in->b_title_demux = true;
2132
2133 InitTitle( p_input );
2134 }
2135
2136
2137 /*****************************************************************************
2138 * InputSourceNew:
2139 *****************************************************************************/
2140 static input_source_t *InputSourceNew( input_thread_t *p_input )
2141 {
2142 VLC_UNUSED(p_input);
2143
2144 return calloc( 1, sizeof( input_source_t ) );
2145 }
2146
2147 /*****************************************************************************
2148 * InputSourceInit:
2149 *****************************************************************************/
2150 static int InputSourceInit( input_thread_t *p_input,
2151 input_source_t *in, const char *psz_mrl,
2152 const char *psz_forced_demux, bool b_in_can_fail )
2153 {
2154 const char *psz_access, *psz_demux, *psz_path, *psz_anchor = NULL;
2155 char *psz_var_demux = NULL;
2156 double f_fps;
2157
2158 assert( psz_mrl );
2159 char *psz_dup = strdup( psz_mrl );
2160
2161 if( psz_dup == NULL )
2162 goto error;
2163
2164 /* Split uri */
2165 input_SplitMRL( &psz_access, &psz_demux, &psz_path, &psz_anchor, psz_dup );
2166
2167 msg_Dbg( p_input, "`%s' gives access `%s' demux `%s' path `%s'",
2168 psz_mrl, psz_access, psz_demux, psz_path );
2169 if( !p_input->b_preparsing )
2170 {
2171 /* Find optional titles and seekpoints */
2172 MRLSections( psz_anchor, &in->i_title_start, &in->i_title_end,
2173 &in->i_seekpoint_start, &in->i_seekpoint_end );
2174 if( psz_forced_demux && *psz_forced_demux )
2175 {
2176 psz_demux = psz_forced_demux;
2177 }
2178 else if( *psz_demux == '\0' )
2179 {
2180 /* special hack for forcing a demuxer with --demux=module
2181 * (and do nothing with a list) */
2182 psz_var_demux = var_GetNonEmptyString( p_input, "demux" );
2183 psz_demux = (psz_var_demux != NULL) ? psz_var_demux : "any";
2184 msg_Dbg( p_input, "specified demux `%s'", psz_demux );
2185 }
2186
2187 /* Try access_demux first */
2188 in->p_demux = demux_New( p_input, p_input, psz_access, psz_demux,
2189 psz_path, NULL, p_input->p->p_es_out, false );
2190 }
2191 else
2192 {
2193 if( *psz_demux )
2194 goto error;
2195 msg_Dbg( p_input, "trying to pre-parse %s", psz_path );
2196 }
2197
2198 mtime_t i_pts_delay;
2199
2200 if( in->p_demux )
2201 {
2202 /* Get infos from access_demux */
2203 in->b_title_demux = true;
2204 if( demux_Control( in->p_demux, DEMUX_GET_TITLE_INFO,
2205 &in->title, &in->i_title,
2206 &in->i_title_offset, &in->i_seekpoint_offset ) )
2207 {
2208 TAB_INIT( in->i_title, in->title );
2209 }
2210 if( demux_Control( in->p_demux, DEMUX_CAN_CONTROL_PACE,
2211 &in->b_can_pace_control ) )
2212 in->b_can_pace_control = false;
2213
2214 assert( in->p_demux->pf_demux != NULL || !in->b_can_pace_control );
2215
2216 if( !in->b_can_pace_control )
2217 {
2218 if( demux_Control( in->p_demux, DEMUX_CAN_CONTROL_RATE,
2219 &in->b_can_rate_control, &in->b_rescale_ts ) )
2220 {
2221 in->b_can_rate_control = false;
2222 in->b_rescale_ts = true; /* not used */
2223 }
2224 }
2225 else
2226 {
2227 in->b_can_rate_control = true;
2228 in->b_rescale_ts = true;
2229 }
2230 if( demux_Control( in->p_demux, DEMUX_CAN_PAUSE,
2231 &in->b_can_pause ) )
2232 in->b_can_pause = false;
2233 var_SetBool( p_input, "can-pause", in->b_can_pause || !in->b_can_pace_control ); /* XXX temporary because of es_out_timeshift*/
2234 var_SetBool( p_input, "can-rate", !in->b_can_pace_control || in->b_can_rate_control ); /* XXX temporary because of es_out_timeshift*/
2235 var_SetBool( p_input, "can-rewind", !in->b_rescale_ts && !in->b_can_pace_control && in->b_can_rate_control );
2236
2237 bool b_can_seek;
2238 if( demux_Control( in->p_demux, DEMUX_CAN_SEEK, &b_can_seek ) )
2239 b_can_seek = false;
2240 var_SetBool( p_input, "can-seek", b_can_seek );
2241 }
2242 else
2243 { /* Now try a real access */
2244 if( &p_input->p->input == in )
2245 { /* On master stream only, use input-list */
2246 char *str = var_InheritString( p_input, "input-list" );
2247 if( str != NULL )
2248 {
2249 char *list;
2250
2251 var_Create( p_input, "concat-list", VLC_VAR_STRING );
2252 if( likely(asprintf( &list, "%s://%s,%s", psz_access, psz_path,
2253 str ) >= 0) )
2254 {
2255 var_SetString( p_input, "concat-list", list );
2256 free( list );
2257 }
2258 free( str );
2259 psz_access = "concat";
2260 }
2261 }
2262
2263 if( strcasecmp( psz_access, "concat" ) )
2264 { /* Autodetect extra files if none specified */
2265 int count;
2266 char **tab;
2267
2268 TAB_INIT( count, tab );
2269 InputGetExtraFiles( p_input, &count, &tab, psz_access, psz_path );
2270 if( count > 0 )
2271 {
2272 char *list = NULL;
2273
2274 for( int i = 0; i < count; i++ )
2275 {
2276 char *str;
2277 if( asprintf( &str, "%s,%s", list ? list : psz_mrl,
2278 tab[i] ) < 0 )
2279 break;
2280
2281 free( tab[i] );
2282 free( list );
2283 list = str;
2284 }
2285
2286 var_Create( p_input, "concat-list", VLC_VAR_STRING );
2287 if( likely(list != NULL) )
2288 {
2289 var_SetString( p_input, "concat-list", list );
2290 free( list );
2291 }
2292 psz_access = "concat";
2293 }
2294 TAB_CLEAN( count, tab );
2295 }
2296
2297 /* */
2298 access_t *p_access = access_New( p_input, p_input,
2299 psz_access, psz_path );
2300 if( p_access == NULL )
2301 {
2302 msg_Err( p_input, "open of `%s' failed", psz_mrl );
2303 if( !b_in_can_fail && !input_Stopped( p_input ) )
2304 dialog_Fatal( p_input, _("Your input can't be opened"),
2305 _("VLC is unable to open the MRL '%s'."
2306 " Check the log for details."), psz_mrl );
2307 goto error;
2308 }
2309
2310 /* Access-forced demuxer (PARENTAL ADVISORY: EXPLICIT HACK) */
2311 #warning FIXME: parse content type
2312
2313 /* Create the stream_t */
2314 stream_t *p_stream = stream_AccessNew( p_access );
2315 if( p_stream == NULL )
2316 {
2317 msg_Warn( p_input, "cannot create a stream_t from access" );
2318 goto error;
2319 }
2320
2321 /* Add stream filters */
2322 char *psz_stream_filter = var_GetNonEmptyString( p_input,
2323 "stream-filter" );
2324 p_stream = stream_FilterChainNew( p_stream, psz_stream_filter,
2325 var_GetBool( p_input, "input-record-native" ) );
2326 free( psz_stream_filter );
2327
2328 if( !p_input->b_preparsing )
2329 {
2330 bool b;
2331
2332 stream_Control( p_stream, STREAM_CAN_CONTROL_PACE,
2333 &in->b_can_pace_control );
2334 in->b_can_rate_control = in->b_can_pace_control;
2335 in->b_rescale_ts = true;
2336
2337 stream_Control( p_stream, STREAM_CAN_PAUSE, &in->b_can_pause );
2338 var_SetBool( p_input, "can-pause",
2339 in->b_can_pause || !in->b_can_pace_control ); /* XXX temporary because of es_out_timeshift*/
2340 var_SetBool( p_input, "can-rate",
2341 !in->b_can_pace_control || in->b_can_rate_control ); /* XXX temporary because of es_out_timeshift*/
2342 var_SetBool( p_input, "can-rewind",
2343 !in->b_rescale_ts && !in->b_can_pace_control );
2344
2345 stream_Control( p_stream, STREAM_CAN_SEEK, &b );
2346 var_SetBool( p_input, "can-seek", b );
2347
2348 in->b_title_demux = false;
2349
2350 stream_Control( p_stream, STREAM_GET_PTS_DELAY, &i_pts_delay );
2351 }
2352
2353 if( p_stream->psz_url != NULL )
2354 /* Take access/stream redirections into account: */
2355 psz_path = strstr( p_stream->psz_url, "://" );
2356 if( psz_path == NULL )
2357 psz_path = "";
2358
2359 in->p_demux = demux_New( p_input, p_input, psz_access, psz_demux,
2360 psz_path, p_stream, p_input->p->p_es_out,
2361 p_input->b_preparsing );
2362
2363 if( in->p_demux == NULL )
2364 {
2365 msg_Err( p_input, "no suitable demux module for `%s/%s://%s'",
2366 psz_access, psz_demux, psz_path );
2367 if( !b_in_can_fail && !input_Stopped( p_input ) )
2368 dialog_Fatal( VLC_OBJECT( p_input ),
2369 _("VLC can't recognize the input's format"),
2370 _("The format of '%s' cannot be detected. "
2371 "Have a look at the log for details."),
2372 psz_mrl );
2373 stream_Delete( p_stream );
2374 goto error;
2375 }
2376 assert( in->p_demux->pf_demux != NULL );
2377
2378 /* Get title from demux */
2379 if( !p_input->b_preparsing && in->i_title <= 0 )
2380 {
2381 if( demux_Control( in->p_demux, DEMUX_GET_TITLE_INFO,
2382 &in->title, &in->i_title,
2383 &in->i_title_offset, &in->i_seekpoint_offset ))
2384 {
2385 TAB_INIT( in->i_title, in->title );
2386 }
2387 else
2388 {
2389 in->b_title_demux = true;
2390 }
2391 }
2392 }
2393
2394 free( psz_var_demux );
2395 free( psz_dup );
2396
2397 /* Set record capabilities */
2398 if( demux_Control( in->p_demux, DEMUX_CAN_RECORD, &in->b_can_stream_record ) )
2399 in->b_can_stream_record = false;
2400 #ifdef ENABLE_SOUT
2401 if( !var_GetBool( p_input, "input-record-native" ) )
2402 in->b_can_stream_record = false;
2403 var_SetBool( p_input, "can-record", true );
2404 #else
2405 var_SetBool( p_input, "can-record", in->b_can_stream_record );
2406 #endif
2407
2408 /* get attachment
2409 * FIXME improve for b_preparsing: move it after GET_META and check psz_arturl */
2410 if( !p_input->b_preparsing )
2411 {
2412 int i_attachment;
2413 input_attachment_t **attachment;
2414 if( !demux_Control( in->p_demux, DEMUX_GET_ATTACHMENTS,
2415 &attachment, &i_attachment ) )
2416 {
2417 vlc_mutex_lock( &p_input->p->p_item->lock );
2418 AppendAttachment( &p_input->p->i_attachment, &p_input->p->attachment, &p_input->p->attachment_demux,
2419 i_attachment, attachment, in->p_demux );
2420 vlc_mutex_unlock( &p_input->p->p_item->lock );
2421 }
2422
2423 /* PTS delay: request from demux first. This is required for
2424 * access_demux and some special cases like SDP demux. Otherwise,
2425 * fallback to access */
2426 if( demux_Control( in->p_demux, DEMUX_GET_PTS_DELAY,
2427 &in->i_pts_delay ) )
2428 in->i_pts_delay = i_pts_delay;
2429 if( in->i_pts_delay > INPUT_PTS_DELAY_MAX )
2430 in->i_pts_delay = INPUT_PTS_DELAY_MAX;
2431 else if( in->i_pts_delay < 0 )
2432 in->i_pts_delay = 0;
2433 }
2434
2435 if( !demux_Control( in->p_demux, DEMUX_GET_FPS, &f_fps ) && f_fps > 0.0 )
2436 {
2437 vlc_mutex_lock( &p_input->p->p_item->lock );
2438 p_input->p->f_fps = f_fps;
2439 vlc_mutex_unlock( &p_input->p->p_item->lock );
2440 }
2441
2442 if( var_GetInteger( p_input, "clock-synchro" ) != -1 )
2443 in->b_can_pace_control = !var_GetInteger( p_input, "clock-synchro" );
2444
2445 return VLC_SUCCESS;
2446
2447 error:
2448 if( in->p_demux )
2449 demux_Delete( in->p_demux );
2450
2451 free( psz_var_demux );
2452 free( psz_dup );
2453
2454 return VLC_EGENERIC;
2455 }
2456
2457 /*****************************************************************************
2458 * InputSourceClean:
2459 *****************************************************************************/
2460 static void InputSourceClean( input_source_t *in )
2461 {
2462 int i;
2463
2464 if( in->p_demux )
2465 demux_Delete( in->p_demux );
2466
2467 if( in->i_title > 0 )
2468 {
2469 for( i = 0; i < in->i_title; i++ )
2470 vlc_input_title_Delete( in->title[i] );
2471 TAB_CLEAN( in->i_title, in->title );
2472 }
2473 }
2474
2475 /*****************************************************************************
2476 * InputSourceMeta:
2477 *****************************************************************************/
2478 static void InputSourceMeta( input_thread_t *p_input,
2479 input_source_t *p_source, vlc_meta_t *p_meta )
2480 {
2481 demux_t *p_demux = p_source->p_demux;
2482
2483 /* XXX Remember that checking against p_item->p_meta->i_status & ITEM_PREPARSED
2484 * is a bad idea */
2485
2486 bool has_meta = false;
2487
2488 /* Read demux meta */
2489 if( !demux_Control( p_demux, DEMUX_GET_META, p_meta ) )
2490 has_meta = true;
2491
2492 bool has_unsupported;
2493 if( demux_Control( p_demux, DEMUX_HAS_UNSUPPORTED_META, &has_unsupported ) )
2494 has_unsupported = true;
2495
2496 /* If the demux report unsupported meta data, or if we don't have meta data
2497 * try an external "meta reader" */
2498 if( has_meta && !has_unsupported )
2499 return;
2500
2501 demux_meta_t *p_demux_meta =
2502 vlc_custom_create( p_input, sizeof( *p_demux_meta ), "demux meta" );
2503 if( unlikely(p_demux_meta == NULL) )
2504 return;
2505 p_demux_meta->p_item = p_input->p->p_item;
2506
2507 module_t *p_id3 = module_need( p_demux_meta, "meta reader", NULL, false );
2508 if( p_id3 )
2509 {
2510 if( p_demux_meta->p_meta )
2511 {
2512 vlc_meta_Merge( p_meta, p_demux_meta->p_meta );
2513 vlc_meta_Delete( p_demux_meta->p_meta );
2514 }
2515
2516 if( p_demux_meta->i_attachments > 0 )
2517 {
2518 vlc_mutex_lock( &p_input->p->p_item->lock );
2519 AppendAttachment( &p_input->p->i_attachment, &p_input->p->attachment, &p_input->p->attachment_demux,
2520 p_demux_meta->i_attachments, p_demux_meta->attachments, p_demux);
2521 vlc_mutex_unlock( &p_input->p->p_item->lock );
2522 }
2523 module_unneed( p_demux, p_id3 );
2524 }
2525 vlc_object_release( p_demux_meta );
2526 }
2527
2528
2529 static void SlaveDemux( input_thread_t *p_input )
2530 {
2531 int64_t i_time;
2532 int i;
2533
2534 if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_TIME, &i_time ) )
2535 {
2536 msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" );
2537 return;
2538 }
2539
2540 for( i = 0; i < p_input->p->i_slave; i++ )
2541 {
2542 input_source_t *in = p_input->p->slave[i];
2543 int i_ret;
2544
2545 if( in->b_eof )
2546 continue;
2547
2548 /* Call demux_Demux until we have read enough data */
2549 if( demux_Control( in->p_demux, DEMUX_SET_NEXT_DEMUX_TIME, i_time ) )
2550 {
2551 for( ;; )
2552 {
2553 int64_t i_stime;
2554 if( demux_Control( in->p_demux, DEMUX_GET_TIME, &i_stime ) )
2555 {
2556 msg_Err( p_input, "slave[%d] doesn't like "
2557 "DEMUX_GET_TIME -> EOF", i );
2558 i_ret = 0;
2559 break;
2560 }
2561
2562 if( i_stime >= i_time )
2563 {
2564 i_ret = 1;
2565 break;
2566 }
2567
2568 if( ( i_ret = demux_Demux( in->p_demux ) ) <= 0 )
2569 break;
2570 }
2571 }
2572 else
2573 {
2574 i_ret = demux_Demux( in->p_demux );
2575 }
2576
2577 if( i_ret <= 0 )
2578 {
2579 msg_Dbg( p_input, "slave %d EOF", i );
2580 in->b_eof = true;
2581 }
2582 }
2583 }
2584
2585 static void SlaveSeek( input_thread_t *p_input )
2586 {
2587 int64_t i_time;
2588 int i;
2589
2590 if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_TIME, &i_time ) )
2591 {
2592 msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" );
2593 return;
2594 }
2595
2596 for( i = 0; i < p_input->p->i_slave; i++ )
2597 {
2598 input_source_t *in = p_input->p->slave[i];
2599
2600 if( demux_Control( in->p_demux, DEMUX_SET_TIME, i_time, true ) )
2601 {
2602 if( !in->b_eof )
2603 msg_Err( p_input, "seek failed for slave %d -> EOF", i );
2604 in->b_eof = true;
2605 }
2606 else
2607 {
2608 in->b_eof = false;
2609 }
2610 }
2611 }
2612
2613 /*****************************************************************************
2614 * InputMetaUser:
2615 *****************************************************************************/
2616 static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta )
2617 {
2618 static const struct { int i_meta; const char *psz_name; } p_list[] = {
2619 { vlc_meta_Title, "meta-title" },
2620 { vlc_meta_Artist, "meta-artist" },
2621 { vlc_meta_Genre, "meta-genre" },
2622 { vlc_meta_Copyright, "meta-copyright" },
2623 { vlc_meta_Description, "meta-description" },
2624 { vlc_meta_Date, "meta-date" },
2625 { vlc_meta_URL, "meta-url" },
2626 { 0, NULL }
2627 };
2628
2629 /* Get meta information from user */
2630 for( int i = 0; p_list[i].psz_name; i++ )
2631 {
2632 char *psz_string = var_GetNonEmptyString( p_input, p_list[i].psz_name );
2633 if( !psz_string )
2634 continue;
2635
2636 EnsureUTF8( psz_string );
2637 vlc_meta_Set( p_meta, p_list[i].i_meta, psz_string );
2638 free( psz_string );
2639 }
2640 }
2641
2642 static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_attachment, demux_t ***ppp_attachment_demux,
2643 int i_new, input_attachment_t **pp_new, demux_t *p_demux )
2644 {
2645 int i_attachment = *pi_attachment;
2646 input_attachment_t **attachment = *ppp_attachment;
2647 demux_t **attachment_demux = *ppp_attachment_demux;
2648 int i;
2649
2650 attachment = xrealloc( attachment,
2651 sizeof(*attachment) * ( i_attachment + i_new ) );
2652 attachment_demux = xrealloc( attachment_demux,
2653 sizeof(*attachment_demux) * ( i_attachment + i_new ) );
2654 for( i = 0; i < i_new; i++ )
2655 {
2656 attachment[i_attachment] = pp_new[i];
2657 attachment_demux[i_attachment++] = p_demux;
2658 }
2659 free( pp_new );
2660
2661 /* */
2662 *pi_attachment = i_attachment;
2663 *ppp_attachment = attachment;
2664 *ppp_attachment_demux = attachment_demux;
2665 }
2666
2667 /*****************************************************************************
2668 * InputUpdateMeta: merge p_item meta data with p_meta taking care of
2669 * arturl and locking issue.
2670 *****************************************************************************/
2671 static void InputUpdateMeta( input_thread_t *p_input, demux_t *p_demux )
2672 {
2673 vlc_meta_t *p_meta = vlc_meta_New();
2674 if( unlikely(p_meta == NULL) )
2675 return;
2676
2677 demux_Control( p_demux, DEMUX_GET_META, p_meta );
2678
2679 /* If metadata changed, then the attachments might have changed.
2680 We need to update them in case they contain album art. */
2681 input_attachment_t **attachment;
2682 int i_attachment;
2683
2684 if( !demux_Control( p_demux, DEMUX_GET_ATTACHMENTS,
2685 &attachment, &i_attachment ) )
2686 {
2687 vlc_mutex_lock( &p_input->p->p_item->lock );
2688 if( p_input->p->i_attachment > 0 )
2689 {
2690 int j = 0;
2691 for( int i = 0; i < p_input->p->i_attachment; i++ )
2692 {
2693 if( p_input->p->attachment_demux[i] == p_demux )
2694 vlc_input_attachment_Delete( p_input->p->attachment[i] );
2695 else
2696 {
2697 p_input->p->attachment[j] = p_input->p->attachment[i];
2698 p_input->p->attachment_demux[j] = p_input->p->attachment_demux[i];
2699 j++;
2700 }
2701 }
2702 p_input->p->i_attachment = j;
2703 }
2704 AppendAttachment( &p_input->p->i_attachment, &p_input->p->attachment, &p_input->p->attachment_demux,
2705 i_attachment, attachment, p_demux );
2706 vlc_mutex_unlock( &p_input->p->p_item->lock );
2707 }
2708
2709 es_out_ControlSetMeta( p_input->p->p_es_out, p_meta );
2710 vlc_meta_Delete( p_meta );
2711 }
2712
2713 /*****************************************************************************
2714 * InputGetExtraFiles
2715 * Autodetect extra input list
2716 *****************************************************************************/
2717 static void InputGetExtraFilesPattern( input_thread_t *p_input,
2718 int *pi_list, char ***pppsz_list,
2719 const char *psz_path,
2720 const char *psz_match,
2721 const char *psz_format,
2722 int i_start, int i_stop )
2723 {
2724 int i_list;
2725 char **ppsz_list;
2726
2727 TAB_INIT( i_list, ppsz_list );
2728
2729 char *psz_base = strdup( psz_path );
2730 if( !psz_base )
2731 goto exit;
2732
2733 /* Remove the extension */
2734 char *psz_end = &psz_base[strlen(psz_base)-strlen(psz_match)];
2735 assert( psz_end >= psz_base);
2736 *psz_end = '\0';
2737
2738 /* Try to list files */
2739 for( int i = i_start; i <= i_stop; i++ )
2740 {
2741 struct stat st;
2742 char *psz_file;
2743
2744 if( asprintf( &psz_file, psz_format, psz_base, i ) < 0 )
2745 break;
2746
2747 char *psz_tmp_path = get_path( psz_file );
2748
2749 if( vlc_stat( psz_tmp_path, &st ) || !S_ISREG( st.st_mode ) || !st.st_size )
2750 {
2751 free( psz_file );
2752 free( psz_tmp_path );
2753 break;
2754 }
2755
2756 msg_Dbg( p_input, "Detected extra file `%s'", psz_file );
2757 TAB_APPEND( i_list, ppsz_list, psz_file );
2758 free( psz_tmp_path );
2759 }
2760 free( psz_base );
2761 exit:
2762 *pi_list = i_list;
2763 *pppsz_list = ppsz_list;
2764 }
2765
2766 static void InputGetExtraFiles( input_thread_t *p_input,
2767 int *pi_list, char ***pppsz_list,
2768 const char *psz_access, const char *psz_path )
2769 {
2770 static const struct
2771 {
2772 const char *psz_match;
2773 const char *psz_format;
2774 int i_start;
2775 int i_stop;
2776 } p_pattern[] = {
2777 /* XXX the order is important */
2778 { ".001", "%s.%.3d", 2, 999 },
2779 { NULL, NULL, 0, 0 }
2780 };
2781
2782 TAB_INIT( *pi_list, *pppsz_list );
2783
2784 if( ( psz_access && *psz_access && strcmp( psz_access, "file" ) ) || !psz_path )
2785 return;
2786
2787 const size_t i_path = strlen(psz_path);
2788
2789 for( int i = 0; p_pattern[i].psz_match != NULL; i++ )
2790 {
2791 const size_t i_ext = strlen(p_pattern[i].psz_match );
2792
2793 if( i_path < i_ext )
2794 continue;
2795 if( !strcmp( &psz_path[i_path-i_ext], p_pattern[i].psz_match ) )
2796 {
2797 InputGetExtraFilesPattern( p_input, pi_list, pppsz_list,
2798 psz_path,
2799 p_pattern[i].psz_match, p_pattern[i].psz_format,
2800 p_pattern[i].i_start, p_pattern[i].i_stop );
2801 return;
2802 }
2803 }
2804 }
2805
2806 /* */
2807 static void input_ChangeState( input_thread_t *p_input, int i_state )
2808 {
2809 if( p_input->p->i_state == i_state )
2810 return;
2811
2812 p_input->p->i_state = i_state;
2813 if( i_state == ERROR_S )
2814 input_item_SetErrorWhenReading( p_input->p->p_item, true );
2815 input_SendEventState( p_input, i_state );
2816 }
2817
2818
2819 /*****************************************************************************
2820 * MRLSplit: parse the access, demux and url part of the
2821 * Media Resource Locator.
2822 *****************************************************************************/
2823 void input_SplitMRL( const char **access, const char **demux,
2824 const char **path, const char **anchor, char *buf )
2825 {
2826 char *p;
2827
2828 /* Separate <path> from <access>[/<demux>]:// */
2829 p = strstr( buf, "://" );
2830 if( p != NULL )
2831 {
2832 *p = '\0';
2833 p += 3; /* skips "://" */
2834 *path = p;
2835
2836 /* Remove HTML anchor if present (not supported).
2837 * The hash symbol itself should be URI-encoded. */
2838 p = strchr( p, '#' );
2839 if( p != NULL )
2840 {
2841 *(p++) = '\0';
2842 *anchor = p;
2843 }
2844 else
2845 *anchor = "";
2846 }
2847 else
2848 {
2849 #ifndef NDEBUG
2850 fprintf( stderr, "%s(\"%s\") probably not a valid URI!\n", __func__,
2851 buf );
2852 #endif
2853 /* Note: this is a valid non const pointer to "": */
2854 *path = buf + strlen( buf );
2855 }
2856
2857 /* Separate access from demux */
2858 p = strchr( buf, '/' );
2859 if( p != NULL )
2860 {
2861 *(p++) = '\0';
2862 if( p[0] == '$' )
2863 p++;
2864 *demux = p;
2865 }
2866 else
2867 *demux = "";
2868
2869 /* We really don't want module name substitution here! */
2870 p = buf;
2871 if( p[0] == '$' )
2872 p++;
2873 *access = p;
2874 }
2875
2876 static const char *MRLSeekPoint( const char *str, int *title, int *chapter )
2877 {
2878 char *end;
2879 unsigned long u;
2880
2881 /* Look for the title */
2882 u = strtoul( str, &end, 0 );
2883 *title = (str == end || u > (unsigned long)INT_MAX) ? -1 : (int)u;
2884 str = end;
2885
2886 /* Look for the chapter */
2887 if( *str == ':' )
2888 {
2889 str++;
2890 u = strtoul( str, &end, 0 );
2891 *chapter = (str == end || u > (unsigned long)INT_MAX) ? -1 : (int)u;
2892 str = end;
2893 }
2894 else
2895 *chapter = -1;
2896
2897 return str;
2898 }
2899
2900
2901 /*****************************************************************************
2902 * MRLSections: parse title and seekpoint info from the Media Resource Locator.
2903 *
2904 * Syntax:
2905 * [url][@[title_start][:chapter_start][-[title_end][:chapter_end]]]
2906 *****************************************************************************/
2907 static void MRLSections( const char *p,
2908 int *pi_title_start, int *pi_title_end,
2909 int *pi_chapter_start, int *pi_chapter_end )
2910 {
2911 *pi_title_start = *pi_title_end = *pi_chapter_start = *pi_chapter_end = -1;
2912
2913 int title_start, chapter_start, title_end, chapter_end;
2914
2915 if( !p )
2916 return;
2917
2918 if( *p != '-' )
2919 p = MRLSeekPoint( p, &title_start, &chapter_start );
2920 else
2921 title_start = chapter_start = -1;
2922
2923 if( *p == '-' )
2924 p = MRLSeekPoint( p + 1, &title_end, &chapter_end );
2925 else
2926 title_end = chapter_end = -1;
2927
2928 if( *p ) /* syntax error */
2929 return;
2930
2931 *pi_title_start = title_start;
2932 *pi_title_end = title_end;
2933 *pi_chapter_start = chapter_start;
2934 *pi_chapter_end = chapter_end;
2935 }
2936
2937 /*****************************************************************************
2938 * input_AddSubtitles: add a subtitle file and enable it
2939 *****************************************************************************/
2940 static void input_SubtitleAdd( input_thread_t *p_input,
2941 const char *url, unsigned i_flags )
2942 {
2943 input_source_t *sub = InputSourceNew( p_input );
2944 if( sub == NULL )
2945 return;
2946
2947 vlc_value_t count;
2948
2949 var_Change( p_input, "spu-es", VLC_VAR_CHOICESCOUNT, &count, NULL );
2950
2951 if( InputSourceInit( p_input, sub, url, "subtitle",
2952 (i_flags & SUB_CANFAIL) ) )
2953 {
2954 free( sub );
2955 return;
2956 }
2957 TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub );
2958
2959 if( !(i_flags & SUB_FORCED) )//one of them is false
2960 return;
2961
2962 /* Select the ES */
2963 vlc_value_t list;
2964
2965 if( var_Change( p_input, "spu-es", VLC_VAR_GETCHOICES, &list, NULL ) )
2966 return;
2967 if( count.i_int == 0 )
2968 count.i_int++;
2969 /* if it was first one, there is disable too */
2970
2971 if( count.i_int < list.p_list->i_count )//the count must have been increased by other thread, in EsOutAdd
2972 {
2973 const int i_id = list.p_list->p_values[count.i_int].i_int;
2974
2975 es_out_Control( p_input->p->p_es_out_display, ES_OUT_SET_ES_DEFAULT_BY_ID, i_id );
2976 es_out_Control( p_input->p->p_es_out_display, ES_OUT_SET_ES_BY_ID, i_id );
2977 }
2978 var_FreeList( &list, NULL );
2979 }
2980
2981 static void input_SubtitleFileAdd( input_thread_t *p_input, char *psz_subtitle,
2982 unsigned i_flags )
2983 {
2984 /* if we are provided a subtitle.sub file,
2985 * see if we don't have a subtitle.idx and use it instead */
2986 char *psz_path = strdup( psz_subtitle );
2987 if( likely(psz_path != NULL) )
2988 {
2989 char *psz_extension = strrchr( psz_path, '.');
2990 if( psz_extension && strcmp( psz_extension, ".sub" ) == 0 )
2991 {
2992 struct stat st;
2993
2994 strcpy( psz_extension, ".idx" );
2995
2996 if( !vlc_stat( psz_path, &st ) && S_ISREG( st.st_mode ) )
2997 {
2998 msg_Dbg( p_input, "using %s as subtitle file instead of %s",
2999 psz_path, psz_subtitle );
3000 strcpy( psz_subtitle, psz_path ); /* <- FIXME! constify */
3001 }
3002 }
3003 free( psz_path );
3004 }
3005
3006 char *url = vlc_path2uri( psz_subtitle, NULL );
3007 if( url == NULL )
3008 return;
3009
3010 input_SubtitleAdd( p_input, url, i_flags );
3011 free( url );
3012 }
3013
3014 /*****************************************************************************
3015 * Statistics
3016 *****************************************************************************/
3017 void input_UpdateStatistic( input_thread_t *p_input,
3018 input_statistic_t i_type, int i_delta )
3019 {
3020 assert( p_input->p->i_state != INIT_S );
3021
3022 vlc_mutex_lock( &p_input->p->counters.counters_lock);
3023 switch( i_type )
3024 {
3025 #define I(c) stats_Update( p_input->p->counters.c, i_delta, NULL )
3026 case INPUT_STATISTIC_DECODED_VIDEO:
3027 I(p_decoded_video);
3028 break;
3029 case INPUT_STATISTIC_DECODED_AUDIO:
3030 I(p_decoded_audio);
3031 break;
3032 case INPUT_STATISTIC_DECODED_SUBTITLE:
3033 I(p_decoded_sub);
3034 break;
3035 case INPUT_STATISTIC_SENT_PACKET:
3036 I(p_sout_sent_packets);
3037 break;
3038 #undef I
3039 case INPUT_STATISTIC_SENT_BYTE:
3040 {
3041 uint64_t bytes;
3042
3043 stats_Update( p_input->p->counters.p_sout_sent_bytes, i_delta, &bytes );
3044 stats_Update( p_input->p->counters.p_sout_send_bitrate, bytes, NULL );
3045 break;
3046 }
3047 default:
3048 msg_Err( p_input, "Invalid statistic type %d (internal error)", i_type );
3049 break;
3050 }
3051 vlc_mutex_unlock( &p_input->p->counters.counters_lock);
3052 }
3053
3054 /**/
3055 /* TODO FIXME nearly the same logic that snapshot code */
3056 char *input_CreateFilename( input_thread_t *input, const char *psz_path, const char *psz_prefix, const char *psz_extension )
3057 {
3058 char *psz_file;
3059 DIR *path;
3060
3061 path = vlc_opendir( psz_path );
3062 if( path )
3063 {
3064 closedir( path );
3065
3066 char *psz_tmp = str_format( input, psz_prefix );
3067 if( !psz_tmp )
3068 return NULL;
3069
3070 filename_sanitize( psz_tmp );
3071
3072 if( asprintf( &psz_file, "%s"DIR_SEP"%s%s%s",
3073 psz_path, psz_tmp,
3074 psz_extension ? "." : "",
3075 psz_extension ? psz_extension : "" ) < 0 )
3076 psz_file = NULL;
3077 free( psz_tmp );
3078 return psz_file;
3079 }
3080 else
3081 {
3082 psz_file = str_format( input, psz_path );
3083 path_sanitize( psz_file );
3084 return psz_file;
3085 }
3086 }
allow multiple subtitles displayed at the same time(two currently )