include/vlc_variables.h

   1 /*****************************************************************************
   2  * vlc_variables.h: variables handling
   3  *****************************************************************************
   4  * Copyright (C) 2002-2004 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *          Gildas Bazin <gbazin@netcourrier.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #ifndef VLC_VARIABLES_H
  26 #define VLC_VARIABLES_H 1
  27
  28 /**
  29  * \defgroup variables Variables
  30  * \ingroup vlc_object
  31  *
  32  * VLC object variables and callbacks
  33  *
  34  * @{
  35  * \file
  36  * VLC object variables and callbacks interface
  37  */
  38
  39 #define VLC_VAR_TYPE      0x00ff
  40 #define VLC_VAR_CLASS     0x00f0
  41 #define VLC_VAR_FLAGS     0xff00
  42
  43 /**
  44  * \defgroup var_type Variable types
  45  * These are the different types a vlc variable can have.
  46  * @{
  47  */
  48 #define VLC_VAR_VOID      0x0010
  49 #define VLC_VAR_BOOL      0x0020
  50 #define VLC_VAR_INTEGER   0x0030
  51 #define VLC_VAR_STRING    0x0040
  52 #define VLC_VAR_FLOAT     0x0050
  53 #define VLC_VAR_ADDRESS   0x0070
  54 #define VLC_VAR_COORDS    0x00A0
  55 /**@}*/
  56
  57 /** \defgroup var_flags Additive flags
  58  * These flags are added to the type field of the variable. Most as a result of
  59  * a var_Change() call, but some may be added at creation time
  60  * @{
  61  */
  62 #define VLC_VAR_HASCHOICE 0x0100
  63
  64 #define VLC_VAR_ISCOMMAND 0x2000
  65
  66 /** Creation flag */
  67 /* If the variable is not found on the current module
  68    search all parents and finally module config until found */
  69 #define VLC_VAR_DOINHERIT 0x8000
  70 /**@}*/
  71
  72 /**
  73  * \defgroup var_action Variable actions
  74  * These are the different actions that can be used with var_Change().
  75  * The parameters given are the meaning of the two last parameters of
  76  * var_Change() when this action is being used.
  77  * @{
  78  */
  79
  80 #define VLC_VAR_SETSTEP             0x0012
  81
  82 /**
  83  * Set the value of this variable without triggering any callbacks
  84  * \param p_val The new value
  85  * \param p_val2 Unused
  86  */
  87 #define VLC_VAR_SETVALUE            0x0013
  88
  89 #define VLC_VAR_SETTEXT             0x0014
  90 #define VLC_VAR_GETTEXT             0x0015
  91
  92 #define VLC_VAR_GETMIN              0x0016
  93 #define VLC_VAR_GETMAX              0x0017
  94 #define VLC_VAR_GETSTEP             0x0018
  95
  96 #define VLC_VAR_ADDCHOICE           0x0020
  97 #define VLC_VAR_DELCHOICE           0x0021
  98 #define VLC_VAR_CLEARCHOICES        0x0022
  99 #define VLC_VAR_GETCHOICES          0x0024
 100
 101 #define VLC_VAR_CHOICESCOUNT        0x0026
 102 #define VLC_VAR_SETMINMAX           0x0027
 103
 104 /**@}*/
 105
 106 /**
 107  * Variable actions.
 108  *
 109  * These are the different actions that can be used with var_GetAndSet().
 110  */
 111 enum vlc_var_atomic_op {
 112     VLC_VAR_BOOL_TOGGLE, /**< Invert a boolean value (param ignored) */
 113     VLC_VAR_INTEGER_ADD, /**< Add parameter to an integer value */
 114     VLC_VAR_INTEGER_OR,  /**< Binary OR over an integer bits field */
 115     VLC_VAR_INTEGER_NAND,/**< Binary NAND over an integer bits field */
 116 };
 117
 118 /**
 119  * Creates a VLC object variable.
 120  *
 121  * This function creates a named variable within a VLC object.
 122  * If a variable already exists with the same name within the same object, its
 123  * reference count is incremented instead.
 124  *
 125  * \param obj Object to hold the variable
 126  * \param name Variable name
 127  * \param type Variable type. Must be one of \ref var_type combined with
 128  *               zero or more \ref var_flags
 129  */
 130 VLC_API int var_Create(vlc_object_t *obj, const char *name, int type);
 131
 132 /**
 133  * Destroys a VLC object variable.
 134  *
 135  * This function decrements the reference count of a named variable within a
 136  * VLC object. If the reference count reaches zero, the variable is destroyed.
 137  *
 138  * \param obj Object holding the variable
 139  * \param name Variable name
 140  */
 141 VLC_API void var_Destroy(vlc_object_t *obj, const char *name);
 142
 143 /**
 144  * Performs a special action on a variable.
 145  *
 146  * \param obj Object holding the variable
 147  * \param name Variable name
 148  * \param action Action to perform. Must be one of \ref var_action
 149  */
 150 VLC_API int var_Change(vlc_object_t *obj, const char *name, int action, ...);
 151
 152 /**
 153  * Get the type of a variable.
 154  *
 155  * \see var_type
 156  *
 157  * \return The variable type if it exists
 158  *         or 0 if the variable could not be found.
 159  */
 160 VLC_API int var_Type(vlc_object_t *obj, const char *name) VLC_USED;
 161
 162 /**
 163  * Sets a variable value.
 164  *
 165  * \param obj Object holding the variable
 166  * \param name Variable name
 167  * \param val Variable value to set
 168  */
 169 VLC_API int var_Set(vlc_object_t *obj, const char *name, vlc_value_t val);
 170
 171 /**
 172  * Gets a variable value.
 173  *
 174  * \param obj Object holding the variable
 175  * \param name Variable name
 176  * \param valp Pointer to a \ref vlc_value_t object to hold the value [OUT]
 177  */
 178 VLC_API int var_Get(vlc_object_t *obj, const char *name, vlc_value_t *valp);
 179
 180 VLC_API int var_SetChecked( vlc_object_t *, const char *, int, vlc_value_t );
 181 VLC_API int var_GetChecked( vlc_object_t *, const char *, int, vlc_value_t * );
 182
 183 /**
 184  * Perform an atomic read-modify-write of a variable.
 185  *
 186  * \param obj object holding the variable
 187  * \param name variable name
 188  * \param op read-modify-write operation to perform
 189  *           (see \ref vlc_var_atomic_op)
 190  * \param value value of the variable after the modification
 191  * \retval VLC_SUCCESS Operation successful
 192  * \retval VLC_ENOVAR Variable not found
 193  *
 194  * \bug The modified value is returned rather than the original value.
 195  * As such, the original value cannot be known in the case of non-reversible
 196  * operation such as \ref VLC_VAR_INTEGER_OR and \ref VLC_VAR_INTEGER_NAND.
 197  */
 198 VLC_API int var_GetAndSet(vlc_object_t *obj, const char *name, int op,
 199                           vlc_value_t *value);
 200
 201 /**
 202  * Finds the value of a variable.
 203  *
 204  * If the specified object does not hold a variable with the specified name,
 205  * try the parent object, and iterate until the top of the objects tree. If no
 206  * match is found, the value is read from the configuration.
 207  */
 208 VLC_API int var_Inherit( vlc_object_t *, const char *, int, vlc_value_t * );
 209
 210
 211 /*****************************************************************************
 212  * Variable callbacks
 213  *****************************************************************************
 214  * int MyCallback( vlc_object_t *p_this,
 215  *                 char const *psz_variable,
 216  *                 vlc_value_t oldvalue,
 217  *                 vlc_value_t newvalue,
 218  *                 void *p_data);
 219  *****************************************************************************/
 220
 221 /**
 222  * Registers a callback for a variable.
 223  *
 224  * We store a function pointer that will be called upon variable
 225  * modification.
 226  *
 227  * \param obj Object holding the variable
 228  * \param name Variable name
 229  * \param callback Callback function pointer
 230  * \param opaque Opaque data pointer for use by the callback.
 231  *
 232  * \warning The callback function is run in the thread that calls var_Set() on
 233  *          the variable. Use proper locking. This thread may not have much
 234  *          time to spare, so keep callback functions short.
 235  *
 236  * \bug It is not possible to atomically retrieve the current value and
 237  * register a callback. As a consequence, extreme care must be taken to ensure
 238  * that the variable value cannot change before the callback is registered.
 239  * Failure to do so will result in intractable race conditions.
 240  */
 241 VLC_API void var_AddCallback(vlc_object_t *obj, const char *name,
 242                              vlc_callback_t callback, void *opaque);
 243
 244 /**
 245  * Deregisters a callback from a variable.
 246  *
 247  * The callback and opaque pointer must be supplied again, as the same callback
 248  * function might have been registered more than once.
 249  */
 250 VLC_API void var_DelCallback(vlc_object_t *obj, const char *name,
 251                              vlc_callback_t callback, void *opaque);
 252
 253 /**
 254  * Triggers callbacks on a variable.
 255  *
 256  * This triggers any callbacks registered on the named variable without
 257  * actually modifying the variable value. This is primarily useful for
 258  * variables with \ref VLC_VAR_VOID type (which do not have a value).
 259  *
 260  * \param obj Object holding the variable
 261  * \param name Variable name
 262  */
 263 VLC_API void var_TriggerCallback(vlc_object_t *obj, const char *name);
 264
 265 /**
 266  * Register a callback for a list variable
 267  *
 268  * The callback is triggered when an element is added/removed from the
 269  * list or when the list is cleared.
 270  *
 271  * See var_AddCallback().
 272  */
 273 VLC_API void var_AddListCallback( vlc_object_t *, const char *, vlc_list_callback_t, void * );
 274
 275 /**
 276  * Remove a callback from a list variable
 277  *
 278  * See var_DelCallback().
 279  */
 280 VLC_API void var_DelListCallback( vlc_object_t *, const char *, vlc_list_callback_t, void * );
 281
 282 /*****************************************************************************
 283  * helpers functions
 284  *****************************************************************************/
 285
 286 /**
 287  * Set the value of an integer variable
 288  *
 289  * \param p_obj The object that holds the variable
 290  * \param psz_name The name of the variable
 291  * \param i The new integer value of this variable
 292  */
 293 static inline int var_SetInteger( vlc_object_t *p_obj, const char *psz_name,
 294                                   int64_t i )
 295 {
 296     vlc_value_t val;
 297     val.i_int = i;
 298     return var_SetChecked( p_obj, psz_name, VLC_VAR_INTEGER, val );
 299 }
 300
 301 /**
 302  * Set the value of an boolean variable
 303  *
 304  * \param p_obj The object that holds the variable
 305  * \param psz_name The name of the variable
 306  * \param b The new boolean value of this variable
 307  */
 308 static inline int var_SetBool( vlc_object_t *p_obj, const char *psz_name, bool b )
 309 {
 310     vlc_value_t val;
 311     val.b_bool = b;
 312     return var_SetChecked( p_obj, psz_name, VLC_VAR_BOOL, val );
 313 }
 314
 315 static inline int var_SetCoords( vlc_object_t *obj, const char *name,
 316                                  int32_t x, int32_t y )
 317 {
 318     vlc_value_t val;
 319     val.coords.x = x;
 320     val.coords.y = y;
 321     return var_SetChecked (obj, name, VLC_VAR_COORDS, val);
 322 }
 323
 324 /**
 325  * Set the value of a float variable
 326  *
 327  * \param p_obj The object that holds the variable
 328  * \param psz_name The name of the variable
 329  * \param f The new float value of this variable
 330  */
 331 static inline int var_SetFloat( vlc_object_t *p_obj, const char *psz_name, float f )
 332 {
 333     vlc_value_t val;
 334     val.f_float = f;
 335     return var_SetChecked( p_obj, psz_name, VLC_VAR_FLOAT, val );
 336 }
 337
 338 /**
 339  * Set the value of a string variable
 340  *
 341  * \param p_obj The object that holds the variable
 342  * \param psz_name The name of the variable
 343  * \param psz_string The new string value of this variable
 344  */
 345 static inline int var_SetString( vlc_object_t *p_obj, const char *psz_name, const char *psz_string )
 346 {
 347     vlc_value_t val;
 348     val.psz_string = (char *)psz_string;
 349     return var_SetChecked( p_obj, psz_name, VLC_VAR_STRING, val );
 350 }
 351
 352 /**
 353  * Set the value of a pointer variable
 354  *
 355  * \param p_obj The object that holds the variable
 356  * \param psz_name The name of the variable
 357  * \param ptr The new pointer value of this variable
 358  */
 359 static inline
 360 int var_SetAddress( vlc_object_t *p_obj, const char *psz_name, void *ptr )
 361 {
 362     vlc_value_t val;
 363     val.p_address = ptr;
 364     return var_SetChecked( p_obj, psz_name, VLC_VAR_ADDRESS, val );
 365 }
 366
 367 /**
 368  * Get an integer value
 369 *
 370  * \param p_obj The object that holds the variable
 371  * \param psz_name The name of the variable
 372  */
 373 VLC_USED
 374 static inline int64_t var_GetInteger( vlc_object_t *p_obj, const char *psz_name )
 375 {
 376     vlc_value_t val;
 377     if( !var_GetChecked( p_obj, psz_name, VLC_VAR_INTEGER, &val ) )
 378         return val.i_int;
 379     else
 380         return 0;
 381 }
 382
 383 /**
 384  * Get a boolean value
 385  *
 386  * \param p_obj The object that holds the variable
 387  * \param psz_name The name of the variable
 388  */
 389 VLC_USED
 390 static inline bool var_GetBool( vlc_object_t *p_obj, const char *psz_name )
 391 {
 392     vlc_value_t val; val.b_bool = false;
 393
 394     if( !var_GetChecked( p_obj, psz_name, VLC_VAR_BOOL, &val ) )
 395         return val.b_bool;
 396     else
 397         return false;
 398 }
 399
 400 static inline void var_GetCoords( vlc_object_t *obj, const char *name,
 401                                   int32_t *px, int32_t *py )
 402 {
 403     vlc_value_t val;
 404
 405     if (likely(!var_GetChecked (obj, name, VLC_VAR_COORDS, &val)))
 406     {
 407         *px = val.coords.x;
 408         *py = val.coords.y;
 409     }
 410     else
 411         *px = *py = 0;
 412 }
 413
 414 /**
 415  * Get a float value
 416  *
 417  * \param p_obj The object that holds the variable
 418  * \param psz_name The name of the variable
 419  */
 420 VLC_USED
 421 static inline float var_GetFloat( vlc_object_t *p_obj, const char *psz_name )
 422 {
 423     vlc_value_t val; val.f_float = 0.0;
 424     if( !var_GetChecked( p_obj, psz_name, VLC_VAR_FLOAT, &val ) )
 425         return val.f_float;
 426     else
 427         return 0.0;
 428 }
 429
 430 /**
 431  * Get a string value
 432  *
 433  * \param p_obj The object that holds the variable
 434  * \param psz_name The name of the variable
 435  */
 436 VLC_USED VLC_MALLOC
 437 static inline char *var_GetString( vlc_object_t *p_obj, const char *psz_name )
 438 {
 439     vlc_value_t val; val.psz_string = NULL;
 440     if( var_GetChecked( p_obj, psz_name, VLC_VAR_STRING, &val ) )
 441         return NULL;
 442     else
 443         return val.psz_string;
 444 }
 445
 446 VLC_USED VLC_MALLOC
 447 static inline char *var_GetNonEmptyString( vlc_object_t *p_obj, const char *psz_name )
 448 {
 449     vlc_value_t val;
 450     if( var_GetChecked( p_obj, psz_name, VLC_VAR_STRING, &val ) )
 451         return NULL;
 452     if( val.psz_string && *val.psz_string )
 453         return val.psz_string;
 454     free( val.psz_string );
 455     return NULL;
 456 }
 457
 458 VLC_USED
 459 static inline void *var_GetAddress( vlc_object_t *p_obj, const char *psz_name )
 460 {
 461     vlc_value_t val;
 462     if( var_GetChecked( p_obj, psz_name, VLC_VAR_ADDRESS, &val ) )
 463         return NULL;
 464     else
 465         return val.p_address;
 466 }
 467
 468 /**
 469  * Increment an integer variable
 470  * \param p_obj the object that holds the variable
 471  * \param psz_name the name of the variable
 472  */
 473 static inline int64_t var_IncInteger( vlc_object_t *p_obj, const char *psz_name )
 474 {
 475     vlc_value_t val;
 476     val.i_int = 1;
 477     if( var_GetAndSet( p_obj, psz_name, VLC_VAR_INTEGER_ADD, &val ) )
 478         return 0;
 479     return val.i_int;
 480 }
 481
 482 /**
 483  * Decrement an integer variable
 484  * \param p_obj the object that holds the variable
 485  * \param psz_name the name of the variable
 486  */
 487 static inline int64_t var_DecInteger( vlc_object_t *p_obj, const char *psz_name )
 488 {
 489     vlc_value_t val;
 490     val.i_int = -1;
 491     if( var_GetAndSet( p_obj, psz_name, VLC_VAR_INTEGER_ADD, &val ) )
 492         return 0;
 493     return val.i_int;
 494 }
 495
 496 static inline uint64_t var_OrInteger( vlc_object_t *obj, const char *name,
 497                                       unsigned v )
 498 {
 499     vlc_value_t val;
 500     val.i_int = v;
 501     if( var_GetAndSet( obj, name, VLC_VAR_INTEGER_OR, &val ) )
 502         return 0;
 503     return val.i_int;
 504 }
 505
 506 static inline uint64_t var_NAndInteger( vlc_object_t *obj, const char *name,
 507                                         unsigned v )
 508 {
 509     vlc_value_t val;
 510     val.i_int = v;
 511     if( var_GetAndSet( obj, name, VLC_VAR_INTEGER_NAND, &val ) )
 512         return 0;
 513     return val.i_int;
 514 }
 515
 516 /**
 517  * Create a integer variable with inherit and get its value.
 518  *
 519  * \param p_obj The object that holds the variable
 520  * \param psz_name The name of the variable
 521  */
 522 VLC_USED
 523 static inline int64_t var_CreateGetInteger( vlc_object_t *p_obj, const char *psz_name )
 524 {
 525     var_Create( p_obj, psz_name, VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 526     return var_GetInteger( p_obj, psz_name );
 527 }
 528
 529 /**
 530  * Create a boolean variable with inherit and get its value.
 531  *
 532  * \param p_obj The object that holds the variable
 533  * \param psz_name The name of the variable
 534  */
 535 VLC_USED
 536 static inline bool var_CreateGetBool( vlc_object_t *p_obj, const char *psz_name )
 537 {
 538     var_Create( p_obj, psz_name, VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 539     return var_GetBool( p_obj, psz_name );
 540 }
 541
 542 /**
 543  * Create a float variable with inherit and get its value.
 544  *
 545  * \param p_obj The object that holds the variable
 546  * \param psz_name The name of the variable
 547  */
 548 VLC_USED
 549 static inline float var_CreateGetFloat( vlc_object_t *p_obj, const char *psz_name )
 550 {
 551     var_Create( p_obj, psz_name, VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
 552     return var_GetFloat( p_obj, psz_name );
 553 }
 554
 555 /**
 556  * Create a string variable with inherit and get its value.
 557  *
 558  * \param p_obj The object that holds the variable
 559  * \param psz_name The name of the variable
 560  */
 561 VLC_USED VLC_MALLOC
 562 static inline char *var_CreateGetString( vlc_object_t *p_obj,
 563                                            const char *psz_name )
 564 {
 565     var_Create( p_obj, psz_name, VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 566     return var_GetString( p_obj, psz_name );
 567 }
 568
 569 VLC_USED VLC_MALLOC
 570 static inline char *var_CreateGetNonEmptyString( vlc_object_t *p_obj,
 571                                                    const char *psz_name )
 572 {
 573     var_Create( p_obj, psz_name, VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 574     return var_GetNonEmptyString( p_obj, psz_name );
 575 }
 576
 577 /**
 578  * Create an address variable with inherit and get its value.
 579  *
 580  * \param p_obj The object that holds the variable
 581  * \param psz_name The name of the variable
 582  */
 583 VLC_USED
 584 static inline void *var_CreateGetAddress( vlc_object_t *p_obj,
 585                                            const char *psz_name )
 586 {
 587     var_Create( p_obj, psz_name, VLC_VAR_ADDRESS | VLC_VAR_DOINHERIT );
 588     return var_GetAddress( p_obj, psz_name );
 589 }
 590
 591 /**
 592  * Create a integer command variable with inherit and get its value.
 593  *
 594  * \param p_obj The object that holds the variable
 595  * \param psz_name The name of the variable
 596  */
 597 VLC_USED
 598 static inline int64_t var_CreateGetIntegerCommand( vlc_object_t *p_obj, const char *psz_name )
 599 {
 600     var_Create( p_obj, psz_name, VLC_VAR_INTEGER | VLC_VAR_DOINHERIT
 601                                    | VLC_VAR_ISCOMMAND );
 602     return var_GetInteger( p_obj, psz_name );
 603 }
 604
 605 /**
 606  * Create a boolean command variable with inherit and get its value.
 607  *
 608  * \param p_obj The object that holds the variable
 609  * \param psz_name The name of the variable
 610  */
 611 VLC_USED
 612 static inline bool var_CreateGetBoolCommand( vlc_object_t *p_obj, const char *psz_name )
 613 {
 614     var_Create( p_obj, psz_name, VLC_VAR_BOOL | VLC_VAR_DOINHERIT
 615                                    | VLC_VAR_ISCOMMAND );
 616     return var_GetBool( p_obj, psz_name );
 617 }
 618
 619 /**
 620  * Create a float command variable with inherit and get its value.
 621  *
 622  * \param p_obj The object that holds the variable
 623  * \param psz_name The name of the variable
 624  */
 625 VLC_USED
 626 static inline float var_CreateGetFloatCommand( vlc_object_t *p_obj, const char *psz_name )
 627 {
 628     var_Create( p_obj, psz_name, VLC_VAR_FLOAT | VLC_VAR_DOINHERIT
 629                                    | VLC_VAR_ISCOMMAND );
 630     return var_GetFloat( p_obj, psz_name );
 631 }
 632
 633 /**
 634  * Create a string command variable with inherit and get its value.
 635  *
 636  * \param p_obj The object that holds the variable
 637  * \param psz_name The name of the variable
 638  */
 639 VLC_USED VLC_MALLOC
 640 static inline char *var_CreateGetStringCommand( vlc_object_t *p_obj,
 641                                            const char *psz_name )
 642 {
 643     var_Create( p_obj, psz_name, VLC_VAR_STRING | VLC_VAR_DOINHERIT
 644                                    | VLC_VAR_ISCOMMAND );
 645     return var_GetString( p_obj, psz_name );
 646 }
 647
 648 VLC_USED VLC_MALLOC
 649 static inline char *var_CreateGetNonEmptyStringCommand( vlc_object_t *p_obj,
 650                                                    const char *psz_name )
 651 {
 652     var_Create( p_obj, psz_name, VLC_VAR_STRING | VLC_VAR_DOINHERIT
 653                                    | VLC_VAR_ISCOMMAND );
 654     return var_GetNonEmptyString( p_obj, psz_name );
 655 }
 656
 657 VLC_USED
 658 static inline int var_CountChoices( vlc_object_t *p_obj, const char *psz_name )
 659 {
 660     size_t count;
 661     if( var_Change( p_obj, psz_name, VLC_VAR_CHOICESCOUNT, &count ) )
 662         return 0;
 663     return count;
 664 }
 665
 666 static inline bool var_ToggleBool( vlc_object_t *p_obj, const char *psz_name )
 667 {
 668     vlc_value_t val;
 669     if( var_GetAndSet( p_obj, psz_name, VLC_VAR_BOOL_TOGGLE, &val ) )
 670         return false;
 671     return val.b_bool;
 672 }
 673
 674 VLC_USED
 675 static inline bool var_InheritBool( vlc_object_t *obj, const char *name )
 676 {
 677     vlc_value_t val;
 678
 679     if( var_Inherit( obj, name, VLC_VAR_BOOL, &val ) )
 680         val.b_bool = false;
 681     return val.b_bool;
 682 }
 683
 684 VLC_USED
 685 static inline int64_t var_InheritInteger( vlc_object_t *obj, const char *name )
 686 {
 687     vlc_value_t val;
 688
 689     if( var_Inherit( obj, name, VLC_VAR_INTEGER, &val ) )
 690         val.i_int = 0;
 691     return val.i_int;
 692 }
 693
 694 VLC_USED
 695 static inline float var_InheritFloat( vlc_object_t *obj, const char *name )
 696 {
 697     vlc_value_t val;
 698
 699     if( var_Inherit( obj, name, VLC_VAR_FLOAT, &val ) )
 700         val.f_float = 0.;
 701     return val.f_float;
 702 }
 703
 704 VLC_USED VLC_MALLOC
 705 static inline char *var_InheritString( vlc_object_t *obj, const char *name )
 706 {
 707     vlc_value_t val;
 708
 709     if( var_Inherit( obj, name, VLC_VAR_STRING, &val ) )
 710         val.psz_string = NULL;
 711     else if( val.psz_string && !*val.psz_string )
 712     {
 713         free( val.psz_string );
 714         val.psz_string = NULL;
 715     }
 716     return val.psz_string;
 717 }
 718
 719 VLC_USED
 720 static inline void *var_InheritAddress( vlc_object_t *obj, const char *name )
 721 {
 722     vlc_value_t val;
 723
 724     if( var_Inherit( obj, name, VLC_VAR_ADDRESS, &val ) )
 725         val.p_address = NULL;
 726     return val.p_address;
 727 }
 728
 729
 730 /**
 731  * Inherit a string as a fractional value.
 732  *
 733  * This function inherits a string, and interprets it as an unsigned rational
 734  * number, i.e. a fraction. It also accepts a normally formatted floating point
 735  * number.
 736  *
 737  * \warning The caller shall perform any and all necessary boundary checks.
 738  *
 739  * \note The rational number is always reduced,
 740  * i.e. the returned numerator and denominator are always co-prime numbers.
 741  *
 742  * \note Fraction with zero as denominator are considered valid,
 743  * including the undefined form zero-by-zero.
 744  *
 745  * \return Zero on success, an error if parsing fails.
 746   */
 747 VLC_API int var_InheritURational(vlc_object_t *obj, unsigned *num,
 748                                  unsigned *den, const char *name);
 749
 750 /**
 751  * Parses a string with multiple options.
 752  *
 753  * Parses a set of colon-separated or semicolon-separated
 754  * <code>name=value</code> pairs.
 755  * Some access (or access_demux) plugins uses this scheme
 756  * in media resource location.
 757  * @note Only trusted/safe variables are allowed. This is intended.
 758  *
 759  * @warning Only use this for plugins implementing VLC-specific resource
 760  * location schemes. This would not make any sense for standardized ones.
 761  *
 762  * @param obj VLC object on which to set variables (and emit error messages)
 763  * @param mrl string to parse
 764  * @param pref prefix to prepend to option names in the string
 765  *
 766  * @return VLC_ENOMEM on error, VLC_SUCCESS on success.
 767  */
 768 VLC_API int var_LocationParse(vlc_object_t *, const char *mrl, const char *prefix);
 769
 770 #ifndef DOC
 771 #define var_Create(a,b,c) var_Create(VLC_OBJECT(a), b, c)
 772 #define var_Destroy(a,b) var_Destroy(VLC_OBJECT(a), b)
 773 #define var_Change(a,b,...) var_Change(VLC_OBJECT(a), b, __VA_ARGS__)
 774 #define var_Type(a,b) var_Type(VLC_OBJECT(a), b)
 775 #define var_Set(a,b,c) var_Set(VLC_OBJECT(a), b, c)
 776 #define var_Get(a,b,c) var_Get(VLC_OBJECT(a), b, c)
 777 #define var_SetChecked(o,n,t,v) var_SetChecked(VLC_OBJECT(o), n, t, v)
 778 #define var_GetChecked(o,n,t,v) var_GetChecked(VLC_OBJECT(o), n, t, v)
 779
 780 #define var_AddCallback(a,b,c,d) var_AddCallback(VLC_OBJECT(a), b, c, d)
 781 #define var_DelCallback(a,b,c,d) var_DelCallback(VLC_OBJECT(a), b, c, d)
 782 #define var_TriggerCallback(a,b) var_TriggerCallback(VLC_OBJECT(a), b)
 783 #define var_AddListCallback(a,b,c,d) \
 784         var_AddListCallback(VLC_OBJECT(a), b, c, d)
 785 #define var_DelListCallback(a,b,c,d) \
 786         var_DelListCallback(VLC_OBJECT(a), b, c, d)
 787
 788 #define var_SetInteger(a,b,c) var_SetInteger(VLC_OBJECT(a), b, c)
 789 #define var_SetBool(a,b,c) var_SetBool(VLC_OBJECT(a), b, c)
 790 #define var_SetCoords(o,n,x,y) var_SetCoords(VLC_OBJECT(o), n, x, y)
 791 #define var_SetFloat(a,b,c) var_SetFloat(VLC_OBJECT(a), b, c)
 792 #define var_SetString(a,b,c) var_SetString(VLC_OBJECT(a), b, c)
 793 #define var_SetAddress(o, n, p) var_SetAddress(VLC_OBJECT(o), n, p)
 794
 795 #define var_GetCoords(o,n,x,y) var_GetCoords(VLC_OBJECT(o), n, x, y)
 796
 797 #define var_IncInteger(a,b) var_IncInteger(VLC_OBJECT(a), b)
 798 #define var_DecInteger(a,b) var_DecInteger(VLC_OBJECT(a), b)
 799 #define var_OrInteger(a,b,c) var_OrInteger(VLC_OBJECT(a), b, c)
 800 #define var_NAndInteger(a,b,c) var_NAndInteger(VLC_OBJECT(a), b, c)
 801
 802 #define var_CreateGetInteger(a,b) var_CreateGetInteger(VLC_OBJECT(a), b)
 803 #define var_CreateGetBool(a,b) var_CreateGetBool(VLC_OBJECT(a), b)
 804 #define var_CreateGetFloat(a,b) var_CreateGetFloat(VLC_OBJECT(a), b)
 805 #define var_CreateGetString(a,b) var_CreateGetString(VLC_OBJECT(a), b)
 806 #define var_CreateGetNonEmptyString(a,b) \
 807         var_CreateGetNonEmptyString(VLC_OBJECT(a), b)
 808 #define var_CreateGetAddress(a,b) var_CreateGetAddress( VLC_OBJECT(a), b)
 809
 810 #define var_CreateGetIntegerCommand(a,b)   var_CreateGetIntegerCommand( VLC_OBJECT(a),b)
 811 #define var_CreateGetBoolCommand(a,b)   var_CreateGetBoolCommand( VLC_OBJECT(a),b)
 812 #define var_CreateGetFloatCommand(a,b)   var_CreateGetFloatCommand( VLC_OBJECT(a),b)
 813 #define var_CreateGetStringCommand(a,b)   var_CreateGetStringCommand( VLC_OBJECT(a),b)
 814 #define var_CreateGetNonEmptyStringCommand(a,b)   var_CreateGetNonEmptyStringCommand( VLC_OBJECT(a),b)
 815
 816 #define var_CountChoices(a,b) var_CountChoices(VLC_OBJECT(a),b)
 817 #define var_ToggleBool(a,b) var_ToggleBool(VLC_OBJECT(a),b )
 818
 819 #define var_InheritBool(o, n) var_InheritBool(VLC_OBJECT(o), n)
 820 #define var_InheritInteger(o, n) var_InheritInteger(VLC_OBJECT(o), n)
 821 #define var_InheritFloat(o, n) var_InheritFloat(VLC_OBJECT(o), n)
 822 #define var_InheritString(o, n) var_InheritString(VLC_OBJECT(o), n)
 823 #define var_InheritAddress(o, n) var_InheritAddress(VLC_OBJECT(o), n)
 824 #define var_InheritURational(a,b,c,d) var_InheritURational(VLC_OBJECT(a), b, c, d)
 825
 826 #define var_GetInteger(a,b) var_GetInteger(VLC_OBJECT(a),b)
 827 #define var_GetBool(a,b) var_GetBool(VLC_OBJECT(a),b)
 828 #define var_GetFloat(a,b) var_GetFloat(VLC_OBJECT(a),b)
 829 #define var_GetString(a,b) var_GetString(VLC_OBJECT(a),b)
 830 #define var_GetNonEmptyString(a,b) var_GetNonEmptyString( VLC_OBJECT(a),b)
 831 #define var_GetAddress(a,b) var_GetAddress(VLC_OBJECT(a),b)
 832
 833 #define var_LocationParse(o, m, p) var_LocationParse(VLC_OBJECT(o), m, p)
 834 #endif
 835
 836 /**
 837  * @}
 838  */
 839 #endif /*  _VLC_VARIABLES_H */