Merge pull request #7 from lukaslihotzki/no-alloc

Avoid allocations

Author: binaryfields

Cargo.toml

@@ -15,7 +15,8 @@ name = "resid"
 
 [features]
 default = ["std"]
-std = []
+std = ["alloc"]
+alloc = []
 
 [dependencies]
 bit_field = "0.10"

src/filter.rs

@@ -5,7 +5,6 @@
 
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::cast_lossless))]
 
-use alloc::vec::Vec;
 use core::f64;
 
 use super::spline;
@@ -518,18 +517,8 @@ impl Filter {
     }
 
     fn set_f0(&mut self) {
-        let points = self
-            .f0_points
-            .iter()
-            .map(|&pt| spline::Point {
-                x: pt.0 as f64,
-                y: pt.1 as f64,
-            })
-            .collect::<Vec<spline::Point>>();
-        let mut plotter = spline::PointPlotter::new(2048);
-        spline::interpolate(&points, &mut plotter, 1.0);
-        let output = plotter.output();
-        self.f0[..2048].clone_from_slice(&output[..2048]);
+        let mut plotter = spline::PointPlotter::new(&mut self.f0[..2048]);
+        spline::interpolate(self.f0_points, &mut plotter, 1.0);
     }
 
     fn set_q(&mut self) {

src/lib.rs

@@ -5,9 +5,9 @@
 
 #![no_std]
 
-#[cfg(not(feature = "std"))]
+#[cfg(all(feature = "alloc", not(feature = "std")))]
 extern crate alloc;
-#[cfg(feature = "std")]
+#[cfg(all(feature = "alloc", feature = "std"))]
 extern crate std as alloc;
 
 mod data;

src/sampler.rs

@@ -6,8 +6,11 @@
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::cast_lossless))]
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::cast_ptr_alignment))]
 
-use alloc::vec::Vec;
 use core::f64;
+
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
 #[cfg(not(feature = "std"))]
 use libm::F64Ext;
 
@@ -34,19 +37,27 @@ const FIXP_MASK: i32 = 0xffff;
 pub enum SamplingMethod {
     Fast,
     Interpolate,
+    #[cfg(feature = "alloc")]
     Resample,
+    #[cfg(feature = "alloc")]
     ResampleFast,
 }
 
