refactor: replace interpolator rate methods with set_bandwidth

Author: roderickvd

CHANGELOG.md

@@ -2,9 +2,8 @@
 
 - Fixed aliasing in Sinc interpolator when downsampling by adding automatic
   anti-aliasing filter cutoff adjustment. The `Interpolator` trait now includes
-  `set_hz_to_hz`, `set_playback_hz_scale`, and `set_sample_hz_scale` methods
-  (with default no-op implementations) that are called automatically by the
-  corresponding `Converter` methods to configure rate-dependent parameters.
+  a `set_bandwidth` method (with default no-op implementation) that is called
+  automatically by `Converter`.
 - Renamed `window-hanning` to `window-hann`
 - Made `IntoInterleavedSamples` and `IntoInterleavedSamplesIterator` stop
   yielding samples when the underlying signal gets exhausted. This is a breaking

dasp_interpolate/src/lib.rs

@@ -38,17 +38,6 @@ pub mod sinc;
 ///
 /// Implementations should keep track of the necessary data both before and after the current
 /// frame.
-///
-/// # Rate Configuration
-///
-/// Some interpolators require sample rate information to operate correctly (e.g., sinc
-/// interpolation needs the rate ratio for anti-aliasing). The `set_hz_to_hz`,
-/// `set_playback_hz_scale`, and `set_sample_hz_scale` methods provide alternative ways
-/// to configure this - use whichever matches the information available. These methods
-/// are called automatically by the corresponding `Converter` methods.
-///
-/// Interpolators that don't need rate information (floor, linear) can use the default
-/// no-op implementations.
 pub trait Interpolator {
     /// The type of frame over which the interpolate may operate.
     type Frame: Frame;
@@ -65,12 +54,8 @@ pub trait Interpolator {
     /// Call this when there's a break in the continuity of the input data stream.
     fn reset(&mut self);
 
-    /// Configures the interpolator from absolute sample rates.
-    fn set_hz_to_hz(&mut self, _source_hz: f64, _target_hz: f64) {}
-
-    /// Configures the interpolator from playback rate scale (`source_hz / target_hz`).
-    fn set_playback_hz_scale(&mut self, _scale: f64) {}
-
-    /// Configures the interpolator from sample rate scale (`target_hz / source_hz`).
-    fn set_sample_hz_scale(&mut self, _scale: f64) {}
+    /// Configures filter bandwidth for anti-aliasing. No-op for non-filtering interpolators.
+    ///
+    /// For downsampling, set to `target_hz / source_hz` to prevent aliasing.
+    fn set_bandwidth(&mut self, _bandwidth: f64) {}
 }

dasp_interpolate/src/sinc/mod.rs

@@ -145,15 +145,7 @@ where
         }
     }
 
-    fn set_hz_to_hz(&mut self, source_hz: f64, target_hz: f64) {
-        self.bandwidth = (target_hz / source_hz).min(1.0);
-    }
-
-    fn set_playback_hz_scale(&mut self, scale: f64) {
-        self.bandwidth = (1.0 / scale).min(1.0);
-    }
-
-    fn set_sample_hz_scale(&mut self, scale: f64) {
-        self.bandwidth = scale.min(1.0);
+    fn set_bandwidth(&mut self, bandwidth: f64) {
+        self.bandwidth = bandwidth.clamp(f64::MIN_POSITIVE, 1.0);
     }
 }

dasp_signal/src/interpolate.rs

@@ -32,10 +32,10 @@ where
     /// Construct a new `Converter` from the source frames and the source and target sample rates
     /// (in Hz).
     ///
-    /// This method calls `interpolator.set_hz_to_hz(source_hz, target_hz)` internally.
+    /// Configures the interpolator's bandwidth for anti-aliasing when downsampling.
     #[inline]
     pub fn from_hz_to_hz(source: S, mut interpolator: I, source_hz: f64, target_hz: f64) -> Self {
-        interpolator.set_hz_to_hz(source_hz, target_hz);
+        interpolator.set_bandwidth(target_hz / source_hz);
         Self::scale_playback_hz(source, interpolator, source_hz / target_hz)
     }
 
@@ -75,33 +75,27 @@ where
     /// Update the `source_to_target_ratio` internally given the source and target hz.
     ///
     /// This method might be useful for changing the sample rate during playback.
-    ///
-    /// This method calls `interpolator.set_hz_to_hz(source_hz, target_hz)` internally.
     #[inline]
     pub fn set_hz_to_hz(&mut self, source_hz: f64, target_hz: f64) {
-        self.interpolator.set_hz_to_hz(source_hz, target_hz);
+        self.interpolator.set_bandwidth(target_hz / source_hz);
         self.set_playback_hz_scale(source_hz / target_hz)
     }
 
     /// Update the `source_to_target_ratio` internally given a new **playback rate** multiplier.
     ///
     /// This method is useful for dynamically changing rates.
-    ///
-    /// This method calls `interpolator.set_playback_hz_scale(scale)` internally.
     #[inline]
     pub fn set_playback_hz_scale(&mut self, scale: f64) {
-        self.interpolator.set_playback_hz_scale(scale);
+        self.interpolator.set_bandwidth(1.0 / scale);
         self.source_to_target_ratio = scale;
     }
 
     /// Update the `source_to_target_ratio` internally given a new **sample rate** multiplier.
     ///
     /// This method is useful for dynamically changing rates.
-    ///
-    /// This method calls `interpolator.set_sample_hz_scale(scale)` internally.
     #[inline]
     pub fn set_sample_hz_scale(&mut self, scale: f64) {
-        self.interpolator.set_sample_hz_scale(scale);
+        self.interpolator.set_bandwidth(scale);
         self.set_playback_hz_scale(1.0 / scale);
     }