git.sesse.net Git - vlc/blob - src/input/input.c

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