module_t * p_memcpy_module; ///< Fast memcpy plugin used
- bool b_stats; ///< Should we collect stats ?
- vlc_mutex_t timer_lock; ///< Lock to protect timers
- int i_timers; ///< Number of timers
- counter_t **pp_timers; ///< Array of all timers
-
- vlc_mutex_t config_lock; ///< Lock for the config file
-
/* Structure storing the action name / key associations */
struct hotkey
{
*****************************************************************************/
void __config_ResetAll( vlc_object_t *p_this )
{
+ libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc);
int i_index;
vlc_list_t *p_list;
module_t *p_module;
/* Acquire config file lock */
- vlc_mutex_lock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_lock( &priv->config_lock );
p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
}
vlc_list_release( p_list );
- vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_unlock( &priv->config_lock );
}
/**
*****************************************************************************/
int __config_LoadConfigFile( vlc_object_t *p_this, const char *psz_module_name )
{
+ libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc);
vlc_list_t *p_list;
FILE *file;
return VLC_EGENERIC;
/* Acquire config file lock */
- vlc_mutex_lock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_lock( &priv->config_lock );
/* Look for the selected module, if NULL then save everything */
p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
vlc_list_release( p_list );
- vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_unlock( &priv->config_lock );
return 0;
}
static int SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name,
bool b_autosave )
{
+ libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc);
module_t *p_parser;
vlc_list_t *p_list;
FILE *file;
int i_index;
/* Acquire config file lock */
- vlc_mutex_lock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_lock( &priv->config_lock );
if( p_this->p_libvlc->psz_configfile == NULL )
{
if( !psz_configdir ) /* XXX: This should never happen */
{
msg_Err( p_this, "no configuration directory defined" );
- vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_unlock( &priv->config_lock );
return -1;
}
if( !p_bigbuffer )
{
if( file ) fclose( file );
- vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_unlock( &priv->config_lock );
return -1;
}
p_bigbuffer[0] = 0;
{
vlc_list_release( p_list );
free( p_bigbuffer );
- vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_unlock( &priv->config_lock );
return -1;
}
free( p_bigbuffer );
fclose( file );
- vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_unlock( &priv->config_lock );
return 0;
}
int config_AutoSaveConfigFile( vlc_object_t *p_this )
{
+ libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc);
vlc_list_t *p_list;
int i_index, i_count;
assert( p_this );
/* Check if there's anything to save */
- vlc_mutex_lock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_lock( &priv->config_lock );
p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
i_count = p_list->i_count;
for( i_index = 0; i_index < i_count; i_index++ )
if( p_item < p_end ) break;
}
vlc_list_release( p_list );
- vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+ vlc_mutex_unlock( &priv->config_lock );
if( i_index == i_count ) return VLC_SUCCESS;
return SaveConfigFile( p_this, 0, true );
else
i_delay = 0;
- if( p_input->p_libvlc->b_stats )
+ if( libvlc_stats (p_input) )
{
vlc_mutex_lock( &p_input->p->counters.counters_lock );
stats_UpdateInteger( p_input, p_input->p->counters.p_demux_read,
/* Prepare statistics */
#define INIT_COUNTER( c, type, compute ) p_input->p->counters.p_##c = \
stats_CounterCreate( p_input, VLC_VAR_##type, STATS_##compute);
- if( p_input->p_libvlc->b_stats )
+ if( libvlc_stats (p_input) )
{
INIT_COUNTER( read_bytes, INTEGER, COUNTER );
INIT_COUNTER( read_packets, INTEGER, COUNTER );
return VLC_EGENERIC;
}
}
- if( p_input->p_libvlc->b_stats )
+ if( libvlc_stats (p_input) )
{
INIT_COUNTER( sout_sent_packets, INTEGER, COUNTER );
INIT_COUNTER (sout_sent_bytes, INTEGER, COUNTER );
}
#endif
- if( !p_input->b_preparsing && p_input->p_libvlc->b_stats )
+ if( !p_input->b_preparsing && libvlc_stats (p_input) )
{
#define EXIT_COUNTER( c ) do { if( p_input->p->counters.p_##c ) \
stats_CounterClean( p_input->p->counters.p_##c );\
if( !p_input->b_preparsing )
{
#define CL_CO( c ) stats_CounterClean( p_input->p->counters.p_##c ); p_input->p->counters.p_##c = NULL;
- if( p_input->p_libvlc->b_stats )
+ if( libvlc_stats (p_input) )
{
/* make sure we are up to date */
stats_ComputeInputStats( p_input, p_input->p->input.p_item->p_stats );
{
p_block = p_access->pf_block( p_access );
if( pb_eof ) *pb_eof = p_access->info.b_eof;
- if( p_input && p_block && p_access->p_libvlc->b_stats )
+ if( p_input && p_block && libvlc_stats (p_access) )
{
vlc_mutex_lock( &p_input->p->counters.counters_lock );
stats_UpdateInteger( s, p_input->p->counters.p_read_bytes,
*/
libvlc_int_t * libvlc_InternalCreate( void )
{
- libvlc_int_t * p_libvlc = NULL;
+ libvlc_int_t *p_libvlc;
+ libvlc_priv_t *priv;
char *psz_env = NULL;
/* vlc_threads_init *must* be the first internal call! No other call is
}
/* Allocate a libvlc instance object */
- p_libvlc = vlc_object_create( p_libvlc_global, VLC_OBJECT_LIBVLC );
+ p_libvlc = vlc_custom_create( VLC_OBJECT(p_libvlc_global),
+ sizeof (*p_libvlc) + sizeof (libvlc_priv_t),
+ VLC_OBJECT_LIBVLC, "libvlc" );
if( p_libvlc != NULL )
i_instances++;
vlc_mutex_unlock( lock );
p_libvlc->p_interaction = NULL;
p_libvlc->p_vlm = NULL;
p_libvlc->psz_object_name = strdup( "libvlc" );
+ priv = libvlc_priv (p_libvlc);
/* Initialize message queue */
msg_Create( p_libvlc );
msg_Dbg( p_libvlc, "libvlc was configured with %s", CONFIGURE_LINE );
/* Initialize mutexes */
- vlc_mutex_init( &p_libvlc->timer_lock );
- vlc_mutex_init( &p_libvlc->config_lock );
+ vlc_mutex_init( &priv->timer_lock );
+ vlc_mutex_init( &priv->config_lock );
#ifdef __APPLE__
vlc_thread_set_priority( p_libvlc, VLC_THREAD_PRIORITY_LOW );
#endif
const char *ppsz_argv[] )
{
libvlc_global_data_t *p_libvlc_global = vlc_global();
+ libvlc_priv_t *priv = libvlc_priv (p_libvlc);
char p_capabilities[200];
char * p_tmp = NULL;
char * psz_modules = NULL;
*/
p_libvlc->p_memcpy_module = module_Need( p_libvlc, "memcpy", "$memcpy", 0 );
- p_libvlc->b_stats = config_GetInt( p_libvlc, "stats" ) > 0;
- p_libvlc->i_timers = 0;
- p_libvlc->pp_timers = NULL;
+ priv->b_stats = config_GetInt( p_libvlc, "stats" ) > 0;
+ priv->i_timers = 0;
+ priv->pp_timers = NULL;
/* Init stats */
p_libvlc->p_stats = (global_stats_t *)malloc( sizeof( global_stats_t ) );
if( !p_libvlc )
return VLC_EGENERIC;
+ libvlc_priv_t *priv = libvlc_priv (p_libvlc);
+
#ifndef WIN32
char* psz_pidfile = NULL;
msg_Destroy( p_libvlc );
/* Destroy mutexes */
- vlc_mutex_destroy( &p_libvlc->config_lock );
- vlc_mutex_destroy( &p_libvlc->timer_lock );
+ vlc_mutex_destroy( &priv->config_lock );
+ vlc_mutex_destroy( &priv->timer_lock );
if( b_release ) vlc_object_release( p_libvlc );
vlc_object_release( p_libvlc );
libvlc_global_data_t *vlc_global (void);
libvlc_int_t *vlc_current_object (int i_object);
-/* Private LibVLC data for each objects */
+/**
+ * Private LibVLC data for each object.
+ */
struct vlc_object_internals_t
{
/* Object variables */
return ((vlc_object_internals_t *)obj) - 1;
}
+/**
+ * Private LibVLC instance data.
+ */
+typedef struct libvlc_priv_t
+{
+ vlc_mutex_t config_lock; ///< config file lock
+
+ vlc_mutex_t timer_lock; ///< Lock to protect timers
+ counter_t **pp_timers; ///< Array of all timers
+ int i_timers; ///< Number of timers
+ bool b_stats; ///< Whether to collect stats
+} libvlc_priv_t;
+
+static inline libvlc_priv_t *libvlc_priv (libvlc_int_t *libvlc)
+{
+ return (libvlc_priv_t *)(libvlc + 1);
+}
+
+static inline bool libvlc_stats (vlc_object_t *obj)
+{
+ return libvlc_priv (obj->p_libvlc)->b_stats;
+}
+
+/**
+ * LibVLC "main module" configuration settings array.
+ */
extern module_config_t libvlc_config[];
extern const size_t libvlc_config_count;
int __stats_Update( vlc_object_t *p_this, counter_t *p_counter,
vlc_value_t val, vlc_value_t *val_new )
{
- if( !p_this->p_libvlc->b_stats || !p_counter ) return VLC_EGENERIC;
+ if( !libvlc_stats (p_this) || !p_counter ) return VLC_EGENERIC;
return CounterUpdate( p_this, p_counter, val, val_new );
}
*/
int __stats_Get( vlc_object_t *p_this, counter_t *p_counter, vlc_value_t *val )
{
- if( !p_this->p_libvlc->b_stats || !p_counter || p_counter->i_samples == 0 )
+ if( !libvlc_stats (p_this) || !p_counter || p_counter->i_samples == 0 )
{
val->i_int = val->f_float = 0.0;
return VLC_EGENERIC;
void stats_ComputeInputStats( input_thread_t *p_input, input_stats_t *p_stats )
{
- if( !p_input->p_libvlc->b_stats ) return;
+ if( !libvlc_stats (p_input) ) return;
vlc_mutex_lock( &p_input->p->counters.counters_lock );
vlc_mutex_lock( &p_stats->lock );
vlc_list_t *p_list;
int i_index;
- if( !p_obj->p_libvlc->b_stats ) return;
+ if( !libvlc_stats (p_obj) ) return;
vlc_mutex_lock( &p_stats->lock );
void __stats_TimerStart( vlc_object_t *p_obj, const char *psz_name,
unsigned int i_id )
{
- int i;
+ libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
counter_t *p_counter = NULL;
- if( !p_obj->p_libvlc->b_stats ) return;
- vlc_mutex_lock( &p_obj->p_libvlc->timer_lock );
- for( i = 0 ; i < p_obj->p_libvlc->i_timers; i++ )
+ if( !priv->b_stats ) return;
+
+ vlc_mutex_lock( &priv->timer_lock );
+
+ for( int i = 0 ; i < priv->i_timers; i++ )
{
- if( p_obj->p_libvlc->pp_timers[i]->i_id == i_id
- && p_obj->p_libvlc->pp_timers[i]->p_obj == p_obj )
+ if( priv->pp_timers[i]->i_id == i_id
+ && priv->pp_timers[i]->p_obj == p_obj )
{
- p_counter = p_obj->p_libvlc->pp_timers[i];
+ p_counter = priv->pp_timers[i];
break;
}
}
p_counter = stats_CounterCreate( p_obj->p_libvlc, VLC_VAR_TIME,
STATS_TIMER );
if( !p_counter )
- {
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
- return;
- }
+ goto out;
p_counter->psz_name = strdup( psz_name );
p_counter->i_id = i_id;
p_counter->p_obj = p_obj;
- INSERT_ELEM( p_obj->p_libvlc->pp_timers, p_obj->p_libvlc->i_timers,
- p_obj->p_libvlc->i_timers, p_counter );
+ INSERT_ELEM( priv->pp_timers, priv->i_timers,
+ priv->i_timers, p_counter );
/* 1st sample : if started: start_date, else last_time, b_started */
p_sample = (counter_sample_t *)malloc( sizeof( counter_sample_t ) );
if( p_counter->pp_samples[0]->value.b_bool == true )
{
msg_Warn( p_obj, "timer '%s' was already started !", psz_name );
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
- return;
+ goto out;
}
p_counter->pp_samples[0]->value.b_bool = true;
p_counter->pp_samples[0]->date = mdate();
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
+out:
+ vlc_mutex_unlock( &priv->timer_lock );
}
void __stats_TimerStop( vlc_object_t *p_obj, unsigned int i_id )
{
counter_t *p_counter = NULL;
- int i;
- if( !p_obj->p_libvlc->b_stats ) return;
- vlc_mutex_lock( &p_obj->p_libvlc->timer_lock );
- for( i = 0 ; i < p_obj->p_libvlc->i_timers; i++ )
+ libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
+
+ if( !priv->b_stats ) return;
+ vlc_mutex_lock( &priv->timer_lock );
+ for( int i = 0 ; i < priv->i_timers; i++ )
{
- if( p_obj->p_libvlc->pp_timers[i]->i_id == i_id
- && p_obj->p_libvlc->pp_timers[i]->p_obj == p_obj )
+ if( priv->pp_timers[i]->i_id == i_id
+ && priv->pp_timers[i]->p_obj == p_obj )
{
- p_counter = p_obj->p_libvlc->pp_timers[i];
+ p_counter = priv->pp_timers[i];
break;
}
}
if( !p_counter || p_counter->i_samples != 2 )
{
msg_Err( p_obj, "timer does not exist" );
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
- return;
+ goto out;
}
p_counter->pp_samples[0]->value.b_bool = false;
p_counter->pp_samples[1]->value.i_int += 1;
p_counter->pp_samples[0]->date = mdate() - p_counter->pp_samples[0]->date;
p_counter->pp_samples[1]->date += p_counter->pp_samples[0]->date;
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
+out:
+ vlc_mutex_unlock( &priv->timer_lock );
}
void __stats_TimerDump( vlc_object_t *p_obj, unsigned int i_id )
{
counter_t *p_counter = NULL;
- int i;
- if( !p_obj->p_libvlc->b_stats ) return;
- vlc_mutex_lock( &p_obj->p_libvlc->timer_lock );
- for( i = 0 ; i < p_obj->p_libvlc->i_timers; i++ )
+ libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
+
+ if( !priv->b_stats ) return;
+ vlc_mutex_lock( &priv->timer_lock );
+ for( int i = 0 ; i < priv->i_timers; i++ )
{
- if( p_obj->p_libvlc->pp_timers[i]->i_id == i_id
- && p_obj->p_libvlc->pp_timers[i]->p_obj == p_obj )
+ if( priv->pp_timers[i]->i_id == i_id
+ && priv->pp_timers[i]->p_obj == p_obj )
{
- p_counter = p_obj->p_libvlc->pp_timers[i];
+ p_counter = priv->pp_timers[i];
break;
}
}
TimerDump( p_obj, p_counter, true );
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
+ vlc_mutex_unlock( &priv->timer_lock );
}
void __stats_TimersDumpAll( vlc_object_t *p_obj )
{
- int i;
- if( !p_obj->p_libvlc->b_stats ) return;
- vlc_mutex_lock( &p_obj->p_libvlc->timer_lock );
- for ( i = 0 ; i< p_obj->p_libvlc->i_timers ; i++ )
- TimerDump( p_obj, p_obj->p_libvlc->pp_timers[i], false );
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
+ libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
+
+ if( !priv->b_stats ) return;
+ vlc_mutex_lock( &priv->timer_lock );
+ for ( int i = 0 ; i < priv->i_timers ; i++ )
+ TimerDump( p_obj, priv->pp_timers[i], false );
+ vlc_mutex_unlock( &priv->timer_lock );
}
void __stats_TimerClean( vlc_object_t *p_obj, unsigned int i_id )
{
- int i;
- vlc_mutex_lock( &p_obj->p_libvlc->timer_lock );
- for ( i = p_obj->p_libvlc->i_timers -1 ; i >= 0; i-- )
+ libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
+
+ vlc_mutex_lock( &priv->timer_lock );
+ for ( int i = priv->i_timers -1 ; i >= 0; i-- )
{
- counter_t *p_counter = p_obj->p_libvlc->pp_timers[i];
+ counter_t *p_counter = priv->pp_timers[i];
if( p_counter->i_id == i_id && p_counter->p_obj == p_obj )
{
- REMOVE_ELEM( p_obj->p_libvlc->pp_timers,
- p_obj->p_libvlc->i_timers, i );
+ REMOVE_ELEM( priv->pp_timers, priv->i_timers, i );
stats_CounterClean( p_counter );
}
}
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
+ vlc_mutex_unlock( &priv->timer_lock );
}
void __stats_TimersCleanAll( vlc_object_t *p_obj )
{
- int i;
- vlc_mutex_lock( &p_obj->p_libvlc->timer_lock );
- for ( i = p_obj->p_libvlc->i_timers -1 ; i >= 0; i-- )
+ libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
+
+ vlc_mutex_lock( &priv->timer_lock );
+ for ( int i = priv->i_timers -1 ; i >= 0; i-- )
{
- counter_t *p_counter = p_obj->p_libvlc->pp_timers[i];
- REMOVE_ELEM( p_obj->p_libvlc->pp_timers, p_obj->p_libvlc->i_timers, i );
+ counter_t *p_counter = priv->pp_timers[i];
+ REMOVE_ELEM( priv->pp_timers, priv->i_timers, i );
stats_CounterClean( p_counter );
}
- vlc_mutex_unlock( &p_obj->p_libvlc->timer_lock );
+ vlc_mutex_unlock( &priv->timer_lock );
}
void stats_CounterClean( counter_t *p_c )
{
- int i;
if( p_c )
{
- i = p_c->i_samples - 1 ;
+ int i = p_c->i_samples - 1 ;
while( i >= 0 )
{
counter_sample_t *p_s = p_c->pp_samples[i];
int i_bytes; /* That's pretty stupid to define it as an integer, it will overflow
really fast ... */
- if( !p_sout->p_libvlc->b_stats )
+ if( !libvlc_stats (p_sout) )
return;
/* FIXME that's ugly