add level meter + various tweaks

Author: phandasm

data/locale/en-US.ini

@@ -62,6 +62,11 @@ display_mode="Display Mode"
 curve="Curve"
 bars="Bars"
 stepped_bars="Stepped Bars"
+level_meter="Level Meter"
+stepped_level_meter="Stepped Level Meter"
+
+rms_mode="RMS Mode"
+meter_buf="Meter Buffer"
 
 bar_width="Bar Width"
 bar_gap="Bar Gap"

src/settings.hpp

@@ -86,6 +86,11 @@ static inline bool p_equ(const char *s1, const char *s2) { return std::strcmp(s1
 #define P_CURVE             "curve"
 #define P_BARS              "bars"
 #define P_STEP_BARS         "stepped_bars"
+#define P_LEVEL_METER       "level_meter"
+#define P_STEPPED_METER     "stepped_level_meter"
+
+#define P_RMS_MODE          "rms_mode"
+#define P_METER_BUF         "meter_buf"
 
 #define P_BAR_WIDTH         "bar_width"
 #define P_BAR_GAP           "bar_gap"

src/source.cpp

@@ -67,7 +67,9 @@ enum class DisplayMode
 {
     CURVE,
     BAR,
-    STEPPED_BAR
+    STEPPED_BAR,
+    METER,
+    STEPPED_METER
 };
 
 class WAVSource
@@ -88,16 +90,25 @@ class WAVSource
     circlebuf m_capturebufs[2]{};
     uint32_t m_capture_channels = 0;    // audio input channels
     uint32_t m_output_channels = 0;     // fft output channels (*not* display channels)
-    bool m_output_bus_captured = false;   // do we have an active audio output callback? (via audio_output_connect())
+    bool m_output_bus_captured = false; // do we have an active audio output callback? (via audio_output_connect())
 
     // 32-byte aligned buffers for FFT/AVX processing
     AVXBufR m_fft_input;
     AVXBufC m_fft_output;
     fftwf_plan m_fft_plan{};
     AVXBufR m_window_coefficients;
     AVXBufR m_tsmooth_buf[2];   // last frames magnitudes
-    AVXBufR m_decibels[2];      // dBFS
-    size_t m_fft_size = 0;      // number of fft elements (not bytes, multiple of 16)
+    AVXBufR m_decibels[2];      // dBFS, or audio sample buffer in meter mode
+    size_t m_fft_size = 0;      // number of fft elements, or audio samples in meter mode (not bytes, multiple of 16)
+                                // in meter mode m_fft_size is the size of of the circular buffer in samples
+
+    // meter mode
+    size_t m_meter_pos[2] = { 0, 0 };       // circular buffer position (per channel)
+    float m_meter_val[2] = { 0.0f, 0.0f };  // dBFS
+    float m_meter_buf[2] = { 0.0f, 0.0f };  // EMA
+    bool m_meter_rms = false;               // RMS mode
+    bool m_meter_mode = false;              // either meter or stepped meter display mode is selected
+    int m_meter_ms = 100;                   // milliseconds of audio data to buffer
 
     // video fps
     double m_fps = 0.0;
@@ -116,9 +127,6 @@ class WAVSource
     int m_retries = 0;
     float m_next_retry = 0.0f;
 
-    // vertex buffer
-    gs_vertbuffer_t *m_vbuf = nullptr;
-
     // settings
     RenderMode m_render_mode = RenderMode::SOLID;
     FFTWindow m_window_func = FFTWindow::HANN;
@@ -160,18 +168,26 @@ class WAVSource
     // slope
     AVXBufR m_slope_modifiers;
 
+    // rounded caps
+    float m_cap_radius = 0.0f;
+    int m_cap_tris = 4;             // number of triangles each cap is composed of (4 min)
+    std::vector<vec2> m_cap_verts;  // pre-rotated cap vertices (to be translated to final pos)
+
     void get_settings(obs_data_t *settings);
 
     void recapture_audio();
     void release_audio_capture();
-    bool check_audio_capture(float seconds);
+    bool check_audio_capture(float seconds); // check if capture is valid and retry if not
     void free_bufs();
 
     void init_interp(unsigned int sz);
 
     void render_curve(gs_effect_t *effect);
     void render_bars(gs_effect_t *effect);
 
+    virtual void tick_spectrum(float) = 0;  // process audio data in frequency spectrum mode
+    virtual void tick_meter(float);         // process audio data in meter mode
+
     // constants
     static const float DB_MIN;
     static constexpr auto RETRY_DELAY = 2.0f;
@@ -197,7 +213,7 @@ class WAVSource
 
     // main callbacks
     virtual void update(obs_data_t *settings);
-    virtual void tick(float seconds) = 0;
+    virtual void tick(float seconds);
     virtual void render(gs_effect_t *effect);
 
     void show();
@@ -224,7 +240,7 @@ class WAVSourceAVX2 : public WAVSource
     using WAVSource::WAVSource;
     ~WAVSourceAVX2() override {}
 
-    void tick(float seconds) override;
+    void tick_spectrum(float seconds) override;
 };
 
 class WAVSourceAVX : public WAVSource
@@ -233,7 +249,7 @@ class WAVSourceAVX : public WAVSource
     using WAVSource::WAVSource;
     ~WAVSourceAVX() override {}
 
-    void tick(float seconds) override;
+    void tick_spectrum(float seconds) override;
 };
 
 class WAVSourceSSE2 : public WAVSource
