feat: add const generic mixer, voice stealing, 2nd-order sigma-delta, Q15 biquad & eaf-bake codegen

Author: leftger

src/bank.rs

@@ -97,6 +97,22 @@ impl<'a> SoundBank<'a> {
     }
 
     pub fn find_by_id(&self, id: u16) -> Result<EffectEntry, AudioError> {
+        let mut low = 0i32;
+        let mut high = self.effect_count as i32 - 1;
+
+        while low <= high {
+            let mid = (low + high) / 2;
+            let entry = self.entry(mid as usize)?;
+            if entry.id == id {
+                return Ok(entry);
+            } else if entry.id < id {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+
+        // Fallback linear scan in case bank entries were not sorted
         for i in 0..self.effect_count as usize {
             let e = self.entry(i)?;
             if e.id == id {
@@ -129,6 +145,7 @@ impl BankBuilder {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn add_effect(
         &mut self,
         id: u16,
@@ -166,11 +183,20 @@ impl BankBuilder {
         &self,
         out: &mut heapless::Vec<u8, { BANK_BUILD_CAP }>,
     ) -> Result<(), AudioError> {
+        let mut sorted_entries = self.entries.clone();
+        for i in 0..sorted_entries.len() {
+            for j in (i + 1)..sorted_entries.len() {
+                if sorted_entries[i].id > sorted_entries[j].id {
+                    sorted_entries.swap(i, j);
+                }
+            }
+        }
+
         out.clear();
         out.extend_from_slice(&BANK_MAGIC)
             .map_err(|_| AudioError::BankFull)?;
         out.push(BANK_VERSION).map_err(|_| AudioError::BankFull)?;
-        let count = self.entries.len() as u16;
+        let count = sorted_entries.len() as u16;
         out.push((count & 0xFF) as u8)
             .map_err(|_| AudioError::BankFull)?;
         out.push((count >> 8) as u8)
@@ -181,7 +207,7 @@ impl BankBuilder {
         out.push((rate >> 8) as u8)
             .map_err(|_| AudioError::BankFull)?;
         out.push(0).map_err(|_| AudioError::BankFull)?; // reserved
-        for e in &self.entries {
+        for e in &sorted_entries {
             out.push((e.id & 0xFF) as u8)
                 .map_err(|_| AudioError::BankFull)?;
             out.push((e.id >> 8) as u8)

src/config.rs

@@ -59,6 +59,7 @@ pub const fn crossfade_step_q8(duration_ms: u16, sample_rate_hz: u32) -> u8 {
     if samples == 0 {
         return 255;
     }
-    let step = (255u32 + samples - 1) / samples;
+    let step = 255u32.div_ceil(samples);
+
     if step > 255 { 255 } else { step as u8 }
 }

src/decode/pcm.rs

@@ -1,40 +1,94 @@
-/// Streaming 8-bit PCM (Tier B).
+use crate::fixed::lerp_i8;
+
+/// Streaming 8-bit PCM (Tier B) with fractional speed resampling.
 #[derive(Debug, Clone, Copy)]
 pub struct Pcm8Stream<'a> {
     data: &'a [u8],
-    pos: usize,
+    phase_q16: u32,
+    speed_q16: u32,
     looped: bool,
+    is_signed: bool,
 }
 
 impl<'a> Pcm8Stream<'a> {
     pub fn new(data: &'a [u8], flags: u8) -> Self {
+        Self::with_speed(data, flags, 65536)
+    }
+
+    pub fn with_speed(data: &'a [u8], flags: u8, speed_q16: u32) -> Self {
         Self {
             data,
-            pos: 0,
+            phase_q16: 0,
+            speed_q16,
             looped: flags & crate::tier::flags::LOOP != 0,
+            is_signed: flags & crate::tier::flags::SIGNED != 0,
         }
     }
 
+    pub fn set_speed_q16(&mut self, speed_q16: u32) {
+        self.speed_q16 = speed_q16;
+    }
+
+    pub fn speed_q16(&self) -> u32 {
+        self.speed_q16
+    }
+
     pub fn reset(&mut self) {
-        self.pos = 0;
+        self.phase_q16 = 0;
     }
 
     pub fn is_done(&self) -> bool {
-        !self.looped && self.pos >= self.data.len()
+        if self.data.is_empty() {
+            return true;
+        }
+        let pos = (self.phase_q16 >> 16) as usize;
+        !self.looped && pos >= self.data.len()
+    }
+
+    #[inline]
+    fn get_sample(&self, idx: usize) -> i8 {
+        if idx >= self.data.len() {
+            0
+        } else if self.is_signed {
+            self.data[idx] as i8
+        } else {
+            self.data[idx].wrapping_sub(128) as i8
+        }
     }
-}
 
-impl<'a> Pcm8Stream<'a> {
     pub fn next_sample(&mut self) -> Option<i8> {
-        if self.pos >= self.data.len() {
-            if self.looped && !self.data.is_empty() {
-                self.pos = 0;
+        if self.data.is_empty() {
+            return None;
+        }
+
+        let curr_idx = (self.phase_q16 >> 16) as usize;
+
+        if curr_idx >= self.data.len() {
+            if self.looped {
+                let len = self.data.len();
+                let wrap = (curr_idx % len) << 16;
+                self.phase_q16 = (wrap as u32) | (self.phase_q16 & 0xFFFF);
             } else {
                 return None;
             }
         }
-        let s = self.data[self.pos] as i8;
-        self.pos += 1;
-        Some(s)
+
+        let idx = (self.phase_q16 >> 16) as usize;
+        let frac = ((self.phase_q16 >> 8) & 0xFF) as u8;
+
+        let a = self.get_sample(idx);
+        let next_idx = if idx + 1 < self.data.len() {
+            idx + 1
+        } else if self.looped {
+            0
+        } else {
+            idx
+        };
+        let b = self.get_sample(next_idx);
+
+        let sample = lerp_i8(a, b, frac);
+        self.phase_q16 = self.phase_q16.wrapping_add(self.speed_q16);
+
+        Some(sample)
     }
 }

src/dsp.rs

@@ -384,3 +384,66 @@ impl EnvelopeFollower {
         self.envelope = 0.0;
     }
 }
+
+/// Fixed-point Q15 Biquad filter operating without hardware floating-point operations.
+#[derive(Debug, Clone)]
+pub struct BiquadAudioFilterQ15 {
+    // Coefficients scaled in Q14 (1.14 fixed point format)
+    b0: i16,
+    b1: i16,
+    b2: i16,
+    a1: i16,
+    a2: i16,
+    x1: i16,
+    x2: i16,
+    y1: i16,
+    y2: i16,
+}
+
+impl BiquadAudioFilterQ15 {
+    pub const fn new(b0: i16, b1: i16, b2: i16, a1: i16, a2: i16) -> Self {
+        Self {
+            b0,
+            b1,
+            b2,
+            a1,
+            a2,
+            x1: 0,
+            x2: 0,
+            y1: 0,
+            y2: 0,
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.x1 = 0;
+        self.x2 = 0;
+        self.y1 = 0;
+        self.y2 = 0;
+    }
+
+    /// Process a single 16-bit signed PCM sample (`i16`).
+    pub fn process_sample_i16(&mut self, x: i16) -> i16 {
+        let acc = (self.b0 as i32 * x as i32)
+            + (self.b1 as i32 * self.x1 as i32)
+            + (self.b2 as i32 * self.x2 as i32)
+            - (self.a1 as i32 * self.y1 as i32)
+            - (self.a2 as i32 * self.y2 as i32);
+
+        let y = (acc >> 14).clamp(-32768, 32767) as i16;
+
+        self.x2 = self.x1;
+        self.x1 = x;
+        self.y2 = self.y1;
+        self.y1 = y;
+
+        y
+    }
+
+    /// Process a single 8-bit signed PCM sample (`i8`).
+    pub fn process_sample_i8(&mut self, x: i8) -> i8 {
+        let x16 = (x as i16) << 8;
+        let y16 = self.process_sample_i16(x16);
+        (y16 >> 8) as i8
+    }
+}

src/encode/wav.rs

@@ -13,7 +13,8 @@ pub fn write_mono_u8(path: &str, sample_rate_hz: u32, samples: &[u8]) -> Result<
 }
 
 pub fn build_wav_u8(sample_rate_hz: u32, samples: &[u8]) -> Vec<u8> {
-    let byte_rate = sample_rate_hz * 1;
+    let byte_rate = sample_rate_hz;
+
     let block_align = 1u16;
     let data_len = samples.len() as u32;
     let riff_len = 36 + data_len;