Changeset 9df284851e95e95a365d058ae26456e6168c84bb

Show
Ignore:
Timestamp:
05/04/08 19:26:07 (4 months ago)
Author:
Rémi Denis-Courmont <rem@videolan.org>
git-committer:
Rémi Denis-Courmont <rem@videolan.org> 1209921967 +0300
git-parent:

[aebd6a4333c175bd5cd00ced4b25586be74c3837]

git-author:
Rémi Denis-Courmont <rem@videolan.org> 1209921967 +0300
Message:

Add long overdue private libvlc object pointer...

...and use it for stats and the config lock

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • include/vlc_main.h

    rb89d540 r9df2848  
    6969    module_t *             p_memcpy_module;  ///< Fast memcpy plugin used 
    7070 
    71     bool             b_stats;       ///< Should we collect stats ? 
    72     vlc_mutex_t            timer_lock;    ///< Lock to protect timers 
    73     int                    i_timers;      ///< Number of timers 
    74     counter_t            **pp_timers;     ///< Array of all timers 
    75  
    76     vlc_mutex_t            config_lock;    ///< Lock for the config file 
    77  
    7871    /* Structure storing the action name / key associations */ 
    7972    struct hotkey 

  • src/config/core.c

    r449fd28 r9df2848  
    558558void __config_ResetAll( vlc_object_t *p_this ) 
    559559{ 
     560    libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc); 
    560561    int i_index; 
    561562    vlc_list_t *p_list; 
    …… 
    563564 
    564565    /* Acquire config file lock */ 
    565     vlc_mutex_lock( &p_this->p_libvlc->config_lock ); 
     566    vlc_mutex_lock( &priv->config_lock ); 
    566567 
    567568    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); 
    …… 
    590591 
    591592    vlc_list_release( p_list ); 
    592     vlc_mutex_unlock( &p_this->p_libvlc->config_lock ); 
     593    vlc_mutex_unlock( &priv->config_lock ); 
    593594} 
    594595 

  • src/config/file.c

    r449fd28 r9df2848  
    140140int __config_LoadConfigFile( vlc_object_t *p_this, const char *psz_module_name ) 
    141141{ 
     142    libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc); 
    142143    vlc_list_t *p_list; 
    143144    FILE *file; 
    …… 
    148149 
    149150    /* Acquire config file lock */ 
    150     vlc_mutex_lock( &p_this->p_libvlc->config_lock ); 
     151    vlc_mutex_lock( &priv->config_lock ); 
    151152 
    152153    /* Look for the selected module, if NULL then save everything */ 
    …… 
    297298    vlc_list_release( p_list ); 
    298299 
    299     vlc_mutex_unlock( &p_this->p_libvlc->config_lock ); 
     300    vlc_mutex_unlock( &priv->config_lock ); 
    300301    return 0; 
    301302} 
    …… 
    387388                           bool b_autosave ) 
    388389{ 
     390    libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc); 
    389391    module_t *p_parser; 
    390392    vlc_list_t *p_list; 
    …… 
    397399 
    398400    /* Acquire config file lock */ 
    399     vlc_mutex_lock( &p_this->p_libvlc->config_lock ); 
     401    vlc_mutex_lock( &priv->config_lock ); 
    400402 
    401403    if( p_this->p_libvlc->psz_configfile == NULL ) 
    …… 
    405407        { 
    406408            msg_Err( p_this, "no configuration directory defined" ); 
    407             vlc_mutex_unlock( &p_this->p_libvlc->config_lock ); 
     409            vlc_mutex_unlock( &priv->config_lock ); 
    408410            return -1; 
    409411        } 
    …… 
    425427    { 
    426428        if( file ) fclose( file ); 
    427         vlc_mutex_unlock( &p_this->p_libvlc->config_lock ); 
     429        vlc_mutex_unlock( &priv->config_lock ); 
    428430        return -1; 
    429431    } 
    …… 
    499501        vlc_list_release( p_list ); 
    500502        free( p_bigbuffer ); 
    501         vlc_mutex_unlock( &p_this->p_libvlc->config_lock ); 
     503        vlc_mutex_unlock( &priv->config_lock ); 
    502504        return -1; 
    503505    } 
    …… 
    620622 
    621623    fclose( file ); 
    622     vlc_mutex_unlock( &p_this->p_libvlc->config_lock ); 
     624    vlc_mutex_unlock( &priv->config_lock ); 
    623625 
    624626    return 0; 
    …… 
    627629int config_AutoSaveConfigFile( vlc_object_t *p_this ) 
    628630{ 
     631    libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc); 
    629632    vlc_list_t *p_list; 
    630633    int i_index, i_count; 
    …… 
    633636 
    634637    /* Check if there's anything to save */ 
    635     vlc_mutex_lock( &p_this->p_libvlc->config_lock ); 
     638    vlc_mutex_lock( &priv->config_lock ); 
    636639    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); 
    637640    i_count = p_list->i_count; 
    …… 
    652655    } 
    653656    vlc_list_release( p_list ); 
    654     vlc_mutex_unlock( &p_this->p_libvlc->config_lock ); 
     657    vlc_mutex_unlock( &priv->config_lock ); 
    655658 
    656659    if( i_index == i_count ) return VLC_SUCCESS; 

  • src/input/es_out.c

    r2e48e65 r9df2848  
    13631363        i_delay = 0; 
    13641364 
    1365     if( p_input->p_libvlc->b_stats ) 
     1365    if( libvlc_stats (p_input) ) 
    13661366    { 
    13671367        vlc_mutex_lock( &p_input->p->counters.counters_lock ); 

  • src/input/input.c

    r6da90a1 r9df2848  
    796796#define INIT_COUNTER( c, type, compute ) p_input->p->counters.p_##c = \ 
    797797 stats_CounterCreate( p_input, VLC_VAR_##type, STATS_##compute); 
    798     if( p_input->p_libvlc->b_stats ) 
     798    if( libvlc_stats (p_input) ) 
    799799    { 
    800800        INIT_COUNTER( read_bytes, INTEGER, COUNTER ); 
    …… 
    864864            } 
    865865        } 
    866         if( p_input->p_libvlc->b_stats ) 
     866        if( libvlc_stats (p_input) ) 
    867867        { 
    868868            INIT_COUNTER( sout_sent_packets, INTEGER, COUNTER ); 
    …… 
    12611261#endif 
    12621262 
    1263     if( !p_input->b_preparsing && p_input->p_libvlc->b_stats ) 
     1263    if( !p_input->b_preparsing && libvlc_stats (p_input) ) 
    12641264    { 
    12651265#define EXIT_COUNTER( c ) do { if( p_input->p->counters.p_##c ) \ 
    …… 
    13441344    { 
    13451345#define CL_CO( c ) stats_CounterClean( p_input->p->counters.p_##c ); p_input->p->counters.p_##c = NULL; 
    1346         if( p_input->p_libvlc->b_stats ) 
     1346        if( libvlc_stats (p_input) ) 
    13471347        { 
    13481348            /* make sure we are up to date */ 

  • src/input/stream.c

    rd1d3dc1 r9df2848  
    17531753        p_block = p_access->pf_block( p_access ); 
    17541754        if( pb_eof ) *pb_eof = p_access->info.b_eof; 
    1755         if( p_input && p_block && p_access->p_libvlc->b_stats ) 
     1755        if( p_input && p_block && libvlc_stats (p_access) ) 
    17561756        { 
    17571757            vlc_mutex_lock( &p_input->p->counters.counters_lock ); 

  • src/libvlc-common.c

    r9c87bdf r9df2848  
    147147libvlc_int_t * libvlc_InternalCreate( void ) 
    148148{ 
    149     libvlc_int_t * p_libvlc = NULL; 
     149    libvlc_int_t *p_libvlc; 
     150    libvlc_priv_t *priv; 
    150151    char *psz_env = NULL; 
    151152 
    …… 
    168169 
    169170    /* Allocate a libvlc instance object */ 
    170     p_libvlc = vlc_object_create( p_libvlc_global, VLC_OBJECT_LIBVLC ); 
     171    p_libvlc = vlc_custom_create( VLC_OBJECT(p_libvlc_global), 
     172                                  sizeof (*p_libvlc) + sizeof (libvlc_priv_t), 
     173                                  VLC_OBJECT_LIBVLC, "libvlc" ); 
    171174    if( p_libvlc != NULL ) 
    172175        i_instances++; 
    …… 
    180183    p_libvlc->p_vlm = NULL; 
    181184    p_libvlc->psz_object_name = strdup( "libvlc" ); 
     185    priv = libvlc_priv (p_libvlc); 
    182186 
    183187    /* Initialize message queue */ 
    …… 
    201205 
    202206    /* Initialize mutexes */ 
    203     vlc_mutex_init( &p_libvlc->timer_lock ); 
    204     vlc_mutex_init( &p_libvlc->config_lock ); 
     207    vlc_mutex_init( &priv->timer_lock ); 
     208    vlc_mutex_init( &priv->config_lock ); 
    205209#ifdef __APPLE__ 
    206210    vlc_thread_set_priority( p_libvlc, VLC_THREAD_PRIORITY_LOW ); 
    …… 
    224228{ 
    225229    libvlc_global_data_t *p_libvlc_global = vlc_global(); 
     230    libvlc_priv_t *priv = libvlc_priv (p_libvlc); 
    226231    char         p_capabilities[200]; 
    227232    char *       p_tmp = NULL; 
    …… 
    706711    p_libvlc->p_memcpy_module = module_Need( p_libvlc, "memcpy", "$memcpy", 0 ); 
    707712 
    708     p_libvlc->b_stats = config_GetInt( p_libvlc, "stats" ) > 0; 
    709     p_libvlc->i_timers = 0; 
    710     p_libvlc->pp_timers = NULL; 
     713    priv->b_stats = config_GetInt( p_libvlc, "stats" ) > 0; 
     714    priv->i_timers = 0; 
     715    priv->pp_timers = NULL; 
    711716 
    712717    /* Init stats */ 
    …… 
    10311036        return VLC_EGENERIC; 
    10321037 
     1038    libvlc_priv_t *priv = libvlc_priv (p_libvlc); 
     1039 
    10331040#ifndef WIN32 
    10341041    char* psz_pidfile = NULL; 
    …… 
    10821089 
    10831090    /* Destroy mutexes */ 
    1084     vlc_mutex_destroy( &p_libvlc->config_lock ); 
    1085     vlc_mutex_destroy( &p_libvlc->timer_lock ); 
     1091    vlc_mutex_destroy( &priv->config_lock ); 
     1092    vlc_mutex_destroy( &priv->timer_lock ); 
    10861093 
    10871094    if( b_release ) vlc_object_release( p_libvlc ); 

  • src/libvlc.h

    raebd6a4 r9df2848  
    131131libvlc_int_t *vlc_current_object (int i_object); 
    132132 
    133 /* Private LibVLC data for each objects */ 
     133/** 
     134 * Private LibVLC data for each object. 
     135 */ 
    134136struct vlc_object_internals_t 
    135137{ 
    …… 
    164166} 
    165167 
     168/** 
     169 * Private LibVLC instance data. 
     170 */ 
     171typedef struct libvlc_priv_t 
     172{ 
     173    vlc_mutex_t        config_lock; ///< config file lock 
     174 
     175    vlc_mutex_t        timer_lock;  ///< Lock to protect timers 
     176    counter_t        **pp_timers;   ///< Array of all timers 
     177    int                i_timers;    ///< Number of timers 
     178    bool               b_stats;     ///< Whether to collect stats 
     179} libvlc_priv_t; 
     180 
     181static inline libvlc_priv_t *libvlc_priv (libvlc_int_t *libvlc) 
     182{ 
     183    return (libvlc_priv_t *)(libvlc + 1); 
     184} 
     185 
     186static inline bool libvlc_stats (vlc_object_t *obj) 
     187{ 
     188   return libvlc_priv (obj->p_libvlc)->b_stats; 
     189} 
     190 
     191/** 
     192 * LibVLC "main module" configuration settings array. 
     193 */ 
    166194extern module_config_t libvlc_config[]; 
    167195extern const size_t libvlc_config_count; 

  • src/misc/stats.c

    r6da90a1 r9df2848  
    8686                    vlc_value_t val, vlc_value_t *val_new ) 
    8787{ 
    88     if( !p_this->p_libvlc->b_stats || !p_counter ) return VLC_EGENERIC; 
     88    if( !libvlc_stats (p_this) || !p_counter ) return VLC_EGENERIC; 
    8989    return CounterUpdate( p_this, p_counter, val, val_new ); 
    9090} 
    …… 
    9999int __stats_Get( vlc_object_t *p_this, counter_t *p_counter, vlc_value_t *val ) 
    100100{ 
    101     if( !p_this->p_libvlc->b_stats || !p_counter || p_counter->i_samples == 0 ) 
     101    if( !libvlc_stats (p_this) || !p_counter || p_counter->i_samples == 0 ) 
    102102    { 
    103103        val->i_int = val->f_float = 0.0; 
    …… 
    158158void stats_ComputeInputStats( input_thread_t *p_input, input_stats_t *p_stats ) 
    159159{ 
    160     if( !p_input->p_libvlc->b_stats ) return; 
     160    if( !libvlc_stats (p_input) ) return; 
    161161 
    162162    vlc_mutex_lock( &p_input->p->counters.counters_lock ); 
    …… 
    246246    int i_index; 
    247247 
    248     if( !p_obj->p_libvlc->b_stats ) return; 
     248    if( !libvlc_stats (p_obj) ) return; 
    249249 
    250250    vlc_mutex_lock( &p_stats->lock ); 
    …… 
    281281                         unsigned int i_id ) 
    282282{ 
    283     int i; 
     283    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc); 
    284284    counter_t *p_counter = NULL; 
    285     if( !p_obj->p_libvlc->b_stats ) return; 
    286     vlc_mutex_lock( &p_obj->p_libvlc->timer_lock ); 
    287  
    288     for( i = 0 ; i < p_obj->p_libvlc->i_timers; i++ ) 
    289     { 
    290         if( p_obj->p_libvlc->pp_timers[i]->i_id == i_id 
    291             && p_obj->p_libvlc->pp_timers[i]->p_obj == p_obj ) 
    292         { 
    293             p_counter = p_obj->p_libvlc->pp_timers[i]; 
     285 
     286    if( !priv->b_stats ) return; 
     287 
     288    vlc_mutex_lock( &priv->timer_lock ); 
     289 
     290    for( int i = 0 ; i < priv->i_timers; i++ ) 
     291    { 
     292        if( priv->pp_timers[i]->i_id == i_id 
     293            && priv->pp_timers[i]->p_obj == p_obj ) 
     294        { 
     295            p_counter = priv->pp_timers[i]; 
    294296            break; 
    295297        } 
    …… 
    301303                                         STATS_TIMER ); 
    302304        if( !p_counter ) 
    303         { 
    304             vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
    305             return; 
    306         } 
     305            goto out; 
    307306        p_counter->psz_name = strdup( psz_name ); 
    308307        p_counter->i_id = i_id; 
    309308        p_counter->p_obj = p_obj; 
    310         INSERT_ELEM( p_obj->p_libvlc->pp_timers, p_obj->p_libvlc->i_timers, 
    311                      p_obj->p_libvlc->i_timers, p_counter ); 
     309        INSERT_ELEM( priv->pp_timers, priv->i_timers, 
     310                     priv->i_timers, p_counter ); 
    312311 
    313312        /* 1st sample : if started: start_date, else last_time, b_started */ 
    …… 
    325324    { 
    326325        msg_Warn( p_obj, "timer '%s' was already started !", psz_name ); 
    327         vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
    328         return; 
     326        goto out; 
    329327    } 
    330328    p_counter->pp_samples[0]->value.b_bool = true; 
    331329    p_counter->pp_samples[0]->date = mdate(); 
    332     vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
     330out: 
     331    vlc_mutex_unlock( &priv->timer_lock ); 
    333332} 
    334333 
    …… 
    336335{ 
    337336    counter_t *p_counter = NULL; 
    338     int i; 
    339     if( !p_obj->p_libvlc->b_stats ) return; 
    340     vlc_mutex_lock( &p_obj->p_libvlc->timer_lock ); 
    341     for( i = 0 ; i < p_obj->p_libvlc->i_timers; i++ ) 
    342     { 
    343         if( p_obj->p_libvlc->pp_timers[i]->i_id == i_id 
    344             && p_obj->p_libvlc->pp_timers[i]->p_obj == p_obj ) 
    345         { 
    346             p_counter = p_obj->p_libvlc->pp_timers[i]; 
     337    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc); 
     338 
     339    if( !priv->b_stats ) return; 
     340    vlc_mutex_lock( &priv->timer_lock ); 
     341    for( int i = 0 ; i < priv->i_timers; i++ ) 
     342    { 
     343        if( priv->pp_timers[i]->i_id == i_id 
     344            && priv->pp_timers[i]->p_obj == p_obj ) 
     345        { 
     346            p_counter = priv->pp_timers[i]; 
    347347            break; 
    348348        } 
    …… 
    351351    { 
    352352        msg_Err( p_obj, "timer does not exist" ); 
    353         vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
    354         return; 
     353        goto out; 
    355354    } 
    356355    p_counter->pp_samples[0]->value.b_bool = false; 
    …… 
    358357    p_counter->pp_samples[0]->date = mdate() - p_counter->pp_samples[0]->date; 
    359358    p_counter->pp_samples[1]->date += p_counter->pp_samples[0]->date; 
    360     vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
     359out: 
     360    vlc_mutex_unlock( &priv->timer_lock ); 
    361361} 
    362362 
    …… 
    364364{ 
    365365    counter_t *p_counter = NULL; 
    366     int i; 
    367     if( !p_obj->p_libvlc->b_stats ) return; 
    368     vlc_mutex_lock( &p_obj->p_libvlc->timer_lock ); 
    369     for( i = 0 ; i < p_obj->p_libvlc->i_timers; i++ ) 
    370     { 
    371         if( p_obj->p_libvlc->pp_timers[i]->i_id == i_id 
    372             && p_obj->p_libvlc->pp_timers[i]->p_obj == p_obj ) 
    373         { 
    374             p_counter = p_obj->p_libvlc->pp_timers[i]; 
     366    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc); 
     367 
     368    if( !priv->b_stats ) return; 
     369    vlc_mutex_lock( &priv->timer_lock ); 
     370    for( int i = 0 ; i < priv->i_timers; i++ ) 
     371    { 
     372        if( priv->pp_timers[i]->i_id == i_id 
     373            && priv->pp_timers[i]->p_obj == p_obj ) 
     374        { 
     375            p_counter = priv->pp_timers[i]; 
    375376            break; 
    376377        } 
    377378    } 
    378379    TimerDump( p_obj, p_counter, true ); 
    379     vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
     380    vlc_mutex_unlock( &priv->timer_lock ); 
    380381} 
    381382 
    382383void __stats_TimersDumpAll( vlc_object_t *p_obj ) 
    383384{ 
    384     int i; 
    385     if( !p_obj->p_libvlc->b_stats ) return; 
    386     vlc_mutex_lock( &p_obj->p_libvlc->timer_lock ); 
    387     for ( i = 0 ; i< p_obj->p_libvlc->i_timers ; i++ ) 
    388         TimerDump( p_obj, p_obj->p_libvlc->pp_timers[i], false ); 
    389     vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
     385    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc); 
     386 
     387    if( !priv->b_stats ) return; 
     388    vlc_mutex_lock( &priv->timer_lock ); 
     389    for ( int i = 0 ; i < priv->i_timers ; i++ ) 
     390        TimerDump( p_obj, priv->pp_timers[i], false ); 
     391    vlc_mutex_unlock( &priv->timer_lock ); 
    390392} 
    391393 
    392394void __stats_TimerClean( vlc_object_t *p_obj, unsigned int i_id ) 
    393395{ 
    394     int i; 
    395     vlc_mutex_lock( &p_obj->p_libvlc->timer_lock ); 
    396     for ( i = p_obj->p_libvlc->i_timers -1 ; i >= 0; i-- ) 
    397     { 
    398         counter_t *p_counter = p_obj->p_libvlc->pp_timers[i]; 
     396    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc); 
     397 
     398    vlc_mutex_lock( &priv->timer_lock ); 
     399    for ( int i = priv->i_timers -1 ; i >= 0; i-- ) 
     400    { 
     401        counter_t *p_counter = priv->pp_timers[i]; 
    399402        if( p_counter->i_id == i_id && p_counter->p_obj == p_obj ) 
    400403        { 
    401             REMOVE_ELEM( p_obj->p_libvlc->pp_timers, 
    402                          p_obj->p_libvlc->i_timers, i ); 
     404            REMOVE_ELEM( priv->pp_timers, priv->i_timers, i ); 
    403405            stats_CounterClean( p_counter ); 
    404406        } 
    405407    } 
    406     vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
     408    vlc_mutex_unlock( &priv->timer_lock ); 
    407409} 
    408410 
    409411void __stats_TimersCleanAll( vlc_object_t *p_obj ) 
    410412{ 
    411     int i; 
    412     vlc_mutex_lock( &p_obj->p_libvlc->timer_lock ); 
    413     for ( i = p_obj->p_libvlc->i_timers -1 ; i >= 0; i-- ) 
    414     { 
    415         counter_t *p_counter = p_obj->p_libvlc->pp_timers[i]; 
    416         REMOVE_ELEM( p_obj->p_libvlc->pp_timers, p_obj->p_libvlc->i_timers, i ); 
     413    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc); 
     414 
     415    vlc_mutex_lock( &priv->timer_lock ); 
     416    for ( int i = priv->i_timers -1 ; i >= 0; i-- ) 
     417    { 
     418        counter_t *p_counter = priv->pp_timers[i]; 
     419        REMOVE_ELEM( priv->pp_timers, priv->i_timers, i ); 
    417420        stats_CounterClean( p_counter ); 
    418421    } 
    419     vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock ); 
     422    vlc_mutex_unlock( &priv->timer_lock ); 
    420423} 
    421424 
    422425void stats_CounterClean( counter_t *p_c ) 
    423426{ 
    424     int i; 
    425427    if( p_c ) 
    426428    { 
    427         i = p_c->i_samples - 1 ; 
     429        int i = p_c->i_samples - 1 ; 
    428430        while( i >= 0 ) 
    429431        { 

  • src/stream_output/stream_output.c

    rab95c5f r9df2848  
    161161                    really fast ... */ 
    162162 
    163     if( !p_sout->p_libvlc->b_stats ) 
     163    if( !libvlc_stats (p_sout) ) 
    164164        return; 
    165165