X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fvariables.c;h=9374f3e798b76388117fcc9b4aa1552a609a0206;hb=fd907c9abaa6304442ced84809bdb53600c922ca;hp=315d6f1bb6a778272aa2a75247a9259410592713;hpb=03b701d58f53b02d8e735d8bfcd2047ed7fc6e3c;p=vlc diff --git a/src/misc/variables.c b/src/misc/variables.c index 315d6f1bb6..9374f3e798 100644 --- a/src/misc/variables.c +++ b/src/misc/variables.c @@ -1,7 +1,7 @@ /***************************************************************************** * variables.c: routines for object variables handling ***************************************************************************** - * Copyright (C) 2002-2006 the VideoLAN team + * Copyright (C) 2002-2009 the VideoLAN team * $Id$ * * Authors: Samuel Hocevar @@ -29,11 +29,15 @@ #endif #include +#include #include "variables.h" #include "libvlc.h" -#include "vlc_interface.h" +#include +#include +#include +#include /***************************************************************************** * Private types @@ -47,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 ) @@ -67,41 +80,9 @@ static int CmpAddress( vlc_value_t v, vlc_value_t w ) { return v.p_address == w. * Local duplication functions, and local deallocation functions *****************************************************************************/ static void DupDummy( vlc_value_t *p_val ) { (void)p_val; /* unused */ } -static void DupString( vlc_value_t *p_val ) { if( p_val->psz_string ) p_val->psz_string = strdup( p_val->psz_string ); } - -static void DupList( vlc_value_t *p_val ) +static void DupString( 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_TYPE ) - { - case VLC_VAR_STRING: - - DupString( &p_list->p_values[i] ); - break; - default: - break; - } - } - - p_val->p_list = p_list; + p_val->psz_string = strdup( p_val->psz_string ? p_val->psz_string : "" ); } static void FreeDummy( vlc_value_t *p_val ) { (void)p_val; /* unused */ } @@ -113,7 +94,7 @@ static void FreeList( vlc_value_t *p_val ) int i; for( i = 0; i < p_val->p_list->i_count; i++ ) { - switch( p_val->p_list->pi_types[i] & VLC_VAR_TYPE ) + switch( p_val->p_list->pi_types[i] & VLC_VAR_CLASS ) { case VLC_VAR_STRING: FreeString( &p_val->p_list->p_values[i] ); @@ -134,21 +115,66 @@ static void FreeList( vlc_value_t *p_val ) free( p_val->p_list ); } +static const struct variable_ops_t +void_ops = { NULL, DupDummy, FreeDummy, }, +addr_ops = { CmpAddress, DupDummy, FreeDummy, }, +bool_ops = { CmpBool, DupDummy, FreeDummy, }, +float_ops = { CmpFloat, DupDummy, FreeDummy, }, +int_ops = { CmpInt, DupDummy, FreeDummy, }, +mutex_ops = { CmpAddress, DupDummy, FreeMutex, }, +string_ops = { CmpString, DupString, FreeString, }, +time_ops = { CmpTime, DupDummy, FreeDummy, }, +coords_ops = { NULL, 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 *, int, const char * ); -static int LookupInner ( variable_t *, int, uint32_t ); +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 *, + 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 ); +} + +#undef var_Create /** * Initialize a vlc variable * @@ -161,63 +187,18 @@ static int InheritValue( vlc_object_t *, const char *, vlc_value_t *, * \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 ) { - 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_DOINHERIT|VLC_VAR_ISCOMMAND)) != p_priv->p_vars[i_new].i_type ) - { - vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_EBADVAR; - } - - p_priv->p_vars[i_new].i_usage++; - if( i_type & VLC_VAR_ISCOMMAND ) - p_priv->p_vars[i_new].i_type |= VLC_VAR_ISCOMMAND; - 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++; + variable_t *p_var = calloc( 1, sizeof( *p_var ) ); + if( p_var == NULL ) + return VLC_ENOMEM; - p_var = &p_priv->p_vars[i_new]; - memset( p_var, 0, sizeof(*p_var) ); - - p_var->i_hash = HashString( psz_name ); p_var->psz_name = strdup( psz_name ); p_var->psz_text = NULL; p_var->i_type = i_type & ~VLC_VAR_DOINHERIT; - memset( &p_var->val, 0, sizeof(vlc_value_t) ); - - p_var->pf_dup = DupDummy; - p_var->pf_free = FreeDummy; p_var->i_usage = 1; @@ -234,88 +215,100 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) /* Always initialize the variable, even if it is a list variable; this * will lead to errors if the variable is not initialized, but it will * not cause crashes in the variable handling. */ - switch( i_type & VLC_VAR_TYPE ) + switch( i_type & VLC_VAR_CLASS ) { case VLC_VAR_BOOL: - p_var->pf_cmp = CmpBool; + p_var->ops = &bool_ops; p_var->val.b_bool = false; break; case VLC_VAR_INTEGER: - case VLC_VAR_HOTKEY: - p_var->pf_cmp = CmpInt; + p_var->ops = &int_ops; p_var->val.i_int = 0; break; case VLC_VAR_STRING: - case VLC_VAR_MODULE: - case VLC_VAR_FILE: - case VLC_VAR_DIRECTORY: - case VLC_VAR_VARIABLE: - p_var->pf_cmp = CmpString; - p_var->pf_dup = DupString; - p_var->pf_free = FreeString; + p_var->ops = &string_ops; p_var->val.psz_string = NULL; break; case VLC_VAR_FLOAT: - p_var->pf_cmp = CmpFloat; + p_var->ops = &float_ops; p_var->val.f_float = 0.0; break; case VLC_VAR_TIME: - p_var->pf_cmp = CmpTime; + 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->pf_cmp = CmpAddress; + p_var->ops = &addr_ops; p_var->val.p_address = NULL; break; case VLC_VAR_MUTEX: - p_var->pf_cmp = CmpAddress; - p_var->pf_free = FreeMutex; + p_var->ops = &mutex_ops; 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->pf_cmp = CmpAddress; - p_var->pf_dup = DupList; - p_var->pf_free = FreeList; - p_var->val.p_list = &dummy_null_list; - break; + default: + p_var->ops = &void_ops; +#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 } - /* Duplicate the default data we stored. */ - p_var->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->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->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; } +#undef var_Destroy /** * Destroy a vlc variable * @@ -325,71 +318,49 @@ 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, 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->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->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 callbacks if needed */ - if( p_var->p_entries ) - { - free( p_var->p_entries ); + return VLC_ENOVAR; } - 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 ); } +#undef var_Change /** * Perform an action on a variable * @@ -399,36 +370,37 @@ 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 ); + 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: if( p_var->i_type & VLC_VAR_HASMIN ) { - p_var->pf_free( &p_var->min ); + p_var->ops->pf_free( &p_var->min ); } p_var->i_type |= VLC_VAR_HASMIN; p_var->min = *p_val; - p_var->pf_dup( &p_var->min ); + p_var->ops->pf_dup( &p_var->min ); CheckValue( p_var, &p_var->val ); break; case VLC_VAR_GETMIN: @@ -440,11 +412,11 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, case VLC_VAR_SETMAX: if( p_var->i_type & VLC_VAR_HASMAX ) { - p_var->pf_free( &p_var->max ); + p_var->ops->pf_free( &p_var->max ); } p_var->i_type |= VLC_VAR_HASMAX; p_var->max = *p_val; - p_var->pf_dup( &p_var->max ); + p_var->ops->pf_dup( &p_var->max ); CheckValue( p_var, &p_var->val ); break; case VLC_VAR_GETMAX: @@ -456,11 +428,11 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, case VLC_VAR_SETSTEP: if( p_var->i_type & VLC_VAR_HASSTEP ) { - p_var->pf_free( &p_var->step ); + p_var->ops->pf_free( &p_var->step ); } p_var->i_type |= VLC_VAR_HASSTEP; p_var->step = *p_val; - p_var->pf_dup( &p_var->step ); + p_var->ops->pf_dup( &p_var->step ); CheckValue( p_var, &p_var->val ); break; case VLC_VAR_GETSTEP: @@ -476,7 +448,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, i, *p_val ); INSERT_ELEM( p_var->choices_text.p_values, p_var->choices_text.i_count, i, *p_val ); - p_var->pf_dup( &p_var->choices.p_values[i] ); + p_var->ops->pf_dup( &p_var->choices.p_values[i] ); p_var->choices_text.p_values[i].psz_string = ( p_val2 && p_val2->psz_string ) ? strdup( p_val2->psz_string ) : NULL; @@ -486,7 +458,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, case VLC_VAR_DELCHOICE: for( i = 0 ; i < p_var->choices.i_count ; i++ ) { - if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 ) + if( p_var->ops->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 ) { break; } @@ -508,7 +480,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, p_var->i_default = -1; } - p_var->pf_free( &p_var->choices.p_values[i] ); + p_var->ops->pf_free( &p_var->choices.p_values[i] ); free( p_var->choices_text.p_values[i].psz_string ); REMOVE_ELEM( p_var->choices.p_values, p_var->choices.i_count, i ); REMOVE_ELEM( p_var->choices_text.p_values, @@ -522,7 +494,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, case VLC_VAR_CLEARCHOICES: for( i = 0 ; i < p_var->choices.i_count ; i++ ) { - p_var->pf_free( &p_var->choices.p_values[i] ); + p_var->ops->pf_free( &p_var->choices.p_values[i] ); } for( i = 0 ; i < p_var->choices_text.i_count ; i++ ) free( p_var->choices_text.p_values[i].psz_string ); @@ -540,7 +512,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, /* FIXME: the list is sorted, dude. Use something cleverer. */ for( i = 0 ; i < p_var->choices.i_count ; i++ ) { - if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 ) + if( p_var->ops->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 ) { break; } @@ -557,15 +529,16 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, break; case VLC_VAR_SETVALUE: /* Duplicate data if needed */ - p_var->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->pf_free( &oldval ); + p_var->ops->pf_free( &oldval ); break; case VLC_VAR_GETCHOICES: case VLC_VAR_GETLIST: @@ -591,7 +564,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, { p_val->p_list->p_values[i] = p_var->choices.p_values[i]; p_val->p_list->pi_types[i] = p_var->i_type; - p_var->pf_dup( &p_val->p_list->p_values[i] ); + p_var->ops->pf_dup( &p_val->p_list->p_values[i] ); if( p_val2 ) { p_val2->p_list->p_values[i].psz_string = @@ -601,96 +574,17 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, } } break; - case VLC_VAR_FREELIST: - FreeList( p_val ); - if( p_val2 && p_val2->p_list ) - { - for( i = 0; i < p_val2->p_list->i_count; i++ ) - free( p_val2->p_list->p_values[i].psz_string ); - if( p_val2->p_list->i_count ) - { - free( p_val2->p_list->p_values ); - free( p_val2->p_list->pi_types ); - } - free( p_val2->p_list ); - } - break; case VLC_VAR_SETTEXT: free( p_var->psz_text ); if( p_val && p_val->psz_string ) p_var->psz_text = strdup( p_val->psz_string ); + else + 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->pf_free( &oldval ); - } - - if( p_val ) - { - *p_val = p_var->val; - p_var->pf_dup( p_val ); - } - } - break; - case VLC_VAR_TRIGGER_CALLBACKS: - { - /* Deal with callbacks. Tell we're in a callback, release the lock, - * call stored functions, retake the lock. */ - if( p_var->i_entries ) - { - int i_var; - int i_entries = p_var->i_entries; - callback_entry_t *p_entries = p_var->p_entries; - - 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, p_var->val, p_var->val, - p_entries[i_entries].p_data ); - } - - vlc_mutex_lock( &p_priv->var_lock ); - - 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 ); - vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_ENOVAR; - } - - p_var = &p_priv->p_vars[i_var]; - p_var->b_incallback = false; - } - } - break; - case VLC_VAR_SETISCOMMAND: p_var->i_type |= VLC_VAR_ISCOMMAND; break; @@ -704,62 +598,142 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, return VLC_SUCCESS; } +#undef var_GetAndSet /** - * Request a variable's type + * Perform a Get and Set on a variable * - * \return The variable type if it exists, or 0 if the - * variable could not be found. - * \see \ref var_type + * \param p_this: The object that hold the variable + * \param psz_name: the name of the variable + * \param i_action: the action to perform + * \param p_val: The action parameter + * \return vlc error codes */ -int __var_Type( 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 *p_val ) { - int i_var, i_type; + 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 ); + p_var = Lookup( p_this, psz_name ); + if( p_var == NULL ) + { + vlc_mutex_unlock( &p_priv->var_lock ); + return VLC_ENOVAR; + } + + WaitUnused( p_this, p_var ); - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + /* Duplicated data if needed */ + //p_var->ops->pf_dup( &val ); - if( i_var < 0 ) + /* Backup needed stuff */ + oldval = p_var->val; + + /* depending of the action requiered */ + switch( i_action ) { + 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_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 |= 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 ); - return 0; + return VLC_EGENERIC; } - i_type = p_priv->p_vars[i_var].i_type; + /* 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 ); vlc_mutex_unlock( &p_priv->var_lock ); - return i_type; + return i_ret; } +#undef var_Type /** - * Set a variable's value + * Request a variable's type * - * \param p_this The object that hold the variable - * \param psz_name The name of the variable - * \param val the value to set + * \return The variable type if it exists, or 0 if the + * variable could not be found. + * \see \ref var_type */ -int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) +int var_Type( vlc_object_t *p_this, const char *psz_name ) { - int i_var; + variable_t *p_var; + int i_type = 0; + + assert( p_this ); + + vlc_object_internals_t *p_priv = vlc_internals( p_this ); + + vlc_mutex_lock( &p_priv->var_lock ); + + 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_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 ); +#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 ); /* Duplicate data if needed */ - p_var->pf_dup( &val ); + p_var->ops->pf_dup( &val ); /* Backup needed stuff */ oldval = p_var->val; @@ -770,103 +744,82 @@ int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) /* Set the variable */ p_var->val = val; - /* Deal with callbacks. Tell we're in a callback, release the lock, - * call stored functions, retake the lock. */ - if( p_var->i_entries ) - { - int i_var; - int i_entries = p_var->i_entries; - callback_entry_t *p_entries = p_var->p_entries; - - 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, val, - p_entries[i_entries].p_data ); - } - - vlc_mutex_lock( &p_priv->var_lock ); - - 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 ); - vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_ENOVAR; - } - - p_var = &p_priv->p_vars[i_var]; - p_var->b_incallback = false; - } + /* Deal with callbacks */ + i_ret = TriggerCallback( p_this, p_var, psz_name, oldval ); /* Free data if needed */ - p_var->pf_free( &oldval ); + p_var->ops->pf_free( &oldval ); vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_SUCCESS; + return i_ret; } +#undef var_Set /** - * Get a variable's value + * Set a variable's value * - * \param p_this The object that holds the variable + * \param p_this The object that hold the variable * \param psz_name The name of the variable - * \param p_val Pointer to a vlc_value_t that will hold the variable's value - * after the function is finished + * \param val the value to set */ -int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) +int var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) { - int i_var; - variable_t *p_var; + 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 ); + 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 ) { - vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_ENOVAR; - } + assert( expected_type == 0 || + (p_var->i_type & VLC_VAR_CLASS) == expected_type ); - p_var = &p_priv->p_vars[i_var]; + /* Really get the variable */ + *p_val = p_var->val; - /* Really get the variable */ - *p_val = p_var->val; +#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_Get on the void variable '%s' (0x%04x)", psz_name, p_var->i_type ); +#endif - /* Duplicate value if needed */ - p_var->pf_dup( p_val ); + /* Duplicate value if needed */ + p_var->ops->pf_dup( p_val ); + } + else + err = VLC_ENOVAR; vlc_mutex_unlock( &p_priv->var_lock ); - - return VLC_SUCCESS; + return err; } - -#undef var_AcquireMutex +#undef var_Get /** - * Finds a process-wide mutex, creates it if needed, and locks it. - * Unlock with vlc_mutex_unlock(). + * Get a variable's value + * + * \param p_this The object that holds the variable + * \param psz_name The name of the variable + * \param p_val Pointer to a vlc_value_t that will hold the variable's value + * after the function is finished */ -vlc_mutex_t *var_AcquireMutex( const char *name ) +int var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) { - libvlc_global_data_t *p_global = vlc_global(); - vlc_value_t val; - - if( var_Create( p_global, name, VLC_VAR_MUTEX ) ) - return NULL; - - var_Get( p_global, name, &val ); - vlc_mutex_lock( val.p_address ); - return val.p_address; + return var_GetChecked( p_this, psz_name, 0, p_val ); } - +#undef var_AddCallback /** * Register a callback in a variable * @@ -883,12 +836,14 @@ vlc_mutex_t *var_AcquireMutex( const char *name ) * 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; + + assert( p_this ); + vlc_object_internals_t *p_priv = vlc_internals( p_this ); entry.pf_callback = pf_callback; @@ -896,15 +851,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, @@ -915,29 +873,36 @@ 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; +#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-- ; ) { @@ -946,10 +911,20 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, { break; } +#ifndef NDEBUG + else if( p_var->p_entries[i_entry].pf_callback == pf_callback ) + b_found_similar = true; +#endif } if( i_entry < 0 ) { +#ifndef NDEBUG + if( b_found_similar ) + 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; } @@ -961,67 +936,39 @@ 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; - 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]; - - /* Backup needed stuff */ - oldval = p_var->val; + 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 ) - { - int i_var; - int i_entries = p_var->i_entries; - callback_entry_t *p_entries = p_var->p_entries; - - 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, oldval, - p_entries[i_entries].p_data ); - } - - vlc_mutex_lock( &p_priv->var_lock ); - - 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 ); - vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_ENOVAR; - } - - p_var = &p_priv->p_vars[i_var]; - p_var->b_incallback = false; - } + i_ret = TriggerCallback( p_this, p_var, psz_name, p_var->val ); vlc_mutex_unlock( &p_priv->var_lock ); - return VLC_SUCCESS; + return i_ret; } /** Parse a stringified option @@ -1060,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" */ @@ -1091,10 +1033,11 @@ void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, if( !trusted ) { module_config_t *p_config = config_FindConfig( p_obj, psz_name ); - if( !p_config->b_safe ) + if( !p_config || !p_config->b_safe ) { msg_Err( p_obj, "unsafe option \"%s\" has been ignored for " "security reasons", psz_name ); + free( psz_name ); return; } } @@ -1115,7 +1058,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: @@ -1125,36 +1068,6 @@ 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; } @@ -1168,201 +1081,17 @@ cleanup: /* Following functions are local */ -/***************************************************************************** - * GetUnused: find an unused 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 ) { - int i_var, i_tries = 0; vlc_object_internals_t *p_priv = vlc_internals( p_this ); - while( true ) - { - 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; - } - - if( i_tries++ > 100 ) - { - msg_Err( p_this, "caught in a callback deadlock? ('%s')", psz_name ); - return VLC_ETIMEOUT; - } - - vlc_mutex_unlock( &p_priv->var_lock ); - msleep( THREAD_SLEEP ); - vlc_mutex_lock( &p_priv->var_lock ); - } -} - -/***************************************************************************** - * 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; -} - -/***************************************************************************** - * 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. - * XXX: does this really need to be written recursively? - *****************************************************************************/ -static int Lookup( variable_t *p_vars, int i_count, const char *psz_name ) -{ - uint32_t i_hash; - int i, i_pos; - - if( i_count == 0 ) - { - return -1; - } - - i_hash = HashString( psz_name ); - - i_pos = LookupInner( p_vars, i_count, i_hash ); - - /* Hash not found */ - if( i_hash != p_vars[i_pos].i_hash ) - { - return -1; - } - - /* Hash found, entry found */ - if( !strcmp( psz_name, p_vars[i_pos].psz_name ) ) - { - return i_pos; - } - - /* Hash collision! This should be very rare, but we cannot guarantee - * it will never happen. Just do an exhaustive search amongst all - * entries with the same hash. */ - for( i = i_pos - 1 ; i > 0 && i_hash == p_vars[i].i_hash ; i-- ) - { - if( !strcmp( psz_name, p_vars[i].psz_name ) ) - { - return i; - } - } - - for( i = i_pos + 1 ; i < i_count && i_hash == p_vars[i].i_hash ; i++ ) - { - if( !strcmp( psz_name, p_vars[i].psz_name ) ) - { - return i; - } - } - - /* Hash found, but entry not found */ - return -1; -} - -static int LookupInner( 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 - 1; - } - - i_middle = i_count / 2; - - /* We know that 0 < i_middle */ - if( i_hash < p_vars[i_middle].i_hash ) - { - return LookupInner( p_vars, i_middle, i_hash ); - } - - /* We know that i_middle + 1 < i_count */ - if( i_hash > p_vars[i_middle].i_hash ) - { - return i_middle + LookupInner( p_vars + i_middle, - i_count - i_middle, - i_hash ); - } - - return i_middle; + 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( ); } /***************************************************************************** @@ -1379,10 +1108,10 @@ static void CheckValue ( variable_t *p_var, vlc_value_t *p_val ) { int i; - /* FIXME: the list is sorted, dude. Use something cleverer. */ + /* This list is not sorted so go throug it (this is a small list) */ for( i = p_var->choices.i_count ; i-- ; ) { - if( p_var->pf_cmp( *p_val, p_var->choices.p_values[i] ) == 0 ) + if( p_var->ops->pf_cmp( *p_val, p_var->choices.p_values[i] ) == 0 ) { break; } @@ -1392,10 +1121,10 @@ static void CheckValue ( variable_t *p_var, vlc_value_t *p_val ) if( i < 0 ) { /* Free the old variable, get the new one, dup it */ - p_var->pf_free( p_val ); + p_var->ops->pf_free( p_val ); *p_val = p_var->choices.p_values[p_var->i_default >= 0 ? p_var->i_default : 0 ]; - p_var->pf_dup( p_val ); + p_var->ops->pf_dup( p_val ); } } @@ -1447,27 +1176,43 @@ 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. - *****************************************************************************/ -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; - - /* No need to take the structure lock, - * we are only looking for our parents */ - - if( !p_this->p_parent ) +#ifndef NDEBUG + if (p_this != VLC_OBJECT(p_this->p_libvlc) + && unlikely(p_this->p_parent == NULL)) { - switch( i_type & VLC_VAR_TYPE ) + 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)) { - case VLC_VAR_FILE: - case VLC_VAR_DIRECTORY: + 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 ) + { case VLC_VAR_STRING: - case VLC_VAR_MODULE: p_val->psz_string = config_GetPsz( p_this, psz_name ); if( !p_val->psz_string ) p_val->psz_string = strdup(""); break; @@ -1475,83 +1220,115 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, p_val->f_float = config_GetFloat( p_this, psz_name ); break; case VLC_VAR_INTEGER: - case VLC_VAR_HOTKEY: p_val->i_int = config_GetInt( p_this, psz_name ); break; 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 ); return VLC_ENOOBJ; - break; - } - - return VLC_SUCCESS; } + /*msg_Dbg( p_this, "Inherited value for var %s from config", psz_name );*/ + return VLC_SUCCESS; +} - vlc_object_internals_t *p_priv = vlc_internals( p_this->p_parent ); - /* Look for the variable */ - vlc_mutex_lock( &p_priv->var_lock ); +/** + * 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; + } + } - i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + if (n > 0 && d > 0) + vlc_ureduce(num, den, n, d, 0); - if( i_var >= 0 ) - { - /* We found it! */ - p_var = &p_priv->p_vars[i_var]; + free(tmp); + return VLC_SUCCESS; - /* Really get the variable */ - *p_val = p_var->val; +error: + free(tmp); + return VLC_EGENERIC; +} - /* Duplicate value if needed */ - p_var->pf_dup( p_val ); +/********************************************************************** + * Trigger the callbacks. + * 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 *p_var, + const char *psz_name, vlc_value_t oldval ) +{ + assert( p_this ); - vlc_mutex_unlock( &p_priv->var_lock ); + 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 ); + + assert( !p_var->b_incallback ); + p_var->b_incallback = true; vlc_mutex_unlock( &p_priv->var_lock ); - /* We're still not there */ + /* The real calls */ + for( ; i_entries-- ; ) + { + p_entries[i_entries].pf_callback( p_this, psz_name, oldval, p_var->val, + p_entries[i_entries].p_data ); + } - return InheritValue( p_this->p_parent, psz_name, p_val, i_type ); + vlc_mutex_lock( &p_priv->var_lock ); + p_var->b_incallback = false; + vlc_cond_broadcast( &p_priv->var_wait ); + + 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 ); @@ -1573,14 +1350,14 @@ int __var_Command( vlc_object_t *p_this, const char *psz_name, return VLC_EGENERIC; } - i_type &= 0xf0; + i_type &= VLC_VAR_CLASS; switch( i_type ) { case VLC_VAR_INTEGER: 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 ); @@ -1597,10 +1374,32 @@ int __var_Command( vlc_object_t *p_this, const char *psz_name, if( psz_msg ) { - *psz_msg = (char*)malloc( 80 ); - sprintf( *psz_msg, "%s on object %s returned %i (%s)", - psz_cmd, psz_name, i_ret, vlc_error( i_ret ) ); + if( asprintf( psz_msg, "%s on object %s returned %i (%s)", + psz_cmd, psz_name, i_ret, vlc_error( i_ret ) ) == -1) + *psz_msg = NULL; } return i_ret; } + + +/** + * Free a list and the associated strings + * @param p_val: the list variable + * @param p_val2: the variable associated or NULL + */ +void var_FreeList( vlc_value_t *p_val, vlc_value_t *p_val2 ) +{ + FreeList( p_val ); + if( p_val2 && p_val2->p_list ) + { + for( int i = 0; i < p_val2->p_list->i_count; i++ ) + free( p_val2->p_list->p_values[i].psz_string ); + if( p_val2->p_list->i_count ) + { + free( p_val2->p_list->p_values ); + free( p_val2->p_list->pi_types ); + } + free( p_val2->p_list ); + } +}