AudioStream: Replace buffer queue with ring buffer

Should achieve a decent overall minimum latency reduction.

src/common/audio_stream.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "fifo_queue.h"
 #include "types.h"
 #include <condition_variable>
 #include <memory>
@@ -12,11 +13,12 @@ class AudioStream
 public:
   using SampleType = s16;
 
-  enum
+  enum : u32
   {
     DefaultOutputSampleRate = 44100,
     DefaultBufferSize = 2048,
-    DefaultBufferCount = 3,
+    MaxSamples = 32768,
+    FullVolume = 100
   };
 
   AudioStream();
@@ -25,14 +27,14 @@ public:
   u32 GetOutputSampleRate() const { return m_output_sample_rate; }
   u32 GetChannels() const { return m_channels; }
   u32 GetBufferSize() const { return m_buffer_size; }
-  u32 GetBufferCount() const { return static_cast<u32>(m_buffers.size()); }
   s32 GetOutputVolume() const { return m_output_volume; }
   bool IsSyncing() const { return m_sync; }
 
   bool Reconfigure(u32 output_sample_rate = DefaultOutputSampleRate, u32 channels = 1,
-                   u32 buffer_size = DefaultBufferSize, u32 buffer_count = DefaultBufferCount);
+                   u32 buffer_size = DefaultBufferSize);
   void SetSync(bool enable) { m_sync = enable; }
-  void SetOutputVolume(s32 volume);
+
+  virtual void SetOutputVolume(u32 volume);
 
   void PauseOutput(bool paused);
   void EmptyBuffers();
@@ -48,58 +50,43 @@ public:
   static std::unique_ptr<AudioStream> CreateCubebAudioStream();
 
   // Latency computation - returns values in seconds
-  static float GetMinLatency(u32 sample_rate, u32 buffer_size, u32 buffer_count);
-  static float GetMaxLatency(u32 sample_rate, u32 buffer_size, u32 buffer_count);
+  static float GetMaxLatency(u32 sample_rate, u32 buffer_size);
 
 protected:
   virtual bool OpenDevice() = 0;
   virtual void PauseDevice(bool paused) = 0;
   virtual void CloseDevice() = 0;
-  virtual void BufferAvailable() = 0;
+  virtual void FramesAvailable() = 0;
 
-  ALWAYS_INLINE static SampleType ApplyVolume(SampleType sample, s32 volume)
+  ALWAYS_INLINE static SampleType ApplyVolume(SampleType sample, u32 volume)
   {
-    return s16((s32(sample) * volume) / 100);
+    return s16((s32(sample) * s32(volume)) / 100);
   }
 
+  bool SetBufferSize(u32 buffer_size);
   bool IsDeviceOpen() const { return (m_output_sample_rate > 0); }
 
   u32 GetSamplesAvailable() const;
-  u32 ReadSamples(SampleType* samples, u32 num_samples);
-
-  void DropBuffer();
+  u32 GetSamplesAvailableLocked() const;
+  void ReadFrames(SampleType* samples, u32 num_frames, bool apply_volume);
+  void DropFrames(u32 count);
 
   u32 m_output_sample_rate = 0;
   u32 m_channels = 0;
   u32 m_buffer_size = 0;
 
-private:
-  struct Buffer
-  {
-    std::vector<SampleType> data;
-    u32 write_position;
-    u32 read_position;
-  };
-
-  void AllocateBuffers(u32 buffer_count);
-  void EnsureBuffer();
-
-  std::vector<Buffer> m_buffers;
-  mutable std::mutex m_buffer_mutex;
-
-  // For input.
-  u32 m_first_free_buffer = 0;
-  u32 m_num_free_buffers = 0;
-
-  // For output.
-  u32 m_num_available_buffers = 0;
-  u32 m_first_available_buffer = 0;
-
-  // TODO: Switch to semaphore
-  std::condition_variable m_buffer_available_cv;
-
   // volume, 0-100
-  s32 m_output_volume = 100;
+  u32 m_output_volume = FullVolume;
+
+private:
+  ALWAYS_INLINE u32 GetBufferSpace() const { return (m_max_samples - m_buffer.GetSize()); }
+  void EnsureBuffer(u32 size);
+
+  HeapFIFOQueue<SampleType, MaxSamples> m_buffer;
+  mutable std::mutex m_buffer_mutex;
+  std::condition_variable m_buffer_draining_cv;
+  std::vector<SampleType> m_resample_buffer;
+  u32 m_max_samples = 0;
 
   bool m_output_paused = true;
   bool m_sync = true;