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

   1 /*****************************************************************************
   2  * var.c: object variables for input thread
   3  *****************************************************************************
   4  * Copyright (C) 2004-2007 the VideoLAN team
   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
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 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 General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, 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 <stdio.h>
  33 #include <stdlib.h>
  34
  35 #include "input_internal.h"
  36
  37 /*****************************************************************************
  38  * Exported prototypes
  39  *****************************************************************************/
  40 void input_ControlVarInit ( input_thread_t * );
  41 void input_ControlVarClean( input_thread_t * );
  42 void input_ControlVarNavigation( input_thread_t * );
  43 void input_ControlVarTitle( input_thread_t *p_input, int i_title );
  44
  45 void input_ConfigVarInit ( input_thread_t *p_input );
  46
  47 /*****************************************************************************
  48  * Callbacks
  49  *****************************************************************************/
  50 static int StateCallback   ( vlc_object_t *p_this, char const *psz_cmd,
  51                              vlc_value_t oldval, vlc_value_t newval, void * );
  52 static int RateCallback    ( vlc_object_t *p_this, char const *psz_cmd,
  53                              vlc_value_t oldval, vlc_value_t newval, void * );
  54 static int PositionCallback( vlc_object_t *p_this, char const *psz_cmd,
  55                              vlc_value_t oldval, vlc_value_t newval, void * );
  56 static int TimeCallback    ( vlc_object_t *p_this, char const *psz_cmd,
  57                              vlc_value_t oldval, vlc_value_t newval, void * );
  58 static int ProgramCallback ( vlc_object_t *p_this, char const *psz_cmd,
  59                              vlc_value_t oldval, vlc_value_t newval, void * );
  60 static int TitleCallback   ( vlc_object_t *p_this, char const *psz_cmd,
  61                              vlc_value_t oldval, vlc_value_t newval, void * );
  62 static int SeekpointCallback( vlc_object_t *p_this, char const *psz_cmd,
  63                              vlc_value_t oldval, vlc_value_t newval, void * );
  64 static int NavigationCallback( vlc_object_t *p_this, char const *psz_cmd,
  65                              vlc_value_t oldval, vlc_value_t newval, void * );
  66 static int ESCallback      ( vlc_object_t *p_this, char const *psz_cmd,
  67                              vlc_value_t oldval, vlc_value_t newval, void * );
  68 static int EsDelayCallback ( vlc_object_t *p_this, char const *psz_cmd,
  69                              vlc_value_t oldval, vlc_value_t newval, void * );
  70
  71 static int BookmarkCallback( vlc_object_t *p_this, char const *psz_cmd,
  72                              vlc_value_t oldval, vlc_value_t newval, void * );
  73
  74 /*****************************************************************************
  75  * input_ControlVarInit:
  76  *  Create all control object variables with their callbacks
  77  *****************************************************************************/
  78 void input_ControlVarInit ( input_thread_t *p_input )
  79 {
  80     vlc_value_t val, text;
  81
  82     /* XXX we put callback only in non preparsing mode. We need to create the variable
  83      * unless someone want to check all var_Get/var_Change return value ... */
  84 #define ADD_CALLBACK( name, callback ) do { if( !p_input->b_preparsing ) { var_AddCallback( p_input, name, callback, NULL ); } } while(0)
  85     /* State */
  86     var_Create( p_input, "state", VLC_VAR_INTEGER );
  87     val.i_int = p_input->i_state;
  88     var_Change( p_input, "state", VLC_VAR_SETVALUE, &val, NULL );
  89     ADD_CALLBACK( "state", StateCallback );
  90
  91     /* Rate */
  92     var_Create( p_input, "rate", VLC_VAR_INTEGER );
  93     val.i_int = p_input->p->i_rate;
  94     var_Change( p_input, "rate", VLC_VAR_SETVALUE, &val, NULL );
  95     ADD_CALLBACK( "rate", RateCallback );
  96
  97     var_Create( p_input, "rate-slower", VLC_VAR_VOID );
  98     ADD_CALLBACK( "rate-slower", RateCallback );
  99
 100     var_Create( p_input, "rate-faster", VLC_VAR_VOID );
 101     ADD_CALLBACK( "rate-faster", RateCallback );
 102
 103     /* Position */
 104     var_Create( p_input, "position",  VLC_VAR_FLOAT );
 105     var_Create( p_input, "position-offset",  VLC_VAR_FLOAT );
 106     val.f_float = 0.0;
 107     var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL );
 108     ADD_CALLBACK( "position", PositionCallback );
 109     ADD_CALLBACK( "position-offset", PositionCallback );
 110
 111     /* Time */
 112     var_Create( p_input, "time",  VLC_VAR_TIME );
 113     var_Create( p_input, "time-offset",  VLC_VAR_TIME );    /* relative */
 114     val.i_time = 0;
 115     var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL );
 116     ADD_CALLBACK( "time", TimeCallback );
 117     ADD_CALLBACK( "time-offset", TimeCallback );
 118
 119     /* Bookmark */
 120     var_Create( p_input, "bookmark", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE |
 121                 VLC_VAR_ISCOMMAND );
 122     val.psz_string = _("Bookmark");
 123     var_Change( p_input, "bookmark", VLC_VAR_SETTEXT, &val, NULL );
 124     ADD_CALLBACK( "bookmark", BookmarkCallback );
 125
 126     /* Program */
 127     var_Create( p_input, "program", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE |
 128                 VLC_VAR_DOINHERIT );
 129     var_Get( p_input, "program", &val );
 130     if( val.i_int <= 0 )
 131         var_Change( p_input, "program", VLC_VAR_DELCHOICE, &val, NULL );
 132     text.psz_string = _("Program");
 133     var_Change( p_input, "program", VLC_VAR_SETTEXT, &text, NULL );
 134     ADD_CALLBACK( "program", ProgramCallback );
 135
 136     /* Programs */
 137     var_Create( p_input, "programs", VLC_VAR_LIST | VLC_VAR_DOINHERIT );
 138     text.psz_string = _("Programs");
 139     var_Change( p_input, "programs", VLC_VAR_SETTEXT, &text, NULL );
 140
 141     /* Title */
 142     var_Create( p_input, "title", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
 143     text.psz_string = _("Title");
 144     var_Change( p_input, "title", VLC_VAR_SETTEXT, &text, NULL );
 145     ADD_CALLBACK( "title", TitleCallback );
 146
 147     /* Chapter */
 148     var_Create( p_input, "chapter", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
 149     text.psz_string = _("Chapter");
 150     var_Change( p_input, "chapter", VLC_VAR_SETTEXT, &text, NULL );
 151     ADD_CALLBACK( "chapter", SeekpointCallback );
 152
 153     /* Navigation The callback is added after */
 154     var_Create( p_input, "navigation", VLC_VAR_VARIABLE | VLC_VAR_HASCHOICE );
 155     text.psz_string = _("Navigation");
 156     var_Change( p_input, "navigation", VLC_VAR_SETTEXT, &text, NULL );
 157
 158     /* Delay */
 159     var_Create( p_input, "audio-delay", VLC_VAR_TIME );
 160     val.i_time = 0;
 161     var_Change( p_input, "audio-delay", VLC_VAR_SETVALUE, &val, NULL );
 162     ADD_CALLBACK( "audio-delay", EsDelayCallback );
 163     var_Create( p_input, "spu-delay", VLC_VAR_TIME );
 164     val.i_time = 0;
 165     var_Change( p_input, "spu-delay", VLC_VAR_SETVALUE, &val, NULL );
 166     ADD_CALLBACK( "spu-delay", EsDelayCallback );
 167
 168     p_input->p->pts_adjust.auto_adjust = var_CreateGetBool(
 169             p_input, "auto-adjust-pts-delay" );
 170
 171     /* Video ES */
 172     var_Create( p_input, "video-es", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
 173     text.psz_string = _("Video Track");
 174     var_Change( p_input, "video-es", VLC_VAR_SETTEXT, &text, NULL );
 175     ADD_CALLBACK( "video-es", ESCallback );
 176
 177     /* Audio ES */
 178     var_Create( p_input, "audio-es", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
 179     text.psz_string = _("Audio Track");
 180     var_Change( p_input, "audio-es", VLC_VAR_SETTEXT, &text, NULL );
 181     ADD_CALLBACK( "audio-es", ESCallback );
 182
 183     /* Spu ES */
 184     var_Create( p_input, "spu-es", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
 185     text.psz_string = _("Subtitles Track");
 186     var_Change( p_input, "spu-es", VLC_VAR_SETTEXT, &text, NULL );
 187     ADD_CALLBACK( "spu-es", ESCallback );
 188
 189     /* Special read only objects variables for intf */
 190     var_Create( p_input, "bookmarks", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 191
 192     var_Create( p_input, "length",  VLC_VAR_TIME );
 193     val.i_time = 0;
 194     var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL );
 195
 196     if( !p_input->b_preparsing )
 197     {
 198         /* Special "intf-change" variable, it allows intf to set up a callback
 199          * to be notified of some changes.
 200          *
 201          * Add rate-change to inform about rate changin
 202          *
 203          * TODO list all changes warn by this callbacks */
 204         var_Create( p_input, "intf-change", VLC_VAR_BOOL );
 205         var_SetBool( p_input, "intf-change", true );
 206         var_Create( p_input, "rate-change", VLC_VAR_BOOL );
 207         var_SetBool( p_input, "rate-change", true );
 208     }
 209 #undef ADD_CALLBACK
 210 }
 211
 212 /*****************************************************************************
 213  * input_ControlVarClean:
 214  *****************************************************************************/
 215 void input_ControlVarClean( input_thread_t *p_input )
 216 {
 217     var_Destroy( p_input, "state" );
 218     var_Destroy( p_input, "rate" );
 219     var_Destroy( p_input, "rate-slower" );
 220     var_Destroy( p_input, "rate-faster" );
 221     var_Destroy( p_input, "position" );
 222     var_Destroy( p_input, "position-offset" );
 223     var_Destroy( p_input, "time" );
 224     var_Destroy( p_input, "time-offset" );
 225
 226     var_Destroy( p_input, "audio-delay" );
 227     var_Destroy( p_input, "spu-delay" );
 228
 229     var_Destroy( p_input, "bookmark" );
 230
 231     var_Destroy( p_input, "program" );
 232     if( p_input->p->i_title > 1 )
 233     {
 234         /* TODO Destroy sub navigation var ? */
 235
 236         var_Destroy( p_input, "next-title" );
 237         var_Destroy( p_input, "prev-title" );
 238     }
 239     if( p_input->p->i_title > 0 )
 240     {
 241         /* FIXME title > 0 doesn't mean current title has more than 1 seekpoint */
 242         var_Destroy( p_input, "next-chapter" );
 243         var_Destroy( p_input, "prev-chapter" );
 244     }
 245     var_Destroy( p_input, "title" );
 246     var_Destroy( p_input, "chapter" );
 247     var_Destroy( p_input, "navigation" );
 248
 249     var_Destroy( p_input, "video-es" );
 250     var_Destroy( p_input, "audio-es" );
 251     var_Destroy( p_input, "spu-es" );
 252
 253     var_Destroy( p_input, "bookmarks" );
 254     var_Destroy( p_input, "length" );
 255
 256     var_Destroy( p_input, "intf-change" );
 257  }
 258
 259 /*****************************************************************************
 260  * input_ControlVarNavigation:
 261  *  Create all remaining control object variables
 262  *****************************************************************************/
 263 void input_ControlVarNavigation( input_thread_t *p_input )
 264 {
 265     vlc_value_t val, text;
 266     int  i;
 267
 268     /* Create more command variables */
 269     if( p_input->p->i_title > 1 )
 270     {
 271         var_Create( p_input, "next-title", VLC_VAR_VOID );
 272         text.psz_string = _("Next title");
 273         var_Change( p_input, "next-title", VLC_VAR_SETTEXT, &text, NULL );
 274         var_AddCallback( p_input, "next-title", TitleCallback, NULL );
 275
 276         var_Create( p_input, "prev-title", VLC_VAR_VOID );
 277         text.psz_string = _("Previous title");
 278         var_Change( p_input, "prev-title", VLC_VAR_SETTEXT, &text, NULL );
 279         var_AddCallback( p_input, "prev-title", TitleCallback, NULL );
 280     }
 281
 282     /* Create title and navigation */
 283     val.psz_string = malloc( sizeof("title ") + 5 );
 284     for( i = 0; i < p_input->p->i_title; i++ )
 285     {
 286         vlc_value_t val2, text, text2;
 287         int j;
 288
 289         /* Add Navigation entries */
 290         sprintf( val.psz_string,  "title %2i", i );
 291         var_Destroy( p_input, val.psz_string );
 292         var_Create( p_input, val.psz_string,
 293                     VLC_VAR_INTEGER|VLC_VAR_HASCHOICE|VLC_VAR_ISCOMMAND );
 294         var_AddCallback( p_input, val.psz_string,
 295                          NavigationCallback, (void *)(intptr_t)i );
 296
 297         if( p_input->p->title[i]->psz_name == NULL ||
 298             *p_input->p->title[i]->psz_name == '\0' )
 299         {
 300             asprintf( &text.psz_string, _("Title %i"),
 301                       i + p_input->p->i_title_offset );
 302         }
 303         else
 304         {
 305             text.psz_string = strdup( p_input->p->title[i]->psz_name );
 306         }
 307         var_Change( p_input, "navigation", VLC_VAR_ADDCHOICE, &val, &text );
 308
 309         /* Add title choice */
 310         val2.i_int = i;
 311         var_Change( p_input, "title", VLC_VAR_ADDCHOICE, &val2, &text );
 312
 313         free( text.psz_string );
 314
 315         for( j = 0; j < p_input->p->title[i]->i_seekpoint; j++ )
 316         {
 317             val2.i_int = j;
 318
 319             if( p_input->p->title[i]->seekpoint[j]->psz_name == NULL ||
 320                 *p_input->p->title[i]->seekpoint[j]->psz_name == '\0' )
 321             {
 322                 /* Default value */
 323                 asprintf( &text2.psz_string, _("Chapter %i"),
 324                           j + p_input->p->i_seekpoint_offset );
 325             }
 326             else
 327             {
 328                 text2.psz_string =
 329                     strdup( p_input->p->title[i]->seekpoint[j]->psz_name );
 330             }
 331
 332             var_Change( p_input, val.psz_string, VLC_VAR_ADDCHOICE,
 333                         &val2, &text2 );
 334             free( text2.psz_string );
 335         }
 336
 337     }
 338     free( val.psz_string );
 339 }
 340
 341 /*****************************************************************************
 342  * input_ControlVarTitle:
 343  *  Create all variables for a title
 344  *****************************************************************************/
 345 void input_ControlVarTitle( input_thread_t *p_input, int i_title )
 346 {
 347     input_title_t *t = p_input->p->title[i_title];
 348     vlc_value_t val;
 349     int  i;
 350
 351     /* Create/Destroy command variables */
 352     if( t->i_seekpoint <= 1 )
 353     {
 354         var_Destroy( p_input, "next-chapter" );
 355         var_Destroy( p_input, "prev-chapter" );
 356     }
 357     else if( var_Get( p_input, "next-chapter", &val ) != VLC_SUCCESS )
 358     {
 359         vlc_value_t text;
 360
 361         var_Create( p_input, "next-chapter", VLC_VAR_VOID );
 362         text.psz_string = _("Next chapter");
 363         var_Change( p_input, "next-chapter", VLC_VAR_SETTEXT, &text, NULL );
 364         var_AddCallback( p_input, "next-chapter", SeekpointCallback, NULL );
 365
 366         var_Create( p_input, "prev-chapter", VLC_VAR_VOID );
 367         text.psz_string = _("Previous chapter");
 368         var_Change( p_input, "prev-chapter", VLC_VAR_SETTEXT, &text, NULL );
 369         var_AddCallback( p_input, "prev-chapter", SeekpointCallback, NULL );
 370     }
 371
 372     /* Build chapter list */
 373     var_Change( p_input, "chapter", VLC_VAR_CLEARCHOICES, NULL, NULL );
 374     for( i = 0; i <  t->i_seekpoint; i++ )
 375     {
 376         vlc_value_t text;
 377         val.i_int = i;
 378
 379         if( t->seekpoint[i]->psz_name == NULL ||
 380             *t->seekpoint[i]->psz_name == '\0' )
 381         {
 382             /* Default value */
 383             asprintf( &text.psz_string, _("Chapter %i"),
 384                       i + p_input->p->i_seekpoint_offset );
 385         }
 386         else
 387         {
 388             text.psz_string = strdup( t->seekpoint[i]->psz_name );
 389         }
 390
 391         var_Change( p_input, "chapter", VLC_VAR_ADDCHOICE, &val, &text );
 392         free( text.psz_string );
 393     }
 394 }
 395
 396 /*****************************************************************************
 397  * input_ConfigVarInit:
 398  *  Create all config object variables
 399  *****************************************************************************/
 400 void input_ConfigVarInit ( input_thread_t *p_input )
 401 {
 402     vlc_value_t val;
 403
 404     /* Create Object Variables for private use only */
 405
 406     if( !p_input->b_preparsing )
 407     {
 408         var_Create( p_input, "video", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 409         var_Create( p_input, "audio", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 410         var_Create( p_input, "spu", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 411
 412         var_Create( p_input, "audio-track", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 413         var_Create( p_input, "sub-track", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 414
 415         var_Create( p_input, "audio-language",
 416                     VLC_VAR_STRING|VLC_VAR_DOINHERIT );
 417         var_Create( p_input, "sub-language",
 418                     VLC_VAR_STRING|VLC_VAR_DOINHERIT );
 419
 420         var_Create( p_input, "audio-track-id",
 421                     VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 422         var_Create( p_input, "sub-track-id",
 423                     VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 424
 425         var_Create( p_input, "sub-file", VLC_VAR_FILE | VLC_VAR_DOINHERIT );
 426         var_Create( p_input, "sub-autodetect-file", VLC_VAR_BOOL |
 427                     VLC_VAR_DOINHERIT );
 428         var_Create( p_input, "sub-autodetect-path", VLC_VAR_STRING |
 429                     VLC_VAR_DOINHERIT );
 430         var_Create( p_input, "sub-autodetect-fuzzy", VLC_VAR_INTEGER |
 431                     VLC_VAR_DOINHERIT );
 432
 433         var_Create( p_input, "sout", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 434         var_Create( p_input, "sout-all",   VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 435         var_Create( p_input, "sout-audio", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 436         var_Create( p_input, "sout-video", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 437         var_Create( p_input, "sout-spu", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 438         var_Create( p_input, "sout-keep",  VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 439
 440         var_Create( p_input, "input-repeat",
 441                     VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 442         var_Create( p_input, "start-time", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 443         var_Create( p_input, "stop-time", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 444         var_Create( p_input, "run-time", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 445
 446         var_Create( p_input, "input-slave",
 447                     VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 448
 449         var_Create( p_input, "minimize-threads",
 450                     VLC_VAR_BOOL|VLC_VAR_DOINHERIT );
 451
 452         var_Create( p_input, "audio-desync",
 453                     VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 454         var_Create( p_input, "cr-average",
 455                     VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 456         var_Create( p_input, "clock-synchro",
 457                     VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 458     }
 459
 460     var_Create( p_input, "seekable", VLC_VAR_BOOL );
 461     val.b_bool = true; /* Fixed later*/
 462     var_Change( p_input, "seekable", VLC_VAR_SETVALUE, &val, NULL );
 463     var_Create( p_input, "can-pause", VLC_VAR_BOOL );
 464     val.b_bool = true; /* Fixed later*/
 465     var_Change( p_input, "can-pause", VLC_VAR_SETVALUE, &val, NULL );
 466
 467     /* */
 468     var_Create( p_input, "access-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 469     var_Create( p_input, "access", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 470     var_Create( p_input, "demux", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 471
 472     /* Meta */
 473     var_Create( p_input, "meta-title", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 474     var_Create( p_input, "meta-author", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 475     var_Create( p_input, "meta-artist", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 476     var_Create( p_input, "meta-genre", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 477     var_Create( p_input, "meta-copyright", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
 478     var_Create( p_input, "meta-description", VLC_VAR_STRING|VLC_VAR_DOINHERIT);
 479     var_Create( p_input, "meta-date", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 480     var_Create( p_input, "meta-url", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 481 }
 482
 483 /*****************************************************************************
 484  * All Callbacks:
 485  *****************************************************************************/
 486 static int StateCallback( vlc_object_t *p_this, char const *psz_cmd,
 487                           vlc_value_t oldval, vlc_value_t newval,
 488                           void *p_data )
 489 {
 490     input_thread_t *p_input = (input_thread_t*)p_this;
 491     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 492
 493     if( newval.i_int == PLAYING_S || newval.i_int == PAUSE_S )
 494     {
 495         input_ControlPush( p_input, INPUT_CONTROL_SET_STATE, &newval );
 496         return VLC_SUCCESS;
 497     }
 498
 499     return VLC_EGENERIC;
 500 }
 501
 502 static int RateCallback( vlc_object_t *p_this, char const *psz_cmd,
 503                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
 504 {
 505     input_thread_t *p_input = (input_thread_t*)p_this;
 506     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 507
 508     /* Problem with this way: the "rate" variable is update after the input thread do the change */
 509     if( !strcmp( psz_cmd, "rate-slower" ) )
 510     {
 511         input_ControlPush( p_input, INPUT_CONTROL_SET_RATE_SLOWER, NULL );
 512     }
 513     else if( !strcmp( psz_cmd, "rate-faster" ) )
 514     {
 515         input_ControlPush( p_input, INPUT_CONTROL_SET_RATE_FASTER, NULL );
 516     }
 517     else
 518     {
 519         input_ControlPush( p_input, INPUT_CONTROL_SET_RATE, &newval );
 520     }
 521
 522     return VLC_SUCCESS;
 523 }
 524
 525 static int PositionCallback( vlc_object_t *p_this, char const *psz_cmd,
 526                              vlc_value_t oldval, vlc_value_t newval,
 527                              void *p_data )
 528 {
 529     input_thread_t *p_input = (input_thread_t*)p_this;
 530     vlc_value_t val, length;
 531     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 532
 533     if( !strcmp( psz_cmd, "position-offset" ) )
 534     {
 535         input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION_OFFSET, &newval );
 536
 537         val.f_float = var_GetFloat( p_input, "position" ) + newval.f_float;
 538         if( val.f_float < 0.0 ) val.f_float = 0.0;
 539         if( val.f_float > 1.0 ) val.f_float = 1.0;
 540         var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL );
 541     }
 542     else
 543     {
 544         val.f_float = newval.f_float;
 545         input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION, &newval );
 546     }
 547
 548     /* Update "position" for better intf behavour */
 549     var_Get( p_input, "length", &length );
 550     if( length.i_time > 0 && val.f_float >= 0.0 && val.f_float <= 1.0 )
 551     {
 552         val.i_time = length.i_time * val.f_float;
 553         var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL );
 554     }
 555
 556     return VLC_SUCCESS;
 557 }
 558
 559 static int TimeCallback( vlc_object_t *p_this, char const *psz_cmd,
 560                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
 561 {
 562     input_thread_t *p_input = (input_thread_t*)p_this;
 563     vlc_value_t val, length;
 564     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 565
 566     if( !strcmp( psz_cmd, "time-offset" ) )
 567     {
 568         input_ControlPush( p_input, INPUT_CONTROL_SET_TIME_OFFSET, &newval );
 569         val.i_time = var_GetTime( p_input, "time" ) + newval.i_time;
 570         if( val.i_time < 0 ) val.i_time = 0;
 571         /* TODO maybe test against i_length ? */
 572         var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL );
 573     }
 574     else
 575     {
 576         val.i_time = newval.i_time;
 577         input_ControlPush( p_input, INPUT_CONTROL_SET_TIME, &newval );
 578     }
 579
 580     /* Update "position" for better intf behavour */
 581     var_Get( p_input, "length", &length );
 582     if( length.i_time > 0 && val.i_time >= 0 && val.i_time <= length.i_time )
 583     {
 584         val.f_float = (double)val.i_time/(double)length.i_time;
 585         var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL );
 586     }
 587
 588     return VLC_SUCCESS;
 589 }
 590
 591 static int ProgramCallback( vlc_object_t *p_this, char const *psz_cmd,
 592                             vlc_value_t oldval, vlc_value_t newval,
 593                             void *p_data )
 594 {
 595     input_thread_t *p_input = (input_thread_t*)p_this;
 596     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 597
 598     input_ControlPush( p_input, INPUT_CONTROL_SET_PROGRAM, &newval );
 599
 600     return VLC_SUCCESS;
 601 }
 602
 603 static int TitleCallback( vlc_object_t *p_this, char const *psz_cmd,
 604                           vlc_value_t oldval, vlc_value_t newval,
 605                           void *p_data )
 606 {
 607     input_thread_t *p_input = (input_thread_t*)p_this;
 608     vlc_value_t val, count;
 609     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 610
 611     if( !strcmp( psz_cmd, "next-title" ) )
 612     {
 613         input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE_NEXT, NULL );
 614
 615         val.i_int = var_GetInteger( p_input, "title" ) + 1;
 616         var_Change( p_input, "title", VLC_VAR_CHOICESCOUNT, &count, NULL );
 617         if( val.i_int < count.i_int )
 618             var_Change( p_input, "title", VLC_VAR_SETVALUE, &val, NULL );
 619     }
 620     else if( !strcmp( psz_cmd, "prev-title" ) )
 621     {
 622         input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE_PREV, NULL );
 623
 624         val.i_int = var_GetInteger( p_input, "title" ) - 1;
 625         if( val.i_int >= 0 )
 626             var_Change( p_input, "title", VLC_VAR_SETVALUE, &val, NULL );
 627     }
 628     else
 629     {
 630         input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE, &newval );
 631     }
 632
 633     return VLC_SUCCESS;
 634 }
 635
 636 static int SeekpointCallback( vlc_object_t *p_this, char const *psz_cmd,
 637                               vlc_value_t oldval, vlc_value_t newval,
 638                               void *p_data )
 639 {
 640     input_thread_t *p_input = (input_thread_t*)p_this;
 641     vlc_value_t val, count;
 642     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 643
 644     if( !strcmp( psz_cmd, "next-chapter" ) )
 645     {
 646         input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT_NEXT, NULL );
 647
 648         val.i_int = var_GetInteger( p_input, "chapter" ) + 1;
 649         var_Change( p_input, "chapter", VLC_VAR_CHOICESCOUNT, &count, NULL );
 650         if( val.i_int < count.i_int )
 651             var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &val, NULL );
 652     }
 653     else if( !strcmp( psz_cmd, "prev-chapter" ) )
 654     {
 655         input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT_PREV, NULL );
 656
 657         val.i_int = var_GetInteger( p_input, "chapter" ) - 1;
 658         if( val.i_int >= 0 )
 659             var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &val, NULL );
 660     }
 661     else
 662     {
 663         input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT, &newval );
 664     }
 665
 666     return VLC_SUCCESS;
 667 }
 668
 669 static int NavigationCallback( vlc_object_t *p_this, char const *psz_cmd,
 670                                vlc_value_t oldval, vlc_value_t newval,
 671                                void *p_data )
 672 {
 673     input_thread_t *p_input = (input_thread_t*)p_this;
 674     vlc_value_t     val;
 675     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
 676
 677     /* Issue a title change */
 678     val.i_int = (intptr_t)p_data;
 679     input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE, &val );
 680
 681     var_Change( p_input, "title", VLC_VAR_SETVALUE, &val, NULL );
 682
 683     /* And a chapter change */
 684     input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT, &newval );
 685
 686     var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &newval, NULL );
 687
 688     return VLC_SUCCESS;
 689 }
 690
 691 static int ESCallback( vlc_object_t *p_this, char const *psz_cmd,
 692                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 693 {
 694     input_thread_t *p_input = (input_thread_t*)p_this;
 695     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 696
 697     if( newval.i_int < 0 )
 698     {
 699         vlc_value_t v;
 700         /* Hack */
 701         if( !strcmp( psz_cmd, "audio-es" ) )
 702             v.i_int = -AUDIO_ES;
 703         else if( !strcmp( psz_cmd, "video-es" ) )
 704             v.i_int = -VIDEO_ES;
 705         else if( !strcmp( psz_cmd, "spu-es" ) )
 706             v.i_int = -SPU_ES;
 707         else
 708             v.i_int = 0;
 709         if( v.i_int != 0 )
 710             input_ControlPush( p_input, INPUT_CONTROL_SET_ES, &v );
 711     }
 712     else
 713     {
 714         input_ControlPush( p_input, INPUT_CONTROL_SET_ES, &newval );
 715     }
 716
 717     return VLC_SUCCESS;
 718 }
 719
 720 static int EsDelayCallback ( vlc_object_t *p_this, char const *psz_cmd,
 721                              vlc_value_t oldval, vlc_value_t newval, void *p_data )
 722 {
 723     input_thread_t *p_input = (input_thread_t*)p_this;
 724     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 725
 726     if( !strcmp( psz_cmd, "audio-delay" ) )
 727     {
 728         /*Change i_pts_delay to make sure es are decoded in time*/
 729         if (newval.i_int < 0 || oldval.i_int < 0 )
 730         {
 731             p_input->i_pts_delay -= newval.i_int - oldval.i_int;
 732         }
 733         input_ControlPush( p_input, INPUT_CONTROL_SET_AUDIO_DELAY, &newval );
 734     }
 735     else if( !strcmp( psz_cmd, "spu-delay" ) )
 736         input_ControlPush( p_input, INPUT_CONTROL_SET_SPU_DELAY, &newval );
 737     return VLC_SUCCESS;
 738 }
 739
 740 static int BookmarkCallback( 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_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
 746
 747     input_ControlPush( p_input, INPUT_CONTROL_SET_BOOKMARK, &newval );
 748
 749     return VLC_SUCCESS;
 750 }