src/input/var.c

   1 /*****************************************************************************
   2  * var.c: object variables for input thread
   3  *****************************************************************************
   4  * Copyright (C) 2004-2007 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc_common.h>
  32 #include <assert.h>
  33 #include <math.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36
  37 #include "input_internal.h"
  38
  39 /*****************************************************************************
  40  * Callbacks
  41  *****************************************************************************/
  42 static int StateCallback   ( vlc_object_t *p_this, char const *psz_cmd,
  43                              vlc_value_t oldval, vlc_value_t newval, void * );
  44 static int RateCallback    ( vlc_object_t *p_this, char const *psz_cmd,
  45                              vlc_value_t oldval, vlc_value_t newval, void * );
  46 static int PositionCallback( vlc_object_t *p_this, char const *psz_cmd,
  47                              vlc_value_t oldval, vlc_value_t newval, void * );
  48 static int TimeCallback    ( vlc_object_t *p_this, char const *psz_cmd,
  49                              vlc_value_t oldval, vlc_value_t newval, void * );
  50 static int TimeOffsetCallback( vlc_object_t *p_this, char const *psz_cmd,
  51                              vlc_value_t oldval, vlc_value_t newval, void * );
  52 static int ProgramCallback ( vlc_object_t *p_this, char const *psz_cmd,
  53                              vlc_value_t oldval, vlc_value_t newval, void * );
  54 static int TitleCallback   ( vlc_object_t *p_this, char const *psz_cmd,
  55                              vlc_value_t oldval, vlc_value_t newval, void * );
  56 static int SeekpointCallback( vlc_object_t *p_this, char const *psz_cmd,
  57                              vlc_value_t oldval, vlc_value_t newval, void * );
  58 static int NavigationCallback( vlc_object_t *p_this, char const *psz_cmd,
  59                              vlc_value_t oldval, vlc_value_t newval, void * );
  60 static int EsVideoCallback ( vlc_object_t *p_this, char const *psz_cmd,
  61                              vlc_value_t oldval, vlc_value_t newval, void * );
  62 static int EsAudioCallback ( vlc_object_t *p_this, char const *psz_cmd,
  63                              vlc_value_t oldval, vlc_value_t newval, void * );
  64 static int EsSpuCallback ( vlc_object_t *p_this, char const *psz_cmd,
  65                            vlc_value_t oldval, vlc_value_t newval, void * );
  66 static int EsDelayCallback ( vlc_object_t *p_this, char const *psz_cmd,
  67                              vlc_value_t oldval, vlc_value_t newval, void * );
  68
  69 static int BookmarkCallback( vlc_object_t *p_this, char const *psz_cmd,
  70                              vlc_value_t oldval, vlc_value_t newval, void * );
  71
  72 static int RecordCallback( vlc_object_t *p_this, char const *psz_cmd,
  73                            vlc_value_t oldval, vlc_value_t newval,
  74                            void *p_data );
  75 static int FrameNextCallback( vlc_object_t *p_this, char const *psz_cmd,
  76                               vlc_value_t oldval, vlc_value_t newval,
  77                               void *p_data );
  78
  79 typedef struct
  80 {
  81     const char *psz_name;
  82     vlc_callback_t callback;
  83 } vlc_input_callback_t;
  84
  85 static void InputAddCallbacks( input_thread_t *, const vlc_input_callback_t * );
  86 static void InputDelCallbacks( input_thread_t *, const vlc_input_callback_t * );
  87
  88 #ifdef CALLBACK /* For windows */
  89 # undef CALLBACK /* We don't care of this one here */
  90 #endif
  91 /* List all callbacks added by input */
  92 #define CALLBACK(name,cb) { name, cb }
  93 static const vlc_input_callback_t p_input_callbacks[] =
  94 {
  95     CALLBACK( "state", StateCallback ),
  96     CALLBACK( "rate", RateCallback ),
  97     CALLBACK( "position", PositionCallback ),
  98     CALLBACK( "time", TimeCallback ),
  99     CALLBACK( "time-offset", TimeOffsetCallback ),
 100     CALLBACK( "bookmark", BookmarkCallback ),
 101     CALLBACK( "program", ProgramCallback ),
 102     CALLBACK( "title", TitleCallback ),
 103     CALLBACK( "chapter", SeekpointCallback ),
 104     CALLBACK( "audio-delay", EsDelayCallback ),
 105     CALLBACK( "spu-delay", EsDelayCallback ),
 106     CALLBACK( "video-es", EsVideoCallback ),
 107     CALLBACK( "audio-es", EsAudioCallback ),
 108     CALLBACK( "spu-es", EsSpuCallback ),
 109     CALLBACK( "record", RecordCallback ),
 110     CALLBACK( "frame-next", FrameNextCallback ),
 111
 112     CALLBACK( NULL, NULL )
 113 };
 114 static const vlc_input_callback_t p_input_title_navigation_callbacks[] =
 115 {
 116     CALLBACK( "next-title", TitleCallback ),
 117     CALLBACK( "prev-title", TitleCallback ),
 118     CALLBACK( "menu-popup", TitleCallback ),
 119     CALLBACK( "menu-title", TitleCallback ),
 120
 121     CALLBACK( NULL, NULL )
 122 };
 123 static const vlc_input_callback_t p_input_seekpoint_navigation_callbacks[] =
 124 {
 125     CALLBACK( "next-chapter", SeekpointCallback ),
 126     CALLBACK( "prev-chapter", SeekpointCallback ),
 127
 128     CALLBACK( NULL, NULL )
 129 };
 130 #undef CALLBACK
 131
 132 /*****************************************************************************
 133  * input_ControlVarInit:
 134  *  Create all control object variables with their callbacks
 135  *****************************************************************************/
 136 void input_ControlVarInit ( input_thread_t *p_input )
 137 {
 138     vlc_value_t val, text;
 139
 140     /* State */
 141     var_Create( p_input, "state", VLC_VAR_INTEGER );
 142     val.i_int = input_priv(p_input)->i_state;
 143     var_Change( p_input, "state", VLC_VAR_SETVALUE, &val, NULL );
 144
 145     /* Rate */
 146     var_Create( p_input, "rate", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
 147
 148     var_Create( p_input, "frame-next", VLC_VAR_VOID );
 149
 150     /* Position */
 151     var_Create( p_input, "position",  VLC_VAR_FLOAT );
 152
 153     /* Time */
 154     var_Create( p_input, "time", VLC_VAR_INTEGER );
 155     var_Create( p_input, "time-offset", VLC_VAR_INTEGER );    /* relative */
 156
 157     /* Bookmark */
 158     var_Create( p_input, "bookmark", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 159     val.psz_string = _("Bookmark");
 160     var_Change( p_input, "bookmark", VLC_VAR_SETTEXT, &val, NULL );
 161
 162     /* Program */
 163     var_Create( p_input, "program", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 164     var_Get( p_input, "program", &val );
 165     if( val.i_int <= 0 )
 166         var_Change( p_input, "program", VLC_VAR_DELCHOICE, &val, NULL );
 167     text.psz_string = _("Program");
 168     var_Change( p_input, "program", VLC_VAR_SETTEXT, &text, NULL );
 169
 170     /* Programs */
 171     var_Create( p_input, "programs", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 172     text.psz_string = _("Programs");
 173     var_Change( p_input, "programs", VLC_VAR_SETTEXT, &text, NULL );
 174
 175     /* Title */
 176     var_Create( p_input, "title", VLC_VAR_INTEGER );
 177     text.psz_string = _("Title");
 178     var_Change( p_input, "title", VLC_VAR_SETTEXT, &text, NULL );
 179
 180     /* Chapter */
 181     var_Create( p_input, "chapter", VLC_VAR_INTEGER );
 182     text.psz_string = _("Chapter");
 183     var_Change( p_input, "chapter", VLC_VAR_SETTEXT, &text, NULL );
 184
 185     /* Delay */
 186     var_Create( p_input, "audio-delay", VLC_VAR_INTEGER );
 187     var_SetInteger( p_input, "audio-delay",
 188                     1000 * var_GetInteger( p_input, "audio-desync" ) );
 189     var_Create( p_input, "spu-delay", VLC_VAR_INTEGER );
 190
 191     val.i_int = -1;
 192     /* Video ES */
 193     var_Create( p_input, "video-es", VLC_VAR_INTEGER );
 194     var_Change( p_input, "video-es", VLC_VAR_SETVALUE, &val, NULL );
 195     text.psz_string = _("Video Track");
 196     var_Change( p_input, "video-es", VLC_VAR_SETTEXT, &text, NULL );
 197
 198     /* Audio ES */
 199     var_Create( p_input, "audio-es", VLC_VAR_INTEGER );
 200     var_Change( p_input, "audio-es", VLC_VAR_SETVALUE, &val, NULL );
 201     text.psz_string = _("Audio Track");
 202     var_Change( p_input, "audio-es", VLC_VAR_SETTEXT, &text, NULL );
 203
 204     /* Spu ES */
 205     var_Create( p_input, "spu-es", VLC_VAR_INTEGER );
 206     var_Change( p_input, "spu-es", VLC_VAR_SETVALUE, &val, NULL );
 207     text.psz_string = _("Subtitle Track");
 208     var_Change( p_input, "spu-es", VLC_VAR_SETTEXT, &text, NULL );
 209
 210     var_Create( p_input, "spu-choice", VLC_VAR_INTEGER );
 211     var_SetInteger( p_input, "spu-choice", -1 );
 212
 213     /* Special read only objects variables for intf */
 214     var_Create( p_input, "bookmarks", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 215
 216     var_Create( p_input, "length", VLC_VAR_INTEGER );
 217
 218     var_Create( p_input, "bit-rate", VLC_VAR_INTEGER );
 219     var_Create( p_input, "sample-rate", VLC_VAR_INTEGER );
 220
 221     /* Special "intf-event" variable. */
 222     var_Create( p_input, "intf-event", VLC_VAR_INTEGER );
 223
 224     /* Add all callbacks
 225      * XXX we put callback only in non preparsing mode. We need to create the variable
 226      * unless someone want to check all var_Get/var_Change return value ... */
 227     if( !input_priv(p_input)->b_preparsing )
 228         InputAddCallbacks( p_input, p_input_callbacks );
 229 }
 230
 231 /*****************************************************************************
 232  * input_ControlVarStop:
 233  *****************************************************************************/
 234 void input_ControlVarStop( input_thread_t *p_input )
 235 {
 236     demux_t* p_demux  = input_priv(p_input)->master->p_demux;
 237     int i_cur_title;
 238
 239     if( !input_priv(p_input)->b_preparsing )
 240         InputDelCallbacks( p_input, p_input_callbacks );
 241
 242     if( input_priv(p_input)->i_title > 1 )
 243         InputDelCallbacks( p_input, p_input_title_navigation_callbacks );
 244
 245     for( int i = 0; i < input_priv(p_input)->i_title; i++ )
 246     {
 247         char name[sizeof("title ") + 3 * sizeof (int)];
 248
 249         sprintf( name, "title %2u", i );
 250         var_DelCallback( p_input, name, NavigationCallback, (void *)(intptr_t)i );
 251     }
 252
 253     if( !demux_Control( p_demux, DEMUX_GET_TITLE, &i_cur_title ) )
 254     {
 255         const input_title_t* t = input_priv(p_input)->title[ i_cur_title ];
 256
 257         if( t->i_seekpoint > 1 )
 258             InputDelCallbacks( p_input, p_input_seekpoint_navigation_callbacks );
 259     }
 260 }
 261
 262 /*****************************************************************************
 263  * input_ControlVarNavigation:
 264  *  Create all remaining control object variables
 265  *****************************************************************************/
 266 void input_ControlVarNavigation( input_thread_t *p_input )
 267 {
 268     vlc_value_t text;
 269
 270     /* Create more command variables */
 271     if( input_priv(p_input)->i_title > 1 )
 272     {
 273         if( var_Type( p_input, "next-title" ) == 0 ) {
 274             var_Create( p_input, "next-title", VLC_VAR_VOID );
 275             text.psz_string = _("Next title");
 276             var_Change( p_input, "next-title", VLC_VAR_SETTEXT, &text, NULL );
 277             var_AddCallback( p_input, "next-title", TitleCallback, NULL );
 278         }
 279
 280         if( var_Type( p_input, "prev-title" ) == 0 ) {
 281             var_Create( p_input, "prev-title", VLC_VAR_VOID );
 282             text.psz_string = _("Previous title");
 283             var_Change( p_input, "prev-title", VLC_VAR_SETTEXT, &text, NULL );
 284             var_AddCallback( p_input, "prev-title", TitleCallback, NULL );
 285         }
 286
 287         if( var_Type( p_input, "menu-title" ) == 0 ) {
 288             var_Create( p_input, "menu-title", VLC_VAR_VOID );
 289             text.psz_string = _("Menu title");
 290             var_Change( p_input, "menu-title", VLC_VAR_SETTEXT, &text, NULL );
 291             var_AddCallback( p_input, "menu-title", TitleCallback, NULL );
 292         }
 293
 294         if( var_Type( p_input, "menu-popup" ) == 0 ) {
 295             var_Create( p_input, "menu-popup", VLC_VAR_VOID );
 296             text.psz_string = _("Menu popup");
 297             var_Change( p_input, "menu-popup", VLC_VAR_SETTEXT, &text, NULL );
 298             var_AddCallback( p_input, "menu-popup", TitleCallback, NULL );
 299         }
 300     }
 301
 302     /* Create titles and chapters */
 303     var_Change( p_input, "title", VLC_VAR_CLEARCHOICES, NULL, NULL );
 304
 305     for( int i = 0; i < input_priv(p_input)->i_title; i++ )
 306     {
 307         vlc_value_t val2, text2;
 308         char title[sizeof("title ") + 3 * sizeof (int)];
 309
 310         /* Add Navigation entries */
 311         sprintf( title, "title %2u", i );
 312         var_Destroy( p_input, title );
 313         var_Create( p_input, title, VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 314         var_AddCallback( p_input, title,
 315                          NavigationCallback, (void *)(intptr_t)i );
 316
 317         char psz_length[MSTRTIME_MAX_SIZE + sizeof(" []")];
 318         if( input_priv(p_input)->title[i]->i_length > 0 )
 319         {
 320             strcpy( psz_length, " [" );
 321             secstotimestr( &psz_length[2], input_priv(p_input)->title[i]->i_length / CLOCK_FREQ );
 322             strcat( psz_length, "]" );
 323         }
 324         else
 325             psz_length[0] = '\0';
 326
 327         if( input_priv(p_input)->title[i]->psz_name == NULL ||
 328             *input_priv(p_input)->title[i]->psz_name == '\0' )
 329         {
 330             if( asprintf( &text.psz_string, _("Title %i%s"),
 331                           i + input_priv(p_input)->i_title_offset, psz_length ) == -1 )
 332                 continue;
 333         }
 334         else
 335         {
 336             if( asprintf( &text.psz_string, "%s%s",
 337                           input_priv(p_input)->title[i]->psz_name, psz_length ) == -1 )
 338                 continue;
 339         }
 340
 341         /* Add title choice */
 342         val2.i_int = i;
 343         var_Change( p_input, "title", VLC_VAR_ADDCHOICE, &val2, &text );
 344
 345         free( text.psz_string );
 346
 347         for( int j = 0; j < input_priv(p_input)->title[i]->i_seekpoint; j++ )
 348         {
 349             val2.i_int = j;
 350
 351             if( input_priv(p_input)->title[i]->seekpoint[j]->psz_name == NULL ||
 352                 *input_priv(p_input)->title[i]->seekpoint[j]->psz_name == '\0' )
 353             {
 354                 /* Default value */
 355                 if( asprintf( &text2.psz_string, _("Chapter %i"),
 356                           j + input_priv(p_input)->i_seekpoint_offset ) == -1 )
 357                     continue;
 358             }
 359             else
 360             {
 361                 text2.psz_string =
 362                     strdup( input_priv(p_input)->title[i]->seekpoint[j]->psz_name );
 363             }
 364
 365             var_Change( p_input, title, VLC_VAR_ADDCHOICE, &val2, &text2 );
 366             free( text2.psz_string );
 367         }
 368
 369     }
 370 }
 371
 372 /*****************************************************************************
 373  * input_ControlVarTitle:
 374  *  Create all variables for a title
 375  *****************************************************************************/
 376 void input_ControlVarTitle( input_thread_t *p_input, int i_title )
 377 {
 378     const input_title_t *t = input_priv(p_input)->title[i_title];
 379     vlc_value_t text;
 380     int  i;
 381
 382     /* Create/Destroy command variables */
 383     if( t->i_seekpoint <= 1 )
 384     {
 385         var_Destroy( p_input, "next-chapter" );
 386         var_Destroy( p_input, "prev-chapter" );
 387     }
 388     else if( var_Type( p_input, "next-chapter" ) == 0 )
 389     {
 390         var_Create( p_input, "next-chapter", VLC_VAR_VOID );
 391         text.psz_string = _("Next chapter");
 392         var_Change( p_input, "next-chapter", VLC_VAR_SETTEXT, &text, NULL );
 393         var_AddCallback( p_input, "next-chapter", SeekpointCallback, NULL );
 394
 395         var_Create( p_input, "prev-chapter", VLC_VAR_VOID );
 396         text.psz_string = _("Previous chapter");
 397         var_Change( p_input, "prev-chapter", VLC_VAR_SETTEXT, &text, NULL );
 398         var_AddCallback( p_input, "prev-chapter", SeekpointCallback, NULL );
 399     }
 400
 401     /* Build chapter list */
 402     var_Change( p_input, "chapter", VLC_VAR_CLEARCHOICES, NULL, NULL );
 403     for( i = 0; i <  t->i_seekpoint; i++ )
 404     {
 405         vlc_value_t val;
 406         val.i_int = i;
 407
 408         if( t->seekpoint[i]->psz_name == NULL ||
 409             *t->seekpoint[i]->psz_name == '\0' )
 410         {
 411             /* Default value */
 412             if( asprintf( &text.psz_string, _("Chapter %i"),
 413                       i + input_priv(p_input)->i_seekpoint_offset ) == -1 )
 414                 continue;
 415         }
 416         else
 417         {
 418             text.psz_string = strdup( t->seekpoint[i]->psz_name );
 419         }
 420
 421         var_Change( p_input, "chapter", VLC_VAR_ADDCHOICE, &val, &text );
 422         free( text.psz_string );
 423     }
 424 }
 425
 426 /*****************************************************************************
 427  * input_ConfigVarInit:
 428  *  Create all config object variables
 429  *****************************************************************************/
 430 void input_ConfigVarInit ( input_thread_t *p_input )
 431 {
 432     /* Create Object Variables for private use only */
 433
 434     if( !input_priv(p_input)->b_preparsing )
 435     {
 436         var_Create( p_input, "video", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 437         var_Create( p_input, "audio", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 438         var_Create( p_input, "spu", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 439
 440         var_Create( p_input, "audio-track", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 441         var_Create( p_input, "sub-track", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 442
 443         var_Create( p_input, "audio-language",
 444                     VLC_VAR_STRING|VLC_VAR_DOINHERIT );
 445         var_Create( p_input, "sub-language",
 446                     VLC_VAR_STRING|VLC_VAR_DOINHERIT );
 447         var_Create( p_input, "menu-language",
 448                     VLC_VAR_STRING|VLC_VAR_DOINHERIT );
 449
 450         var_Create( p_input, "audio-track-id",
 451                     VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 452         var_Create( p_input, "sub-track-id",
 453                     VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 454
 455         var_Create( p_input, "sub-file", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 456         var_Create( p_input, "sub-autodetect-file", VLC_VAR_BOOL |
 457                     VLC_VAR_DOINHERIT );
 458         var_Create( p_input, "sub-autodetect-path", VLC_VAR_STRING |
 459                     VLC_VAR_DOINHERIT );
 460         var_Create( p_input, "sub-autodetect-fuzzy", VLC_VAR_INTEGER |
 461                     VLC_VAR_DOINHERIT );
 462
 463         var_Create( p_input, "sout", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 464         var_Create( p_input, "sout-all",   VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 465         var_Create( p_input, "sout-audio", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 466         var_Create( p_input, "sout-video", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 467         var_Create( p_input, "sout-spu", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 468         var_Create( p_input, "sout-keep",  VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 469
 470         var_Create( p_input, "input-repeat",
 471                     VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 472         var_Create( p_input, "start-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT );
 473         var_Create( p_input, "stop-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT );
 474         var_Create( p_input, "run-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT );
 475         var_Create( p_input, "input-fast-seek", VLC_VAR_BOOL|VLC_VAR_DOINHERIT );
 476
 477         var_Create( p_input, "input-slave",
 478                     VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 479
 480         var_Create( p_input, "audio-desync",
 481                     VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 482         var_Create( p_input, "cr-average",
 483                     VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 484         var_Create( p_input, "clock-synchro",
 485                     VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 486     }
 487
 488     var_Create( p_input, "can-seek", VLC_VAR_BOOL );
 489     var_SetBool( p_input, "can-seek", true ); /* Fixed later*/
 490
 491     var_Create( p_input, "can-pause", VLC_VAR_BOOL );
 492     var_SetBool( p_input, "can-pause", true ); /* Fixed later*/
 493
 494     var_Create( p_input, "can-rate", VLC_VAR_BOOL );
 495     var_SetBool( p_input, "can-rate", false );
 496
 497     var_Create( p_input, "can-rewind", VLC_VAR_BOOL );
 498     var_SetBool( p_input, "can-rewind", false );
 499
 500     var_Create( p_input, "can-record", VLC_VAR_BOOL );
 501     var_SetBool( p_input, "can-record", false ); /* Fixed later*/
 502
 503     var_Create( p_input, "record", VLC_VAR_BOOL );
 504     var_SetBool( p_input, "record", false );
 505
 506     var_Create( p_input, "teletext-es", VLC_VAR_INTEGER );
 507     var_SetInteger( p_input, "teletext-es", -1 );
 508
 509     var_Create( p_input, "signal-quality", VLC_VAR_FLOAT );
 510     var_SetFloat( p_input, "signal-quality", -1 );
 511
 512     var_Create( p_input, "signal-strength", VLC_VAR_FLOAT );
 513     var_SetFloat( p_input, "signal-strength", -1 );
 514
 515     var_Create( p_input, "program-scrambled", VLC_VAR_BOOL );
 516     var_SetBool( p_input, "program-scrambled", false );
 517
 518     var_Create( p_input, "cache", VLC_VAR_FLOAT );
 519     var_SetFloat( p_input, "cache", 0.0 );
 520
 521     /* */
 522     var_Create( p_input, "input-record-native", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 523
 524     /* */
 525     var_Create( p_input, "access", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 526     var_Create( p_input, "demux", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 527     var_Create( p_input, "demux-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 528     var_Create( p_input, "stream-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 529
 530     /* Meta */
 531     var_Create( p_input, "meta-title", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 532     var_Create( p_input, "meta-author", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 533     var_Create( p_input, "meta-artist", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 534     var_Create( p_input, "meta-genre", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 535     var_Create( p_input, "meta-copyright", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
 536     var_Create( p_input, "meta-description", VLC_VAR_STRING|VLC_VAR_DOINHERIT);
 537     var_Create( p_input, "meta-date", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 538     var_Create( p_input, "meta-url", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 539 }
 540
 541 /*****************************************************************************
 542  * Callbacks managements:
 543  *****************************************************************************/
 544 static void InputAddCallbacks( input_thread_t *p_input,
 545                                const vlc_input_callback_t *p_callbacks )
 546 {
 547     int i;
 548     for( i = 0; p_callbacks[i].psz_name != NULL; i++ )
 549         var_AddCallback( p_input,
 550                          p_callbacks[i].psz_name,
 551                          p_callbacks[i].callback, NULL );
 552 }
 553
 554 static void InputDelCallbacks( input_thread_t *p_input,
 555                                const vlc_input_callback_t *p_callbacks )
 556 {
 557     int i;
 558     for( i = 0; p_callbacks[i].psz_name != NULL; i++ )
 559         var_DelCallback( p_input,
 560                          p_callbacks[i].psz_name,
 561                          p_callbacks[i].callback, NULL );
 562 }
 563
 564 /*****************************************************************************
 565  * All Callbacks:
 566  *****************************************************************************/
 567 static int StateCallback( vlc_object_t *p_this, char const *psz_cmd,
 568                           vlc_value_t oldval, vlc_value_t newval,
 569                           void *p_data )
 570 {
 571     input_thread_t *p_input = (input_thread_t*)p_this;
 572     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 573
 574     if( newval.i_int == PLAYING_S || newval.i_int == PAUSE_S )
 575     {
 576         input_ControlPush( p_input, INPUT_CONTROL_SET_STATE, &newval );
 577         return VLC_SUCCESS;
 578     }
 579
 580     return VLC_EGENERIC;
 581 }
 582
 583 static int RateCallback( vlc_object_t *p_this, char const *psz_cmd,
 584                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
 585 {
 586     input_thread_t *p_input = (input_thread_t*)p_this;
 587     VLC_UNUSED(oldval); VLC_UNUSED(p_data); VLC_UNUSED(psz_cmd);
 588
 589     newval.i_int = INPUT_RATE_DEFAULT / newval.f_float;
 590     input_ControlPush( p_input, INPUT_CONTROL_SET_RATE, &newval );
 591
 592     return VLC_SUCCESS;
 593 }
 594
 595 static int PositionCallback( vlc_object_t *p_this, char const *psz_cmd,
 596                              vlc_value_t oldval, vlc_value_t newval,
 597                              void *p_data )
 598 {
 599     input_thread_t *p_input = (input_thread_t*)p_this;
 600
 601     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 602
 603     /* Update "length" for better intf behaviour */
 604     const int64_t i_length = var_GetInteger( p_input, "length" );
 605     if( i_length > 0 && newval.f_float >= 0.f && newval.f_float <= 1.f )
 606     {
 607         vlc_value_t val;
 608
 609         val.i_int = i_length * newval.f_float;
 610         var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL );
 611     }
 612
 613     input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION, &newval );
 614     return VLC_SUCCESS;
 615 }
 616
 617 static int TimeCallback( vlc_object_t *p_this, char const *psz_cmd,
 618                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
 619 {
 620     input_thread_t *p_input = (input_thread_t*)p_this;
 621     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 622
 623     /* Update "position" for better intf behaviour */
 624     const int64_t i_length = var_GetInteger( p_input, "length" );
 625     if( i_length > 0 && newval.i_int >= 0 && newval.i_int <= i_length )
 626     {
 627         vlc_value_t val;
 628
 629         val.f_float = (double)newval.i_int/(double)i_length;
 630         var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL );
 631         /*
 632          * Notify the intf that a new event has been occurred.
 633          * XXX this is a bit hackish but it's the only way to do it now.
 634          */
 635         var_SetInteger( p_input, "intf-event", INPUT_EVENT_POSITION );
 636     }
 637
 638     input_ControlPush( p_input, INPUT_CONTROL_SET_TIME, &newval );
 639     return VLC_SUCCESS;
 640 }
 641
 642 static int TimeOffsetCallback( vlc_object_t *obj, char const *varname,
 643                                vlc_value_t prev, vlc_value_t cur, void *data )
 644 {
 645     VLC_UNUSED(varname); VLC_UNUSED(prev); VLC_UNUSED(data);
 646
 647     int64_t i_time = var_GetInteger( obj, "time" ) + cur.i_int;
 648     if( i_time < 0 )
 649         i_time = 0;
 650     var_SetInteger( obj, "time", i_time );
 651     return VLC_SUCCESS;
 652 }
 653
 654 static int ProgramCallback( vlc_object_t *p_this, char const *psz_cmd,
 655                             vlc_value_t oldval, vlc_value_t newval,
 656                             void *p_data )
 657 {
 658     input_thread_t *p_input = (input_thread_t*)p_this;
 659     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 660
 661     input_ControlPush( p_input, INPUT_CONTROL_SET_PROGRAM, &newval );
 662
 663     return VLC_SUCCESS;
 664 }
 665
 666 static int TitleCallback( vlc_object_t *p_this, char const *psz_cmd,
 667                           vlc_value_t oldval, vlc_value_t newval,
 668                           void *p_data )
 669 {
 670     input_thread_t *p_input = (input_thread_t*)p_this;
 671     vlc_value_t val, count;
 672     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 673
 674     if( !strcmp( psz_cmd, "next-title" ) )
 675     {
 676         input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE_NEXT, NULL );
 677
 678         val.i_int = var_GetInteger( p_input, "title" ) + 1;
 679         var_Change( p_input, "title", VLC_VAR_CHOICESCOUNT, &count, NULL );
 680         if( val.i_int < count.i_int )
 681             var_Change( p_input, "title", VLC_VAR_SETVALUE, &val, NULL );
 682     }
 683     else if( !strcmp( psz_cmd, "prev-title" ) )
 684     {
 685         input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE_PREV, NULL );
 686
 687         val.i_int = var_GetInteger( p_input, "title" ) - 1;
 688         if( val.i_int >= 0 )
 689             var_Change( p_input, "title", VLC_VAR_SETVALUE, &val, NULL );
 690     }
 691     else if( !strcmp( psz_cmd, "menu-title" ) )
 692     {
 693         input_ControlPush( p_input, INPUT_CONTROL_NAV_MENU, NULL );
 694     }
 695     else if( !strcmp( psz_cmd, "menu-popup" ) )
 696     {
 697         input_ControlPush( p_input, INPUT_CONTROL_NAV_POPUP, NULL );
 698     }
 699     else
 700     {
 701         input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE, &newval );
 702     }
 703
 704     return VLC_SUCCESS;
 705 }
 706
 707 static int SeekpointCallback( vlc_object_t *p_this, char const *psz_cmd,
 708                               vlc_value_t oldval, vlc_value_t newval,
 709                               void *p_data )
 710 {
 711     input_thread_t *p_input = (input_thread_t*)p_this;
 712     vlc_value_t val, count;
 713     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 714
 715     if( !strcmp( psz_cmd, "next-chapter" ) )
 716     {
 717         input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT_NEXT, NULL );
 718
 719         val.i_int = var_GetInteger( p_input, "chapter" ) + 1;
 720         var_Change( p_input, "chapter", VLC_VAR_CHOICESCOUNT, &count, NULL );
 721         if( val.i_int < count.i_int )
 722             var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &val, NULL );
 723     }
 724     else if( !strcmp( psz_cmd, "prev-chapter" ) )
 725     {
 726         input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT_PREV, NULL );
 727
 728         val.i_int = var_GetInteger( p_input, "chapter" ) - 1;
 729         if( val.i_int >= 0 )
 730             var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &val, NULL );
 731     }
 732     else
 733     {
 734         input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT, &newval );
 735     }
 736
 737     return VLC_SUCCESS;
 738 }
 739
 740 static int NavigationCallback( vlc_object_t *p_this, char const *psz_cmd,
 741                                vlc_value_t oldval, vlc_value_t newval,
 742                                void *p_data )
 743 {
 744     input_thread_t *p_input = (input_thread_t*)p_this;
 745     vlc_value_t     val;
 746     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
 747
 748     /* Issue a title change */
 749     val.i_int = (intptr_t)p_data;
 750     input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE, &val );
 751
 752     var_Change( p_input, "title", VLC_VAR_SETVALUE, &val, NULL );
 753
 754     /* And a chapter change */
 755     input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT, &newval );
 756
 757     var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &newval, NULL );
 758
 759     return VLC_SUCCESS;
 760 }
 761
 762 static int EsVideoCallback( vlc_object_t *p_this, char const *psz_cmd,
 763                             vlc_value_t oldval, vlc_value_t newval, void *p_data )
 764 {
 765     input_thread_t *p_input = (input_thread_t*)p_this;
 766     VLC_UNUSED( psz_cmd); VLC_UNUSED( oldval ); VLC_UNUSED( p_data );
 767
 768     if( newval.i_int < 0 )
 769         newval.i_int = -VIDEO_ES; /* disable video es */
 770     else
 771         var_SetBool( p_input, "video", true );
 772
 773     input_ControlPush( p_input, INPUT_CONTROL_SET_ES, &newval );
 774
 775     return VLC_SUCCESS;
 776 }
 777
 778 static int EsAudioCallback( vlc_object_t *p_this, char const *psz_cmd,
 779                             vlc_value_t oldval, vlc_value_t newval, void *p_data )
 780 {
 781     input_thread_t *p_input = (input_thread_t*)p_this;
 782     VLC_UNUSED( psz_cmd); VLC_UNUSED( oldval ); VLC_UNUSED( p_data );
 783
 784     if( newval.i_int < 0 )
 785         newval.i_int = -AUDIO_ES; /* disable audio es */
 786     else
 787         var_SetBool( p_input, "audio", true );
 788
 789     input_ControlPush( p_input, INPUT_CONTROL_SET_ES, &newval );
 790
 791     return VLC_SUCCESS;
 792 }
 793
 794 static int EsSpuCallback( vlc_object_t *p_this, char const *psz_cmd,
 795                            vlc_value_t oldval, vlc_value_t newval, void *p_data )
 796 {
 797     input_thread_t *p_input = (input_thread_t*)p_this;
 798     VLC_UNUSED( psz_cmd); VLC_UNUSED( oldval ); VLC_UNUSED( p_data );
 799
 800     if( newval.i_int < 0 )
 801         newval.i_int = -SPU_ES; /* disable spu es */
 802     else
 803         var_SetBool( p_input, "spu", true );
 804
 805     input_ControlPush( p_input, INPUT_CONTROL_SET_ES, &newval );
 806
 807     return VLC_SUCCESS;
 808 }
 809
 810 static int EsDelayCallback ( vlc_object_t *p_this, char const *psz_cmd,
 811                              vlc_value_t oldval, vlc_value_t newval, void *p_data )
 812 {
 813     input_thread_t *p_input = (input_thread_t*)p_this;
 814     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 815
 816     if( !strcmp( psz_cmd, "audio-delay" ) )
 817     {
 818         input_ControlPush( p_input, INPUT_CONTROL_SET_AUDIO_DELAY, &newval );
 819     }
 820     else if( !strcmp( psz_cmd, "spu-delay" ) )
 821     {
 822         input_ControlPush( p_input, INPUT_CONTROL_SET_SPU_DELAY, &newval );
 823     }
 824     return VLC_SUCCESS;
 825 }
 826
 827 static int BookmarkCallback( vlc_object_t *p_this, char const *psz_cmd,
 828                              vlc_value_t oldval, vlc_value_t newval,
 829                              void *p_data )
 830 {
 831     input_thread_t *p_input = (input_thread_t*)p_this;
 832     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 833
 834     input_ControlPush( p_input, INPUT_CONTROL_SET_BOOKMARK, &newval );
 835
 836     return VLC_SUCCESS;
 837 }
 838
 839 static int RecordCallback( vlc_object_t *p_this, char const *psz_cmd,
 840                            vlc_value_t oldval, vlc_value_t newval,
 841                            void *p_data )
 842 {
 843     input_thread_t *p_input = (input_thread_t*)p_this;
 844     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 845
 846     input_ControlPush( p_input, INPUT_CONTROL_SET_RECORD_STATE, &newval );
 847
 848     return VLC_SUCCESS;
 849 }
 850
 851 static int FrameNextCallback( vlc_object_t *p_this, char const *psz_cmd,
 852                               vlc_value_t oldval, vlc_value_t newval,
 853                               void *p_data )
 854 {
 855     input_thread_t *p_input = (input_thread_t*)p_this;
 856     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 857     VLC_UNUSED(newval);
 858
 859     input_ControlPush( p_input, INPUT_CONTROL_SET_FRAME_NEXT, NULL );
 860
 861     return VLC_SUCCESS;
 862 }
 863