[not-for-merge]Allow limited number of overruns in sherpa-ncnn-alsa

sherpa-ncnn/csrc/alsa.cc

@@ -210,6 +210,22 @@ const std::vector<float> &Alsa::Read16(int32_t num_samples) {
   int32_t count =
       snd_pcm_readi(capture_handle_, samples16_.data(), num_samples);
   if (count == -EPIPE) {
+    static int32_t num_over_runs = 0;
+    ++num_over_runs;
+    fprintf(stderr, "number of overruns: %d/%d\n", num_over_runs,
+            num_allowed_over_runs_);
+
+    if (num_over_runs < num_allowed_over_runs_) {
+      int32_t err = snd_pcm_prepare(capture_handle_);
+      if (err) {
+        fprintf(stderr, "Failed to recover from overrun: %s\n",
+                snd_strerror(err));
+        exit(-1);
+      }
+
+      static std::vector<float> tmp;
+      return tmp;
+    }
     fprintf(
         stderr,
         "An overrun occurred, which means the RTF of the current "
@@ -238,6 +254,24 @@ const std::vector<float> &Alsa::Read32(int32_t num_samples) {
   int32_t count =
       snd_pcm_readi(capture_handle_, samples32_.data(), num_samples);
   if (count == -EPIPE) {
+    static int32_t num_over_runs = 0;
+    ++num_over_runs;
+
+    fprintf(stderr, "number of overruns: %d/%d\n", num_over_runs,
+            num_allowed_over_runs_);
+
+    if (num_over_runs < num_allowed_over_runs_) {
+      int32_t err = snd_pcm_prepare(capture_handle_);
+      if (err) {
+        fprintf(stderr, "Failed to recover from overrun: %s\n",
+                snd_strerror(err));
+        exit(-1);
+      }
+
+      static std::vector<float> tmp;
+      return tmp;
+    }
+
     fprintf(
         stderr,
         "An overrun occurred, which means the RTF of the current "

sherpa-ncnn/csrc/alsa.h

@@ -69,6 +69,8 @@ class Alsa {
 
   std::vector<float> samples1_;  // normalized version of samples_
   std::vector<float> samples2_;  // possibly resampled from samples1_
+
+  int32_t num_allowed_over_runs_ = 20;
 };
 
 }  // namespace sherpa_ncnn

sherpa-ncnn/csrc/sherpa-ncnn-alsa.cc

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <cctype>  // std::tolower
 #include <cstdint>
+#include <fstream>
 
 #include "sherpa-ncnn/csrc/alsa.h"
 #include "sherpa-ncnn/csrc/display.h"
@@ -139,8 +140,37 @@ as the device_name.
   std::string last_text;
   int32_t segment_index = 0;
   sherpa_ncnn::Display display;
+
+  fprintf(stderr, "Writing to test.pcm\n");
+  fprintf(stderr, "Please use\n");
+  fprintf(stderr,
+          " sox -t raw -c 1 -e floating-point -b 32 -r %d test.pcm test.wav\n",
+          alsa.GetExpectedSampleRate());
+  fprintf(stderr, "to convert test.pcm to test.wav\n");
+
+  std::ofstream os("test.pcm", std::ios::out | std::ios::binary);
+
+  int32_t num_samples_wrote = 0;
+
   while (!stop) {
     const std::vector<float> samples = alsa.Read(chunk);
+    if (!samples.empty()) {
+      if (os.is_open()) {
+        fprintf(stderr, "Writing %d samples\n", int32_t(samples.size()));
+        os.write(reinterpret_cast<const char *>(samples.data()),
+                 samples.size() * sizeof(float));
+        num_samples_wrote += samples.size();
+        fprintf(stderr, "Wrote %d samples so far\n", num_samples_wrote);
+        if (num_samples_wrote > 10 * alsa.GetExpectedSampleRate()) {
+          fprintf(stderr,
+                  "Closing test.pcm after writing 10 seconds of data\n");
+          os.close();
+        }
+      }
+    } else {
+      fprintf(stderr, "empty samples!");
+      continue;
+    }
 
     s->AcceptWaveform(expected_sampling_rate, samples.data(), samples.size());
     while (recognizer.IsReady(s.get())) {