Add fetch_and_reset_stats()

Author: mgeier

doc/index.rst

@@ -10,7 +10,8 @@ API Documentation
 .. automodule:: rtmixer
 
 .. autoclass:: Mixer
-   :members: play_buffer, play_ringbuffer, actions, cancel, wait, stats
+   :members: play_buffer, play_ringbuffer, actions, cancel, wait, stats,
+             fetch_and_reset_stats
    :undoc-members:
 
 .. autoclass:: Recorder

examples/fetch_stats.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Example that shows how to use fetch_and_reset_stats().
+
+"""
+import rtmixer
+import sounddevice as sd
+
+
+blocksize = 0
+latency = 0
+device = None
+samplerate = None
+channels = 1
+
+
+def print_stats(obj):
+    print('  blocks:', obj.stats.blocks)
+    print('  overflows:', obj.stats.input_overflows)
+
+
+stream = rtmixer.Recorder(
+    device=device, channels=channels, blocksize=blocksize,
+    latency=latency, samplerate=samplerate)
+
+buffer = bytearray(10 * int(stream.samplerate) * stream.samplesize)
+ringbuffer = rtmixer.RingBuffer(stream.samplesize * channels, 128)
+
+print('checking stats before opening stream:')
+print_stats(stream)
+assert stream.stats.blocks == 0
+assert stream.stats.input_overflows == 0
+
+with stream:
+    print('waiting a few seconds')
+    sd.sleep(3 * 1000)
+    print('checking stats:')
+    action = stream.fetch_and_reset_stats()
+    stream.wait(action)
+    print_stats(action)
+    print('starting recording to buffer')
+    action = stream.record_buffer(buffer, channels=channels)
+    # TODO: check if recording started successfully
+    stream.wait(action)
+    print('stats from finished recording:')
+    print_stats(action)
+    print('starting recording to ringbuffer')
+    action = stream.record_ringbuffer(ringbuffer, channels=channels)
+    # TODO: check if recording started successfully
+    # TODO: record ringbuffer, but don't read from it (detect overflow)
+    sd.sleep(3 * 1000)
+    print('checking stats:')
+    action = stream.fetch_and_reset_stats()
+    stream.wait(action)
+    print_stats(action)
+
+print('checking stats after closing stream:')
+print_stats(stream)

src/rtmixer.c

@@ -6,6 +6,8 @@
 #include <portaudio.h>
 #include "rtmixer.h"
 
+static const struct stats EMPTY_STATS;
+
 #ifdef NDEBUG
 #define CALLBACK_ASSERT(expr) ((void)(0))
 #else
@@ -78,6 +80,27 @@ frame_t seconds2samples(PaTime time, double samplerate)
   return (frame_t) llround(time * samplerate);
 }
 
+PaTime get_relevant_time(const struct action* action
+  , const PaStreamCallbackTimeInfo* timeInfo)
+{
+  enum actiontype type = action->type;
+  if (type == FETCH_AND_RESET_STATS)
+  {
+    return timeInfo->currentTime;
+  }
+  if (type == CANCEL)
+  {
+    CALLBACK_ASSERT(action->action);
+    type = action->action->type;
+  }
+  if (type == PLAY_BUFFER || type == PLAY_RINGBUFFER)
+  {
+    return timeInfo->outputBufferDacTime;
+  }
+  CALLBACK_ASSERT(type == RECORD_BUFFER || type == RECORD_RINGBUFFER);
+  return timeInfo->inputBufferAdcTime;
+}
+
 int callback(const void* input, void* output, frame_t frameCount
   , const PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags statusFlags
   , void* userData)
@@ -96,16 +119,7 @@ int callback(const void* input, void* output, frame_t frameCount
   {
     struct action* const action = *actionaddr;
 
-    enum actiontype type = action->type;
-    if (type == CANCEL)
-    {
-      CALLBACK_ASSERT(action->action);
-      type = action->action->type;
-    }
-    const bool playing = type == PLAY_BUFFER || type == PLAY_RINGBUFFER;
-
-    PaTime io_time = playing ? timeInfo->outputBufferDacTime
-                             : timeInfo->inputBufferAdcTime;
+    PaTime time = get_relevant_time(action, timeInfo);
     frame_t offset = 0;
 
     // Check if the action is due to start in the current block
@@ -114,7 +128,7 @@ int callback(const void* input, void* output, frame_t frameCount
     {
       // This action has not yet been "active"
 
-      PaTime diff = action->requested_time - io_time;
+      PaTime diff = action->requested_time - time;
       if (diff >= 0.0)
       {
         offset = seconds2samples(diff, state->samplerate);
@@ -129,7 +143,7 @@ int callback(const void* input, void* output, frame_t frameCount
           continue;
         }
         // Re-calculate "diff" to propagate rounding errors
-        action->actual_time = io_time + (double)offset / state->samplerate;
+        action->actual_time = time + (double)offset / state->samplerate;
       }
       else
       {
@@ -140,7 +154,7 @@ int callback(const void* input, void* output, frame_t frameCount
           remove_action(actionaddr, state);
           continue;
         }
-        action->actual_time = io_time;
+        action->actual_time = time;
       }
     }
 
@@ -161,7 +175,7 @@ int callback(const void* input, void* output, frame_t frameCount
             // delinquent is not yet playing/recording
 
             frame_t delinquent_offset = 0;
-            PaTime diff = delinquent->requested_time - io_time;
+            PaTime diff = delinquent->requested_time - time;
             if (diff >= 0.0)
             {
               delinquent_offset = seconds2samples(diff, state->samplerate);
@@ -217,6 +231,16 @@ int callback(const void* input, void* output, frame_t frameCount
       continue;
     }
 
+    // Handle FETCH_AND_RESET_STATS action
+
+    if (action->type == FETCH_AND_RESET_STATS)
+    {
+      action->stats = state->stats;
+      state->stats = EMPTY_STATS;
+      remove_action(actionaddr, state);
+      continue;
+    }
+
     // Store buffer over-/underflow information
 
     get_stats(statusFlags, &(action->stats));
@@ -238,9 +262,17 @@ int callback(const void* input, void* output, frame_t frameCount
 
     // Shove audio data around
 
-    float* device_data
-      = playing ? (float*)output + offset * state->output_channels
-                : (float*) input + offset * state->input_channels;
+    float* device_data = NULL;
+    if (action->type == PLAY_BUFFER || action->type == PLAY_RINGBUFFER)
+    {
+      device_data = (float*)output + offset * state->output_channels;
+    }
+    else
+    {
+      CALLBACK_ASSERT(action->type == RECORD_BUFFER
+                   || action->type == RECORD_RINGBUFFER);
+      device_data = (float*) input + offset * state->input_channels;
+    }
 
     if (action->type == PLAY_BUFFER || action->type == RECORD_BUFFER)
     {

src/rtmixer.h

@@ -17,7 +17,7 @@ enum actiontype
   RECORD_BUFFER,
   RECORD_RINGBUFFER,
   CANCEL,
-  // TODO: action to query xrun stats etc.?
+  FETCH_AND_RESET_STATS,
 };
 
 struct stats

src/rtmixer.py

@@ -79,6 +79,18 @@ def cancel(self, action, time=0, allow_belated=True):
         self._enqueue(cancel_action)
         return cancel_action
 
+    def fetch_and_reset_stats(self, time=0, allow_belated=True):
+        """Fetch and reset over-/underflow statistics of the stream.
+
+        """
+        action = _ffi.new('struct action*', dict(
+            type=FETCH_AND_RESET_STATS,
+            allow_belated=allow_belated,
+            requested_time=time,
+        ))
+        self._enqueue(action)
+        return action
+
     def wait(self, action, sleeptime=10):
         """Wait for *action* to be finished.