+#[derive(Clone)]
+struct Fir {
+    data: Vec<i16>,
+    n: i32,
+    res: i32,
+}
+
 #[derive(Clone)]
 pub struct Sampler {
     // Dependencies
     pub synth: Synth,
     // Configuration
     cycles_per_sample: u32,
-    fir: Vec<i16>,
-    fir_n: i32,
-    fir_res: i32,
+    #[cfg(feature = "alloc")]
+    fir: Fir,
     sampling_method: SamplingMethod,
     #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
     use_sse42: bool,
@@ -64,9 +75,12 @@ impl Sampler {
         Sampler {
             synth,
             cycles_per_sample: 0,
-            fir: Vec::new(),
-            fir_n: 0,
-            fir_res: 0,
+            #[cfg(feature = "alloc")]
+            fir: Fir {
+                data: Vec::new(),
+                n: 0,
+                res: 0,
+            },
             sampling_method: SamplingMethod::Fast,
             #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
             use_avx2: alloc::is_x86_feature_detected!("avx2"),
@@ -83,6 +97,8 @@ impl Sampler {
         self.cycles_per_sample =
             (clock_freq as f64 / sample_freq as f64 * (1 << FIXP_SHIFT) as f64 + 0.5) as u32;
         self.sampling_method = method;
+
+        #[cfg(feature = "alloc")]
         if self.sampling_method == SamplingMethod::Resample
             || self.sampling_method == SamplingMethod::ResampleFast
         {
@@ -109,7 +125,9 @@ impl Sampler {
         match self.sampling_method {
             SamplingMethod::Fast => self.clock_fast(delta, buffer, interleave),
             SamplingMethod::Interpolate => self.clock_interpolate(delta, buffer, interleave),
+            #[cfg(feature = "alloc")]
             SamplingMethod::Resample => self.clock_resample_interpolate(delta, buffer, interleave),
+            #[cfg(feature = "alloc")]
             SamplingMethod::ResampleFast => self.clock_resample_fast(delta, buffer, interleave),
         }
     }
@@ -215,6 +233,7 @@ impl Sampler {
     ///
     /// NB! the result of right shifting negative numbers is really
     /// implementation dependent in the C++ standard.
+    #[cfg(feature = "alloc")]
     #[inline]
     fn clock_resample_interpolate(
         &mut self,
@@ -242,34 +261,34 @@ impl Sampler {
             delta -= delta_sample;
             self.update_sample_offset2(next_sample_offset);
 
-            let fir_offset_1 = (self.offset * self.fir_res) >> FIXP_SHIFT;
-            let fir_offset_rmd = (self.offset * self.fir_res) & FIXP_MASK;
-            let fir_start_1 = (fir_offset_1 * self.fir_n) as usize;
-            let fir_end_1 = fir_start_1 + self.fir_n as usize;
-            let sample_start_1 = (self.index as i32 - self.fir_n + RING_SIZE as i32) as usize;
-            let sample_end_1 = sample_start_1 + self.fir_n as usize;
+            let fir_offset_1 = (self.offset * self.fir.res) >> FIXP_SHIFT;
+            let fir_offset_rmd = (self.offset * self.fir.res) & FIXP_MASK;
+            let fir_start_1 = (fir_offset_1 * self.fir.n) as usize;
+            let fir_end_1 = fir_start_1 + self.fir.n as usize;
+            let sample_start_1 = (self.index as i32 - self.fir.n + RING_SIZE as i32) as usize;
+            let sample_end_1 = sample_start_1 + self.fir.n as usize;
 
             // Convolution with filter impulse response.
             let v1 = self.compute_convolution_fir(
                 &self.buffer[sample_start_1..sample_end_1],
-                &self.fir[fir_start_1..fir_end_1],
+                &self.fir.data[fir_start_1..fir_end_1],
             );
 
             // Use next FIR table, wrap around to first FIR table using
             // previous sample.
             let mut fir_offset_2 = fir_offset_1 + 1;
             let mut sample_start_2 = sample_start_1;
-            if fir_offset_2 == self.fir_res {
+            if fir_offset_2 == self.fir.res {
                 fir_offset_2 = 0;
                 sample_start_2 -= 1;
             }
-            let fir_start_2 = (fir_offset_2 * self.fir_n) as usize;
-            let fir_end_2 = fir_start_2 + self.fir_n as usize;
-            let sample_end_2 = sample_start_2 + self.fir_n as usize;
+            let fir_start_2 = (fir_offset_2 * self.fir.n) as usize;
+            let fir_end_2 = fir_start_2 + self.fir.n as usize;
+            let sample_end_2 = sample_start_2 + self.fir.n as usize;
 
             let v2 = self.compute_convolution_fir(
                 &self.buffer[sample_start_2..sample_end_2],
-                &self.fir[fir_start_2..fir_end_2],
+                &self.fir.data[fir_start_2..fir_end_2],
             );
 
             // Linear interpolation.
@@ -305,6 +324,7 @@ impl Sampler {
     }
 
     /// SID clocking with audio sampling - cycle based with audio resampling.
+    #[cfg(feature = "alloc")]
     #[inline]
     fn clock_resample_fast(
         &mut self,
@@ -332,16 +352,16 @@ impl Sampler {
             delta -= delta_sample;
             self.update_sample_offset2(next_sample_offset);
 
-            let fir_offset = (self.offset * self.fir_res) >> FIXP_SHIFT;
-            let fir_start = (fir_offset * self.fir_n) as usize;
-            let fir_end = fir_start + self.fir_n as usize;
-            let sample_start = (self.index as i32 - self.fir_n + RING_SIZE as i32) as usize;
-            let sample_end = sample_start + self.fir_n as usize;
+            let fir_offset = (self.offset * self.fir.res) >> FIXP_SHIFT;
+            let fir_start = (fir_offset * self.fir.n) as usize;
+            let fir_end = fir_start + self.fir.n as usize;
+            let sample_start = (self.index as i32 - self.fir.n + RING_SIZE as i32) as usize;
+            let sample_end = sample_start + self.fir.n as usize;
 
             // Convolution with filter impulse response.
             let mut v = self.compute_convolution_fir(
                 &self.buffer[sample_start..sample_end],
-                &self.fir[fir_start..fir_end],
+                &self.fir.data[fir_start..fir_end],
             );
             v >>= FIR_SHIFT;
 
@@ -515,6 +535,7 @@ impl Sampler {
         self.offset = next_sample_offset & FIXP_MASK;
     }
 
+    #[cfg(feature = "alloc")]
     fn init_fir(
         &mut self,
         clock_freq: f64,
@@ -557,8 +578,8 @@ impl Sampler {
 
         // The filter length is equal to the filter order + 1.
         // The filter length must be an odd number (sinc is symmetric about x = 0).
-        self.fir_n = (n_cap as f64 * cycles_per_sample) as i32 + 1;
-        self.fir_n |= 1;
+        self.fir.n = (n_cap as f64 * cycles_per_sample) as i32 + 1;
+        self.fir.n |= 1;
 
         // We clamp the filter table resolution to 2^n, making the fixpoint
         // sample_offset a whole multiple of the filter table resolution.
@@ -568,18 +589,20 @@ impl Sampler {
             FIR_RES_FAST
         };
         let n = ((res as f64 / cycles_per_sample).ln() / (2.0f64).ln()).ceil() as i32;
-        self.fir_res = 1 << n;
+        self.fir.res = 1 << n;
 
-        self.fir.clear();
-        self.fir.resize((self.fir_n * self.fir_res) as usize, 0);
+        self.fir.data.clear();
+        self.fir
+            .data
+            .resize((self.fir.n * self.fir.res) as usize, 0);
 
         // Calculate fir_RES FIR tables for linear interpolation.
-        for i in 0..self.fir_res {
-            let fir_offset = i * self.fir_n + self.fir_n / 2;
-            let j_offset = i as f64 / self.fir_res as f64;
+        for i in 0..self.fir.res {
+            let fir_offset = i * self.fir.n + self.fir.n / 2;
+            let j_offset = i as f64 / self.fir.res as f64;
             // Calculate FIR table. This is the sinc function, weighted by the
             // Kaiser window.
-            let fir_n_div2 = self.fir_n / 2;
+            let fir_n_div2 = self.fir.n / 2;
             for j in -fir_n_div2..=fir_n_div2 {
                 let jx = j as f64 - j_offset;
                 let wt = wc * jx / cycles_per_sample;
@@ -593,7 +616,7 @@ impl Sampler {
                 let val = (1i32 << FIR_SHIFT) as f64 * filter_scale * samples_per_cycle * wc / pi
                     * sincwt
                     * kaiser;
-                self.fir[(fir_offset + j) as usize] = (val + 0.5) as i16;
+                self.fir.data[(fir_offset + j) as usize] = (val + 0.5) as i16;
             }
         }
     }

src/spline.rs

@@ -99,28 +99,28 @@
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::float_cmp))]
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::too_many_arguments))]
 
-use alloc::vec;
-use alloc::vec::Vec;
-
 #[derive(Clone, Copy, PartialEq)]
 pub struct Point {
     pub x: f64,
     pub y: f64,
 }
 
-pub struct PointPlotter {
-    output: Vec<i32>,
-}
-
-impl PointPlotter {
-    pub fn new(capacity: usize) -> Self {
-        PointPlotter {
-            output: vec![0; capacity],
+impl From<(i32, i32)> for Point {
+    fn from((x, y): (i32, i32)) -> Point {
+        Point {
+            x: x as f64,
+            y: y as f64,
         }
     }
+}
+
+pub struct PointPlotter<'a> {
+    output: &'a mut [i32],
+}
 
-    pub fn output(&self) -> &Vec<i32> {
-        &self.output
+impl<'a> PointPlotter<'a> {
+    pub fn new(output: &'a mut [i32]) -> Self {
+        PointPlotter { output }
     }
 
     pub fn plot(&mut self, x: f64, y: f64) {
@@ -202,14 +202,14 @@ fn interpolate_forward_difference(
 /// desirable, the end points can simply be repeated to ensure interpolation.
 /// Note also that points of non-differentiability and discontinuity can be
 /// introduced by repeating points.
-pub fn interpolate(points: &[Point], plotter: &mut PointPlotter, res: f64) {
+pub fn interpolate<P: Into<Point> + Copy>(points: &[P], plotter: &mut PointPlotter, res: f64) {
     let last_index = points.len() - 4;
     let mut i = 0;
     while i <= last_index {
-        let p0 = points[i];
-        let p1 = points[i + 1];
-        let p2 = points[i + 2];
-        let p3 = points[i + 3];
+        let p0 = points[i].into();
+        let p1 = points[i + 1].into();
+        let p2 = points[i + 2].into();
+        let p3 = points[i + 3].into();
         // p1 and p2 equal; single point.
         if p1.x != p2.x {
             let k1;

tests/spline_test.rs

@@ -46,12 +46,8 @@ fn set_f0(f0: &mut [i32; 2048]) {
             y: pt.1 as f64,
         })
         .collect::<Vec<spline::Point>>();
-    let mut plotter = spline::PointPlotter::new(2048);
+    let mut plotter = spline::PointPlotter::new(f0);
     spline::interpolate(&points, &mut plotter, 1.0);
-    let output = plotter.output();
-    for i in 0..2048 {
-        f0[i] = output[i];
-    }
 }
 
 #[test]