eacd6a02ffa236cd13b605f0ca4c7b764ad105de
[vlc.git] / src / misc / variables.c
1 /*****************************************************************************
2  * variables.c: routines for object variables handling
3  *****************************************************************************
4  * Copyright (C) 2002 VideoLAN
5  * $Id: variables.c,v 1.25 2003/05/24 23:40:11 gbazin Exp $
6  *
7  * Authors: Samuel Hocevar <sam@zoy.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <vlc/vlc.h>
28
29 #ifdef HAVE_STDLIB_H
30 #   include <stdlib.h>                                          /* realloc() */
31 #endif
32
33 /*****************************************************************************
34  * Private types
35  *****************************************************************************/
36 struct callback_entry_t
37 {
38     vlc_callback_t pf_callback;
39     void *         p_data;
40 };
41
42 /*****************************************************************************
43  * Local comparison functions, returns 0 if v == w, < 0 if v < w, > 0 if v > w
44  *****************************************************************************/
45 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; }
46 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; }
47 static int CmpTime( vlc_value_t v, vlc_value_t w )
48 {
49     mtime_t v_time,w_time;
50     v_time = ( (mtime_t)v.time.i_high << 32 ) + v.time.i_low;
51     w_time = ( (mtime_t)w.time.i_high << 32 ) + w.time.i_low;
52     return v_time == w_time ? 0 : v_time > w_time ? 1 : -1;
53 }
54 static int CmpString( vlc_value_t v, vlc_value_t w ) { return strcmp( v.psz_string, w.psz_string ); }
55 static int CmpFloat( vlc_value_t v, vlc_value_t w ) { return v.f_float == w.f_float ? 0 : v.f_float > w.f_float ? 1 : -1; }
56 static int CmpAddress( vlc_value_t v, vlc_value_t w ) { return v.p_address == w.p_address ? 0 : v.p_address > w.p_address ? 1 : -1; }
57
58 /*****************************************************************************
59  * Local duplication functions, and local deallocation functions
60  *****************************************************************************/
61 static void DupDummy( vlc_value_t *p_val ) { (void)p_val; /* unused */ }
62 static void DupString( vlc_value_t *p_val ) { p_val->psz_string = strdup( p_val->psz_string ); }
63
64 static void DupList( vlc_value_t *p_val )
65 {
66     int i;
67     vlc_list_t *p_list = malloc( sizeof(vlc_list_t) );
68
69     if( p_val->p_list->i_count )
70     {
71         p_list->i_count = p_val->p_list->i_count;
72         p_list->p_values = malloc( p_list->i_count * sizeof(vlc_value_t) );
73         p_list->pi_types = malloc( p_list->i_count * sizeof(int) );
74     }
75
76     for( i = 0; i < p_list->i_count; i++ )
77     {
78         p_list->p_values[i] = p_val->p_list->p_values[i];
79         switch( p_val->p_list->pi_types[i] & VLC_VAR_TYPE )
80         {
81         case VLC_VAR_STRING:
82             
83             DupString( &p_list->p_values[i] );
84             break;
85         default:
86             break;
87         }
88     }
89
90     p_val->p_list = p_list;
91 }
92
93 static void FreeDummy( vlc_value_t *p_val ) { (void)p_val; /* unused */ }
94 static void FreeString( vlc_value_t *p_val ) { free( p_val->psz_string ); }
95 static void FreeMutex( vlc_value_t *p_val ) { vlc_mutex_destroy( (vlc_mutex_t*)p_val->p_address ); free( p_val->p_address ); }
96
97 static void FreeList( vlc_value_t *p_val )
98 {
99     int i;
100     for( i = 0; i < p_val->p_list->i_count; i++ )
101     {
102         switch( p_val->p_list->pi_types[i] & VLC_VAR_TYPE )
103         {
104         case VLC_VAR_STRING:
105             FreeString( &p_val->p_list->p_values[i] );
106             break;
107         case VLC_VAR_MUTEX:
108             FreeMutex( &p_val->p_list->p_values[i] );
109             break;
110         default:
111             break;
112         }
113     }
114
115     if( p_val->p_list->i_count )
116     {
117         free( p_val->p_list->p_values );
118         free( p_val->p_list->pi_types );
119     }
120     free( p_val->p_list );
121 }
122
123 /*****************************************************************************
124  * Local prototypes
125  *****************************************************************************/
126 static int      GetUnused   ( vlc_object_t *, const char * );
127 static uint32_t HashString  ( const char * );
128 static int      Insert      ( variable_t *, int, const char * );
129 static int      InsertInner ( variable_t *, int, uint32_t );
130 static int      Lookup      ( variable_t *, int, const char * );
131 static int      LookupInner ( variable_t *, int, uint32_t );
132
133 static void     CheckValue  ( variable_t *, vlc_value_t * );
134
135 static int      InheritValue( vlc_object_t *, const char *, vlc_value_t *,
136                               int );
137
138 /*****************************************************************************
139  * var_Create: initialize a vlc variable
140  *****************************************************************************
141  * We hash the given string and insert it into the sorted list. The insertion
142  * may require slow memory copies, but think about what we gain in the log(n)
143  * lookup phase when setting/getting the variable value!
144  *****************************************************************************/
145 int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type )
146 {
147     int i_new;
148     variable_t *p_var;
149     static vlc_list_t dummy_null_list = {0, NULL, NULL};
150
151     vlc_mutex_lock( &p_this->var_lock );
152
153     /* FIXME: if the variable already exists, we don't duplicate it. But we
154      * duplicate the lookups. It's not that serious, but if anyone finds some
155      * time to rework Insert() so that only one lookup has to be done, feel
156      * free to do so. */
157     i_new = Lookup( p_this->p_vars, p_this->i_vars, psz_name );
158
159     if( i_new >= 0 )
160     {
161         /* If the types differ, variable creation failed. */
162         if( i_type != p_this->p_vars[i_new].i_type )
163         {
164             vlc_mutex_unlock( &p_this->var_lock );
165             return VLC_EBADVAR;
166         }
167
168         p_this->p_vars[i_new].i_usage++;
169         vlc_mutex_unlock( &p_this->var_lock );
170         return VLC_SUCCESS;
171     }
172
173     i_new = Insert( p_this->p_vars, p_this->i_vars, psz_name );
174
175     if( (p_this->i_vars & 15) == 15 )
176     {
177         p_this->p_vars = realloc( p_this->p_vars,
178                                   (p_this->i_vars+17) * sizeof(variable_t) );
179     }
180
181     memmove( p_this->p_vars + i_new + 1,
182              p_this->p_vars + i_new,
183              (p_this->i_vars - i_new) * sizeof(variable_t) );
184
185     p_this->i_vars++;
186
187     p_var = &p_this->p_vars[i_new];
188
189     p_var->i_hash = HashString( psz_name );
190     p_var->psz_name = strdup( psz_name );
191     p_var->psz_text = NULL;
192
193     p_var->i_type = i_type;
194     memset( &p_var->val, 0, sizeof(vlc_value_t) );
195
196     p_var->pf_dup = DupDummy;
197     p_var->pf_free = FreeDummy;
198
199     p_var->i_usage = 1;
200
201     p_var->i_default = -1;
202     p_var->choices.i_count = 0;
203     p_var->choices.p_values = NULL;
204     p_var->choices_text.i_count = 0;
205     p_var->choices_text.p_values = NULL;
206
207     p_var->b_incallback = VLC_FALSE;
208     p_var->i_entries = 0;
209     p_var->p_entries = NULL;
210
211     /* Always initialize the variable, even if it is a list variable; this
212      * will lead to errors if the variable is not initialized, but it will
213      * not cause crashes in the variable handling. */
214     switch( i_type & VLC_VAR_TYPE )
215     {
216         case VLC_VAR_BOOL:
217             p_var->pf_cmp = CmpBool;
218             p_var->val.b_bool = VLC_FALSE;
219             break;
220         case VLC_VAR_INTEGER:
221             p_var->pf_cmp = CmpInt;
222             p_var->val.i_int = 0;
223             break;
224         case VLC_VAR_STRING:
225         case VLC_VAR_MODULE:
226         case VLC_VAR_FILE:
227         case VLC_VAR_DIRECTORY:
228         case VLC_VAR_VARIABLE:
229             p_var->pf_cmp = CmpString;
230             p_var->pf_dup = DupString;
231             p_var->pf_free = FreeString;
232             p_var->val.psz_string = "";
233             break;
234         case VLC_VAR_FLOAT:
235             p_var->pf_cmp = CmpFloat;
236             p_var->val.f_float = 0.0;
237             break;
238         case VLC_VAR_TIME:
239             p_var->pf_cmp = CmpTime;
240             p_var->val.time.i_low = 0;
241             p_var->val.time.i_high = 0;
242             break;
243         case VLC_VAR_ADDRESS:
244             p_var->pf_cmp = CmpAddress;
245             p_var->val.p_address = NULL;
246             break;
247         case VLC_VAR_MUTEX:
248             p_var->pf_cmp = CmpAddress;
249             p_var->pf_free = FreeMutex;
250             p_var->val.p_address = malloc( sizeof(vlc_mutex_t) );
251             vlc_mutex_init( p_this, (vlc_mutex_t*)p_var->val.p_address );
252             break;
253         case VLC_VAR_LIST:
254             p_var->pf_cmp = CmpAddress;
255             p_var->pf_dup = DupList;
256             p_var->pf_free = FreeList;
257             p_var->val.p_list = &dummy_null_list;
258             break;
259     }
260
261     /* Duplicate the default data we stored. */
262     p_var->pf_dup( &p_var->val );
263
264     vlc_mutex_unlock( &p_this->var_lock );
265
266     return VLC_SUCCESS;
267 }
268
269 /*****************************************************************************
270  * var_Destroy: destroy a vlc variable
271  *****************************************************************************
272  * Look for the variable and destroy it if it is found. As in var_Create we
273  * do a call to memmove() but we have performance counterparts elsewhere.
274  *****************************************************************************/
275 int __var_Destroy( vlc_object_t *p_this, const char *psz_name )
276 {
277     int i_var, i;
278     variable_t *p_var;
279
280     vlc_mutex_lock( &p_this->var_lock );
281
282     i_var = GetUnused( p_this, psz_name );
283     if( i_var < 0 )
284     {
285         vlc_mutex_unlock( &p_this->var_lock );
286         return i_var;
287     }
288
289     p_var = &p_this->p_vars[i_var];
290
291     if( p_var->i_usage > 1 )
292     {
293         p_var->i_usage--;
294         vlc_mutex_unlock( &p_this->var_lock );
295         return VLC_SUCCESS;
296     }
297
298     /* Free value if needed */
299     p_var->pf_free( &p_var->val );
300
301     /* Free choice list if needed */
302     if( p_var->choices.i_count )
303     {
304         for( i = 0 ; i < p_var->choices.i_count ; i++ )
305         {
306             p_var->pf_free( &p_var->choices.p_values[i] );
307         }
308         free( p_var->choices.p_values );
309     }
310
311     /* Free callbacks if needed */
312     if( p_var->p_entries )
313     {
314         free( p_var->p_entries );
315     }
316
317     free( p_var->psz_name );
318     if( p_var->psz_text ) free( p_var->psz_text );
319
320     memmove( p_this->p_vars + i_var,
321              p_this->p_vars + i_var + 1,
322              (p_this->i_vars - i_var - 1) * sizeof(variable_t) );
323
324     if( (p_this->i_vars & 15) == 0 )
325     {
326         p_this->p_vars = realloc( p_this->p_vars,
327                           (p_this->i_vars) * sizeof( variable_t ) );
328     }
329
330     p_this->i_vars--;
331
332     vlc_mutex_unlock( &p_this->var_lock );
333
334     return VLC_SUCCESS;
335 }
336
337 /*****************************************************************************
338  * var_Change: perform an action on a variable
339  *****************************************************************************
340  *
341  *****************************************************************************/
342 int __var_Change( vlc_object_t *p_this, const char *psz_name,
343                   int i_action, vlc_value_t *p_val, vlc_value_t *p_val2 )
344 {
345     int i_var, i;
346     variable_t *p_var;
347     vlc_value_t oldval;
348
349     vlc_mutex_lock( &p_this->var_lock );
350
351     i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name );
352
353     if( i_var < 0 )
354     {
355         vlc_mutex_unlock( &p_this->var_lock );
356         return VLC_ENOVAR;
357     }
358
359     p_var = &p_this->p_vars[i_var];
360
361     switch( i_action )
362     {
363         case VLC_VAR_SETMIN:
364             if( p_var->i_type & VLC_VAR_HASMIN )
365             {
366                 p_var->pf_free( &p_var->min );
367             }
368             p_var->i_type |= VLC_VAR_HASMIN;
369             p_var->min = *p_val;
370             p_var->pf_dup( &p_var->min );
371             CheckValue( p_var, &p_var->val );
372             break;
373         case VLC_VAR_SETMAX:
374             if( p_var->i_type & VLC_VAR_HASMAX )
375             {
376                 p_var->pf_free( &p_var->max );
377             }
378             p_var->i_type |= VLC_VAR_HASMAX;
379             p_var->max = *p_val;
380             p_var->pf_dup( &p_var->max );
381             CheckValue( p_var, &p_var->val );
382             break;
383         case VLC_VAR_SETSTEP:
384             if( p_var->i_type & VLC_VAR_HASSTEP )
385             {
386                 p_var->pf_free( &p_var->step );
387             }
388             p_var->i_type |= VLC_VAR_HASSTEP;
389             p_var->step = *p_val;
390             p_var->pf_dup( &p_var->step );
391             CheckValue( p_var, &p_var->val );
392             break;
393         case VLC_VAR_ADDCHOICE:
394             /* FIXME: the list is sorted, dude. Use something cleverer. */
395             for( i = p_var->choices.i_count ; i-- ; )
396             {
397                 if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) < 0 )
398                 {
399                     break;
400                 }
401             }
402
403             /* The new place is i+1 */
404             i++;
405
406             if( p_var->i_default >= i )
407             {
408                 p_var->i_default++;
409             }
410
411             INSERT_ELEM( p_var->choices.p_values, p_var->choices.i_count,
412                          i, *p_val );
413             INSERT_ELEM( p_var->choices_text.p_values,
414                          p_var->choices_text.i_count, i, *p_val );
415             p_var->pf_dup( &p_var->choices.p_values[i] );
416             p_var->choices_text.p_values[i].psz_string =
417                 ( p_val2 && p_val2->psz_string ) ?
418                 strdup( p_val2->psz_string ) : NULL;
419
420             CheckValue( p_var, &p_var->val );
421             break;
422         case VLC_VAR_DELCHOICE:
423             /* FIXME: the list is sorted, dude. Use something cleverer. */
424             for( i = 0 ; i < p_var->choices.i_count ; i++ )
425             {
426                 if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 )
427                 {
428                     break;
429                 }
430             }
431
432             if( i == p_var->choices.i_count )
433             {
434                 /* Not found */
435                 vlc_mutex_unlock( &p_this->var_lock );
436                 return VLC_EGENERIC;
437             }
438
439             if( p_var->i_default > i )
440             {
441                 p_var->i_default--;
442             }
443             else if( p_var->i_default == i )
444             {
445                 p_var->i_default = -1;
446             }
447
448             p_var->pf_free( &p_var->choices.p_values[i] );
449             if( p_var->choices_text.p_values[i].psz_string )
450                 free( p_var->choices_text.p_values[i].psz_string );
451             REMOVE_ELEM( p_var->choices.p_values, p_var->choices.i_count, i );
452             REMOVE_ELEM( p_var->choices_text.p_values,
453                          p_var->choices_text.i_count, i );
454
455             CheckValue( p_var, &p_var->val );
456             break;
457         case VLC_VAR_CHOICESCOUNT:
458             p_val->i_int = p_var->choices.i_count;
459             break;
460         case VLC_VAR_CLEARCHOICES:
461             for( i = 0 ; i < p_var->choices.i_count ; i++ )
462             {
463                 p_var->pf_free( &p_var->choices.p_values[i] );
464             }
465             if( p_var->choices.i_count )
466                 free( p_var->choices.p_values );
467
468             p_var->choices.i_count = 0;
469             p_var->choices.p_values = NULL;
470             p_var->i_default = -1;
471             break;
472         case VLC_VAR_SETDEFAULT:
473             /* FIXME: the list is sorted, dude. Use something cleverer. */
474             for( i = 0 ; i < p_var->choices.i_count ; i++ )
475             {
476                 if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 )
477                 {
478                     break;
479                 }
480             }
481
482             if( i == p_var->choices.i_count )
483             {
484                 /* Not found */
485                 break;
486             }
487
488             p_var->i_default = i;
489             CheckValue( p_var, &p_var->val );
490             break;
491         case VLC_VAR_SETVALUE:
492             /* Duplicate data if needed */
493             p_var->pf_dup( p_val );
494             /* Backup needed stuff */
495             oldval = p_var->val;
496             /* Check boundaries and list */
497             CheckValue( p_var, p_val );
498             /* Set the variable */
499             p_var->val = *p_val;
500             /* Free data if needed */
501             p_var->pf_free( &oldval );
502             break;
503         case VLC_VAR_GETCHOICES:
504         case VLC_VAR_GETLIST:
505             p_val->p_list = malloc( sizeof(vlc_list_t) );
506             if( p_val2 ) p_val2->p_list = malloc( sizeof(vlc_list_t) );
507             if( p_var->choices.i_count )
508             {
509                 p_val->p_list->p_values = malloc( p_var->choices.i_count
510                                                   * sizeof(vlc_value_t) );
511                 p_val->p_list->pi_types = malloc( p_var->choices.i_count
512                                                   * sizeof(int) );
513                 if( p_val2 )
514                 {
515                     p_val2->p_list->p_values =
516                         malloc( p_var->choices.i_count * sizeof(vlc_value_t) );
517                     p_val2->p_list->pi_types =
518                         malloc( p_var->choices.i_count * sizeof(int) );
519                 }
520             }
521             p_val->p_list->i_count = p_var->choices.i_count;
522             if( p_val2 ) p_val2->p_list->i_count = p_var->choices.i_count;
523             for( i = 0 ; i < p_var->choices.i_count ; i++ )
524             {
525                 p_val->p_list->p_values[i] = p_var->choices.p_values[i];
526                 p_val->p_list->pi_types[i] = p_var->i_type;
527                 p_var->pf_dup( &p_val->p_list->p_values[i] );
528                 if( p_val2 )
529                 {
530                     p_val2->p_list->p_values[i].psz_string =
531                         p_var->choices_text.p_values[i].psz_string ?
532                     strdup(p_var->choices_text.p_values[i].psz_string) : NULL;
533                     p_val2->p_list->pi_types[i] = VLC_VAR_STRING;
534                 }
535             }
536             break;
537         case VLC_VAR_FREELIST:
538             FreeList( p_val );
539             break;
540         case VLC_VAR_SETTEXT:
541             if( p_var->psz_text ) free( p_var->psz_text );
542             if( p_val && p_val->psz_string )
543                 p_var->psz_text = strdup( p_val->psz_string );
544             break;
545         case VLC_VAR_GETTEXT:
546             p_val->psz_string = NULL;
547             if( p_var->psz_text )
548             {
549                 p_val->psz_string = strdup( p_var->psz_text );
550             }
551             break;
552         case VLC_VAR_INHERITVALUE:
553             {
554                 vlc_value_t val;
555
556                 if( InheritValue( p_this, psz_name, &val, p_var->i_type )
557                     == VLC_SUCCESS );
558                 {
559                     /* Duplicate already done */
560
561                     /* Backup needed stuff */
562                     oldval = p_var->val;
563                     /* Check boundaries and list */
564                     CheckValue( p_var, &val );
565                     /* Set the variable */
566                     p_var->val = val;
567                     /* Free data if needed */
568                     p_var->pf_free( &oldval );
569                 }
570             }
571             break;
572
573         default:
574             break;
575     }
576
577     vlc_mutex_unlock( &p_this->var_lock );
578
579     return VLC_SUCCESS;
580 }
581
582 /*****************************************************************************
583  * var_Type: request a variable's type
584  *****************************************************************************
585  * This function returns the variable type if it exists, or 0 if the
586  * variable could not be found.
587  *****************************************************************************/
588 int __var_Type( vlc_object_t *p_this, const char *psz_name )
589 {
590     int i_var, i_type;
591
592     vlc_mutex_lock( &p_this->var_lock );
593
594     i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name );
595
596     if( i_var < 0 )
597     {
598         vlc_mutex_unlock( &p_this->var_lock );
599         return 0;
600     }
601
602     i_type = p_this->p_vars[i_var].i_type;
603
604     vlc_mutex_unlock( &p_this->var_lock );
605
606     return i_type;
607 }
608
609 /*****************************************************************************
610  * var_Set: set a variable's value
611  *****************************************************************************
612  *
613  *****************************************************************************/
614 int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val )
615 {
616     int i_var;
617     variable_t *p_var;
618     vlc_value_t oldval;
619
620     vlc_mutex_lock( &p_this->var_lock );
621
622     i_var = GetUnused( p_this, psz_name );
623     if( i_var < 0 )
624     {
625         vlc_mutex_unlock( &p_this->var_lock );
626         return i_var;
627     }
628
629     p_var = &p_this->p_vars[i_var];
630
631     /* Duplicate data if needed */
632     p_var->pf_dup( &val );
633
634     /* Backup needed stuff */
635     oldval = p_var->val;
636
637     /* Check boundaries and list */
638     CheckValue( p_var, &val );
639
640     /* Set the variable */
641     p_var->val = val;
642
643     /* Deal with callbacks. Tell we're in a callback, release the lock,
644      * call stored functions, retake the lock. */
645     if( p_var->i_entries )
646     {
647         int i_var;
648         int i_entries = p_var->i_entries;
649         callback_entry_t *p_entries = p_var->p_entries;
650
651         p_var->b_incallback = VLC_TRUE;
652         vlc_mutex_unlock( &p_this->var_lock );
653
654         /* The real calls */
655         for( ; i_entries-- ; )
656         {
657             p_entries[i_entries].pf_callback( p_this, psz_name, oldval, val,
658                                               p_entries[i_entries].p_data );
659         }
660
661         vlc_mutex_lock( &p_this->var_lock );
662
663         i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name );
664         if( i_var < 0 )
665         {
666             msg_Err( p_this, "variable %s has disappeared", psz_name );
667             vlc_mutex_unlock( &p_this->var_lock );
668             return VLC_ENOVAR;
669         }
670
671         p_var = &p_this->p_vars[i_var];
672         p_var->b_incallback = VLC_FALSE;
673     }
674
675     /* Free data if needed */
676     p_var->pf_free( &oldval );
677
678     vlc_mutex_unlock( &p_this->var_lock );
679
680     return VLC_SUCCESS;
681 }
682
683 /*****************************************************************************
684  * var_Get: get a variable's value
685  *****************************************************************************
686  *
687  *****************************************************************************/
688 int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val )
689 {
690     int i_var;
691     variable_t *p_var;
692
693     vlc_mutex_lock( &p_this->var_lock );
694
695     i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name );
696
697     if( i_var < 0 )
698     {
699         vlc_mutex_unlock( &p_this->var_lock );
700         return VLC_ENOVAR;
701     }
702
703     p_var = &p_this->p_vars[i_var];
704
705     /* Really get the variable */
706     *p_val = p_var->val;
707
708     /* Duplicate value if needed */
709     p_var->pf_dup( p_val );
710
711     vlc_mutex_unlock( &p_this->var_lock );
712
713     return VLC_SUCCESS;
714 }
715
716 /*****************************************************************************
717  * var_AddCallback: register a callback in a variable
718  *****************************************************************************
719  * We store a function pointer pf_callback that will be called upon variable
720  * modification. p_data is a generic pointer that will be passed as additional
721  * argument to the callback function.
722  *****************************************************************************/
723 int __var_AddCallback( vlc_object_t *p_this, const char *psz_name,
724                        vlc_callback_t pf_callback, void *p_data )
725 {
726     int i_var;
727     variable_t *p_var;
728     callback_entry_t entry;
729
730     entry.pf_callback = pf_callback;
731     entry.p_data = p_data;
732
733     vlc_mutex_lock( &p_this->var_lock );
734
735     i_var = GetUnused( p_this, psz_name );
736     if( i_var < 0 )
737     {
738         vlc_mutex_unlock( &p_this->var_lock );
739         return i_var;
740     }
741
742     p_var = &p_this->p_vars[i_var];
743
744     INSERT_ELEM( p_var->p_entries,
745                  p_var->i_entries,
746                  p_var->i_entries,
747                  entry );
748
749     vlc_mutex_unlock( &p_this->var_lock );
750
751     return VLC_SUCCESS;
752 }
753
754 /*****************************************************************************
755  * var_DelCallback: remove a callback from a variable
756  *****************************************************************************
757  * pf_callback and p_data have to be given again, because different objects
758  * might have registered the same callback function.
759  *****************************************************************************/
760 int __var_DelCallback( vlc_object_t *p_this, const char *psz_name,
761                        vlc_callback_t pf_callback, void *p_data )
762 {
763     int i_entry, i_var;
764     variable_t *p_var;
765
766     vlc_mutex_lock( &p_this->var_lock );
767
768     i_var = GetUnused( p_this, psz_name );
769     if( i_var < 0 )
770     {
771         vlc_mutex_unlock( &p_this->var_lock );
772         return i_var;
773     }
774
775     p_var = &p_this->p_vars[i_var];
776
777     for( i_entry = p_var->i_entries ; i_entry-- ; )
778     {
779         if( p_var->p_entries[i_entry].pf_callback == pf_callback
780             && p_var->p_entries[i_entry].p_data == p_data )
781         {
782             break;
783         }
784     }
785
786     if( i_entry < 0 )
787     {
788         vlc_mutex_unlock( &p_this->var_lock );
789         return VLC_EGENERIC;
790     }
791
792     REMOVE_ELEM( p_var->p_entries, p_var->i_entries, i_entry );
793
794     vlc_mutex_unlock( &p_this->var_lock );
795
796     return VLC_SUCCESS;
797 }
798
799 /* Following functions are local */
800
801 /*****************************************************************************
802  * GetUnused: find an unused variable from its name
803  *****************************************************************************
804  * We do i_tries tries before giving up, just in case the variable is being
805  * modified and called from a callback.
806  *****************************************************************************/
807 static int GetUnused( vlc_object_t *p_this, const char *psz_name )
808 {
809     int i_var, i_tries = 0;
810
811     while( VLC_TRUE )
812     {
813         i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name );
814         if( i_var < 0 )
815         {
816             return VLC_ENOVAR;
817         }
818
819         if( ! p_this->p_vars[i_var].b_incallback )
820         {
821             return i_var;
822         }
823
824         if( i_tries++ > 100 )
825         {
826             msg_Err( p_this, "caught in a callback deadlock?" );
827             return VLC_ETIMEOUT;
828         }
829
830         vlc_mutex_unlock( &p_this->var_lock );
831         msleep( THREAD_SLEEP );
832         vlc_mutex_lock( &p_this->var_lock );
833     }
834 }
835
836 /*****************************************************************************
837  * HashString: our cool hash function
838  *****************************************************************************
839  * This function is not intended to be crypto-secure, we only want it to be
840  * fast and not suck too much. This one is pretty fast and did 0 collisions
841  * in wenglish's dictionary.
842  *****************************************************************************/
843 static uint32_t HashString( const char *psz_string )
844 {
845     uint32_t i_hash = 0;
846
847     while( *psz_string )
848     {
849         i_hash += *psz_string++;
850         i_hash += i_hash << 10;
851         i_hash ^= i_hash >> 8;
852     }
853
854     return i_hash;
855 }
856
857 /*****************************************************************************
858  * Insert: find an empty slot to insert a new variable
859  *****************************************************************************
860  * We use a recursive inner function indexed on the hash. This function does
861  * nothing in the rare cases where a collision may occur, see Lookup()
862  * to see how we handle them.
863  * XXX: does this really need to be written recursively?
864  *****************************************************************************/
865 static int Insert( variable_t *p_vars, int i_count, const char *psz_name )
866 {
867     if( i_count == 0 )
868     {
869         return 0;
870     }
871
872     return InsertInner( p_vars, i_count, HashString( psz_name ) );
873 }
874
875 static int InsertInner( variable_t *p_vars, int i_count, uint32_t i_hash )
876 {
877     int i_middle;
878
879     if( i_hash <= p_vars[0].i_hash )
880     {
881         return 0;
882     }
883
884     if( i_hash >= p_vars[i_count - 1].i_hash )
885     {
886         return i_count;
887     }
888
889     i_middle = i_count / 2;
890
891     /* We know that 0 < i_middle */
892     if( i_hash < p_vars[i_middle].i_hash )
893     {
894         return InsertInner( p_vars, i_middle, i_hash );
895     }
896
897     /* We know that i_middle + 1 < i_count */
898     if( i_hash > p_vars[i_middle + 1].i_hash )
899     {
900         return i_middle + 1 + InsertInner( p_vars + i_middle + 1,
901                                            i_count - i_middle - 1,
902                                            i_hash );
903     }
904
905     return i_middle + 1;
906 }
907
908 /*****************************************************************************
909  * Lookup: find an existing variable given its name
910  *****************************************************************************
911  * We use a recursive inner function indexed on the hash. Care is taken of
912  * possible hash collisions.
913  * XXX: does this really need to be written recursively?
914  *****************************************************************************/
915 static int Lookup( variable_t *p_vars, int i_count, const char *psz_name )
916 {
917     uint32_t i_hash;
918     int i, i_pos;
919
920     if( i_count == 0 )
921     {
922         return -1;
923     }
924
925     i_hash = HashString( psz_name );
926
927     i_pos = LookupInner( p_vars, i_count, i_hash );
928
929     /* Hash not found */
930     if( i_hash != p_vars[i_pos].i_hash )
931     {
932         return -1;
933     }
934
935     /* Hash found, entry found */
936     if( !strcmp( psz_name, p_vars[i_pos].psz_name ) )
937     {
938         return i_pos;
939     }
940
941     /* Hash collision! This should be very rare, but we cannot guarantee
942      * it will never happen. Just do an exhaustive search amongst all
943      * entries with the same hash. */
944     for( i = i_pos - 1 ; i > 0 && i_hash == p_vars[i].i_hash ; i-- )
945     {
946         if( !strcmp( psz_name, p_vars[i].psz_name ) )
947         {
948             return i;
949         }
950     }
951
952     for( i = i_pos + 1 ; i < i_count && i_hash == p_vars[i].i_hash ; i++ )
953     {
954         if( !strcmp( psz_name, p_vars[i].psz_name ) )
955         {
956             return i;
957         }
958     }
959
960     /* Hash found, but entry not found */
961     return -1;
962 }
963
964 static int LookupInner( variable_t *p_vars, int i_count, uint32_t i_hash )
965 {
966     int i_middle;
967
968     if( i_hash <= p_vars[0].i_hash )
969     {
970         return 0;
971     }
972
973     if( i_hash >= p_vars[i_count-1].i_hash )
974     {
975         return i_count - 1;
976     }
977
978     i_middle = i_count / 2;
979
980     /* We know that 0 < i_middle */
981     if( i_hash < p_vars[i_middle].i_hash )
982     {
983         return LookupInner( p_vars, i_middle, i_hash );
984     }
985
986     /* We know that i_middle + 1 < i_count */
987     if( i_hash > p_vars[i_middle].i_hash )
988     {
989         return i_middle + LookupInner( p_vars + i_middle,
990                                        i_count - i_middle,
991                                        i_hash );
992     }
993
994     return i_middle;
995 }
996
997 /*****************************************************************************
998  * CheckValue: check that a value is valid wrt. a variable
999  *****************************************************************************
1000  * This function checks p_val's value against p_var's limitations such as
1001  * minimal and maximal value, step, in-list position, and modifies p_val if
1002  * necessary.
1003  *****************************************************************************/
1004 static void CheckValue ( variable_t *p_var, vlc_value_t *p_val )
1005 {
1006     /* Check that our variable is in the list */
1007     if( p_var->i_type & VLC_VAR_HASCHOICE && p_var->choices.i_count )
1008     {
1009         int i;
1010
1011         /* FIXME: the list is sorted, dude. Use something cleverer. */
1012         for( i = p_var->choices.i_count ; i-- ; )
1013         {
1014             if( p_var->pf_cmp( *p_val, p_var->choices.p_values[i] ) == 0 )
1015             {
1016                 break;
1017             }
1018         }
1019
1020         /* If not found, change it to anything vaguely valid */
1021         if( i < 0 )
1022         {
1023             /* Free the old variable, get the new one, dup it */
1024             p_var->pf_free( p_val );
1025             *p_val = p_var->choices.p_values[p_var->i_default >= 0
1026                                           ? p_var->i_default : 0 ];
1027             p_var->pf_dup( p_val );
1028         }
1029     }
1030
1031     /* Check that our variable is within the bounds */
1032     switch( p_var->i_type & VLC_VAR_TYPE )
1033     {
1034         case VLC_VAR_INTEGER:
1035             if( p_var->i_type & VLC_VAR_HASSTEP && p_var->step.i_int
1036                  && (p_val->i_int % p_var->step.i_int) )
1037             {
1038                 p_val->i_int = (p_val->i_int + (p_var->step.i_int / 2))
1039                                / p_var->step.i_int * p_var->step.i_int;
1040             }
1041             if( p_var->i_type & VLC_VAR_HASMIN
1042                  && p_val->i_int < p_var->min.i_int )
1043             {
1044                 p_val->i_int = p_var->min.i_int;
1045             }
1046             if( p_var->i_type & VLC_VAR_HASMAX
1047                  && p_val->i_int > p_var->max.i_int )
1048             {
1049                 p_val->i_int = p_var->max.i_int;
1050             }
1051             break;
1052         case VLC_VAR_FLOAT:
1053             if( p_var->i_type & VLC_VAR_HASSTEP && p_var->step.f_float )
1054             {
1055                 float f_round = p_var->step.f_float * (float)(int)( 0.5 +
1056                                         p_val->f_float / p_var->step.f_float );
1057                 if( p_val->f_float != f_round )
1058                 {
1059                     p_val->f_float = f_round;
1060                 }
1061             }
1062             if( p_var->i_type & VLC_VAR_HASMIN
1063                  && p_val->f_float < p_var->min.f_float )
1064             {
1065                 p_val->f_float = p_var->min.f_float;
1066             }
1067             if( p_var->i_type & VLC_VAR_HASMAX
1068                  && p_val->f_float > p_var->max.f_float )
1069             {
1070                 p_val->f_float = p_var->max.f_float;
1071             }
1072             break;
1073         case VLC_VAR_TIME:
1074             /* FIXME: TODO */
1075             break;
1076     }
1077 }
1078
1079 /*****************************************************************************
1080  * InheritValue: try to inherit the value of this variable from the same one
1081  *               in our closest parent.
1082  *****************************************************************************/
1083 static int InheritValue( vlc_object_t *p_this, const char *psz_name,
1084                          vlc_value_t *p_val, int i_type )
1085 {
1086     int i_var;
1087     variable_t *p_var;
1088
1089     /* No need to take the structure lock,
1090      * we are only looking for our parents */
1091
1092     if( !p_this->p_parent )
1093     {
1094         switch( i_type & VLC_VAR_TYPE )
1095         {
1096         case VLC_VAR_STRING:
1097             p_val->psz_string = config_GetPsz( p_this, psz_name );
1098             if( !p_val->psz_string ) p_val->psz_string = strdup("");
1099             break;
1100         case VLC_VAR_FLOAT:
1101             p_val->f_float = config_GetFloat( p_this, psz_name );
1102             break;
1103         case VLC_VAR_INTEGER:
1104             p_val->i_int = config_GetInt( p_this, psz_name );
1105             break;
1106         case VLC_VAR_BOOL:
1107             p_val->b_bool = config_GetInt( p_this, psz_name );
1108             break;
1109         default:
1110             return VLC_ENOOBJ;
1111             break;
1112         }
1113
1114         return VLC_SUCCESS;
1115     }
1116
1117     /* Look for the variable */
1118     vlc_mutex_lock( &p_this->p_parent->var_lock );
1119
1120     i_var = Lookup( p_this->p_parent->p_vars, p_this->p_parent->i_vars,
1121                     psz_name );
1122
1123     if( i_var >= 0 )
1124     {
1125         /* We found it! */
1126
1127         p_var = &p_this->p_parent->p_vars[i_var];
1128
1129         /* Really get the variable */
1130         *p_val = p_var->val;
1131
1132         /* Duplicate value if needed */
1133         p_var->pf_dup( p_val );
1134
1135         vlc_mutex_unlock( &p_this->p_parent->var_lock );
1136
1137         return VLC_SUCCESS;
1138     }
1139
1140     vlc_mutex_unlock( &p_this->p_parent->var_lock );
1141
1142     /* We're still not there */
1143
1144     return InheritValue( p_this->p_parent, psz_name, p_val, i_type );
1145 }