X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fvariables.c;h=c91cb4138c0457e8ea28bbff7b9c3466b90db8f8;hb=479dc6f761dad459f70782c79320cca9e0a84991;hp=d681162a4d25d3a0bcb5fcd3445a95b2bfa1802e;hpb=a8b3eb650fa90bc5601588677cb9399d03e683bb;p=vlc diff --git a/src/misc/variables.c b/src/misc/variables.c index d681162a4d..c91cb4138c 100644 --- a/src/misc/variables.c +++ b/src/misc/variables.c @@ -34,7 +34,10 @@ #include "libvlc.h" +#include #include +#include +#include /***************************************************************************** * Private types @@ -48,12 +51,21 @@ struct callback_entry_t /***************************************************************************** * Local comparison functions, returns 0 if v == w, < 0 if v < w, > 0 if v > w *****************************************************************************/ -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; } -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; } +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; +} + +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; +} + static int CmpTime( vlc_value_t v, vlc_value_t w ) { return v.i_time == w.i_time ? 0 : v.i_time > w.i_time ? 1 : -1; } + static int CmpString( vlc_value_t v, vlc_value_t w ) { if( !v.psz_string ) @@ -73,41 +85,6 @@ static void DupString( vlc_value_t *p_val ) p_val->psz_string = strdup( p_val->psz_string ? p_val->psz_string : "" ); } -static void DupList( vlc_value_t *p_val ) -{ - int i; - vlc_list_t *p_list = malloc( sizeof(vlc_list_t) ); - - p_list->i_count = p_val->p_list->i_count; - if( p_val->p_list->i_count ) - { - p_list->p_values = malloc( p_list->i_count * sizeof(vlc_value_t) ); - p_list->pi_types = malloc( p_list->i_count * sizeof(int) ); - } - else - { - p_list->p_values = NULL; - p_list->pi_types = NULL; - } - - for( i = 0; i < p_list->i_count; i++ ) - { - p_list->p_values[i] = p_val->p_list->p_values[i]; - p_list->pi_types[i] = p_val->p_list->pi_types[i]; - switch( p_val->p_list->pi_types[i] & VLC_VAR_CLASS ) - { - case VLC_VAR_STRING: - - DupString( &p_list->p_values[i] ); - break; - default: - break; - } - } - - p_val->p_list = p_list; -} - static void FreeDummy( vlc_value_t *p_val ) { (void)p_val; /* unused */ } static void FreeString( vlc_value_t *p_val ) { free( p_val->psz_string ); } static void FreeMutex( vlc_value_t *p_val ) { vlc_mutex_destroy( (vlc_mutex_t*)p_val->p_address ); free( p_val->p_address ); } @@ -144,24 +121,40 @@ addr_ops = { CmpAddress, DupDummy, FreeDummy, }, bool_ops = { CmpBool, DupDummy, FreeDummy, }, float_ops = { CmpFloat, DupDummy, FreeDummy, }, int_ops = { CmpInt, DupDummy, FreeDummy, }, -list_ops = { CmpAddress, DupList, FreeList, }, mutex_ops = { CmpAddress, DupDummy, FreeMutex, }, string_ops = { CmpString, DupString, FreeString, }, -time_ops = { CmpTime, DupDummy, FreeDummy, }; +time_ops = { CmpTime, DupDummy, FreeDummy, }, +coords_ops = { NULL, DupDummy, FreeDummy, }; /***************************************************************************** * Local prototypes *****************************************************************************/ static void WaitUnused ( vlc_object_t *, variable_t * ); -static uint32_t HashString ( const char * ); -static size_t Insert ( variable_t **, size_t, const char * ); -static int Lookup ( vlc_object_t *, const char * ); static void CheckValue ( variable_t *, vlc_value_t * ); 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 ); @@ -181,6 +174,7 @@ static void Destroy( variable_t *p_var ) free( p_var ); } +#undef var_Create /** * Initialize a vlc variable * @@ -193,16 +187,14 @@ static void Destroy( variable_t *p_var ) * \param i_type The variables type. Must be one of \ref var_type combined with * zero or more \ref var_flags */ -int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) +int var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) { - static vlc_list_t dummy_null_list = {0, NULL, NULL}; assert( p_this ); 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; @@ -245,6 +237,10 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) p_var->ops = &time_ops; p_var->val.i_time = 0; break; + case VLC_VAR_COORDS: + p_var->ops = &coords_ops; + p_var->val.coords.x = p_var->val.coords.y = 0; + break; case VLC_VAR_ADDRESS: p_var->ops = &addr_ops; p_var->val.p_address = NULL; @@ -254,13 +250,13 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) p_var->val.p_address = malloc( sizeof(vlc_mutex_t) ); vlc_mutex_init( (vlc_mutex_t*)p_var->val.p_address ); break; - case VLC_VAR_LIST: - p_var->ops = &list_ops; - p_var->val.p_list = &dummy_null_list; - break; default: p_var->ops = &void_ops; - break; +#ifndef NDEBUG + if( (i_type & VLC_VAR_CLASS) != VLC_VAR_VOID ) + msg_Err( p_this, "Creating the variable '%s' without a type", + psz_name ); +#endif } if( i_type & VLC_VAR_DOINHERIT ) @@ -282,55 +278,37 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) } vlc_object_internals_t *p_priv = vlc_internals( p_this ); - int i_new; + variable_t **pp_var, *p_oldvar; + int ret = VLC_SUCCESS; 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_this, psz_name ); - - if( i_new >= 0 ) + 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 { - /* 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; + p_oldvar->i_usage++; + p_oldvar->i_type |= i_type & (VLC_VAR_ISCOMMAND|VLC_VAR_HASCHOICE); } - - 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; + /* If we did not need to create a new variable, free everything... */ + if( p_var != NULL ) + Destroy( p_var ); + return ret; } +#undef var_Destroy /** * Destroy a vlc variable * @@ -340,9 +318,8 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) * \param p_this The object that holds the variable * \param psz_name The name of the variable */ -int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) +int var_Destroy( vlc_object_t *p_this, const char *psz_name ) { - int i_var; variable_t *p_var; assert( p_this ); @@ -351,47 +328,39 @@ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( 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 VLC_ENOVAR; } - p_var = p_priv->pp_vars[i_var]; WaitUnused( p_this, p_var ); - if( p_var->i_usage > 1 ) - { - p_var->i_usage--; - vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_SUCCESS; - } - - 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 *) ); - - if( p_priv->i_vars == 0 ) - { - free( p_priv->pp_vars ); - p_priv->pp_vars = NULL; - } + if( --p_var->i_usage == 0 ) + tdelete( p_var, &p_priv->var_root, varcmp ); else - if( (p_priv->i_vars & 15) == 0 ) - { - 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_var = NULL; vlc_mutex_unlock( &p_priv->var_lock ); - Destroy( p_var ); + if( p_var != NULL ) + Destroy( p_var ); return VLC_SUCCESS; } +static void CleanupVar( void *var ) +{ + Destroy( var ); +} + +void var_DestroyAll( vlc_object_t *obj ) +{ + vlc_object_internals_t *priv = vlc_internals( obj ); + + tdestroy( priv->var_root, CleanupVar ); +} + +#undef var_Change /** * Perform an action on a variable * @@ -401,12 +370,13 @@ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) * \param p_val First action parameter * \param p_val2 Second action parameter */ -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 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 ); @@ -414,16 +384,13 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( 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 VLC_ENOVAR; } - p_var = p_priv->pp_vars[i_var]; - switch( i_action ) { case VLC_VAR_SETMIN: @@ -562,13 +529,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; @@ -630,7 +598,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, return VLC_SUCCESS; } - +#undef var_GetAndSet /** * Perform a Get and Set on a variable * @@ -640,27 +608,26 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, * \param p_val: The action parameter * \return vlc error codes */ -int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, - vlc_value_t val ) +int var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, + vlc_value_t *p_val ) { - int i_var; int i_ret; variable_t *p_var; vlc_value_t oldval; assert( p_this ); + assert( p_val ); vlc_object_internals_t *p_priv = vlc_internals( p_this ); vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( 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 VLC_ENOVAR; } - p_var = p_priv->pp_vars[i_var]; WaitUnused( p_this, p_var ); /* Duplicated data if needed */ @@ -672,13 +639,21 @@ int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, /* depending of the action requiered */ switch( i_action ) { - case VLC_VAR_TOGGLE_BOOL: + case VLC_VAR_BOOL_TOGGLE: assert( ( p_var->i_type & VLC_VAR_BOOL ) == VLC_VAR_BOOL ); p_var->val.b_bool = !p_var->val.b_bool; break; - case VLC_VAR_INTEGER_INCDEC: + case VLC_VAR_INTEGER_ADD: + assert( ( p_var->i_type & VLC_VAR_INTEGER ) == VLC_VAR_INTEGER ); + p_var->val.i_int += p_val->i_int; + break; + case VLC_VAR_INTEGER_OR: assert( ( p_var->i_type & VLC_VAR_INTEGER ) == VLC_VAR_INTEGER ); - p_var->val.i_int += val.i_int; + p_var->val.i_int |= p_val->i_int; + break; + case VLC_VAR_INTEGER_NAND: + assert( ( p_var->i_type & VLC_VAR_INTEGER ) == VLC_VAR_INTEGER ); + p_var->val.i_int &= ~p_val->i_int; break; default: vlc_mutex_unlock( &p_priv->var_lock ); @@ -687,6 +662,7 @@ int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, /* Check boundaries */ CheckValue( p_var, &p_var->val ); + *p_val = p_var->val; /* Deal with callbacks.*/ i_ret = TriggerCallback( p_this, p_var, psz_name, oldval ); @@ -696,7 +672,7 @@ int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, return i_ret; } - +#undef var_Type /** * Request a variable's type * @@ -704,9 +680,10 @@ int __var_GetAndSet( vlc_object_t *p_this, const char *psz_name, int i_action, * variable could not be found. * \see \ref var_type */ -int __var_Type( vlc_object_t *p_this, const char *psz_name ) +int var_Type( vlc_object_t *p_this, const char *psz_name ) { - int i_var, i_type; + variable_t *p_var; + int i_type = 0; assert( p_this ); @@ -714,25 +691,19 @@ int __var_Type( vlc_object_t *p_this, const char *psz_name ) vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_this, psz_name ); - - if( i_var < 0 ) - { - vlc_mutex_unlock( &p_priv->var_lock ); - return 0; - } - - i_type = p_priv->pp_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 ); return i_type; } +#undef var_SetChecked 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; @@ -743,16 +714,21 @@ int var_SetChecked( vlc_object_t *p_this, const char *psz_name, vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( 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->pp_vars[i_var]; assert( expected_type == 0 || (p_var->i_type & VLC_VAR_CLASS) == expected_type ); +#ifndef NDEBUG + /* Alert if the type is VLC_VAR_VOID */ + if( ( p_var->i_type & VLC_VAR_TYPE ) == VLC_VAR_VOID ) + msg_Warn( p_this, "Calling var_Set on the void variable '%s' (0x%04x)", psz_name, p_var->i_type ); +#endif + WaitUnused( p_this, p_var ); @@ -779,7 +755,7 @@ int var_SetChecked( vlc_object_t *p_this, const char *psz_name, return i_ret; } - +#undef var_Set /** * Set a variable's value * @@ -787,26 +763,26 @@ int var_SetChecked( vlc_object_t *p_this, const char *psz_name, * \param psz_name The name of the variable * \param val the value to set */ -int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) +int var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) { return var_SetChecked( p_this, psz_name, 0, val ); } +#undef var_GetChecked 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_this, psz_name ); - if( i_var >= 0 ) + p_var = Lookup( p_this, psz_name ); + if( p_var != NULL ) { - variable_t *p_var = p_priv->pp_vars[i_var]; - assert( expected_type == 0 || (p_var->i_type & VLC_VAR_CLASS) == expected_type ); @@ -816,7 +792,7 @@ int var_GetChecked( vlc_object_t *p_this, const char *psz_name, #ifndef NDEBUG /* Alert if the type is VLC_VAR_VOID */ if( ( p_var->i_type & VLC_VAR_TYPE ) == VLC_VAR_VOID ) - msg_Warn( p_this, "Calling var_GetVoid on the void variable '%s' (0x%04x)", psz_name, p_var->i_type ); + msg_Warn( p_this, "Calling var_Get on the void variable '%s' (0x%04x)", psz_name, p_var->i_type ); #endif /* Duplicate value if needed */ @@ -829,6 +805,7 @@ int var_GetChecked( vlc_object_t *p_this, const char *psz_name, return err; } +#undef var_Get /** * Get a variable's value * @@ -837,11 +814,12 @@ int var_GetChecked( vlc_object_t *p_this, const char *psz_name, * \param p_val Pointer to a vlc_value_t that will hold the variable's value * after the function is finished */ -int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) +int var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) { return var_GetChecked( p_this, psz_name, 0, p_val ); } +#undef var_AddCallback /** * Register a callback in a variable * @@ -858,10 +836,9 @@ int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) * the variable. Use proper locking. This thread may not have much * time to spare, so keep callback functions short. */ -int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, - vlc_callback_t pf_callback, void *p_data ) +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; @@ -874,8 +851,8 @@ int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( 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 " @@ -885,8 +862,6 @@ int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, return VLC_ENOVAR; } - p_var = p_priv->pp_vars[i_var]; - WaitUnused( p_this, p_var ); INSERT_ELEM( p_var->p_entries, p_var->i_entries, @@ -898,16 +873,17 @@ int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, return VLC_SUCCESS; } +#undef var_DelCallback /** * Remove a callback from a variable * * pf_callback and p_data have to be given again, because different objects * might have registered the same callback function. */ -int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, - vlc_callback_t pf_callback, void *p_data ) +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; @@ -919,14 +895,13 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( 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 VLC_ENOVAR; } - p_var = p_priv->pp_vars[i_var]; WaitUnused( p_this, p_var ); for( i_entry = p_var->i_entries ; i_entry-- ; ) @@ -961,15 +936,15 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, return VLC_SUCCESS; } +#undef var_TriggerCallback /** * Trigger callback on a variable * * \param p_this The object that hold the variable * \param psz_name The name of the variable */ -int __var_TriggerCallback( 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; variable_t *p_var; @@ -979,14 +954,13 @@ int __var_TriggerCallback( vlc_object_t *p_this, const char *psz_name ) vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( 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 VLC_ENOVAR; } - p_var = p_priv->pp_vars[i_var]; WaitUnused( p_this, p_var ); /* Deal with callbacks. Tell we're in a callback, release the lock, @@ -1033,12 +1007,7 @@ void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, if( psz_value != NULL ) *psz_value++ = '\0'; - /* FIXME: :programs should be handled generically */ - if( !strcmp( psz_name, "programs" ) ) - i_type = VLC_VAR_LIST; - else - i_type = config_GetType( p_obj, psz_name ); - + i_type = config_GetType( p_obj, psz_name ); if( !i_type && !psz_value ) { /* check for "no-foo" or "nofoo" */ @@ -1076,7 +1045,7 @@ void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, /* Create the variable in the input object. * Children of the input object will be able to retreive this value * thanks to the inheritance property of the object variables. */ - __var_Create( p_obj, psz_name, i_type ); + var_Create( p_obj, psz_name, i_type ); switch( i_type ) { @@ -1085,7 +1054,7 @@ void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, break; case VLC_VAR_INTEGER: - val.i_int = strtol( psz_value, NULL, 0 ); + val.i_int = strtoll( psz_value, NULL, 0 ); break; case VLC_VAR_FLOAT: @@ -1099,45 +1068,11 @@ void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, val.psz_string = psz_value; break; - case VLC_VAR_LIST: - { - char *psz_orig, *psz_var; - vlc_list_t *p_list = malloc(sizeof(vlc_list_t)); - val.p_list = p_list; - p_list->i_count = 0; - - psz_var = psz_orig = strdup(psz_value); - while( psz_var && *psz_var ) - { - char *psz_item = psz_var; - vlc_value_t val2; - while( *psz_var && *psz_var != ',' ) psz_var++; - if( *psz_var == ',' ) - { - *psz_var = '\0'; - psz_var++; - } - val2.i_int = strtol( psz_item, NULL, 0 ); - INSERT_ELEM( p_list->p_values, p_list->i_count, - p_list->i_count, val2 ); - /* p_list->i_count is incremented twice by INSERT_ELEM */ - p_list->i_count--; - INSERT_ELEM( p_list->pi_types, p_list->i_count, - p_list->i_count, VLC_VAR_INTEGER ); - } - free( psz_orig ); - break; - } - default: goto cleanup; } - __var_Set( p_obj, psz_name, val ); - - /* If that's a list, remove all elements allocated */ - if( i_type == VLC_VAR_LIST ) - FreeList( &val ); + var_Set( p_obj, psz_name, val ); cleanup: free( psz_name ); @@ -1159,114 +1094,6 @@ static void WaitUnused( vlc_object_t *p_this, variable_t *p_var ) 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 the slot where to insert a variable - *****************************************************************************/ -static size_t Insert( variable_t **pp_vars, size_t n, const char *psz_name ) -{ - size_t offset = 0; - uint32_t hash = HashString( psz_name ); - - if( n == 0 ) - return 0; - - while( n > 1 ) - { - size_t middle = n / 2; - - if( hash < pp_vars[middle]->i_hash ) - { - n = middle; - } - else - { - pp_vars += middle; - offset += middle; - n -= middle; - } - } - - if( hash >= pp_vars[0]->i_hash ) - offset++; - return offset; -} - -static int u32cmp( const void *key, const void *data ) -{ - const variable_t *const *pp_var = data; - uint32_t hash = *(const uint32_t *)key ; - - if( hash > (*pp_var)->i_hash ) - return 1; - if( hash < (*pp_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( vlc_object_t *obj, const char *psz_name ) -{ - vlc_object_internals_t *priv = vlc_internals( obj ); - variable_t *const *pp_vars = priv->pp_vars; - size_t i_vars = priv->i_vars; - variable_t *const *pp_var; - uint32_t i_hash = HashString( psz_name ); - - pp_var = bsearch( &i_hash, pp_vars, i_vars, sizeof( *pp_var ), u32cmp ); - - /* Hash not found */ - if( pp_var == NULL ) - return -1; - - assert( i_vars > 0 ); - - /* Find the first entry with the right hash */ - while( (pp_var > pp_vars) && (i_hash == pp_var[-1]->i_hash) ) - pp_var--; - - 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 *const *p_end = pp_vars + i_vars; - (pp_var < p_end) && (i_hash == (*pp_var)->i_hash); - pp_var++ ) - { - if( !strcmp( psz_name, (*pp_var)->psz_name ) ) - return pp_var - pp_vars; - } - - /* Hash found, but entry not found */ - return -1; -} - /***************************************************************************** * CheckValue: check that a value is valid wrt. a variable ***************************************************************************** @@ -1358,10 +1185,29 @@ static void CheckValue ( variable_t *p_var, vlc_value_t *p_val ) int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type, vlc_value_t *p_val ) { +#ifndef NDEBUG + if (p_this != VLC_OBJECT(p_this->p_libvlc) + && unlikely(p_this->p_parent == NULL)) + { + msg_Info (p_this, "%s(%s) on detached object", __func__, psz_name); + //vlc_backtrace (); + } +#endif 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; +#ifndef NDEBUG + if (obj != p_this && obj != VLC_OBJECT(p_this->p_libvlc) + && unlikely(obj->p_parent == NULL)) + { + msg_Info (p_this, "%s(%s) on detached tree [%p] %s", __func__, + psz_name, obj, obj->psz_object_type); + //vlc_backtrace (); + } +#endif + } /* else take value from config */ switch( i_type & VLC_VAR_CLASS ) @@ -1379,35 +1225,8 @@ int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type, case VLC_VAR_BOOL: p_val->b_bool = config_GetInt( p_this, psz_name ); break; - case VLC_VAR_LIST: - { - char *psz_orig, *psz_var; - vlc_list_t *p_list = malloc(sizeof(vlc_list_t)); - p_val->p_list = p_list; - p_list->i_count = 0; - - psz_var = psz_orig = config_GetPsz( p_this, psz_name ); - while( psz_var && *psz_var ) - { - char *psz_item = psz_var; - vlc_value_t val; - while( *psz_var && *psz_var != ',' ) psz_var++; - if( *psz_var == ',' ) - { - *psz_var = '\0'; - psz_var++; - } - val.i_int = strtol( psz_item, NULL, 0 ); - INSERT_ELEM( p_list->p_values, p_list->i_count, - p_list->i_count, val ); - /* p_list->i_count is incremented twice by INSERT_ELEM */ - p_list->i_count--; - INSERT_ELEM( p_list->pi_types, p_list->i_count, - p_list->i_count, VLC_VAR_INTEGER ); - } - free( psz_orig ); - break; - } + case VLC_VAR_ADDRESS: + return VLC_ENOOBJ; default: msg_Warn( p_this, "Could not inherit value for var %s " "from config. Invalid Type", psz_name ); @@ -1418,6 +1237,57 @@ int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type, } +/** + * It inherits a string as an unsigned rational number (it also accepts basic + * float number). + * + * It returns an error if the rational number cannot be parsed (0/0 is valid). + * The rational is already reduced. + */ +int (var_InheritURational)(vlc_object_t *object, + unsigned *num, unsigned *den, + const char *var) +{ + /* */ + *num = 0; + *den = 0; + + /* */ + char *tmp = var_InheritString(object, var); + if (!tmp) + goto error; + + char *next; + unsigned n = strtol(tmp, &next, 0); + unsigned d = strtol(*next ? &next[1] : "0", NULL, 0); + + if (*next == '.') { + /* Interpret as a float number */ + double r = us_atof(tmp); + double c = ceil(r); + if (c >= UINT_MAX) + goto error; + unsigned m = c; + if (m > 0) { + d = UINT_MAX / m; + n = r * d; + } else { + n = 0; + d = 0; + } + } + + if (n > 0 && d > 0) + vlc_ureduce(num, den, n, d, 0); + + free(tmp); + return VLC_SUCCESS; + +error: + free(tmp); + return VLC_EGENERIC; +} + /********************************************************************** * Trigger the callbacks. * Tell we're in a callback, release the lock, call stored functions, @@ -1453,12 +1323,12 @@ static int TriggerCallback( vlc_object_t *p_this, variable_t *p_var, return VLC_SUCCESS; } - +#undef var_Command /********************************************************************** * Execute a var command on an object identified by its name **********************************************************************/ -int __var_Command( vlc_object_t *p_this, const char *psz_name, - const char *psz_cmd, const char *psz_arg, char **psz_msg ) +int var_Command( vlc_object_t *p_this, const char *psz_name, + const char *psz_cmd, const char *psz_arg, char **psz_msg ) { vlc_object_t *p_obj = vlc_object_find_name( p_this->p_libvlc, psz_name, FIND_CHILD );