X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fvariables.c;h=74e99f89c7385888d975be50e05901a9d5aaa531;hb=c159f79f2a5b00556347d302e9fb8221cfb0d7fe;hp=ed2b916b95f02a1fcde6fc79bc23d20d0437154a;hpb=5df0631325ad8e897c63962d50f32bd883a79c80;p=vlc

diff --git a/src/misc/variables.c b/src/misc/variables.c
index ed2b916b95..74e99f89c7 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 <sam@zoy.org>
@@ -68,7 +68,10 @@ 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 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 )
 {
@@ -159,6 +162,8 @@ 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 );
 
 /**
  * Initialize a vlc variable
@@ -190,15 +195,17 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type )
     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 )
+        if( (i_type & VLC_VAR_TYPE) != (p_priv->p_vars[i_new].i_type & VLC_VAR_TYPE) )
         {
+            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++;
-        if( i_type & VLC_VAR_ISCOMMAND )
-            p_priv->p_vars[i_new].i_type |= VLC_VAR_ISCOMMAND;
+        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;
     }
@@ -225,7 +232,6 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type )
     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->i_usage = 1;
 
@@ -602,24 +608,12 @@ 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;
@@ -656,41 +650,6 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name,
                 }
             }
             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;
@@ -705,6 +664,70 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name,
     return VLC_SUCCESS;
 }
 
+
+/**
+ * Perform a Get and Set on a variable
+ *
+ * \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_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;
+    variable_t *p_var;
+    vlc_value_t oldval;
+    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 )
+    {
+        vlc_mutex_unlock( &p_priv->var_lock );
+        return i_var;
+    }
+
+    p_var = &p_priv->p_vars[i_var];
+
+    /* Duplicated data if needed */
+    //p_var->ops->pf_dup( &val );
+
+    /* Backup needed stuff */
+    oldval = p_var->val;
+
+    /* depending of the action requiered */
+    switch( i_action )
+    {
+    case VLC_VAR_TOGGLE_BOOL:
+        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:
+        assert( ( p_var->i_type & VLC_VAR_INTEGER ) == VLC_VAR_INTEGER );
+        p_var->val.i_int += val.i_int;
+        break;
+    default:
+        vlc_mutex_unlock( &p_priv->var_lock );
+        return VLC_EGENERIC;
+    }
+
+    /*  Check boundaries */
+    CheckValue( p_var, &p_var->val );
+
+    /* Deal with callbacks.*/
+    if( p_var->i_entries )
+        i_ret = TriggerCallback( p_this, &p_var, psz_name, oldval );
+
+    vlc_mutex_unlock( &p_priv->var_lock );
+
+    return i_ret;
+}
+
+
 /**
  * Request a variable's type
  *
@@ -738,6 +761,7 @@ 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;
     vlc_object_internals_t *p_priv = vlc_internals( p_this );
@@ -767,44 +791,16 @@ int var_SetChecked( vlc_object_t *p_this, const char *psz_name,
     /* 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. */
+    /* Deal with callbacks */
     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;
-    }
+        i_ret = TriggerCallback( p_this, &p_var, psz_name, oldval );
 
     /* Free data if needed */
     p_var->ops->pf_free( &oldval );
 
     vlc_mutex_unlock( &p_priv->var_lock );
 
-    return VLC_SUCCESS;
+    return i_ret;
 }
 
 
@@ -839,6 +835,12 @@ int var_GetChecked( vlc_object_t *p_this, const char *psz_name,
         /* 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_GetVoid on the void variable '%s' (0x%04x)", psz_name, p_var->i_type );
+#endif
+
         /* Duplicate value if needed */
         p_var->ops->pf_dup( p_val );
     }
@@ -941,6 +943,13 @@ 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 )
+        {
+            msg_Warn( p_this, "Calling var_DelCallback for '%s' with the same "
+                      "function but not the same data.", psz_name );
+        }
+#endif
     }
 
     if( i_entry < 0 )
@@ -965,8 +974,8 @@ 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;
     variable_t *p_var;
-    vlc_value_t oldval;
     vlc_object_internals_t *p_priv = vlc_internals( p_this );
 
     vlc_mutex_lock( &p_priv->var_lock );
@@ -980,43 +989,13 @@ int __var_TriggerCallback( vlc_object_t *p_this, const char *psz_name )
 
     p_var = &p_priv->p_vars[i_var];
 
-    /* Backup needed stuff */
-    oldval = p_var->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, 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
@@ -1098,7 +1077,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 )
     {
@@ -1157,7 +1136,7 @@ void var_OptionParse( vlc_object_t *p_obj, const char *psz_option,
 
     var_Set( p_obj, psz_name, val );
 
-    // If that's a list, remove all elements allocated
+    /* If that's a list, remove all elements allocated */
     if( i_type == VLC_VAR_LIST )
         FreeList( &val );
 
@@ -1169,18 +1148,19 @@ cleanup:
 /* Following functions are local */
 
 /*****************************************************************************
- * GetUnused: find an unused variable from its name
+ * 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 )
 {
-    int i_var, i_tries = 0;
     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 )
         {
@@ -1192,15 +1172,9 @@ static int GetUnused( vlc_object_t *p_this, const char *psz_name )
             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 );
+        mutex_cleanup_push( &p_priv->var_lock );
+        vlc_cond_wait( &p_priv->var_wait, &p_priv->var_lock );
+        vlc_cleanup_pop( );
     }
 }
 
@@ -1343,7 +1317,7 @@ 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->ops->pf_cmp( *p_val, p_var->choices.p_values[i] ) == 0 )
@@ -1422,7 +1396,7 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name,
     int i_var;
     variable_t *p_var;
 
-    if( p_this->p_parent || ( p_this->p_libvlc && p_this != p_this->p_libvlc ) )
+    if( p_this->p_parent || ( p_this->p_libvlc && p_this != (vlc_object_t*) p_this->p_libvlc ) )
     {
         vlc_object_internals_t *p_priv;
 
@@ -1444,6 +1418,10 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name,
             /* 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)" );*/
             return VLC_SUCCESS;
         }
         else if ( p_this->p_parent ) /* We are still not there */
@@ -1498,12 +1476,56 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name,
             break;
         }
         default:
+            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;
 }
 
+
+/**********************************************************************
+ * 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 **pp_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;
+    vlc_object_internals_t *p_priv = vlc_internals( p_this );
+
+    (*pp_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].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 );
+        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;
+}
+
+
 /**********************************************************************
  * Execute a var command on an object identified by its name
  **********************************************************************/
@@ -1561,3 +1583,25 @@ int __var_Command( vlc_object_t *p_this, const char *psz_name,
 
     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 );
+    }
+}