X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fvariables.c;h=89ade8e803aec3b361a5f96212a1226794c8a10b;hb=19adcbe5be83ce12a07d83092503c3f4a622b3b6;hp=b5ac4bf889a73d5c318d104a1cc0b4d80172661f;hpb=a02413ba579ecc8501c5a65c9c315b7c0a64ff5a;p=vlc diff --git a/src/misc/variables.c b/src/misc/variables.c index b5ac4bf889..89ade8e803 100644 --- a/src/misc/variables.c +++ b/src/misc/variables.c @@ -29,10 +29,12 @@ #endif #include +#include #include "variables.h" #include "libvlc.h" +#include #include /***************************************************************************** @@ -151,19 +153,51 @@ time_ops = { CmpTime, DupDummy, FreeDummy, }; /***************************************************************************** * Local prototypes *****************************************************************************/ -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 void WaitUnused ( vlc_object_t *, variable_t * ); 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 int varcmp( const void *a, const void *b ) +{ + const variable_t *va = a, *vb = b; + + /* psz_name must be first */ + assert( va == (const void *)&va->psz_name ); + return strcmp( va->psz_name, vb->psz_name ); +} + +static variable_t *Lookup( vlc_object_t *obj, const char *psz_name ) +{ + vlc_object_internals_t *priv = vlc_internals( obj ); + variable_t **pp_var; + + vlc_assert_locked( &priv->var_lock ); + pp_var = tfind( &psz_name, &priv->var_root, varcmp ); + return (pp_var != NULL) ? *pp_var : NULL; +} + +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,55 +212,13 @@ 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}; - 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) ); + assert( p_this ); - 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 ); p_var->psz_text = NULL; @@ -287,39 +279,53 @@ 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( var_Inherit( p_this, psz_name, i_type, &p_var->val ) ) + 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 ); + variable_t **pp_var, *p_oldvar; + int ret = VLC_SUCCESS; + + vlc_mutex_lock( &p_priv->var_lock ); + + pp_var = tsearch( p_var, &p_priv->var_root, varcmp ); + if( unlikely(pp_var == NULL) ) + ret = VLC_ENOMEM; + else if( (p_oldvar = *pp_var) == p_var ) + p_var = NULL; + else if( unlikely((i_type ^ p_oldvar->i_type) & VLC_VAR_CLASS) ) + { /* If the types differ, variable creation failed. */ + msg_Err( p_this, "Variable '%s' (0x%04x) already exist " + "but with a different type (0x%04x)", + psz_name, p_oldvar->i_type, i_type ); + ret = VLC_EBADVAR; + } + else + { + p_oldvar->i_usage++; + p_oldvar->i_type |= i_type & (VLC_VAR_ISCOMMAND|VLC_VAR_HASCHOICE); + } vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_SUCCESS; + /* If we did not need to create a new variable, free everything... */ + if( p_var != NULL ) + Destroy( p_var ); + return ret; } /** @@ -333,64 +339,44 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) */ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) { - int i_var, i; variable_t *p_var; - vlc_object_internals_t *p_priv = vlc_internals( p_this ); - vlc_mutex_lock( &p_priv->var_lock ); + assert( p_this ); - i_var = GetUnused( p_this, psz_name ); - if( i_var < 0 ) - { - vlc_mutex_unlock( &p_priv->var_lock ); - return i_var; - } + vlc_object_internals_t *p_priv = vlc_internals( p_this ); - p_var = &p_priv->p_vars[i_var]; + vlc_mutex_lock( &p_priv->var_lock ); - if( p_var->i_usage > 1 ) + p_var = Lookup( p_this, psz_name ); + if( p_var == NULL ) { - p_var->i_usage--; vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_SUCCESS; - } - - /* Free value if needed */ - p_var->ops->pf_free( &p_var->val ); - - /* Free choice list if needed */ - if( p_var->choices.i_count ) - { - 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 ); + return VLC_ENOVAR; } - /* Free callbacks if needed */ - free( p_var->p_entries ); - - free( p_var->psz_name ); - free( p_var->psz_text ); + WaitUnused( p_this, p_var ); - memmove( p_priv->p_vars + i_var, - p_priv->p_vars + i_var + 1, - (p_priv->i_vars - i_var - 1) * sizeof(variable_t) ); + if( --p_var->i_usage == 0 ) + tdelete( p_var, &p_priv->var_root, varcmp ); + else + p_var = NULL; + vlc_mutex_unlock( &p_priv->var_lock ); - if( (p_priv->i_vars & 15) == 0 ) - { - p_priv->p_vars = realloc( p_priv->p_vars, - (p_priv->i_vars) * sizeof( variable_t ) ); - } + if( p_var != NULL ) + Destroy( p_var ); + return VLC_SUCCESS; +} - p_priv->i_vars--; +static void CleanupVar( void *var ) +{ + Destroy( var ); +} - vlc_mutex_unlock( &p_priv->var_lock ); +void var_DestroyAll( vlc_object_t *obj ) +{ + vlc_object_internals_t *priv = vlc_internals( obj ); - return VLC_SUCCESS; + tdestroy( priv->var_root, CleanupVar ); } /** @@ -405,23 +391,24 @@ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) int __var_Change( vlc_object_t *p_this, const char *psz_name, int i_action, vlc_value_t *p_val, vlc_value_t *p_val2 ) { - int i_var, i; + int i; variable_t *p_var; vlc_value_t oldval; + vlc_value_t newval; + + assert( p_this ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); - - if( i_var < 0 ) + p_var = Lookup( p_this, psz_name ); + if( p_var == NULL ) { vlc_mutex_unlock( &p_priv->var_lock ); return VLC_ENOVAR; } - p_var = &p_priv->p_vars[i_var]; - switch( i_action ) { case VLC_VAR_SETMIN: @@ -560,13 +547,14 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, break; case VLC_VAR_SETVALUE: /* Duplicate data if needed */ - p_var->ops->pf_dup( p_val ); + newval = *p_val; + p_var->ops->pf_dup( &newval ); /* Backup needed stuff */ oldval = p_var->val; /* Check boundaries and list */ - CheckValue( p_var, p_val ); + CheckValue( p_var, &newval ); /* Set the variable */ - p_var->val = *p_val; + p_var->val = newval; /* Free data if needed */ p_var->ops->pf_free( &oldval ); break; @@ -612,41 +600,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 ); - } - 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 ); - } - } + p_val->psz_string = p_var->psz_text ? strdup( p_var->psz_text ) + : NULL; break; - case VLC_VAR_SETISCOMMAND: p_var->i_type |= VLC_VAR_ISCOMMAND; break; @@ -673,21 +629,23 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, vlc_value_t val ) { - int i_var; - int i_ret = VLC_SUCCESS; + int i_ret; variable_t *p_var; vlc_value_t oldval; + + assert( p_this ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); vlc_mutex_lock( &p_priv->var_lock ); - i_var = GetUnused( p_this, psz_name ); - if( i_var < 0 ) + p_var = Lookup( p_this, psz_name ); + if( p_var == NULL ) { vlc_mutex_unlock( &p_priv->var_lock ); - return i_var; + return VLC_ENOVAR; } - p_var = &p_priv->p_vars[i_var]; + WaitUnused( p_this, p_var ); /* Duplicated data if needed */ //p_var->ops->pf_dup( &val ); @@ -715,8 +673,7 @@ int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, CheckValue( p_var, &p_var->val ); /* 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 ); @@ -733,20 +690,18 @@ int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, */ int __var_Type( vlc_object_t *p_this, const char *psz_name ) { - int i_var, i_type; - vlc_object_internals_t *p_priv = vlc_internals( p_this ); + variable_t *p_var; + int i_type = 0; - vlc_mutex_lock( &p_priv->var_lock ); + assert( p_this ); - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); - if( i_var < 0 ) - { - vlc_mutex_unlock( &p_priv->var_lock ); - return 0; - } + vlc_mutex_lock( &p_priv->var_lock ); - i_type = p_priv->p_vars[i_var].i_type; + p_var = Lookup( p_this, psz_name ); + if( p_var != NULL ) + i_type = p_var->i_type; vlc_mutex_unlock( &p_priv->var_lock ); @@ -756,25 +711,28 @@ int __var_Type( vlc_object_t *p_this, const char *psz_name ) int var_SetChecked( vlc_object_t *p_this, const char *psz_name, int expected_type, vlc_value_t val ) { - int i_var; int i_ret = VLC_SUCCESS; variable_t *p_var; vlc_value_t oldval; + + assert( p_this ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); vlc_mutex_lock( &p_priv->var_lock ); - i_var = GetUnused( p_this, psz_name ); - if( i_var < 0 ) + p_var = Lookup( p_this, psz_name ); + if( p_var == NULL ) { vlc_mutex_unlock( &p_priv->var_lock ); - return i_var; + return VLC_ENOVAR; } - p_var = &p_priv->p_vars[i_var]; assert( expected_type == 0 || (p_var->i_type & VLC_VAR_CLASS) == expected_type ); + WaitUnused( p_this, p_var ); + /* Duplicate data if needed */ p_var->ops->pf_dup( &val ); @@ -788,8 +746,7 @@ int var_SetChecked( vlc_object_t *p_this, const char *psz_name, p_var->val = val; /* 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 ); @@ -815,16 +772,17 @@ int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) int var_GetChecked( vlc_object_t *p_this, const char *psz_name, int expected_type, vlc_value_t *p_val ) { + assert( p_this ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); - int i_var, err = VLC_SUCCESS; + variable_t *p_var; + int err = VLC_SUCCESS; vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); - if( i_var >= 0 ) + p_var = Lookup( p_this, psz_name ); + if( p_var != NULL ) { - variable_t *p_var = &p_priv->p_vars[i_var]; - assert( expected_type == 0 || (p_var->i_type & VLC_VAR_CLASS) == expected_type ); @@ -879,9 +837,11 @@ int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, vlc_callback_t pf_callback, void *p_data ) { - int i_var; variable_t *p_var; callback_entry_t entry; + + assert( p_this ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); entry.pf_callback = pf_callback; @@ -889,15 +849,18 @@ int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, vlc_mutex_lock( &p_priv->var_lock ); - i_var = GetUnused( p_this, psz_name ); - if( i_var < 0 ) + p_var = Lookup( p_this, psz_name ); + if( p_var == NULL ) { +#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; + return VLC_ENOVAR; } - p_var = &p_priv->p_vars[i_var]; - + WaitUnused( p_this, p_var ); INSERT_ELEM( p_var->p_entries, p_var->i_entries, p_var->i_entries, @@ -917,23 +880,26 @@ int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, vlc_callback_t pf_callback, void *p_data ) { - int i_entry, i_var; + int i_entry; variable_t *p_var; #ifndef NDEBUG bool b_found_similar = false; #endif + + assert( p_this ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); vlc_mutex_lock( &p_priv->var_lock ); - i_var = GetUnused( p_this, psz_name ); - if( i_var < 0 ) + p_var = Lookup( p_this, psz_name ); + if( p_var == NULL ) { vlc_mutex_unlock( &p_priv->var_lock ); - return i_var; + return VLC_ENOVAR; } - p_var = &p_priv->p_vars[i_var]; + WaitUnused( p_this, p_var ); for( i_entry = p_var->i_entries ; i_entry-- ; ) { @@ -952,11 +918,9 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, { #ifndef NDEBUG if( b_found_similar ) - msg_Warn( p_this, "Calling var_DelCallback for '%s' with the same " - "function but not the same data.", psz_name ); - else - msg_Warn( p_this, "var_DelCallback can't find the callback for " - "'%s'", psz_name ); + fprintf( stderr, "Calling var_DelCallback for '%s' with the same " + "function but not the same data.", psz_name ); + assert( 0 ); #endif vlc_mutex_unlock( &p_priv->var_lock ); return VLC_EGENERIC; @@ -977,26 +941,27 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, */ int __var_TriggerCallback( vlc_object_t *p_this, const char *psz_name ) { - int i_var; - int i_ret = VLC_SUCCESS; + int i_ret; variable_t *p_var; + + assert( p_this ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); vlc_mutex_lock( &p_priv->var_lock ); - i_var = GetUnused( p_this, psz_name ); - if( i_var < 0 ) + p_var = Lookup( p_this, psz_name ); + if( p_var == NULL ) { vlc_mutex_unlock( &p_priv->var_lock ); - return i_var; + return VLC_ENOVAR; } - p_var = &p_priv->p_vars[i_var]; + WaitUnused( p_this, p_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; @@ -1094,7 +1059,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: @@ -1151,160 +1116,17 @@ cleanup: /* Following functions are local */ -/***************************************************************************** - * 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 ) +/** + * Waits until the variable is inactive (i.e. not executing a callback) + */ +static void WaitUnused( vlc_object_t *p_this, variable_t *p_var ) { vlc_object_internals_t *p_priv = vlc_internals( p_this ); - while( true ) - { - int i_var; - - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); - if( i_var < 0 ) - { - return VLC_ENOVAR; - } - - if( ! p_priv->p_vars[i_var].b_incallback ) - { - return i_var; - } - - mutex_cleanup_push( &p_priv->var_lock ); + mutex_cleanup_push( &p_priv->var_lock ); + while( p_var->b_incallback ) vlc_cond_wait( &p_priv->var_wait, &p_priv->var_lock ); - vlc_cleanup_pop( ); - } -} - -/***************************************************************************** - * HashString: our cool hash function - ***************************************************************************** - * This function is not intended to be crypto-secure, we only want it to be - * fast and not suck too much. This one is pretty fast and did 0 collisions - * in wenglish's dictionary. - *****************************************************************************/ -static uint32_t HashString( const char *psz_string ) -{ - uint32_t i_hash = 0; - - while( *psz_string ) - { - i_hash += *psz_string++; - i_hash += i_hash << 10; - i_hash ^= i_hash >> 8; - } - - return i_hash; -} - -/***************************************************************************** - * Insert: find an empty slot to insert a new variable - ***************************************************************************** - * We use a recursive inner function indexed on the hash. This function does - * nothing in the rare cases where a collision may occur, see Lookup() - * 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 ) -{ - if( i_count == 0 ) - { - return 0; - } - - return InsertInner( p_vars, i_count, HashString( psz_name ) ); -} - -static int InsertInner( variable_t *p_vars, int i_count, uint32_t i_hash ) -{ - int i_middle; - - if( i_hash <= p_vars[0].i_hash ) - { - return 0; - } - - if( i_hash >= p_vars[i_count - 1].i_hash ) - { - return i_count; - } - - i_middle = i_count / 2; - - /* We know that 0 < i_middle */ - if( i_hash < p_vars[i_middle].i_hash ) - { - return InsertInner( p_vars, i_middle, i_hash ); - } - - /* We know that i_middle + 1 < i_count */ - if( i_hash > p_vars[i_middle + 1].i_hash ) - { - return i_middle + 1 + InsertInner( p_vars + i_middle + 1, - i_count - i_middle - 1, - i_hash ); - } - - return i_middle + 1; -} - -static int u32cmp( const void *key, const void *data ) -{ - const variable_t *p_var = data; - uint32_t hash = *(const uint32_t *)key ; - - if( hash > p_var->i_hash ) - return 1; - if( hash < p_var->i_hash ) - return -1; - return 0; -} - -/***************************************************************************** - * Lookup: find an existing variable given its name - ***************************************************************************** - * 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 ) -{ - variable_t *p_var; - uint32_t i_hash; - - i_hash = HashString( psz_name ); - p_var = bsearch( &i_hash, p_vars, i_count, sizeof( *p_var ), u32cmp ); - - /* Hash not found */ - if( p_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--; - - assert( p_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++ ) - { - if( !strcmp( psz_name, p_var->psz_name ) ) - return p_var - p_vars; - } - - /* Hash found, but entry not found */ - return -1; + vlc_cleanup_pop( ); } /***************************************************************************** @@ -1389,52 +1211,21 @@ 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. - * 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 ) +/** + * Finds the value of a variable. If the specified object does not hold a + * variable with the specified name, try the parent object, and iterate until + * the top of the tree. If no match is found, the value is read from the + * configuration. + */ +int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type, + vlc_value_t *p_val ) { - 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; 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: @@ -1483,7 +1274,6 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, msg_Warn( p_this, "Could not inherit value for var %s " "from config. Invalid Type", psz_name ); return VLC_ENOOBJ; - break; } /*msg_Dbg( p_this, "Inherited value for var %s from config", psz_name );*/ return VLC_SUCCESS; @@ -1495,38 +1285,34 @@ 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; + assert( p_this ); + + int i_entries = p_var->i_entries; + if( i_entries == 0 ) + return VLC_SUCCESS; + + callback_entry_t *p_entries = p_var->p_entries; vlc_object_internals_t *p_priv = vlc_internals( p_this ); - (*pp_var)->b_incallback = true; + assert( !p_var->b_incallback ); + 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; } @@ -1563,7 +1349,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 );