git.sesse.net Git - vlc/blob - src/misc/variables.c

   1 /*****************************************************************************
   2  * variables.c: routines for object variables handling
   3  *****************************************************************************
   4  * Copyright (C) 2002-2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   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 #include <vlc/vlc.h>
  28 #include "variables.h"
  29
  30 #include "libvlc.h"
  31
  32 /*****************************************************************************
  33  * Private types
  34  *****************************************************************************/
  35 struct callback_entry_t
  36 {
  37     vlc_callback_t pf_callback;
  38     void *         p_data;
  39 };
  40
  41 /*****************************************************************************
  42  * Local comparison functions, returns 0 if v == w, < 0 if v < w, > 0 if v > w
  43  *****************************************************************************/
  44 static int CmpBool( vlc_value_t v, vlc_value_t w ) { return v.b_bool ? w.b_bool ? 0 : 1 : w.b_bool ? -1 : 0; }
  45 static int CmpInt( vlc_value_t v, vlc_value_t w ) { return v.i_int == w.i_int ? 0 : v.i_int > w.i_int ? 1 : -1; }
  46 static int CmpTime( vlc_value_t v, vlc_value_t w )
  47 {
  48     return v.i_time == w.i_time ? 0 : v.i_time > w.i_time ? 1 : -1;
  49 }
  50 static int CmpString( vlc_value_t v, vlc_value_t w ) { return strcmp( v.psz_string, w.psz_string ); }
  51 static int CmpFloat( vlc_value_t v, vlc_value_t w ) { return v.f_float == w.f_float ? 0 : v.f_float > w.f_float ? 1 : -1; }
  52 static int CmpAddress( vlc_value_t v, vlc_value_t w ) { return v.p_address == w.p_address ? 0 : v.p_address > w.p_address ? 1 : -1; }
  53
  54 /*****************************************************************************
  55  * Local duplication functions, and local deallocation functions
  56  *****************************************************************************/
  57 static void DupDummy( vlc_value_t *p_val ) { (void)p_val; /* unused */ }
  58 static void DupString( vlc_value_t *p_val ) { p_val->psz_string = strdup( p_val->psz_string ); }
  59
  60 static void DupList( vlc_value_t *p_val )
  61 {
  62     int i;
  63     vlc_list_t *p_list = malloc( sizeof(vlc_list_t) );
  64
  65     p_list->i_count = p_val->p_list->i_count;
  66     if( p_val->p_list->i_count )
  67     {
  68         p_list->p_values = malloc( p_list->i_count * sizeof(vlc_value_t) );
  69         p_list->pi_types = malloc( p_list->i_count * sizeof(int) );
  70     }
  71     else
  72     {
  73         p_list->p_values = NULL;
  74         p_list->pi_types = NULL;
  75     }
  76
  77     for( i = 0; i < p_list->i_count; i++ )
  78     {
  79         p_list->p_values[i] = p_val->p_list->p_values[i];
  80         p_list->pi_types[i] = p_val->p_list->pi_types[i];
  81         switch( p_val->p_list->pi_types[i] & VLC_VAR_TYPE )
  82         {
  83         case VLC_VAR_STRING:
  84
  85             DupString( &p_list->p_values[i] );
  86             break;
  87         default:
  88             break;
  89         }
  90     }
  91
  92     p_val->p_list = p_list;
  93 }
  94
  95 static void FreeDummy( vlc_value_t *p_val ) { (void)p_val; /* unused */ }
  96 static void FreeString( vlc_value_t *p_val ) { free( p_val->psz_string ); }
  97 static void FreeMutex( vlc_value_t *p_val ) { vlc_mutex_destroy( (vlc_mutex_t*)p_val->p_address ); free( p_val->p_address ); }
  98
  99 static void FreeList( vlc_value_t *p_val )
 100 {
 101     int i;
 102     for( i = 0; i < p_val->p_list->i_count; i++ )
 103     {
 104         switch( p_val->p_list->pi_types[i] & VLC_VAR_TYPE )
 105         {
 106         case VLC_VAR_STRING:
 107             FreeString( &p_val->p_list->p_values[i] );
 108             break;
 109         case VLC_VAR_MUTEX:
 110             FreeMutex( &p_val->p_list->p_values[i] );
 111             break;
 112         default:
 113             break;
 114         }
 115     }
 116
 117     if( p_val->p_list->i_count )
 118     {
 119         free( p_val->p_list->p_values );
 120         free( p_val->p_list->pi_types );
 121     }
 122     free( p_val->p_list );
 123 }
 124
 125 /*****************************************************************************
 126  * Local prototypes
 127  *****************************************************************************/
 128 static int      GetUnused   ( vlc_object_t *, const char * );
 129 static uint32_t HashString  ( const char * );
 130 static int      Insert      ( variable_t *, int, const char * );
 131 static int      InsertInner ( variable_t *, int, uint32_t );
 132 static int      Lookup      ( variable_t *, int, const char * );
 133 static int      LookupInner ( variable_t *, int, uint32_t );
 134
 135 static void     CheckValue  ( variable_t *, vlc_value_t * );
 136
 137 static int      InheritValue( vlc_object_t *, const char *, vlc_value_t *,
 138                               int );
 139
 140 /**
 141  * Initialize a vlc variable
 142  *
 143  * We hash the given string and insert it into the sorted list. The insertion
 144  * may require slow memory copies, but think about what we gain in the log(n)
 145  * lookup phase when setting/getting the variable value!
 146  *
 147  * \param p_this The object in which to create the variable
 148  * \param psz_name The name of the variable
 149  * \param i_type The variables type. Must be one of \ref var_type combined with
 150  *               zero or more \ref var_flags
 151  */
 152 int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type )
 153 {
 154     int i_new;
 155     variable_t *p_var;
 156     static vlc_list_t dummy_null_list = {0, NULL, NULL};
 157     vlc_object_internals_t *p_priv = p_this->p_internals;
 158
 159     vlc_mutex_lock( &p_priv->var_lock );
 160
 161     /* FIXME: if the variable already exists, we don't duplicate it. But we
 162      * duplicate the lookups. It's not that serious, but if anyone finds some
 163      * time to rework Insert() so that only one lookup has to be done, feel
 164      * free to do so. */
 165     i_new = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
 166
 167     if( i_new >= 0 )
 168     {
 169         /* If the types differ, variable creation failed. */
 170         if( (i_type & ~(VLC_VAR_DOINHERIT|VLC_VAR_ISCOMMAND)) != p_priv->p_vars[i_new].i_type )
 171         {
 172             vlc_mutex_unlock( &p_priv->var_lock );
 173             return VLC_EBADVAR;
 174         }
 175
 176         p_priv->p_vars[i_new].i_usage++;
 177         if( i_type & VLC_VAR_ISCOMMAND )
 178             p_priv->p_vars[i_new].i_type |= VLC_VAR_ISCOMMAND;
 179         vlc_mutex_unlock( &p_priv->var_lock );
 180         return VLC_SUCCESS;
 181     }
 182
 183     i_new = Insert( p_priv->p_vars, p_priv->i_vars, psz_name );
 184
 185     if( (p_priv->i_vars & 15) == 15 )
 186     {
 187         p_priv->p_vars = realloc( p_priv->p_vars,
 188                                   (p_priv->i_vars+17) * sizeof(variable_t) );
 189     }
 190
 191     memmove( p_priv->p_vars + i_new + 1,
 192              p_priv->p_vars + i_new,
 193              (p_priv->i_vars - i_new) * sizeof(variable_t) );
 194
 195     p_priv->i_vars++;
 196
 197     p_var = &p_priv->p_vars[i_new];
 198     memset( p_var, 0, sizeof(*p_var) );
 199
 200     p_var->i_hash = HashString( psz_name );
 201     p_var->psz_name = strdup( psz_name );
 202     p_var->psz_text = NULL;
 203
 204     p_var->i_type = i_type & ~VLC_VAR_DOINHERIT;
 205     memset( &p_var->val, 0, sizeof(vlc_value_t) );
 206
 207     p_var->pf_dup = DupDummy;
 208     p_var->pf_free = FreeDummy;
 209
 210     p_var->i_usage = 1;
 211
 212     p_var->i_default = -1;
 213     p_var->choices.i_count = 0;
 214     p_var->choices.p_values = NULL;
 215     p_var->choices_text.i_count = 0;
 216     p_var->choices_text.p_values = NULL;
 217
 218     p_var->b_incallback = VLC_FALSE;
 219     p_var->i_entries = 0;
 220     p_var->p_entries = NULL;
 221
 222     /* Always initialize the variable, even if it is a list variable; this
 223      * will lead to errors if the variable is not initialized, but it will
 224      * not cause crashes in the variable handling. */
 225     switch( i_type & VLC_VAR_TYPE )
 226     {
 227         case VLC_VAR_BOOL:
 228             p_var->pf_cmp = CmpBool;
 229             p_var->val.b_bool = VLC_FALSE;
 230             break;
 231         case VLC_VAR_INTEGER:
 232         case VLC_VAR_HOTKEY:
 233             p_var->pf_cmp = CmpInt;
 234             p_var->val.i_int = 0;
 235             break;
 236         case VLC_VAR_STRING:
 237         case VLC_VAR_MODULE:
 238         case VLC_VAR_FILE:
 239         case VLC_VAR_DIRECTORY:
 240         case VLC_VAR_VARIABLE:
 241             p_var->pf_cmp = CmpString;
 242             p_var->pf_dup = DupString;
 243             p_var->pf_free = FreeString;
 244             p_var->val.psz_string = "";
 245             break;
 246         case VLC_VAR_FLOAT:
 247             p_var->pf_cmp = CmpFloat;
 248             p_var->val.f_float = 0.0;
 249             break;
 250         case VLC_VAR_TIME:
 251             p_var->pf_cmp = CmpTime;
 252             p_var->val.i_time = 0;
 253             break;
 254         case VLC_VAR_ADDRESS:
 255             p_var->pf_cmp = CmpAddress;
 256             p_var->val.p_address = NULL;
 257             break;
 258         case VLC_VAR_MUTEX:
 259             p_var->pf_cmp = CmpAddress;
 260             p_var->pf_free = FreeMutex;
 261             p_var->val.p_address = malloc( sizeof(vlc_mutex_t) );
 262             vlc_mutex_init( p_this, (vlc_mutex_t*)p_var->val.p_address );
 263             break;
 264         case VLC_VAR_LIST:
 265             p_var->pf_cmp = CmpAddress;
 266             p_var->pf_dup = DupList;
 267             p_var->pf_free = FreeList;
 268             p_var->val.p_list = &dummy_null_list;
 269             break;
 270     }
 271
 272     /* Duplicate the default data we stored. */
 273     p_var->pf_dup( &p_var->val );
 274
 275     if( i_type & VLC_VAR_DOINHERIT )
 276     {
 277         vlc_value_t val;
 278
 279         if( InheritValue( p_this, psz_name, &val, p_var->i_type )
 280             == VLC_SUCCESS )
 281         {
 282             /* Free data if needed */
 283             p_var->pf_free( &p_var->val );
 284             /* Set the variable */
 285             p_var->val = val;
 286
 287             if( i_type & VLC_VAR_HASCHOICE )
 288             {
 289                 /* We must add the inherited value to our choice list */
 290                 p_var->i_default = 0;
 291
 292                 INSERT_ELEM( p_var->choices.p_values, p_var->choices.i_count,
 293                              0, val );
 294                 INSERT_ELEM( p_var->choices_text.p_values,
 295                              p_var->choices_text.i_count, 0, val );
 296                 p_var->pf_dup( &p_var->choices.p_values[0] );
 297                 p_var->choices_text.p_values[0].psz_string = NULL;
 298             }
 299         }
 300     }
 301
 302     vlc_mutex_unlock( &p_priv->var_lock );
 303
 304     return VLC_SUCCESS;
 305 }
 306
 307 /**
 308  * Destroy a vlc variable
 309  *
 310  * Look for the variable and destroy it if it is found. As in var_Create we
 311  * do a call to memmove() but we have performance counterparts elsewhere.
 312  *
 313  * \param p_this The object that holds the variable
 314  * \param psz_name The name of the variable
 315  */
 316 int __var_Destroy( vlc_object_t *p_this, const char *psz_name )
 317 {
 318     int i_var, i;
 319     variable_t *p_var;
 320     vlc_object_internals_t *p_priv = p_this->p_internals;
 321
 322     vlc_mutex_lock( &p_priv->var_lock );
 323
 324     i_var = GetUnused( p_this, psz_name );
 325     if( i_var < 0 )
 326     {
 327         vlc_mutex_unlock( &p_priv->var_lock );
 328         return i_var;
 329     }
 330
 331     p_var = &p_priv->p_vars[i_var];
 332
 333     if( p_var->i_usage > 1 )
 334     {
 335         p_var->i_usage--;
 336         vlc_mutex_unlock( &p_priv->var_lock );
 337         return VLC_SUCCESS;
 338     }
 339
 340     /* Free value if needed */
 341     p_var->pf_free( &p_var->val );
 342
 343     /* Free choice list if needed */
 344     if( p_var->choices.i_count )
 345     {
 346         for( i = 0 ; i < p_var->choices.i_count ; i++ )
 347         {
 348             p_var->pf_free( &p_var->choices.p_values[i] );
 349             if( p_var->choices_text.p_values[i].psz_string )
 350                 free( p_var->choices_text.p_values[i].psz_string );
 351         }
 352         free( p_var->choices.p_values );
 353         free( p_var->choices_text.p_values );
 354     }
 355
 356     /* Free callbacks if needed */
 357     if( p_var->p_entries )
 358     {
 359         free( p_var->p_entries );
 360     }
 361
 362     free( p_var->psz_name );
 363     if( p_var->psz_text ) free( p_var->psz_text );
 364
 365     memmove( p_priv->p_vars + i_var,
 366              p_priv->p_vars + i_var + 1,
 367              (p_priv->i_vars - i_var - 1) * sizeof(variable_t) );
 368
 369     if( (p_priv->i_vars & 15) == 0 )
 370     {
 371         p_priv->p_vars = realloc( p_priv->p_vars,
 372                           (p_priv->i_vars) * sizeof( variable_t ) );
 373     }
 374
 375     p_priv->i_vars--;
 376
 377     vlc_mutex_unlock( &p_priv->var_lock );
 378
 379     return VLC_SUCCESS;
 380 }
 381
 382 /**
 383  * Perform an action on a variable
 384  *
 385  * \param p_this The object that holds the variable
 386  * \param psz_name The name of the variable
 387  * \param i_action The action to perform. Must be one of \ref var_action
 388  * \param p_val First action parameter
 389  * \param p_val2 Second action parameter
 390  */
 391 int __var_Change( vlc_object_t *p_this, const char *psz_name,
 392                   int i_action, vlc_value_t *p_val, vlc_value_t *p_val2 )
 393 {
 394     int i_var, i;
 395     variable_t *p_var;
 396     vlc_value_t oldval;
 397     vlc_object_internals_t *p_priv = p_this->p_internals;
 398
 399     vlc_mutex_lock( &p_priv->var_lock );
 400
 401     i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
 402
 403     if( i_var < 0 )
 404     {
 405         vlc_mutex_unlock( &p_priv->var_lock );
 406         return VLC_ENOVAR;
 407     }
 408
 409     p_var = &p_priv->p_vars[i_var];
 410
 411     switch( i_action )
 412     {
 413         case VLC_VAR_SETMIN:
 414             if( p_var->i_type & VLC_VAR_HASMIN )
 415             {
 416                 p_var->pf_free( &p_var->min );
 417             }
 418             p_var->i_type |= VLC_VAR_HASMIN;
 419             p_var->min = *p_val;
 420             p_var->pf_dup( &p_var->min );
 421             CheckValue( p_var, &p_var->val );
 422             break;
 423         case VLC_VAR_SETMAX:
 424             if( p_var->i_type & VLC_VAR_HASMAX )
 425             {
 426                 p_var->pf_free( &p_var->max );
 427             }
 428             p_var->i_type |= VLC_VAR_HASMAX;
 429             p_var->max = *p_val;
 430             p_var->pf_dup( &p_var->max );
 431             CheckValue( p_var, &p_var->val );
 432             break;
 433         case VLC_VAR_SETSTEP:
 434             if( p_var->i_type & VLC_VAR_HASSTEP )
 435             {
 436                 p_var->pf_free( &p_var->step );
 437             }
 438             p_var->i_type |= VLC_VAR_HASSTEP;
 439             p_var->step = *p_val;
 440             p_var->pf_dup( &p_var->step );
 441             CheckValue( p_var, &p_var->val );
 442             break;
 443         case VLC_VAR_ADDCHOICE:
 444             /* FIXME: the list is sorted, dude. Use something cleverer. */
 445             for( i = p_var->choices.i_count ; i-- ; )
 446             {
 447                 if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) < 0 )
 448                 {
 449                     break;
 450                 }
 451             }
 452
 453             /* The new place is i+1 */
 454             i++;
 455
 456             if( p_var->i_default >= i )
 457             {
 458                 p_var->i_default++;
 459             }
 460
 461             INSERT_ELEM( p_var->choices.p_values, p_var->choices.i_count,
 462                          i, *p_val );
 463             INSERT_ELEM( p_var->choices_text.p_values,
 464                          p_var->choices_text.i_count, i, *p_val );
 465             p_var->pf_dup( &p_var->choices.p_values[i] );
 466             p_var->choices_text.p_values[i].psz_string =
 467                 ( p_val2 && p_val2->psz_string ) ?
 468                 strdup( p_val2->psz_string ) : NULL;
 469
 470             CheckValue( p_var, &p_var->val );
 471             break;
 472         case VLC_VAR_DELCHOICE:
 473             /* FIXME: the list is sorted, dude. Use something cleverer. */
 474             for( i = 0 ; i < p_var->choices.i_count ; i++ )
 475             {
 476                 if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 )
 477                 {
 478                     break;
 479                 }
 480             }
 481
 482             if( i == p_var->choices.i_count )
 483             {
 484                 /* Not found */
 485                 vlc_mutex_unlock( &p_priv->var_lock );
 486                 return VLC_EGENERIC;
 487             }
 488
 489             if( p_var->i_default > i )
 490             {
 491                 p_var->i_default--;
 492             }
 493             else if( p_var->i_default == i )
 494             {
 495                 p_var->i_default = -1;
 496             }
 497
 498             p_var->pf_free( &p_var->choices.p_values[i] );
 499             if( p_var->choices_text.p_values[i].psz_string )
 500                 free( p_var->choices_text.p_values[i].psz_string );
 501             REMOVE_ELEM( p_var->choices.p_values, p_var->choices.i_count, i );
 502             REMOVE_ELEM( p_var->choices_text.p_values,
 503                          p_var->choices_text.i_count, i );
 504
 505             CheckValue( p_var, &p_var->val );
 506             break;
 507         case VLC_VAR_CHOICESCOUNT:
 508             p_val->i_int = p_var->choices.i_count;
 509             break;
 510         case VLC_VAR_CLEARCHOICES:
 511             for( i = 0 ; i < p_var->choices.i_count ; i++ )
 512             {
 513                 p_var->pf_free( &p_var->choices.p_values[i] );
 514             }
 515             for( i = 0 ; i < p_var->choices_text.i_count ; i++ )
 516             {
 517                 if( p_var->choices_text.p_values[i].psz_string )
 518                     free( p_var->choices_text.p_values[i].psz_string );
 519             }
 520             if( p_var->choices.i_count ) free( p_var->choices.p_values );
 521             if( p_var->choices_text.i_count ) free( p_var->choices_text.p_values );
 522
 523             p_var->choices.i_count = 0;
 524             p_var->choices.p_values = NULL;
 525             p_var->choices_text.i_count = 0;
 526             p_var->choices_text.p_values = NULL;
 527             p_var->i_default = -1;
 528             break;
 529         case VLC_VAR_SETDEFAULT:
 530             /* FIXME: the list is sorted, dude. Use something cleverer. */
 531             for( i = 0 ; i < p_var->choices.i_count ; i++ )
 532             {
 533                 if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 )
 534                 {
 535                     break;
 536                 }
 537             }
 538
 539             if( i == p_var->choices.i_count )
 540             {
 541                 /* Not found */
 542                 break;
 543             }
 544
 545             p_var->i_default = i;
 546             CheckValue( p_var, &p_var->val );
 547             break;
 548         case VLC_VAR_SETVALUE:
 549             /* Duplicate data if needed */
 550             p_var->pf_dup( p_val );
 551             /* Backup needed stuff */
 552             oldval = p_var->val;
 553             /* Check boundaries and list */
 554             CheckValue( p_var, p_val );
 555             /* Set the variable */
 556             p_var->val = *p_val;
 557             /* Free data if needed */
 558             p_var->pf_free( &oldval );
 559             break;
 560         case VLC_VAR_GETCHOICES:
 561         case VLC_VAR_GETLIST:
 562             p_val->p_list = malloc( sizeof(vlc_list_t) );
 563             if( p_val2 ) p_val2->p_list = malloc( sizeof(vlc_list_t) );
 564             if( p_var->choices.i_count )
 565             {
 566                 p_val->p_list->p_values = malloc( p_var->choices.i_count
 567                                                   * sizeof(vlc_value_t) );
 568                 p_val->p_list->pi_types = malloc( p_var->choices.i_count
 569                                                   * sizeof(int) );
 570                 if( p_val2 )
 571                 {
 572                     p_val2->p_list->p_values =
 573                         malloc( p_var->choices.i_count * sizeof(vlc_value_t) );
 574                     p_val2->p_list->pi_types =
 575                         malloc( p_var->choices.i_count * sizeof(int) );
 576                 }
 577             }
 578             p_val->p_list->i_count = p_var->choices.i_count;
 579             if( p_val2 ) p_val2->p_list->i_count = p_var->choices.i_count;
 580             for( i = 0 ; i < p_var->choices.i_count ; i++ )
 581             {
 582                 p_val->p_list->p_values[i] = p_var->choices.p_values[i];
 583                 p_val->p_list->pi_types[i] = p_var->i_type;
 584                 p_var->pf_dup( &p_val->p_list->p_values[i] );
 585                 if( p_val2 )
 586                 {
 587                     p_val2->p_list->p_values[i].psz_string =
 588                         p_var->choices_text.p_values[i].psz_string ?
 589                     strdup(p_var->choices_text.p_values[i].psz_string) : NULL;
 590                     p_val2->p_list->pi_types[i] = VLC_VAR_STRING;
 591                 }
 592             }
 593             break;
 594         case VLC_VAR_FREELIST:
 595             FreeList( p_val );
 596             if( p_val2 && p_val2->p_list )
 597             {
 598                 for( i = 0; i < p_val2->p_list->i_count; i++ )
 599                     if( p_val2->p_list->p_values[i].psz_string )
 600                         free( p_val2->p_list->p_values[i].psz_string );
 601                 if( p_val2->p_list->i_count )
 602                 {
 603                     free( p_val2->p_list->p_values );
 604                     free( p_val2->p_list->pi_types );
 605                 }
 606                 free( p_val2->p_list );
 607             }
 608             break;
 609         case VLC_VAR_SETTEXT:
 610             if( p_var->psz_text ) free( p_var->psz_text );
 611             if( p_val && p_val->psz_string )
 612                 p_var->psz_text = strdup( p_val->psz_string );
 613             break;
 614         case VLC_VAR_GETTEXT:
 615             p_val->psz_string = NULL;
 616             if( p_var->psz_text )
 617             {
 618                 p_val->psz_string = strdup( p_var->psz_text );
 619             }
 620             break;
 621         case VLC_VAR_INHERITVALUE:
 622             {
 623                 vlc_value_t val;
 624
 625                 if( InheritValue( p_this, psz_name, &val, p_var->i_type )
 626                     == VLC_SUCCESS )
 627                 {
 628                     /* Duplicate already done */
 629
 630                     /* Backup needed stuff */
 631                     oldval = p_var->val;
 632                     /* Check boundaries and list */
 633                     CheckValue( p_var, &val );
 634                     /* Set the variable */
 635                     p_var->val = val;
 636                     /* Free data if needed */
 637                     p_var->pf_free( &oldval );
 638                 }
 639
 640                 if( p_val )
 641                 {
 642                     *p_val = p_var->val;
 643                     p_var->pf_dup( p_val );
 644                 }
 645             }
 646             break;
 647         case VLC_VAR_TRIGGER_CALLBACKS:
 648             {
 649                 /* Deal with callbacks. Tell we're in a callback, release the lock,
 650                  * call stored functions, retake the lock. */
 651                 if( p_var->i_entries )
 652                 {
 653                     int i_var;
 654                     int i_entries = p_var->i_entries;
 655                     callback_entry_t *p_entries = p_var->p_entries;
 656
 657                     p_var->b_incallback = VLC_TRUE;
 658                     vlc_mutex_unlock( &p_priv->var_lock );
 659
 660                     /* The real calls */
 661                     for( ; i_entries-- ; )
 662                     {
 663                         p_entries[i_entries].pf_callback( p_this, psz_name, p_var->val, p_var->val,
 664                                                           p_entries[i_entries].p_data );
 665                     }
 666
 667                     vlc_mutex_lock( &p_priv->var_lock );
 668
 669                     i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
 670                     if( i_var < 0 )
 671                     {
 672                         msg_Err( p_this, "variable %s has disappeared", psz_name );
 673                         vlc_mutex_unlock( &p_priv->var_lock );
 674                         return VLC_ENOVAR;
 675                     }
 676
 677                     p_var = &p_priv->p_vars[i_var];
 678                     p_var->b_incallback = VLC_FALSE;
 679                 }
 680             }
 681             break;
 682
 683         default:
 684             break;
 685     }
 686
 687     vlc_mutex_unlock( &p_priv->var_lock );
 688
 689     return VLC_SUCCESS;
 690 }
 691
 692 /**
 693  * Request a variable's type
 694  *
 695  * \return The variable type if it exists, or 0 if the
 696  * variable could not be found.
 697  * \see \ref var_type
 698  */
 699 int __var_Type( vlc_object_t *p_this, const char *psz_name )
 700 {
 701     int i_var, i_type;
 702     vlc_object_internals_t *p_priv = p_this->p_internals;
 703
 704     vlc_mutex_lock( &p_priv->var_lock );
 705
 706     i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
 707
 708     if( i_var < 0 )
 709     {
 710         vlc_mutex_unlock( &p_priv->var_lock );
 711         return 0;
 712     }
 713
 714     i_type = p_priv->p_vars[i_var].i_type;
 715
 716     vlc_mutex_unlock( &p_priv->var_lock );
 717
 718     return i_type;
 719 }
 720
 721 /**
 722  * Set a variable's value
 723  *
 724  * \param p_this The object that hold the variable
 725  * \param psz_name The name of the variable
 726  * \param val the value to set
 727  */
 728 int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val )
 729 {
 730     int i_var;
 731     variable_t *p_var;
 732     vlc_value_t oldval;
 733     vlc_object_internals_t *p_priv = p_this->p_internals;
 734
 735     vlc_mutex_lock( &p_priv->var_lock );
 736
 737     i_var = GetUnused( p_this, psz_name );
 738     if( i_var < 0 )
 739     {
 740         vlc_mutex_unlock( &p_priv->var_lock );
 741         return i_var;
 742     }
 743
 744     p_var = &p_priv->p_vars[i_var];
 745
 746     /* Duplicate data if needed */
 747     p_var->pf_dup( &val );
 748
 749     /* Backup needed stuff */
 750     oldval = p_var->val;
 751
 752     /* Check boundaries and list */
 753     CheckValue( p_var, &val );
 754
 755     /* Set the variable */
 756     p_var->val = val;
 757
 758     /* Deal with callbacks. Tell we're in a callback, release the lock,
 759      * call stored functions, retake the lock. */
 760     if( p_var->i_entries )
 761     {
 762         int i_var;
 763         int i_entries = p_var->i_entries;
 764         callback_entry_t *p_entries = p_var->p_entries;
 765
 766         p_var->b_incallback = VLC_TRUE;
 767         vlc_mutex_unlock( &p_priv->var_lock );
 768
 769         /* The real calls */
 770         for( ; i_entries-- ; )
 771         {
 772             p_entries[i_entries].pf_callback( p_this, psz_name, oldval, val,
 773                                               p_entries[i_entries].p_data );
 774         }
 775
 776         vlc_mutex_lock( &p_priv->var_lock );
 777
 778         i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
 779         if( i_var < 0 )
 780         {
 781             msg_Err( p_this, "variable %s has disappeared", psz_name );
 782             vlc_mutex_unlock( &p_priv->var_lock );
 783             return VLC_ENOVAR;
 784         }
 785
 786         p_var = &p_priv->p_vars[i_var];
 787         p_var->b_incallback = VLC_FALSE;
 788     }
 789
 790     /* Free data if needed */
 791     p_var->pf_free( &oldval );
 792
 793     vlc_mutex_unlock( &p_priv->var_lock );
 794
 795     return VLC_SUCCESS;
 796 }
 797
 798 /**
 799  * Get a variable's value
 800  *
 801  * \param p_this The object that holds the variable
 802  * \param psz_name The name of the variable
 803  * \param p_val Pointer to a vlc_value_t that will hold the variable's value
 804  *              after the function is finished
 805  */
 806 int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val )
 807 {
 808     int i_var;
 809     variable_t *p_var;
 810     vlc_object_internals_t *p_priv = p_this->p_internals;
 811
 812     vlc_mutex_lock( &p_priv->var_lock );
 813
 814     i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
 815
 816     if( i_var < 0 )
 817     {
 818         vlc_mutex_unlock( &p_priv->var_lock );
 819         return VLC_ENOVAR;
 820     }
 821
 822     p_var = &p_priv->p_vars[i_var];
 823
 824     /* Really get the variable */
 825     *p_val = p_var->val;
 826
 827     /* Duplicate value if needed */
 828     p_var->pf_dup( p_val );
 829
 830     vlc_mutex_unlock( &p_priv->var_lock );
 831
 832     return VLC_SUCCESS;
 833 }
 834
 835
 836 /**
 837  * Finds a process-wide mutex, creates it if needed, and locks it.
 838  * Unlock with vlc_mutex_unlock().
 839  */
 840 vlc_mutex_t *var_AcquireMutex( const char *name )
 841 {
 842     libvlc_global_data_t *p_global = vlc_global();
 843     vlc_value_t val;
 844
 845     if( var_Create( p_global, name, VLC_VAR_MUTEX ) )
 846         return NULL;
 847
 848     var_Get( p_global, name, &val );
 849     vlc_mutex_lock( &val.p_address );
 850     return val.p_address;
 851 }
 852
 853
 854 /**
 855  * Register a callback in a variable
 856  *
 857  * We store a function pointer that will be called upon variable
 858  * modification.
 859  *
 860  * \param p_this The object that holds the variable
 861  * \param psz_name The name of the variable
 862  * \param pf_callback The function pointer
 863  * \param p_data A generic pointer that will be passed as the last
 864  *               argument to the callback function.
 865  *
 866  * \warning The callback function is run in the thread that calls var_Set on
 867  *          the variable. Use proper locking. This thread may not have much
 868  *          time to spare, so keep callback functions short.
 869  */
 870 int __var_AddCallback( vlc_object_t *p_this, const char *psz_name,
 871                        vlc_callback_t pf_callback, void *p_data )
 872 {
 873     int i_var;
 874     variable_t *p_var;
 875     callback_entry_t entry;
 876     vlc_object_internals_t *p_priv = p_this->p_internals;
 877
 878     entry.pf_callback = pf_callback;
 879     entry.p_data = p_data;
 880
 881     vlc_mutex_lock( &p_priv->var_lock );
 882
 883     i_var = GetUnused( p_this, psz_name );
 884     if( i_var < 0 )
 885     {
 886         vlc_mutex_unlock( &p_priv->var_lock );
 887         return i_var;
 888     }
 889
 890     p_var = &p_priv->p_vars[i_var];
 891
 892     INSERT_ELEM( p_var->p_entries,
 893                  p_var->i_entries,
 894                  p_var->i_entries,
 895                  entry );
 896
 897     vlc_mutex_unlock( &p_priv->var_lock );
 898
 899     return VLC_SUCCESS;
 900 }
 901
 902 /**
 903  * Remove a callback from a variable
 904  *
 905  * pf_callback and p_data have to be given again, because different objects
 906  * might have registered the same callback function.
 907  */
 908 int __var_DelCallback( vlc_object_t *p_this, const char *psz_name,
 909                        vlc_callback_t pf_callback, void *p_data )
 910 {
 911     int i_entry, i_var;
 912     variable_t *p_var;
 913     vlc_object_internals_t *p_priv = p_this->p_internals;
 914
 915     vlc_mutex_lock( &p_priv->var_lock );
 916
 917     i_var = GetUnused( p_this, psz_name );
 918     if( i_var < 0 )
 919     {
 920         vlc_mutex_unlock( &p_priv->var_lock );
 921         return i_var;
 922     }
 923
 924     p_var = &p_priv->p_vars[i_var];
 925
 926     for( i_entry = p_var->i_entries ; i_entry-- ; )
 927     {
 928         if( p_var->p_entries[i_entry].pf_callback == pf_callback
 929             && p_var->p_entries[i_entry].p_data == p_data )
 930         {
 931             break;
 932         }
 933     }
 934
 935     if( i_entry < 0 )
 936     {
 937         vlc_mutex_unlock( &p_priv->var_lock );
 938         return VLC_EGENERIC;
 939     }
 940
 941     REMOVE_ELEM( p_var->p_entries, p_var->i_entries, i_entry );
 942
 943     vlc_mutex_unlock( &p_priv->var_lock );
 944
 945     return VLC_SUCCESS;
 946 }
 947
 948 /**
 949  * Trigger callback on a variable
 950  *
 951  * \param p_this The object that hold the variable
 952  * \param psz_name The name of the variable
 953  */
 954 int __var_TriggerCallback( vlc_object_t *p_this, const char *psz_name )
 955 {
 956     int i_var;
 957     variable_t *p_var;
 958     vlc_value_t oldval;
 959     vlc_object_internals_t *p_priv = p_this->p_internals;
 960
 961     vlc_mutex_lock( &p_priv->var_lock );
 962
 963     i_var = GetUnused( p_this, psz_name );
 964     if( i_var < 0 )
 965     {
 966         vlc_mutex_unlock( &p_priv->var_lock );
 967         return i_var;
 968     }
 969
 970     p_var = &p_priv->p_vars[i_var];
 971
 972     /* Backup needed stuff */
 973     oldval = p_var->val;
 974
 975     /* Deal with callbacks. Tell we're in a callback, release the lock,
 976      * call stored functions, retake the lock. */
 977     if( p_var->i_entries )
 978     {
 979         int i_var;
 980         int i_entries = p_var->i_entries;
 981         callback_entry_t *p_entries = p_var->p_entries;
 982
 983         p_var->b_incallback = VLC_TRUE;
 984         vlc_mutex_unlock( &p_priv->var_lock );
 985
 986         /* The real calls */
 987         for( ; i_entries-- ; )
 988         {
 989             p_entries[i_entries].pf_callback( p_this, psz_name, oldval, oldval,
 990                                               p_entries[i_entries].p_data );
 991         }
 992
 993         vlc_mutex_lock( &p_priv->var_lock );
 994
 995         i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
 996         if( i_var < 0 )
 997         {
 998             msg_Err( p_this, "variable %s has disappeared", psz_name );
 999             vlc_mutex_unlock( &p_priv->var_lock );
1000             return VLC_ENOVAR;
1001         }
1002
1003         p_var = &p_priv->p_vars[i_var];
1004         p_var->b_incallback = VLC_FALSE;
1005     }
1006
1007     vlc_mutex_unlock( &p_priv->var_lock );
1008     return VLC_SUCCESS;
1009 }
1010
1011 /** Parse a stringified option
1012  * This function parse a string option and create the associated object
1013  * variable
1014  * The option must be of the form "[no[-]]foo[=bar]" where foo is the
1015  * option name and bar is the value of the option.
1016  * \param p_obj the object in which the variable must be created
1017  * \param psz_option the option to parse
1018  * \return nothing
1019  */
1020 void __var_OptionParse( vlc_object_t *p_obj, const char *psz_option )
1021 {
1022     char *psz_name, *psz_value = strchr( psz_option, '=' );
1023     int  i_name_len, i_type;
1024     vlc_bool_t b_isno = VLC_FALSE;
1025     vlc_value_t val;
1026
1027     if( psz_value ) i_name_len = psz_value - psz_option;
1028     else i_name_len = strlen( psz_option );
1029
1030     /* It's too much of a hassle to remove the ':' when we parse
1031      * the cmd line :) */
1032     if( i_name_len && *psz_option == ':' )
1033     {
1034         psz_option++;
1035         i_name_len--;
1036     }
1037
1038     if( i_name_len == 0 ) return;
1039
1040     psz_name = strndup( psz_option, i_name_len );
1041     if( psz_value ) psz_value++;
1042
1043     /* FIXME: :programs should be handled generically */
1044     if( !strcmp( psz_name, "programs" ) )
1045         i_type = VLC_VAR_LIST;
1046     else
1047         i_type = config_GetType( p_obj, psz_name );
1048
1049     if( !i_type && !psz_value )
1050     {
1051         /* check for "no-foo" or "nofoo" */
1052         if( !strncmp( psz_name, "no-", 3 ) )
1053         {
1054             memmove( psz_name, psz_name + 3, strlen(psz_name) + 1 - 3 );
1055         }
1056         else if( !strncmp( psz_name, "no", 2 ) )
1057         {
1058             memmove( psz_name, psz_name + 2, strlen(psz_name) + 1 - 2 );
1059         }
1060         else goto cleanup;           /* Option doesn't exist */
1061
1062         b_isno = VLC_TRUE;
1063         i_type = config_GetType( p_obj, psz_name );
1064
1065         if( !i_type ) goto cleanup;  /* Option doesn't exist */
1066     }
1067     else if( !i_type ) goto cleanup; /* Option doesn't exist */
1068
1069     if( ( i_type != VLC_VAR_BOOL ) &&
1070         ( !psz_value || !*psz_value ) ) goto cleanup; /* Invalid value */
1071
1072     /* Create the variable in the input object.
1073      * Children of the input object will be able to retreive this value
1074      * thanks to the inheritance property of the object variables. */
1075     var_Create( p_obj, psz_name, i_type );
1076
1077     switch( i_type )
1078     {
1079     case VLC_VAR_BOOL:
1080         val.b_bool = !b_isno;
1081         break;
1082
1083     case VLC_VAR_INTEGER:
1084         val.i_int = strtol( psz_value, NULL, 0 );
1085         break;
1086
1087     case VLC_VAR_FLOAT:
1088         val.f_float = atof( psz_value );
1089         break;
1090
1091     case VLC_VAR_STRING:
1092     case VLC_VAR_MODULE:
1093     case VLC_VAR_FILE:
1094     case VLC_VAR_DIRECTORY:
1095         val.psz_string = psz_value;
1096         break;
1097
1098     case VLC_VAR_LIST:
1099     {
1100         char *psz_orig, *psz_var;
1101         vlc_list_t *p_list = malloc(sizeof(vlc_list_t));
1102         val.p_list = p_list;
1103         p_list->i_count = 0;
1104
1105         psz_var = psz_orig = strdup(psz_value);
1106         while( psz_var && *psz_var )
1107         {
1108             char *psz_item = psz_var;
1109             vlc_value_t val2;
1110             while( *psz_var && *psz_var != ',' ) psz_var++;
1111             if( *psz_var == ',' )
1112             {
1113                 *psz_var = '\0';
1114                 psz_var++;
1115             }
1116             val2.i_int = strtol( psz_item, NULL, 0 );
1117             INSERT_ELEM( p_list->p_values, p_list->i_count,
1118                          p_list->i_count, val2 );
1119             /* p_list->i_count is incremented twice by INSERT_ELEM */
1120             p_list->i_count--;
1121             INSERT_ELEM( p_list->pi_types, p_list->i_count,
1122                          p_list->i_count, VLC_VAR_INTEGER );
1123         }
1124         if( psz_orig ) free( psz_orig );
1125         break;
1126     }
1127
1128     default:
1129         goto cleanup;
1130         break;
1131     }
1132
1133     var_Set( p_obj, psz_name, val );
1134
1135   cleanup:
1136     if( psz_name ) free( psz_name );
1137     return;
1138 }
1139
1140
1141 /* Following functions are local */
1142
1143 /*****************************************************************************
1144  * GetUnused: find an unused variable from its name
1145  *****************************************************************************
1146  * We do i_tries tries before giving up, just in case the variable is being
1147  * modified and called from a callback.
1148  *****************************************************************************/
1149 static int GetUnused( vlc_object_t *p_this, const char *psz_name )
1150 {
1151     int i_var, i_tries = 0;
1152     vlc_object_internals_t *p_priv = p_this->p_internals;
1153
1154     while( VLC_TRUE )
1155     {
1156         i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
1157         if( i_var < 0 )
1158         {
1159             return VLC_ENOVAR;
1160         }
1161
1162         if( ! p_priv->p_vars[i_var].b_incallback )
1163         {
1164             return i_var;
1165         }
1166
1167         if( i_tries++ > 100 )
1168         {
1169             msg_Err( p_this, "caught in a callback deadlock?" );
1170             return VLC_ETIMEOUT;
1171         }
1172
1173         vlc_mutex_unlock( &p_priv->var_lock );
1174         msleep( THREAD_SLEEP );
1175         vlc_mutex_lock( &p_priv->var_lock );
1176     }
1177 }
1178
1179 /*****************************************************************************
1180  * HashString: our cool hash function
1181  *****************************************************************************
1182  * This function is not intended to be crypto-secure, we only want it to be
1183  * fast and not suck too much. This one is pretty fast and did 0 collisions
1184  * in wenglish's dictionary.
1185  *****************************************************************************/
1186 static uint32_t HashString( const char *psz_string )
1187 {
1188     uint32_t i_hash = 0;
1189
1190     while( *psz_string )
1191     {
1192         i_hash += *psz_string++;
1193         i_hash += i_hash << 10;
1194         i_hash ^= i_hash >> 8;
1195     }
1196
1197     return i_hash;
1198 }
1199
1200 /*****************************************************************************
1201  * Insert: find an empty slot to insert a new variable
1202  *****************************************************************************
1203  * We use a recursive inner function indexed on the hash. This function does
1204  * nothing in the rare cases where a collision may occur, see Lookup()
1205  * to see how we handle them.
1206  * XXX: does this really need to be written recursively?
1207  *****************************************************************************/
1208 static int Insert( variable_t *p_vars, int i_count, const char *psz_name )
1209 {
1210     if( i_count == 0 )
1211     {
1212         return 0;
1213     }
1214
1215     return InsertInner( p_vars, i_count, HashString( psz_name ) );
1216 }
1217
1218 static int InsertInner( variable_t *p_vars, int i_count, uint32_t i_hash )
1219 {
1220     int i_middle;
1221
1222     if( i_hash <= p_vars[0].i_hash )
1223     {
1224         return 0;
1225     }
1226
1227     if( i_hash >= p_vars[i_count - 1].i_hash )
1228     {
1229         return i_count;
1230     }
1231
1232     i_middle = i_count / 2;
1233
1234     /* We know that 0 < i_middle */
1235     if( i_hash < p_vars[i_middle].i_hash )
1236     {
1237         return InsertInner( p_vars, i_middle, i_hash );
1238     }
1239
1240     /* We know that i_middle + 1 < i_count */
1241     if( i_hash > p_vars[i_middle + 1].i_hash )
1242     {
1243         return i_middle + 1 + InsertInner( p_vars + i_middle + 1,
1244                                            i_count - i_middle - 1,
1245                                            i_hash );
1246     }
1247
1248     return i_middle + 1;
1249 }
1250
1251 /*****************************************************************************
1252  * Lookup: find an existing variable given its name
1253  *****************************************************************************
1254  * We use a recursive inner function indexed on the hash. Care is taken of
1255  * possible hash collisions.
1256  * XXX: does this really need to be written recursively?
1257  *****************************************************************************/
1258 static int Lookup( variable_t *p_vars, int i_count, const char *psz_name )
1259 {
1260     uint32_t i_hash;
1261     int i, i_pos;
1262
1263     if( i_count == 0 )
1264     {
1265         return -1;
1266     }
1267
1268     i_hash = HashString( psz_name );
1269
1270     i_pos = LookupInner( p_vars, i_count, i_hash );
1271
1272     /* Hash not found */
1273     if( i_hash != p_vars[i_pos].i_hash )
1274     {
1275         return -1;
1276     }
1277
1278     /* Hash found, entry found */
1279     if( !strcmp( psz_name, p_vars[i_pos].psz_name ) )
1280     {
1281         return i_pos;
1282     }
1283
1284     /* Hash collision! This should be very rare, but we cannot guarantee
1285      * it will never happen. Just do an exhaustive search amongst all
1286      * entries with the same hash. */
1287     for( i = i_pos - 1 ; i > 0 && i_hash == p_vars[i].i_hash ; i-- )
1288     {
1289         if( !strcmp( psz_name, p_vars[i].psz_name ) )
1290         {
1291             return i;
1292         }
1293     }
1294
1295     for( i = i_pos + 1 ; i < i_count && i_hash == p_vars[i].i_hash ; i++ )
1296     {
1297         if( !strcmp( psz_name, p_vars[i].psz_name ) )
1298         {
1299             return i;
1300         }
1301     }
1302
1303     /* Hash found, but entry not found */
1304     return -1;
1305 }
1306
1307 static int LookupInner( variable_t *p_vars, int i_count, uint32_t i_hash )
1308 {
1309     int i_middle;
1310
1311     if( i_hash <= p_vars[0].i_hash )
1312     {
1313         return 0;
1314     }
1315
1316     if( i_hash >= p_vars[i_count-1].i_hash )
1317     {
1318         return i_count - 1;
1319     }
1320
1321     i_middle = i_count / 2;
1322
1323     /* We know that 0 < i_middle */
1324     if( i_hash < p_vars[i_middle].i_hash )
1325     {
1326         return LookupInner( p_vars, i_middle, i_hash );
1327     }
1328
1329     /* We know that i_middle + 1 < i_count */
1330     if( i_hash > p_vars[i_middle].i_hash )
1331     {
1332         return i_middle + LookupInner( p_vars + i_middle,
1333                                        i_count - i_middle,
1334                                        i_hash );
1335     }
1336
1337     return i_middle;
1338 }
1339
1340 /*****************************************************************************
1341  * CheckValue: check that a value is valid wrt. a variable
1342  *****************************************************************************
1343  * This function checks p_val's value against p_var's limitations such as
1344  * minimal and maximal value, step, in-list position, and modifies p_val if
1345  * necessary.
1346  ****************************************************************************/
1347 static void CheckValue ( variable_t *p_var, vlc_value_t *p_val )
1348 {
1349     /* Check that our variable is in the list */
1350     if( p_var->i_type & VLC_VAR_HASCHOICE && p_var->choices.i_count )
1351     {
1352         int i;
1353
1354         /* FIXME: the list is sorted, dude. Use something cleverer. */
1355         for( i = p_var->choices.i_count ; i-- ; )
1356         {
1357             if( p_var->pf_cmp( *p_val, p_var->choices.p_values[i] ) == 0 )
1358             {
1359                 break;
1360             }
1361         }
1362
1363         /* If not found, change it to anything vaguely valid */
1364         if( i < 0 )
1365         {
1366             /* Free the old variable, get the new one, dup it */
1367             p_var->pf_free( p_val );
1368             *p_val = p_var->choices.p_values[p_var->i_default >= 0
1369                                           ? p_var->i_default : 0 ];
1370             p_var->pf_dup( p_val );
1371         }
1372     }
1373
1374     /* Check that our variable is within the bounds */
1375     switch( p_var->i_type & VLC_VAR_TYPE )
1376     {
1377         case VLC_VAR_INTEGER:
1378             if( p_var->i_type & VLC_VAR_HASSTEP && p_var->step.i_int
1379                  && (p_val->i_int % p_var->step.i_int) )
1380             {
1381                 p_val->i_int = (p_val->i_int + (p_var->step.i_int / 2))
1382                                / p_var->step.i_int * p_var->step.i_int;
1383             }
1384             if( p_var->i_type & VLC_VAR_HASMIN
1385                  && p_val->i_int < p_var->min.i_int )
1386             {
1387                 p_val->i_int = p_var->min.i_int;
1388             }
1389             if( p_var->i_type & VLC_VAR_HASMAX
1390                  && p_val->i_int > p_var->max.i_int )
1391             {
1392                 p_val->i_int = p_var->max.i_int;
1393             }
1394             break;
1395         case VLC_VAR_FLOAT:
1396             if( p_var->i_type & VLC_VAR_HASSTEP && p_var->step.f_float )
1397             {
1398                 float f_round = p_var->step.f_float * (float)(int)( 0.5 +
1399                                         p_val->f_float / p_var->step.f_float );
1400                 if( p_val->f_float != f_round )
1401                 {
1402                     p_val->f_float = f_round;
1403                 }
1404             }
1405             if( p_var->i_type & VLC_VAR_HASMIN
1406                  && p_val->f_float < p_var->min.f_float )
1407             {
1408                 p_val->f_float = p_var->min.f_float;
1409             }
1410             if( p_var->i_type & VLC_VAR_HASMAX
1411                  && p_val->f_float > p_var->max.f_float )
1412             {
1413                 p_val->f_float = p_var->max.f_float;
1414             }
1415             break;
1416         case VLC_VAR_TIME:
1417             /* FIXME: TODO */
1418             break;
1419     }
1420 }
1421
1422 /*****************************************************************************
1423  * InheritValue: try to inherit the value of this variable from the same one
1424  *               in our closest parent.
1425  *****************************************************************************/
1426 static int InheritValue( vlc_object_t *p_this, const char *psz_name,
1427                          vlc_value_t *p_val, int i_type )
1428 {
1429     int i_var;
1430     variable_t *p_var;
1431
1432     /* No need to take the structure lock,
1433      * we are only looking for our parents */
1434
1435     if( !p_this->p_parent )
1436     {
1437         switch( i_type & VLC_VAR_TYPE )
1438         {
1439         case VLC_VAR_FILE:
1440         case VLC_VAR_DIRECTORY:
1441         case VLC_VAR_STRING:
1442         case VLC_VAR_MODULE:
1443             p_val->psz_string = config_GetPsz( p_this, psz_name );
1444             if( !p_val->psz_string ) p_val->psz_string = strdup("");
1445             break;
1446         case VLC_VAR_FLOAT:
1447             p_val->f_float = config_GetFloat( p_this, psz_name );
1448             break;
1449         case VLC_VAR_INTEGER:
1450         case VLC_VAR_HOTKEY:
1451             p_val->i_int = config_GetInt( p_this, psz_name );
1452             break;
1453         case VLC_VAR_BOOL:
1454             p_val->b_bool = config_GetInt( p_this, psz_name );
1455             break;
1456         case VLC_VAR_LIST:
1457         {
1458             char *psz_orig, *psz_var;
1459             vlc_list_t *p_list = malloc(sizeof(vlc_list_t));
1460             p_val->p_list = p_list;
1461             p_list->i_count = 0;
1462
1463             psz_var = psz_orig = config_GetPsz( p_this, psz_name );
1464             while( psz_var && *psz_var )
1465             {
1466                 char *psz_item = psz_var;
1467                 vlc_value_t val;
1468                 while( *psz_var && *psz_var != ',' ) psz_var++;
1469                 if( *psz_var == ',' )
1470                 {
1471                     *psz_var = '\0';
1472                     psz_var++;
1473                 }
1474                 val.i_int = strtol( psz_item, NULL, 0 );
1475                 INSERT_ELEM( p_list->p_values, p_list->i_count,
1476                              p_list->i_count, val );
1477                 /* p_list->i_count is incremented twice by INSERT_ELEM */
1478                 p_list->i_count--;
1479                 INSERT_ELEM( p_list->pi_types, p_list->i_count,
1480                              p_list->i_count, VLC_VAR_INTEGER );
1481             }
1482             if( psz_orig ) free( psz_orig );
1483             break;
1484         }
1485         default:
1486             return VLC_ENOOBJ;
1487             break;
1488         }
1489
1490         return VLC_SUCCESS;
1491     }
1492
1493     vlc_object_internals_t *p_priv = p_this->p_parent->p_internals;
1494
1495     /* Look for the variable */
1496     vlc_mutex_lock( &p_priv->var_lock );
1497
1498     i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name );
1499
1500     if( i_var >= 0 )
1501     {
1502         /* We found it! */
1503         p_var = &p_priv->p_vars[i_var];
1504
1505         /* Really get the variable */
1506         *p_val = p_var->val;
1507
1508         /* Duplicate value if needed */
1509         p_var->pf_dup( p_val );
1510
1511         vlc_mutex_unlock( &p_priv->var_lock );
1512         return VLC_SUCCESS;
1513     }
1514
1515     vlc_mutex_unlock( &p_priv->var_lock );
1516
1517     /* We're still not there */
1518
1519     return InheritValue( p_this->p_parent, psz_name, p_val, i_type );
1520 }
1521
1522 /**********************************************************************
1523  * Execute a var command on an object identified by its name
1524  **********************************************************************/
1525 int __var_Command( vlc_object_t *p_this, const char *psz_name,
1526                    const char *psz_cmd, const char *psz_arg, char **psz_msg )
1527 {
1528     vlc_object_t *p_obj = vlc_object_find_name( p_this->p_libvlc,
1529                                                 psz_name, FIND_CHILD );
1530     int i_type, i_ret;
1531
1532     if( !p_obj )
1533     {
1534         if( psz_msg )
1535             *psz_msg = strdup( "Unknown destination object." );
1536         return VLC_ENOOBJ;
1537     }
1538
1539     i_type = var_Type( p_obj, psz_cmd );
1540     if( !( i_type&VLC_VAR_ISCOMMAND ) )
1541     {
1542         vlc_object_release( p_obj );
1543         if( psz_msg )
1544             *psz_msg = strdup( "Variable doesn't exist or isn't a command." );
1545         return VLC_EGENERIC;
1546     }
1547
1548     i_type &= 0xf0;
1549     switch( i_type )
1550     {
1551         case VLC_VAR_INTEGER:
1552             i_ret = var_SetInteger( p_obj, psz_cmd, atoi( psz_arg ) );
1553             break;
1554         case VLC_VAR_FLOAT:
1555             i_ret = var_SetFloat( p_obj, psz_cmd, atof( psz_arg ) );
1556             break;
1557         case VLC_VAR_STRING:
1558             i_ret = var_SetString( p_obj, psz_cmd, psz_arg );
1559             break;
1560         case VLC_VAR_BOOL:
1561             i_ret = var_SetBool( p_obj, psz_cmd, atoi( psz_arg ) );
1562             break;
1563         default:
1564             i_ret = VLC_EGENERIC;
1565             break;
1566     }
1567
1568     vlc_object_release( p_obj );
1569
1570     if( psz_msg )
1571     {
1572         *psz_msg = (char*)malloc( 80 );
1573         sprintf( *psz_msg, "%s on object %s returned %i (%s)",
1574                  psz_cmd, psz_name, i_ret, vlc_error( i_ret ) );
1575     }
1576
1577     return i_ret;
1578 }