memset( p_array, 0, sizeof(vlc_array_t) );}static inline vlc_array_t * vlc_array_new( void ){    vlc_array_t * ret = (vlc_array_t *)malloc( sizeof(vlc_array_t) );    if( ret ) vlc_array_init( ret );    return ret;}static inline void vlc_array_destroy( vlc_array_t * p_array ){    if( !p_array )        return;    vlc_array_clear( p_array );    free( p_array );}/* Read */static inline intvlc_array_count( vlc_array_t * p_array ){    return p_array->i_count;}static inline void *vlc_array_item_at_index( vlc_array_t * p_array, int i_index ){    return p_array->pp_elems[i_index];}static inline intvlc_array_index_of_item( vlc_array_t * p_array, void * item ){    int i;    for( i = 0; i < p_array->i_count; i++)    {        if( p_array->pp_elems[i] == item )            return i;    }    return -1;}/* Write */static inline voidvlc_array_insert( vlc_array_t * p_array, void * p_elem, int i_index ){    TAB_INSERT_CAST( (void **), p_array->i_count, p_array->pp_elems, p_elem, i_index );}static inline voidvlc_array_append( vlc_array_t * p_array, void * p_elem ){    vlc_array_insert( p_array, p_elem, p_array->i_count );}static inline voidvlc_array_remove( vlc_array_t * p_array, int i_index ){    if( i_index >= 0 )    {        if( p_array->i_count > 1 )        {            memmove( p_array->pp_elems + i_index,                     p_array->pp_elems + i_index+1,                     ( p_array->i_count - i_index - 1 ) * sizeof( void* ) );        }        p_array->i_count--;        if( p_array->i_count == 0 )        {            free( p_array->pp_elems );            p_array->pp_elems = NULL;        }    }}/************************************************************************ * Dictionaries ************************************************************************//* 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 inline uint64_t DictHash( const char *psz_string, int hashsize ){    uint64_t i_hash = 0;    if( psz_string )    {        while( *psz_string )        {            i_hash += *psz_string++;            i_hash += i_hash << 10;            i_hash ^= i_hash >> 8;        }    }    return i_hash % hashsize;}typedef struct vlc_dictionary_entry_t{    char *   psz_key;    void *   p_value;    struct vlc_dictionary_entry_t * p_next;} vlc_dictionary_entry_t;typedef struct vlc_dictionary_t{    int i_size;    vlc_dictionary_entry_t ** p_entries;} vlc_dictionary_t;static void * const kVLCDictionaryNotFound = NULL;static inline void vlc_dictionary_init( vlc_dictionary_t * p_dict, int i_size ){    p_dict->p_entries = NULL;    if( i_size > 0 )    {        p_dict->p_entries = (vlc_dictionary_entry_t **)calloc( i_size, sizeof(*p_dict->p_entries) );        if( !p_dict->p_entries )            i_size = 0;    }    p_dict->i_size = i_size;}static inline void vlc_dictionary_clear( vlc_dictionary_t * p_dict,                                         void ( * pf_free )( void * p_data, void * p_obj ),                                         void * p_obj ){    if( p_dict->p_entries )    {        for( int i = 0; i < p_dict->i_size; i++ )        {            vlc_dictionary_entry_t * p_current, * p_next;            p_current = p_dict->p_entries[i];            while( p_current )            {                p_next = p_current->p_next;                if( pf_free != NULL )                    ( * pf_free )( p_current->p_value, p_obj );                free( p_current->psz_key );                free( p_current );                p_current = p_next;            }        }        free( p_dict->p_entries );        p_dict->p_entries = NULL;    }    p_dict->i_size = 0;}static inline void *vlc_dictionary_value_for_key( const vlc_dictionary_t * p_dict, const char * psz_key ){    if( !p_dict->p_entries )        return kVLCDictionaryNotFound;    int i_pos = DictHash( psz_key, p_dict->i_size );    vlc_dictionary_entry_t * p_entry = p_dict->p_entries[i_pos];    if( !p_entry )        return kVLCDictionaryNotFound;    /* Make sure we return the right item. (Hash collision) */    do {        if( !strcmp( psz_key, p_entry->psz_key ) )            return p_entry->p_value;        p_entry = p_entry->p_next;    } while( p_entry );    return kVLCDictionaryNotFound;}static inline intvlc_dictionary_keys_count( const vlc_dictionary_t * p_dict ){    vlc_dictionary_entry_t * p_entry;    int i, count = 0;    if( !p_dict->p_entries )        return 0;    for( i = 0; i < p_dict->i_size; i++ )    {        for( p_entry = p_dict->p_entries[i]; p_entry; p_entry = p_entry->p_next ) count++;    }    return count;}static inline char **vlc_dictionary_all_keys( const vlc_dictionary_t * p_dict ){    vlc_dictionary_entry_t * p_entry;    char ** ppsz_ret;    int i, count = vlc_dictionary_keys_count( p_dict );    ppsz_ret = (char**)malloc(sizeof(char *) * (count + 1));    count = 0;    for( i = 0; i < p_dict->i_size; i++ )    {        for( p_entry = p_dict->p_entries[i]; p_entry; p_entry = p_entry->p_next )            ppsz_ret[count++] = strdup( p_entry->psz_key );    }    ppsz_ret[count] = NULL;    return ppsz_ret;}static inline void__vlc_dictionary_insert( vlc_dictionary_t * p_dict, const char * psz_key,                         void * p_value, bool rebuild ){    if( !p_dict->p_entries )        vlc_dictionary_init( p_dict, 1 );    int i_pos = DictHash( psz_key, p_dict->i_size );    vlc_dictionary_entry_t * p_entry;    p_entry = (vlc_dictionary_entry_t *)malloc(sizeof(*p_entry));    p_entry->psz_key = strdup( psz_key );    p_entry->p_value = p_value;    p_entry->p_next = p_dict->p_entries[i_pos];    p_dict->p_entries[i_pos] = p_entry;    if( rebuild )    {        /* Count how many items there was */        int count;        for( count = 1; p_entry->p_next; count++ )            p_entry = p_entry->p_next;        if( count > 3 ) /* XXX: this need tuning */        {            /* Here it starts to be not good, rebuild a bigger dictionary */            struct vlc_dictionary_t new_dict;            int i_new_size = ( (p_dict->i_size+2) * 3) / 2; /* XXX: this need tuning */            int i;            vlc_dictionary_init( &new_dict, i_new_size );            for( i = 0; i < p_dict->i_size; i++ )            {                p_entry = p_dict->p_entries[i];                while( p_entry )                {                    __vlc_dictionary_insert( &new_dict, p_entry->psz_key,                                             p_entry->p_value,                                             false /* To avoid multiple rebuild loop */);                    p_entry = p_entry->p_next;                }            }            vlc_dictionary_clear( p_dict, NULL, NULL );            p_dict->i_size = new_dict.i_size;            p_dict->p_entries = new_dict.p_entries;        }    }}static inline voidvlc_dictionary_insert( vlc_dictionary_t * p_dict, const char * psz_key, void * p_value ){    __vlc_dictionary_insert( p_dict, psz_key, p_value, true );}static inline voidvlc_dictionary_remove_value_for_key( const vlc_dictionary_t * p_dict, const char * psz_key,                                     void ( * pf_free )( void * p_data, void * p_obj ),                                     void * p_obj ){    if( !p_dict->p_entries )        return;    int i_pos = DictHash( psz_key, p_dict->i_size );    vlc_dictionary_entry_t * p_entry = p_dict->p_entries[i_pos];    vlc_dictionary_entry_t * p_prev;    if( !p_entry )        return; /* Not found, nothing to do */    /* Hash collision */    p_prev = NULL;    do {        if( !strcmp( psz_key, p_entry->psz_key ) )        {            if( pf_free != NULL )                ( * pf_free )( p_entry->p_value, p_obj );            if( !p_prev )                p_dict->p_entries[i_pos] = p_entry->p_next;            else                p_prev->p_next = p_entry->p_next;            free( p_entry->psz_key );            free( p_entry );            return;        }        p_prev = p_entry;        p_entry = p_entry->p_next;    } while( p_entry );    /* No key was found */}#endif