X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fstats.c;h=8a360c4fb046560a04d60cd21fd8db7015999f24;hb=5cc597e79abc2d8acf36ffee70860ee512e9ac19;hp=7e967f9437497959a7b7a111965d4dde76a43283;hpb=d52644844b16b544109bc95add4e0b213c01d909;p=vlc

diff --git a/src/misc/stats.c b/src/misc/stats.c
index 7e967f9437..8a360c4fb0 100644
--- a/src/misc/stats.c
+++ b/src/misc/stats.c
@@ -29,7 +29,7 @@
 # include "config.h"
 #endif
 
-#include <vlc/vlc.h>
+#include <vlc_common.h>
 #include <stdio.h>                                               /* required */
 
 #include "input/input_internal.h"
@@ -46,6 +46,7 @@ static void TimerDump( vlc_object_t *p_this, counter_t *p_counter, bool);
  * Exported functions
  *****************************************************************************/
 
+#undef stats_CounterCreate
 /**
  * Create a statistics counter
  * \param p_this a VLC object
@@ -56,7 +57,7 @@ static void TimerDump( vlc_object_t *p_this, counter_t *p_counter, bool);
  * STATS_MAX (keep the maximum passed value), STATS_MIN, or STATS_DERIVATIVE
  * (keep a time derivative of the value)
  */
-counter_t * __stats_CounterCreate( vlc_object_t *p_this,
+counter_t * stats_CounterCreate( vlc_object_t *p_this,
                                    int i_type, int i_compute_type )
 {
     counter_t *p_counter = (counter_t*) malloc( sizeof( counter_t ) ) ;
@@ -79,16 +80,17 @@ counter_t * __stats_CounterCreate( vlc_object_t *p_this,
  * \param p_this a VLC object
  * \param p_counter the counter to update
  * \param val the vlc_value union containing the new value to aggregate. For
- * more information on how data is aggregated, \see __stats_Create
+ * more information on how data is aggregated, \see stats_Create
  * \param val_new a pointer that will be filled with new data
  */
-int __stats_Update( vlc_object_t *p_this, counter_t *p_counter,
-                    vlc_value_t val, vlc_value_t *val_new )
+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 );
 }
 
+#undef stats_Get
 /** Get the aggregated value for a counter
  * \param p_this an object
  * \param p_counter the counter
@@ -96,9 +98,9 @@ int __stats_Update( vlc_object_t *p_this, counter_t *p_counter,
  * retrieved value
  * \return an error code
  */
-int __stats_Get( vlc_object_t *p_this, counter_t *p_counter, vlc_value_t *val )
+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;
@@ -143,13 +145,11 @@ int __stats_Get( vlc_object_t *p_this, counter_t *p_counter, vlc_value_t *val )
 input_stats_t *stats_NewInputStats( input_thread_t *p_input )
 {
     (void)p_input;
-    input_stats_t *p_stats = malloc( sizeof(input_stats_t) );
-
+    input_stats_t *p_stats = calloc( 1, sizeof(input_stats_t) );
     if( !p_stats )
         return NULL;
 
-    memset( p_stats, 0, sizeof(*p_stats) );
-    vlc_mutex_init( p_input, &p_stats->lock );
+    vlc_mutex_init( &p_stats->lock );
     stats_ReinitInputStats( p_stats );
 
     return p_stats;
@@ -157,7 +157,7 @@ input_stats_t *stats_NewInputStats( input_thread_t *p_input )
 
 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 );
@@ -173,6 +173,10 @@ void stats_ComputeInputStats( input_thread_t *p_input, input_stats_t *p_stats )
                       &p_stats->i_demux_read_bytes );
     stats_GetFloat( p_input, p_input->p->counters.p_demux_bitrate,
                     &p_stats->f_demux_bitrate );
+    stats_GetInteger( p_input, p_input->p->counters.p_demux_corrupted,
+                      &p_stats->i_demux_corrupted );
+    stats_GetInteger( p_input, p_input->p->counters.p_demux_discontinuity,
+                      &p_stats->i_demux_discontinuity );
 
     /* Decoders */
     stats_GetInteger( p_input, p_input->p->counters.p_decoded_video,
@@ -214,6 +218,7 @@ void stats_ReinitInputStats( input_stats_t *p_stats )
     p_stats->f_input_bitrate = p_stats->f_average_input_bitrate =
     p_stats->i_demux_read_packets = p_stats->i_demux_read_bytes =
     p_stats->f_demux_bitrate = p_stats->f_average_demux_bitrate =
+    p_stats->i_demux_corrupted = p_stats->i_demux_discontinuity =
     p_stats->i_displayed_pictures = p_stats->i_lost_pictures =
     p_stats->i_played_abuffers = p_stats->i_lost_abuffers =
     p_stats->i_decoded_video = p_stats->i_decoded_audio =
@@ -240,75 +245,38 @@ void stats_DumpInputStats( input_stats_t *p_stats  )
     vlc_mutex_unlock( &p_stats->lock );
 }
 
