refactor: minor simplifications

Signed-off-by: Maika Namuo <httpworldview@gmail.com>

Author: httpsworldview

CONTRIBUTING.md

@@ -167,7 +167,7 @@ Debian/RPM release number.
 src/domain.rs              shared capture policy and visual identifiers
 src/dsp.rs                 AudioBlock and small DSP types
 src/meter.rs               capture timeline, silence handling, and DSP batching
-src/util/                  low-level audio math, color, musical, and telemetry helpers
+src/util/                  low-level audio math, color, and musical helpers
 src/infra/pipewire/        owned PipeWire graph, tap policy, stream, and audio transport
 src/persistence/           settings schema, lossy loading, store, themes, visual config
 src/visuals.rs             visual module declarations, option enums, widget macros

src/dsp.rs

@@ -257,7 +257,7 @@ impl<'a> AudioBlock<'a> {
     }
 
     pub fn is_empty(&self) -> bool {
-        self.frame_count() == 0
+        self.samples.len() < self.channels.max(1)
     }
 }
 

src/infra/pipewire/transport.rs

@@ -219,8 +219,9 @@ impl CaptureWriter {
     ) -> AudioFormat {
         self.flush_pending();
         let format = self.publish_format(channels, rate, positions);
-        self.configure_pool(format);
-        self.format = Some(format);
+        if self.format.replace(format) != Some(format) {
+            self.configure_pool(format);
+        }
         self.disconnected = false;
         format
     }

src/main.rs

@@ -15,16 +15,24 @@ mod visuals;
 
 use infra::pipewire::AudioBackend;
 use persistence::settings::SettingsHandle;
-use std::cell::RefCell;
-use std::process::ExitCode;
-use std::rc::Rc;
-use ui::UiConfig;
-use util::telemetry;
-
+use std::{cell::RefCell, process::ExitCode, rc::Rc};
 use tracing::{error, info};
+use tracing_subscriber::{EnvFilter, fmt};
+use ui::UiConfig;
 
 fn main() -> ExitCode {
-    telemetry::init();
+    let env_filter = match EnvFilter::try_from_default_env() {
+        Ok(filter) => filter,
+        Err(_) => EnvFilter::new("openmeters=info"),
+    };
+    if let Err(err) = fmt()
+        .with_env_filter(env_filter)
+        .with_target(false)
+        .compact()
+        .try_init()
+    {
+        eprintln!("[telemetry] failed to initialise tracing subscriber: {err}");
+    }
     info!("OpenMeters starting up");
 
     let settings_handle = SettingsHandle::load_or_default();

src/util.rs

@@ -18,28 +18,3 @@ pub(crate) fn unpoison<T>(lock: std::sync::LockResult<T>) -> T {
 pub fn lerp(a: f32, b: f32, t: f32) -> f32 {
     a + (b - a) * t
 }
-
-pub mod telemetry {
-    use std::sync::OnceLock;
-    use tracing::Level;
-    use tracing_subscriber::{EnvFilter, fmt};
-
-    static TELEMETRY_INIT: OnceLock<()> = OnceLock::new();
-
-    pub fn init() {
-        TELEMETRY_INIT.get_or_init(|| {
-            let env_filter = EnvFilter::try_from_default_env()
-                .or_else(|_| EnvFilter::try_new("openmeters=info"))
-                .unwrap_or_else(|_| EnvFilter::default().add_directive(Level::INFO.into()));
-
-            if let Err(err) = fmt()
-                .with_env_filter(env_filter)
-                .with_target(false)
-                .compact()
-                .try_init()
-            {
-                eprintln!("[telemetry] failed to initialise tracing subscriber: {err}");
-            }
-        });
-    }
-}

src/visuals/loudness/render.rs

@@ -61,9 +61,7 @@ impl LoudnessParams {
 
         Some((meter_x, bar_width, stride))
     }
-}
 
-impl LoudnessParams {
     fn build_vertices(&self, scratch: &mut GeometryScratch) {
         let clip = ClipTransform::from_bounds(self.bounds);
         let Some((meter_x, bar_width, stride)) = self.meter_bounds() else {
@@ -162,7 +160,6 @@ impl LoudnessParams {
                 clip,
             ));
         }
-
     }
 }
 

src/visuals/render/common.rs

@@ -704,6 +704,23 @@ pub(in crate::visuals) use sdf_primitive;
 #[cfg(test)]
 mod tests {
     use super::*;
+    use wgpu::naga::front::wgsl::parse_str;
+
+    #[test]
+    fn shaders_are_valid() {
+        for source in [
+            include_str!("shaders/sdf.wgsl"),
+            include_str!("shaders/spectrogram.wgsl"),
+        ] {
+            let module = parse_str(source).expect("shader should parse");
+            wgpu::naga::valid::Validator::new(
+                wgpu::naga::valid::ValidationFlags::all(),
+                wgpu::naga::valid::Capabilities::all(),
+            )
+            .validate(&module)
+            .expect("shader should validate");
+        }
+    }
 
     #[test]
     fn decimate_line_advances_when_bucket_edge_rounds_below_point() {

src/visuals/spectrogram/render.rs

@@ -653,20 +653,6 @@ fn make_bind_group(
 mod tests {
     use super::*;
 
-    #[test]
-    fn shader_is_valid() {
-        let module = wgpu::naga::front::wgsl::parse_str(include_str!(
-            "../render/shaders/spectrogram.wgsl"
-        ))
-        .expect("spectrogram shader should parse");
-        wgpu::naga::valid::Validator::new(
-            wgpu::naga::valid::ValidationFlags::all(),
-            wgpu::naga::valid::Capabilities::all(),
-        )
-        .validate(&module)
-        .expect("spectrogram shader should validate");
-    }
-
     #[test]
     fn equal_byte_capacity_does_not_reuse_a_different_ring_layout() {
         let current = RingLayout {

src/visuals/spectrogram/state.rs

@@ -323,11 +323,10 @@ impl SpectrogramState {
             return None;
         }
         let age = match self.rotation_index() {
-            0 => bounds.x + bounds.width - cursor.x,
             1 => bounds.y + bounds.height - cursor.y,
             2 => cursor.x - bounds.x,
             3 => cursor.y - bounds.y,
-            _ => return None,
+            _ => bounds.x + bounds.width - cursor.x,
         };
         if age < 0.0 || age >= self.history.col_count as f32 { return None; }
         let secs = age * (self.hop_size as f32 / self.sample_rate);

src/visuals/spectrum/processor.rs

@@ -213,7 +213,6 @@ impl SpectrumProcessor {
     }
 
     fn process_trace_window(&mut self, trace: usize, dt_seconds: f32, floor: f32) -> bool {
-        let bins = self.config.fft_size / 2 + 1;
         copy_dc_removed_windowed_from_deque(
             &mut self.real_buffer,
             &self.pcm_buffers[trace],
@@ -239,7 +238,6 @@ impl SpectrumProcessor {
             .spectrum_buffer
             .iter()
             .zip(&self.bin_normalization)
-            .take(bins)
             .enumerate()
         {
             level.scratch_power[idx] = complex.norm_sqr() * *norm;
@@ -422,8 +420,6 @@ fn a_weight(freq_hz: f32) -> f32 {
     let numerator = C4 * f2 * f2;
     let denom = (f2 + C1) * ((f2 + C2) * (f2 + C3)).sqrt() * (f2 + C4);
 
-    if denom <= 0.0 || numerator <= 0.0 { return f32::NEG_INFINITY; }
-
     let ra = numerator / denom;
     (20.0 * ra.log10() + 2.0) as f32
 }