@@ -242,5 +258,6 @@ class WAVSourceSSE2 : public WAVSource
     using WAVSource::WAVSource;
     ~WAVSourceSSE2() override {}
 
-    void tick(float seconds) override;
+    void tick_spectrum(float seconds) override;
+    void tick_meter(float seconds) override;
 };

src/source.hpp

@@ -24,9 +24,9 @@
 // adaptation of WAVSourceAVX2 to support CPUs without AVX2
 // see comments of WAVSourceAVX2
 DECORATE_AVX
-void WAVSourceAVX::tick(float seconds)
+void WAVSourceAVX::tick_spectrum(float seconds)
 {
-    std::lock_guard lock(m_mtx);
+    //std::lock_guard lock(m_mtx); // now locked in tick()
     if(!check_audio_capture(seconds))
         return;
 
@@ -122,7 +122,7 @@ void WAVSourceAVX::tick(float seconds)
             // load 8 real/imaginary pairs and group the r/i components in the low/high halves
             // de-interleaving 256-bit float vectors is nigh impossible without AVX2, so we'll
             // use 128-bit vectors and merge them, but i question if this is better than a 128-bit loop
-            const auto buf = (float*)&m_fft_output[i];
+            const float *buf = &m_fft_output[i][0];
             auto chunk1 = _mm_load_ps(buf);
             auto chunk2 = _mm_load_ps(&buf[4]);
             auto rvec = _mm256_castps128_ps256(_mm_shuffle_ps(chunk1, chunk2, shuffle_mask_r)); // group octwords
@@ -141,9 +141,7 @@ void WAVSourceAVX::tick(float seconds)
             if(m_tsmoothing == TSmoothingMode::EXPONENTIAL)
             {
                 if(m_fast_peaks)
-                {
                     _mm256_store_ps(&m_tsmooth_buf[channel][i], _mm256_max_ps(mag, _mm256_load_ps(&m_tsmooth_buf[channel][i])));
-                }
 
                 mag = _mm256_fmadd_ps(g, _mm256_load_ps(&m_tsmooth_buf[channel][i]), _mm256_mul_ps(g2, mag));
                 _mm256_store_ps(&m_tsmooth_buf[channel][i], mag);
@@ -168,7 +166,7 @@ void WAVSourceAVX::tick(float seconds)
     else if(m_capture_channels > 1)
     {
         for(size_t i = 0; i < outsz; ++i)
-            m_decibels[0][i] = dbfs((m_decibels[0][i] + m_decibels[1][i]) / 2);
+            m_decibels[0][i] = dbfs((m_decibels[0][i] + m_decibels[1][i]) * 0.5f);
     }
     else
     {

src/source_avx.cpp

@@ -22,9 +22,9 @@
 #include <cstring>
 
 DECORATE_AVX2
-void WAVSourceAVX2::tick(float seconds)
+void WAVSourceAVX2::tick_spectrum(float seconds)
 {
-    std::lock_guard lock(m_mtx);
+    //std::lock_guard lock(m_mtx); // now locked in tick()
     if(!check_audio_capture(seconds))
         return;
 
@@ -35,6 +35,7 @@ void WAVSourceAVX2::tick(float seconds)
     const auto outsz = m_fft_size / 2; // discard bins at nyquist and above
     constexpr auto step = sizeof(__m256) / sizeof(float);
 
+    // reset and stop processing when source is not being displayed
     if(!m_show)
     {
         if(m_last_silent)
@@ -124,7 +125,7 @@ void WAVSourceAVX2::tick(float seconds)
         {
             // this *should* be faster than 2x vgatherxxx instructions
             // load 8 real/imaginary pairs and group the r/i components in the low/high halves
-            const auto buf = (float*)&m_fft_output[i];
+            const float *buf = &m_fft_output[i][0]; // first element of complex (float[2])
             auto chunk1 = _mm256_permutevar8x32_ps(_mm256_load_ps(buf), shuffle_mask);
             auto chunk2 = _mm256_permutevar8x32_ps(_mm256_load_ps(&buf[step]), shuffle_mask);
 
@@ -146,9 +147,7 @@ void WAVSourceAVX2::tick(float seconds)
             {
                 // take new values immediately if larger
                 if(m_fast_peaks)
-                {
                     _mm256_store_ps(&m_tsmooth_buf[channel][i], _mm256_max_ps(mag, _mm256_load_ps(&m_tsmooth_buf[channel][i])));
-                }
 
                 // (gravity * oldval) + ((1 - gravity) * newval)
                 mag = _mm256_fmadd_ps(g, _mm256_load_ps(&m_tsmooth_buf[channel][i]), _mm256_mul_ps(g2, mag));
@@ -176,7 +175,7 @@ void WAVSourceAVX2::tick(float seconds)
     else if(m_capture_channels > 1)
     {
         for(size_t i = 0; i < outsz; ++i)
-            m_decibels[0][i] = dbfs((m_decibels[0][i] + m_decibels[1][i]) / 2);
+            m_decibels[0][i] = dbfs((m_decibels[0][i] + m_decibels[1][i]) * 0.5f);
     }
     else
     {

src/source_avx2.cpp

@@ -24,9 +24,9 @@
 // compatibility fallback using at most SSE2 instructions
 // see comments of WAVSourceAVX2
 DECORATE_SSE2
-void WAVSourceSSE2::tick(float seconds)
+void WAVSourceSSE2::tick_spectrum(float seconds)
 {
-    std::lock_guard lock(m_mtx);
+    //std::lock_guard lock(m_mtx); // now locked in tick()
     if(!check_audio_capture(seconds))
         return;
 
@@ -120,7 +120,7 @@ void WAVSourceSSE2::tick(float seconds)
         for(size_t i = 0; i < outsz; i += step)
         {
             // load 4 real/imaginary pairs and pack the r/i components into separate vectors
-            const auto buf = (float*)&m_fft_output[i];
+            const float *buf = &m_fft_output[i][0];
             auto chunk1 = _mm_load_ps(buf);
             auto chunk2 = _mm_load_ps(&buf[4]);
             auto rvec = _mm_shuffle_ps(chunk1, chunk2, shuffle_mask_r);
@@ -135,9 +135,7 @@ void WAVSourceSSE2::tick(float seconds)
             if(m_tsmoothing == TSmoothingMode::EXPONENTIAL)
             {
                 if(m_fast_peaks)
-                {
                     _mm_store_ps(&m_tsmooth_buf[channel][i], _mm_max_ps(mag, _mm_load_ps(&m_tsmooth_buf[channel][i])));
-                }
 
                 mag = _mm_add_ps(_mm_mul_ps(g, _mm_load_ps(&m_tsmooth_buf[channel][i])), _mm_mul_ps(g2, mag));
                 _mm_store_ps(&m_tsmooth_buf[channel][i], mag);
@@ -162,11 +160,86 @@ void WAVSourceSSE2::tick(float seconds)
     else if(m_capture_channels > 1)
     {
         for(size_t i = 0; i < outsz; ++i)
-            m_decibels[0][i] = dbfs((m_decibels[0][i] + m_decibels[1][i]) / 2);
+            m_decibels[0][i] = dbfs((m_decibels[0][i] + m_decibels[1][i]) * 0.5f);
     }
     else
     {
         for(size_t i = 0; i < outsz; ++i)
             m_decibels[0][i] = dbfs(m_decibels[0][i]);
     }
 }
+
+void WAVSourceSSE2::tick_meter(float seconds)
+{
+    if(!check_audio_capture(seconds))
+        return;
+
+    if(m_capture_channels == 0)
+        return;
+
+    const auto outsz = m_fft_size;
+
+    for(auto channel = 0u; channel < m_capture_channels; ++channel)
+    {
+        while(m_capturebufs[channel].size > 0)
+        {
+            auto consume = m_capturebufs[channel].size;
+            auto max = (m_fft_size - m_meter_pos[channel]) * sizeof(float);
+            if(consume >= max)
+            {
+                circlebuf_pop_front(&m_capturebufs[channel], &m_decibels[channel][m_meter_pos[channel]], max);
+                m_meter_pos[channel] = 0;
+            }
+            else
+            {
+                circlebuf_pop_front(&m_capturebufs[channel], &m_decibels[channel][m_meter_pos[channel]], consume);
+                m_meter_pos[channel] += consume / sizeof(float);
+            }
+        }
+    }
+
+    if(!m_show)
+        return;
+
+    for(auto channel = 0u; channel < m_capture_channels; ++channel)
+    {
+        if(m_meter_rms)
+        {
+            float sum = 0.0f;
+            for(size_t i = 0; i < outsz; ++i)
+            {
+                auto val = m_decibels[channel][i];
+                sum += val * val;
+            }
+            const auto g = m_gravity;
+            const auto g2 = 1.0f - g;
+            auto rms = std::sqrt(sum / m_fft_size);
+            if(m_tsmoothing == TSmoothingMode::EXPONENTIAL)
+            {
+                if(!m_fast_peaks || (rms <= m_meter_buf[channel]))
+                    rms = (g * m_meter_buf[channel]) + (g2 * rms);
+            }
+            m_meter_buf[channel] = rms;
+            m_meter_val[channel] = dbfs(rms);
+        }
+        else
+        {
+            const auto g = m_gravity;
+            const auto g2 = 1.0f - g;
+            float max = 0.0f;
+            for(size_t i = 0; i < outsz; ++i)
+            {
+                auto val = std::abs(m_decibels[channel][i]);
+                if(val > max)
+                    max = val;
+            }
+            if(m_tsmoothing == TSmoothingMode::EXPONENTIAL)
+            {
+                if(!m_fast_peaks || (max <= m_meter_buf[channel]))
+                    max = (g * m_meter_buf[channel]) + (g2 * max);
+            }
+            m_meter_buf[channel] = max;
+            m_meter_val[channel] = dbfs(max);
+        }
+    }
+}