X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fvariables.c;h=365b7cfd22f0a251d4b073e9211a4432856442af;hb=7a4b7465e89a1aa8408667ca91815685b34ef0ae;hp=1134326984892e023bff96ff6c5c141456bd117d;hpb=0eb05e54f05a1a1d358a06cd4b49be403ccb1f61;p=vlc diff --git a/src/misc/variables.c b/src/misc/variables.c index 1134326984..365b7cfd22 100644 --- a/src/misc/variables.c +++ b/src/misc/variables.c @@ -29,6 +29,7 @@ #endif #include +#include #include "variables.h" #include "libvlc.h" @@ -153,17 +154,36 @@ time_ops = { CmpTime, DupDummy, FreeDummy, }; *****************************************************************************/ static int GetUnused ( vlc_object_t *, const char * ); static uint32_t HashString ( const char * ); -static int Insert ( variable_t *, int, const char * ); -static int InsertInner ( variable_t *, int, uint32_t ); -static int Lookup ( variable_t *, size_t, const char * ); +static int Insert ( variable_t **, int, const char * ); +static int InsertInner ( variable_t **, int, uint32_t ); +static int Lookup ( variable_t **, size_t, const char * ); static void CheckValue ( variable_t *, vlc_value_t * ); static int InheritValue( vlc_object_t *, const char *, vlc_value_t *, int ); -static int TriggerCallback( vlc_object_t *, variable_t **, const char *, +static int TriggerCallback( vlc_object_t *, variable_t *, const char *, vlc_value_t ); +static void Destroy( variable_t *p_var ) +{ + p_var->ops->pf_free( &p_var->val ); + if( p_var->choices.i_count ) + { + for( int i = 0 ; i < p_var->choices.i_count ; i++ ) + { + p_var->ops->pf_free( &p_var->choices.p_values[i] ); + free( p_var->choices_text.p_values[i].psz_string ); + } + free( p_var->choices.p_values ); + free( p_var->choices_text.p_values ); + } + free( p_var->psz_name ); + free( p_var->psz_text ); + free( p_var->p_entries ); + free( p_var ); +} + /** * Initialize a vlc variable * @@ -178,56 +198,12 @@ static int TriggerCallback( vlc_object_t *, variable_t **, const char *, */ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) { - int i_new; - variable_t *p_var; static vlc_list_t dummy_null_list = {0, NULL, NULL}; - assert( p_this ); - vlc_object_internals_t *p_priv = vlc_internals( p_this ); - - vlc_mutex_lock( &p_priv->var_lock ); - - /* FIXME: if the variable already exists, we don't duplicate it. But we - * duplicate the lookups. It's not that serious, but if anyone finds some - * time to rework Insert() so that only one lookup has to be done, feel - * free to do so. */ - i_new = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); - - if( i_new >= 0 ) - { - /* If the types differ, variable creation failed. */ - if( (i_type & VLC_VAR_CLASS) != (p_priv->p_vars[i_new].i_type & VLC_VAR_CLASS) ) - { - msg_Err( p_this, "Variable '%s' (0x%04x) already exist but with a different type (0x%04x)", - psz_name, p_priv->p_vars[i_new].i_type, i_type ); - vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_EBADVAR; - } - - p_priv->p_vars[i_new].i_usage++; - p_priv->p_vars[i_new].i_type |= ( i_type & VLC_VAR_ISCOMMAND ); - p_priv->p_vars[i_new].i_type |= ( i_type & VLC_VAR_HASCHOICE ); - vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_SUCCESS; - } - - i_new = Insert( p_priv->p_vars, p_priv->i_vars, psz_name ); - - if( (p_priv->i_vars & 15) == 15 ) - { - p_priv->p_vars = realloc( p_priv->p_vars, - (p_priv->i_vars+17) * sizeof(variable_t) ); - } - - memmove( p_priv->p_vars + i_new + 1, - p_priv->p_vars + i_new, - (p_priv->i_vars - i_new) * sizeof(variable_t) ); - - p_priv->i_vars++; - - p_var = &p_priv->p_vars[i_new]; - memset( p_var, 0, sizeof(*p_var) ); + variable_t *p_var = calloc( 1, sizeof( *p_var ) ); + if( p_var == NULL ) + return VLC_ENOMEM; p_var->i_hash = HashString( psz_name ); p_var->psz_name = strdup( psz_name ); @@ -290,36 +266,69 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) break; } - /* Duplicate the default data we stored. */ - p_var->ops->pf_dup( &p_var->val ); - if( i_type & VLC_VAR_DOINHERIT ) { - vlc_value_t val; - - if( InheritValue( p_this, psz_name, &val, p_var->i_type ) - == VLC_SUCCESS ) + if( InheritValue( p_this, psz_name, &p_var->val, p_var->i_type ) ) + msg_Err( p_this, "cannot inherit value for %s", psz_name ); + else if( i_type & VLC_VAR_HASCHOICE ) { - /* Free data if needed */ - p_var->ops->pf_free( &p_var->val ); - /* Set the variable */ - p_var->val = val; + /* We must add the inherited value to our choice list */ + p_var->i_default = 0; - if( i_type & VLC_VAR_HASCHOICE ) - { - /* We must add the inherited value to our choice list */ - p_var->i_default = 0; - - INSERT_ELEM( p_var->choices.p_values, p_var->choices.i_count, - 0, val ); - INSERT_ELEM( p_var->choices_text.p_values, - p_var->choices_text.i_count, 0, val ); - p_var->ops->pf_dup( &p_var->choices.p_values[0] ); - p_var->choices_text.p_values[0].psz_string = NULL; - } + INSERT_ELEM( p_var->choices.p_values, p_var->choices.i_count, + 0, p_var->val ); + INSERT_ELEM( p_var->choices_text.p_values, + p_var->choices_text.i_count, 0, p_var->val ); + p_var->ops->pf_dup( &p_var->choices.p_values[0] ); + p_var->choices_text.p_values[0].psz_string = NULL; + } + } + + vlc_object_internals_t *p_priv = vlc_internals( p_this ); + int i_new; + + vlc_mutex_lock( &p_priv->var_lock ); + + /* FIXME: if the variable already exists, we don't duplicate it. But we + * duplicate the lookups. It's not that serious, but if anyone finds some + * time to rework Insert() so that only one lookup has to be done, feel + * free to do so. */ + i_new = Lookup( p_priv->pp_vars, p_priv->i_vars, psz_name ); + + if( i_new >= 0 ) + { + /* If the types differ, variable creation failed. */ + if( (i_type & VLC_VAR_CLASS) != (p_priv->pp_vars[i_new]->i_type & VLC_VAR_CLASS) ) + { + msg_Err( p_this, "Variable '%s' (0x%04x) already exist but with a different type (0x%04x)", + psz_name, p_priv->pp_vars[i_new]->i_type, i_type ); + vlc_mutex_unlock( &p_priv->var_lock ); + return VLC_EBADVAR; } + + p_priv->pp_vars[i_new]->i_usage++; + p_priv->pp_vars[i_new]->i_type |= ( i_type & VLC_VAR_ISCOMMAND ); + p_priv->pp_vars[i_new]->i_type |= ( i_type & VLC_VAR_HASCHOICE ); + vlc_mutex_unlock( &p_priv->var_lock ); + + /* We did not need to create a new variable, free everything... */ + Destroy( p_var ); + return VLC_SUCCESS; } + i_new = Insert( p_priv->pp_vars, p_priv->i_vars, psz_name ); + + if( (p_priv->i_vars & 15) == 0 ) + p_priv->pp_vars = xrealloc( p_priv->pp_vars, + (p_priv->i_vars+16) * sizeof(variable_t *) ); + + memmove( p_priv->pp_vars + i_new + 1, + p_priv->pp_vars + i_new, + (p_priv->i_vars - i_new) * sizeof(variable_t *) ); + + p_priv->i_vars++; + + p_priv->pp_vars[i_new] = p_var; vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; @@ -352,7 +361,7 @@ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) return i_var; } - p_var = &p_priv->p_vars[i_var]; + p_var = p_priv->pp_vars[i_var]; if( p_var->i_usage > 1 ) { @@ -361,41 +370,27 @@ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) return VLC_SUCCESS; } - /* Free value if needed */ - p_var->ops->pf_free( &p_var->val ); + p_priv->i_vars--; + memmove( p_priv->pp_vars + i_var, + p_priv->pp_vars + i_var + 1, + (p_priv->i_vars - i_var) * sizeof(variable_t *) ); - /* Free choice list if needed */ - if( p_var->choices.i_count ) + if( p_priv->i_vars == 0 ) { - for( i = 0 ; i < p_var->choices.i_count ; i++ ) - { - p_var->ops->pf_free( &p_var->choices.p_values[i] ); - free( p_var->choices_text.p_values[i].psz_string ); - } - free( p_var->choices.p_values ); - free( p_var->choices_text.p_values ); + free( p_priv->pp_vars ); + p_priv->pp_vars = NULL; } - - /* Free callbacks if needed */ - free( p_var->p_entries ); - - free( p_var->psz_name ); - free( p_var->psz_text ); - - memmove( p_priv->p_vars + i_var, - p_priv->p_vars + i_var + 1, - (p_priv->i_vars - i_var - 1) * sizeof(variable_t) ); - + else if( (p_priv->i_vars & 15) == 0 ) { - p_priv->p_vars = realloc( p_priv->p_vars, - (p_priv->i_vars) * sizeof( variable_t ) ); + variable_t **pp_vars = realloc( p_priv->pp_vars, + (p_priv->i_vars) * sizeof(variable_t *) ); + if( pp_vars != NULL ) + p_priv->pp_vars = pp_vars; } - - p_priv->i_vars--; - vlc_mutex_unlock( &p_priv->var_lock ); + Destroy( p_var ); return VLC_SUCCESS; } @@ -421,7 +416,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + i_var = Lookup( p_priv->pp_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { @@ -429,7 +424,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, return VLC_ENOVAR; } - p_var = &p_priv->p_vars[i_var]; + p_var = p_priv->pp_vars[i_var]; switch( i_action ) { @@ -621,41 +616,9 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, p_var->psz_text = NULL; break; case VLC_VAR_GETTEXT: - p_val->psz_string = NULL; - if( p_var->psz_text ) - { - p_val->psz_string = strdup( p_var->psz_text ); - } + p_val->psz_string = p_var->psz_text ? strdup( p_var->psz_text ) + : NULL; break; - case VLC_VAR_INHERITVALUE: - { - vlc_value_t val; - - if( InheritValue( p_this, - p_val2 ? p_val2->psz_string : psz_name, - &val, p_var->i_type ) - == VLC_SUCCESS ) - { - /* Duplicate already done */ - - /* Backup needed stuff */ - oldval = p_var->val; - /* Check boundaries and list */ - CheckValue( p_var, &val ); - /* Set the variable */ - p_var->val = val; - /* Free data if needed */ - p_var->ops->pf_free( &oldval ); - } - - if( p_val ) - { - *p_val = p_var->val; - p_var->ops->pf_dup( p_val ); - } - } - break; - case VLC_VAR_SETISCOMMAND: p_var->i_type |= VLC_VAR_ISCOMMAND; break; @@ -699,7 +662,7 @@ int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, return i_var; } - p_var = &p_priv->p_vars[i_var]; + p_var = p_priv->pp_vars[i_var]; /* Duplicated data if needed */ //p_var->ops->pf_dup( &val ); @@ -728,7 +691,7 @@ int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, /* Deal with callbacks.*/ if( p_var->i_entries ) - i_ret = TriggerCallback( p_this, &p_var, psz_name, oldval ); + i_ret = TriggerCallback( p_this, p_var, psz_name, oldval ); vlc_mutex_unlock( &p_priv->var_lock ); @@ -753,7 +716,7 @@ int __var_Type( vlc_object_t *p_this, const char *psz_name ) vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + i_var = Lookup( p_priv->pp_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { @@ -761,7 +724,7 @@ int __var_Type( vlc_object_t *p_this, const char *psz_name ) return 0; } - i_type = p_priv->p_vars[i_var].i_type; + i_type = p_priv->pp_vars[i_var]->i_type; vlc_mutex_unlock( &p_priv->var_lock ); @@ -789,7 +752,7 @@ int var_SetChecked( vlc_object_t *p_this, const char *psz_name, return i_var; } - p_var = &p_priv->p_vars[i_var]; + p_var = p_priv->pp_vars[i_var]; assert( expected_type == 0 || (p_var->i_type & VLC_VAR_CLASS) == expected_type ); @@ -807,7 +770,7 @@ int var_SetChecked( vlc_object_t *p_this, const char *psz_name, /* Deal with callbacks */ if( p_var->i_entries ) - i_ret = TriggerCallback( p_this, &p_var, psz_name, oldval ); + i_ret = TriggerCallback( p_this, p_var, psz_name, oldval ); /* Free data if needed */ p_var->ops->pf_free( &oldval ); @@ -840,10 +803,10 @@ int var_GetChecked( vlc_object_t *p_this, const char *psz_name, vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + i_var = Lookup( p_priv->pp_vars, p_priv->i_vars, psz_name ); if( i_var >= 0 ) { - variable_t *p_var = &p_priv->p_vars[i_var]; + variable_t *p_var = p_priv->pp_vars[i_var]; assert( expected_type == 0 || (p_var->i_type & VLC_VAR_CLASS) == expected_type ); @@ -915,11 +878,15 @@ int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, i_var = GetUnused( p_this, psz_name ); if( i_var < 0 ) { +#ifndef NDEBUG + msg_Warn( p_this, "Failed to add a callback to the non-existing " + "variable '%s'", psz_name ); +#endif vlc_mutex_unlock( &p_priv->var_lock ); return i_var; } - p_var = &p_priv->p_vars[i_var]; + p_var = p_priv->pp_vars[i_var]; INSERT_ELEM( p_var->p_entries, p_var->i_entries, @@ -959,7 +926,7 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, return i_var; } - p_var = &p_priv->p_vars[i_var]; + p_var = p_priv->pp_vars[i_var]; for( i_entry = p_var->i_entries ; i_entry-- ; ) { @@ -1018,12 +985,12 @@ int __var_TriggerCallback( vlc_object_t *p_this, const char *psz_name ) return i_var; } - p_var = &p_priv->p_vars[i_var]; + p_var = p_priv->pp_vars[i_var]; /* Deal with callbacks. Tell we're in a callback, release the lock, * call stored functions, retake the lock. */ if( p_var->i_entries ) - i_ret = TriggerCallback( p_this, &p_var, psz_name, p_var->val ); + i_ret = TriggerCallback( p_this, p_var, psz_name, p_var->val ); vlc_mutex_unlock( &p_priv->var_lock ); return i_ret; @@ -1121,7 +1088,7 @@ void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, break; case VLC_VAR_FLOAT: - val.f_float = atof( psz_value ); + val.f_float = us_atof( psz_value ); break; case VLC_VAR_STRING: @@ -1180,9 +1147,6 @@ cleanup: /***************************************************************************** * GetUnused: find an unused (not in callback) variable from its name - ***************************************************************************** - * We do i_tries tries before giving up, just in case the variable is being - * modified and called from a callback. *****************************************************************************/ static int GetUnused( vlc_object_t *p_this, const char *psz_name ) { @@ -1194,13 +1158,13 @@ static int GetUnused( vlc_object_t *p_this, const char *psz_name ) { int i_var; - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + i_var = Lookup( p_priv->pp_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { return VLC_ENOVAR; } - if( ! p_priv->p_vars[i_var].b_incallback ) + if( ! p_priv->pp_vars[i_var]->b_incallback ) { return i_var; } @@ -1240,26 +1204,26 @@ static uint32_t HashString( const char *psz_string ) * to see how we handle them. * XXX: does this really need to be written recursively? *****************************************************************************/ -static int Insert( variable_t *p_vars, int i_count, const char *psz_name ) +static int Insert( variable_t **pp_vars, int i_count, const char *psz_name ) { if( i_count == 0 ) { return 0; } - return InsertInner( p_vars, i_count, HashString( psz_name ) ); + return InsertInner( pp_vars, i_count, HashString( psz_name ) ); } -static int InsertInner( variable_t *p_vars, int i_count, uint32_t i_hash ) +static int InsertInner( variable_t **pp_vars, int i_count, uint32_t i_hash ) { int i_middle; - if( i_hash <= p_vars[0].i_hash ) + if( i_hash <= pp_vars[0]->i_hash ) { return 0; } - if( i_hash >= p_vars[i_count - 1].i_hash ) + if( i_hash >= pp_vars[i_count - 1]->i_hash ) { return i_count; } @@ -1267,15 +1231,15 @@ static int InsertInner( variable_t *p_vars, int i_count, uint32_t i_hash ) i_middle = i_count / 2; /* We know that 0 < i_middle */ - if( i_hash < p_vars[i_middle].i_hash ) + if( i_hash < pp_vars[i_middle]->i_hash ) { - return InsertInner( p_vars, i_middle, i_hash ); + return InsertInner( pp_vars, i_middle, i_hash ); } /* We know that i_middle + 1 < i_count */ - if( i_hash > p_vars[i_middle + 1].i_hash ) + if( i_hash > pp_vars[i_middle + 1]->i_hash ) { - return i_middle + 1 + InsertInner( p_vars + i_middle + 1, + return i_middle + 1 + InsertInner( pp_vars + i_middle + 1, i_count - i_middle - 1, i_hash ); } @@ -1285,12 +1249,12 @@ static int InsertInner( variable_t *p_vars, int i_count, uint32_t i_hash ) static int u32cmp( const void *key, const void *data ) { - const variable_t *p_var = data; + const variable_t *const *pp_var = data; uint32_t hash = *(const uint32_t *)key ; - if( hash > p_var->i_hash ) + if( hash > (*pp_var)->i_hash ) return 1; - if( hash < p_var->i_hash ) + if( hash < (*pp_var)->i_hash ) return -1; return 0; } @@ -1301,35 +1265,35 @@ static int u32cmp( const void *key, const void *data ) * We use a recursive inner function indexed on the hash. Care is taken of * possible hash collisions. *****************************************************************************/ -static int Lookup( variable_t *p_vars, size_t i_count, const char *psz_name ) +static int Lookup( variable_t **pp_vars, size_t i_count, const char *psz_name ) { - variable_t *p_var; + variable_t **pp_var; uint32_t i_hash; i_hash = HashString( psz_name ); - p_var = bsearch( &i_hash, p_vars, i_count, sizeof( *p_var ), u32cmp ); + pp_var = bsearch( &i_hash, pp_vars, i_count, sizeof( *pp_var ), u32cmp ); /* Hash not found */ - if( p_var == NULL ) + if( pp_var == NULL ) return -1; assert( i_count > 0 ); /* Find the first entry with the right hash */ - while( (p_var > p_vars) && (i_hash == p_var[-1].i_hash) ) - p_var--; + while( (pp_var > pp_vars) && (i_hash == pp_var[-1]->i_hash) ) + pp_var--; - assert( p_var->i_hash == i_hash ); + assert( (*pp_var)->i_hash == i_hash ); /* Hash collision should be very unlikely, but we cannot guarantee * it will never happen. So we do an exhaustive search amongst all * entries with the same hash. Typically, there is only one anyway. */ - for( variable_t *p_end = p_vars + i_count; - (p_var < p_end) && (i_hash == p_var->i_hash); - p_var++ ) + for( variable_t **p_end = pp_vars + i_count; + (pp_var < p_end) && (i_hash == (*pp_var)->i_hash); + pp_var++ ) { - if( !strcmp( psz_name, p_var->psz_name ) ) - return p_var - p_vars; + if( !strcmp( psz_name, (*pp_var)->psz_name ) ) + return pp_var - pp_vars; } /* Hash found, but entry not found */ @@ -1419,51 +1383,19 @@ static void CheckValue ( variable_t *p_var, vlc_value_t *p_val ) } /***************************************************************************** - * InheritValue: try to inherit the value of this variable from the same one - * in our closest parent, libvlc or ultimately from the configuration. + * InheritValue: try to inherit the value of this variable from the closest + * ancestor objects or ultimately from the configuration. * The function should always be entered with the object var_lock locked. *****************************************************************************/ static int InheritValue( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val, int i_type ) { - int i_var; - variable_t *p_var; - - if( p_this->p_parent || ( p_this->p_libvlc && p_this != (vlc_object_t*) p_this->p_libvlc ) ) - { - vlc_object_internals_t *p_priv; - - if( p_this->p_parent ) - p_priv = vlc_internals( p_this->p_parent ); - else - p_priv = vlc_internals( p_this->p_libvlc ); - - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); - - if( i_var >= 0 ) - { - /* We found it! */ - p_var = &p_priv->p_vars[i_var]; - - /* Really get the variable */ - *p_val = p_var->val; - - /* Duplicate value if needed */ - p_var->ops->pf_dup( p_val ); - - /*msg_Dbg( p_this, "Inherited value for var %s from object %s", - psz_name ? psz_name : "(null)", - p_this->psz_object_name - ? p_this->psz_object_name : "(Unknown)" );*/ + i_type &= VLC_VAR_CLASS; + for( vlc_object_t *obj = p_this->p_parent; obj != NULL; obj = obj->p_parent ) + if( var_GetChecked( obj, psz_name, i_type, p_val ) == VLC_SUCCESS ) return VLC_SUCCESS; - } - else if ( p_this->p_parent ) /* We are still not there */ - return InheritValue( p_this->p_parent, psz_name, p_val, i_type ); - - /* else take value from config */ - } - + /* else take value from config */ switch( i_type & VLC_VAR_CLASS ) { case VLC_VAR_STRING: @@ -1524,41 +1456,31 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, * Tell we're in a callback, release the lock, call stored functions, * retake the lock. **********************************************************************/ -static int TriggerCallback( vlc_object_t *p_this, variable_t **pp_var, +static int TriggerCallback( vlc_object_t *p_this, variable_t *p_var, const char *psz_name, vlc_value_t oldval ) { - int i_var; - int i_entries = (*pp_var)->i_entries; - callback_entry_t *p_entries = (*pp_var)->p_entries; + int i_entries = p_var->i_entries; + callback_entry_t *p_entries = p_var->p_entries; assert( p_this ); vlc_object_internals_t *p_priv = vlc_internals( p_this ); - (*pp_var)->b_incallback = true; + p_var->b_incallback = true; vlc_mutex_unlock( &p_priv->var_lock ); /* The real calls */ for( ; i_entries-- ; ) { - p_entries[i_entries].pf_callback( p_this, psz_name, oldval, (*pp_var)->val, + p_entries[i_entries].pf_callback( p_this, psz_name, oldval, p_var->val, p_entries[i_entries].p_data ); } vlc_mutex_lock( &p_priv->var_lock ); + p_var->b_incallback = false; + vlc_cond_broadcast( &p_priv->var_wait ); - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); - if( i_var < 0 ) - { - msg_Err( p_this, "variable %s has disappeared", psz_name ); - return VLC_ENOVAR; - } - - *pp_var = &p_priv->p_vars[i_var]; - (*pp_var)->b_incallback = false; - vlc_cond_broadcast( &p_priv->var_wait ); - - return VLC_SUCCESS; + return VLC_SUCCESS; } @@ -1595,7 +1517,7 @@ int __var_Command( vlc_object_t *p_this, const char *psz_name, i_ret = var_SetInteger( p_obj, psz_cmd, atoi( psz_arg ) ); break; case VLC_VAR_FLOAT: - i_ret = var_SetFloat( p_obj, psz_cmd, atof( psz_arg ) ); + i_ret = var_SetFloat( p_obj, psz_cmd, us_atof( psz_arg ) ); break; case VLC_VAR_STRING: i_ret = var_SetString( p_obj, psz_cmd, psz_arg );