Fix meter NaN spike + dB scale + add UI decay

LevelMeasurePipe's rolling +/- accumulation drifts to a tiny negative
value during silence due to floating-point cancellation. sqrt(mean) then
returned NaN, propagating through log10 into the UI which rendered the
NaN as a max-pegged meter spike (very visible when pulling a send fader
toward -inf).

  - Clamp mean to non-negative before sqrt.
  - Floor rms at 1e-6 so log10(0) doesn't produce -inf either.
  - Switch 10*log10(rms) -> 20*log10(rms): the previous formula was the
    intensity scale, not the amplitude scale. RMS peaks now read at the
    correct dBFS.

UI: ShowManager runs a 50 ms QTimer that ramps each channel's displayed
level toward -60 dBFS when no fresh meter packet has arrived for that
channel in the last 100 ms. Without this the meter sticks at its last
value forever when a stream stops (the engine simply stops sending
updates rather than sending zeros).

Decay rate: 1.2 dB/tick = ~24 dB/s; collapses from 0 dB to floor in
~2.5 s. Fast enough to read as "input went quiet," slow enough not to
flicker on a single dropped packet.

Author: jonathan-reichardt

coreui/core/ShowManager.cpp

@@ -97,6 +97,14 @@ bool is_static_range(uint16_t uid) {
 
 ShowManager::ShowManager() : QObject(nullptr) {
     m_netconfig = NetworkConfig{};
+
+    m_last_meter_ms.fill(0);
+    m_last_meter_value_db.fill(METER_FLOOR_DB);
+    m_meter_clock.start();
+
+    m_meter_decay_timer.setInterval(50);
+    connect(&m_meter_decay_timer, &QTimer::timeout, this, &ShowManager::tick_meter_decay);
+    m_meter_decay_timer.start();
 }
 
 ShowManager::~ShowManager() {
@@ -191,18 +199,43 @@ bool ShowManager::init_console(SignalWindow* sw) {
 }
 
 void ShowManager::update_pipe_meter_level(const ControlPacket &data) {
-    for (auto& pipe : m_show_content) {
-        if (pipe->get_channel() == data.packet_data.channel) {
-            float db_level = -60.0f;
-            memcpy(&db_level, data.packet_data.data, sizeof(float));
+    float db_level = METER_FLOOR_DB;
+    memcpy(&db_level, data.packet_data.data, sizeof(float));
 
-            pipe->set_current_level(db_level);
+    const uint8_t ch = data.packet_data.channel;
+    if (ch < METER_CHANNELS) {
+        m_last_meter_ms[ch] = m_meter_clock.elapsed();
+        m_last_meter_value_db[ch] = db_level;
+    }
 
+    for (auto& pipe : m_show_content) {
+        if (pipe->get_channel() == ch) {
+            pipe->set_current_level(db_level);
             break;
         }
     }
 }
 
+void ShowManager::tick_meter_decay() {
+    const qint64 now = m_meter_clock.elapsed();
+    for (auto& pipe : m_show_content) {
+        const uint8_t ch = pipe->get_channel();
+        if (ch >= METER_CHANNELS) continue;
+
+        const qint64 last = m_last_meter_ms[ch];
+        // If the channel has never received a meter packet, leave it
+        // at floor — there's nothing to decay from.
+        if (last == 0) continue;
+        if (now - last < METER_STALE_MS) continue;
+
+        float& v = m_last_meter_value_db[ch];
+        if (v <= METER_FLOOR_DB) continue;
+        v -= METER_DECAY_PER_TICK_DB;
+        if (v < METER_FLOOR_DB) v = METER_FLOOR_DB;
+        pipe->set_current_level(v);
+    }
+}
+
 void ShowManager::send_to_elem(const ControlPacket &data) {
     for (auto& pipe : m_show_content) {
         if (pipe->get_channel() == data.packet_data.channel) {

coreui/core/ShowManager.h

@@ -31,8 +31,11 @@
 #include <qjsonarray.h>
 #include <qjsonobject.h>
 #include <qqueue.h>
+#include <QTimer>
+#include <QElapsedTimer>
 
 #include <unordered_map>
+#include <array>
 
 class ShowManager : public QObject {
 
@@ -83,6 +86,19 @@ class ShowManager : public QObject {
     // started consulting an explicit route table.
     void auto_route_bus_if_needed(PipeDesc* desc, uint8_t channel, uint16_t host);
 
+    void tick_meter_decay();
+
+    static constexpr int METER_CHANNELS = 64;
+    static constexpr float METER_FLOOR_DB = -60.0f;
+    // After this gap with no fresh meter packet, decay the visual level
+    // toward METER_FLOOR_DB. ~100 ms is fast enough that the user sees
+    // "input went quiet" instantly without flickering on a single
+    // dropped packet (meters come in at ~125 Hz from the engine).
+    static constexpr qint64 METER_STALE_MS = 100;
+    // Decay step per tick. 50 ms tick * 1.2 dB/tick = ~24 dB/s; fully
+    // collapses from 0 dB to floor in ~2.5 s.
+    static constexpr float METER_DECAY_PER_TICK_DB = 1.2f;
+
     QList<PipeVisualizer*> m_show_content;
 
     std::shared_ptr<NetworkMapper> m_nmapper;
@@ -91,6 +107,16 @@ class ShowManager : public QObject {
 
     DSPManager* m_dsp_manager = nullptr;
     std::shared_ptr<PluginLoader> m_plugin_loader;
+
+    // Per-channel meter decay state. m_last_meter_value_db keeps the
+    // most-recent value (also used as the decay origin); m_last_meter_ms
+    // is monotonic ms timestamp of the last packet for that channel; the
+    // QTimer fires every METER_TICK_MS to push the displayed level down
+    // when no packet has arrived recently.
+    QTimer m_meter_decay_timer;
+    QElapsedTimer m_meter_clock;
+    std::array<qint64, METER_CHANNELS> m_last_meter_ms{};
+    std::array<float, METER_CHANNELS>  m_last_meter_value_db{};
 };
 
 

engine/piping/feedback/LevelMeasurePipe.cpp

@@ -40,14 +40,20 @@ float LevelMeasurePipe::process_sample(float sample) {
 
     m_value_counter++;
     if (m_value_counter > 300) {
-        float temp_sum = 0.0f;
-        for (auto& val : m_rms_buffer) {
-            temp_sum += val;
-        }
-
+        // Rolling +/- accumulation drifts to a tiny negative when the
+        // window is truly silent. Clamp before sqrt so we never feed
+        // log10 a NaN, which the UI would render as a max-pegged
+        // meter spike.
         float mean = m_sum / 28000.0f;
+        if (mean < 0.0f) mean = 0.0f;
         float rms = std::sqrt(mean);
-        float mean_db = 10 * std::log10(rms); // Max level is 1.0f
+
+        // Floor at -120 dBFS so log10(0) doesn't produce -inf either.
+        // (UI applies its own -60 dBFS floor on top of this; this is
+        // just defensive math against inf/NaN propagating.)
+        constexpr float RMS_FLOOR = 1e-6f; // -120 dBFS
+        if (rms < RMS_FLOOR) rms = RMS_FLOOR;
+        float mean_db = 20.0f * std::log10(rms);
 
         feedback_send(mean_db);