-void __stats_ComputeGlobalStats( vlc_object_t *p_obj, global_stats_t *p_stats )
+#undef stats_TimerStart
+void stats_TimerStart( vlc_object_t *p_obj, const char *psz_name,
+                       unsigned int i_id )
 {
-    vlc_list_t *p_list;
-    int i_index;
-
-    if( !p_obj->p_libvlc->b_stats ) return;
-
-    vlc_mutex_lock( &p_stats->lock );
-
-    p_list = vlc_list_find( p_obj, VLC_OBJECT_INPUT, FIND_ANYWHERE );
-    if( p_list )
-    {
-        float f_total_in = 0, f_total_out = 0,f_total_demux = 0;
-        for( i_index = 0; i_index < p_list->i_count ; i_index ++ )
-        {
-            float f_in = 0, f_out = 0, f_demux = 0;
-            input_thread_t *p_input = (input_thread_t *)
-                             p_list->p_values[i_index].p_object;
-            vlc_mutex_lock( &p_input->p->counters.counters_lock );
-            stats_GetFloat( p_obj, p_input->p->counters.p_input_bitrate, &f_in );
-            if( p_input->p->counters.p_sout_send_bitrate )
-                stats_GetFloat( p_obj, p_input->p->counters.p_sout_send_bitrate,
-                                    &f_out );
-            stats_GetFloat( p_obj, p_input->p->counters.p_demux_bitrate,
-                                &f_demux );
-            vlc_mutex_unlock( &p_input->p->counters.counters_lock );
-            f_total_in += f_in; f_total_out += f_out;f_total_demux += f_demux;
-        }
-        p_stats->f_input_bitrate = f_total_in;
-        p_stats->f_output_bitrate = f_total_out;
-        p_stats->f_demux_bitrate = f_total_demux;
-        vlc_list_release( p_list );
-    }
+    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
+    counter_t *p_counter = NULL;
 
-    vlc_mutex_unlock( &p_stats->lock );
-}
+    if( !priv->b_stats ) return;
 
-void __stats_TimerStart( vlc_object_t *p_obj, const char *psz_name,
-                         unsigned int i_id )
-{
-    int i;
-    counter_t *p_counter = NULL;
-    if( !p_obj->p_libvlc->b_stats ) return;
-    vlc_mutex_lock( &p_obj->p_libvlc->timer_lock );
+    vlc_mutex_lock( &priv->timer_lock );
 
-    for( i = 0 ; i < p_obj->p_libvlc->i_timers; i++ )
+    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 )
     {
         counter_sample_t *p_sample;
-        p_counter = stats_CounterCreate( p_obj->p_libvlc, VLC_VAR_TIME,
-                                         STATS_TIMER );
+        p_counter = stats_CounterCreate( VLC_OBJECT(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 ) );
@@ -324,107 +292,115 @@ void __stats_TimerStart( vlc_object_t *p_obj, const char *psz_name,
     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 )
+#undef stats_TimerStop
+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 )
+#undef stats_TimerDump
+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 )
+#undef stats_TimersDumpAll
+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, int i_id )
+#undef stats_TimerClean
+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 )
+#undef stats_TimersCleanAll
+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];
@@ -511,11 +487,12 @@ static int CounterUpdate( vlc_object_t *p_handler,
     case STATS_DERIVATIVE:
     {
         counter_sample_t *p_new, *p_old;
-        if( mdate() - p_counter->last_update < p_counter->update_interval )
+        mtime_t now = mdate();
+        if( now - p_counter->last_update < p_counter->update_interval )
         {
             return VLC_EGENERIC;
         }
-        p_counter->last_update = mdate();
+        p_counter->last_update = now;
         if( p_counter->i_type != VLC_VAR_FLOAT &&
             p_counter->i_type != VLC_VAR_INTEGER )
         {
@@ -579,9 +556,12 @@ static int CounterUpdate( vlc_object_t *p_handler,
 static void TimerDump( vlc_object_t *p_obj, counter_t *p_counter,
                        bool b_total )
 {
+    if( !p_counter )
+        return;
+
     mtime_t last, total;
     int i_total;
-    if( !p_counter || p_counter->i_samples != 2 )
+    if( p_counter->i_samples != 2 )
     {
         msg_Err( p_obj, "timer %s does not exist", p_counter->psz_name );
         return;