summaryrefslogtreecommitdiff
path: root/src/window_function.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/window_function.rs')
-rw-r--r--src/window_function.rs259
1 files changed, 247 insertions, 12 deletions
diff --git a/src/window_function.rs b/src/window_function.rs
index 8e21694..b0ed54d 100644
--- a/src/window_function.rs
+++ b/src/window_function.rs
@@ -1,3 +1,6 @@
+#![allow(unused)]
+#![allow(dead_code)]
+
use crate::window_size::WindowSize;
use std::{collections::VecDeque, f32::consts::PI};
@@ -12,6 +15,7 @@ pub trait WindowFunction: Send {
fn window_size(&mut self, window_size: WindowSize);
}
+/// Effectively a chunking function rather than a sliding window
pub struct RectangularWindow {
window_size: usize,
}
@@ -33,9 +37,118 @@ impl WindowFunction for RectangularWindow {
self.window_size
}
- fn window_size(&mut self, _window_size: WindowSize) {}
+ fn window_size(&mut self, _window_size: WindowSize) {
+ todo!()
+ }
+}
+
+/// A window designed specifically to reduce clicking and leave all other artifacts
+/// Results vary
+pub struct HaemolacriaaWindow {
+ window_size: usize,
+ function_start: Vec<f32>,
+ function_end: Vec<f32>,
+ previous: Vec<f32>,
+ overlap_add: Vec<f32>,
+}
+
+impl HaemolacriaaWindow {
+ /// Ensure this value isn't greater than or equal to any default window size
+ const SAMPLE_COUNT: usize = 16;
+
+ pub fn new(window_size: &WindowSize) -> Self {
+ let window_size = window_size.inner();
+ let sample_count_f32 = Self::SAMPLE_COUNT as f32;
+
+ let overlap_add = vec![0.0; Self::SAMPLE_COUNT];
+
+ let function_start = (0..Self::SAMPLE_COUNT)
+ .map(|i| {
+ let x = i as f32 / (sample_count_f32 - 1.0);
+
+ f32::sin(PI * 0.5 * x)
+ })
+ .collect::<Vec<f32>>();
+
+ let function_end = (0..Self::SAMPLE_COUNT)
+ .map(|i| {
+ let x = i as f32 / (sample_count_f32 - 1.0);
+
+ f32::cos(PI * 0.5 * x)
+ })
+ .collect::<Vec<f32>>();
+
+ let previous = Vec::with_capacity(Self::SAMPLE_COUNT);
+
+ Self {
+ window_size,
+ function_start,
+ function_end,
+ previous,
+ overlap_add,
+ }
+ }
+}
+
+impl WindowFunction for HaemolacriaaWindow {
+ fn apply(&mut self, data: &mut VecDeque<f32>) {
+ let last_few = self.window_size - Self::SAMPLE_COUNT;
+
+ if self.previous.is_empty() {
+ for sample in data.iter().skip(last_few).copied() {
+ self.previous.push(sample);
+ }
+
+ for i in 0..Self::SAMPLE_COUNT {
+ data[i] *= self.function_start[i];
+ data[last_few + i] *= self.function_end[i];
+ }
+
+ return;
+ }
+
+ for sample in self.previous.iter().rev().copied() {
+ data.push_front(sample);
+ }
+
+ self.previous.clear();
+
+ for sample in data.iter().skip(last_few).copied() {
+ self.previous.push(sample);
+ }
+
+ for i in 0..Self::SAMPLE_COUNT {
+ data[i] *= self.function_start[i];
+ data[last_few + i] *= self.function_end[i];
+ }
+ }
+
+ fn reverse(&mut self, data: &mut [f32]) {
+ let last_few = self.window_size - Self::SAMPLE_COUNT;
+
+ for (i, sample) in data.iter_mut().take(Self::SAMPLE_COUNT).enumerate() {
+ *sample += self.overlap_add[i];
+ }
+
+ for (i, sample) in data.iter().skip(last_few).copied().enumerate() {
+ self.overlap_add[i] = sample;
+ }
+ }
+
+ fn needed(&self) -> usize {
+ if self.previous.is_empty() {
+ self.window_size
+ } else {
+ self.window_size - Self::SAMPLE_COUNT
+ }
+ }
+
+ fn window_size(&mut self, _window_size: WindowSize) {
+ todo!()
+ }
}
+/// Hann function
pub struct HannWindow {
window_size: usize,
function: Vec<f32>,
@@ -101,7 +214,6 @@ impl WindowFunction for HannWindow {
}
// In a real time "sliding window" it's necessary to add in the previous samples
- // to get the full resolution
for sample in self.previous.iter().rev().copied() {
data.push_front(sample);
}
@@ -122,15 +234,15 @@ impl WindowFunction for HannWindow {
fn reverse(&mut self, data: &mut [f32]) {
let half_window_size = self.window_size / 2;
- for i in 0..self.window_size {
- self.overlap_add[i] += data[i] * self.function[i];
+ for (i, sample) in data.iter().copied().enumerate() {
+ self.overlap_add[i] += sample * self.function[i];
}
- for i in 0..half_window_size {
+ for (i, sample) in data.iter_mut().enumerate().take(half_window_size) {
if self.normalize[i] > 1e-6 {
- data[i] = self.overlap_add[i] / self.normalize[i];
+ *sample = self.overlap_add[i] / self.normalize[i];
} else {
- data[i] = 0.0;
+ *sample = 0.0;
}
}
@@ -176,6 +288,7 @@ impl WindowFunction for HannWindow {
}
}
+/// 4-term Blackman-Harris window function
pub struct BlackmanHarrisWindow {
window_size: usize,
function: Vec<f32>,
@@ -267,15 +380,15 @@ impl WindowFunction for BlackmanHarrisWindow {
let quarter_window_size = self.window_size / 4;
let three_quarters_window_size = 3 * quarter_window_size;
- for i in 0..self.window_size {
- self.overlap_add[i] += data[i] * self.function[i];
+ for (i, sample) in data.iter().copied().enumerate() {
+ self.overlap_add[i] += sample * self.function[i];
}
- for i in 0..quarter_window_size {
+ for (i, sample) in data.iter_mut().enumerate().take(quarter_window_size) {
if self.normalize[i] > 1e-6 {
- data[i] = self.overlap_add[i] / self.normalize[i];
+ *sample = self.overlap_add[i] / self.normalize[i];
} else {
- data[i] = 0.0;
+ *sample = 0.0;
}
}
@@ -330,3 +443,125 @@ impl WindowFunction for BlackmanHarrisWindow {
.collect::<Vec<f32>>();
}
}
+
+/// 4th order power of sine window function
+pub struct Sine4Window {
+ window_size: usize,
+ function: Vec<f32>,
+ normalize: Vec<f32>,
+ previous: Vec<f32>,
+ overlap_add: Vec<f32>,
+}
+
+impl Sine4Window {
+ const A_0: f32 = 0.375;
+ const A_1: f32 = 0.5;
+ const A_2: f32 = 0.125;
+
+ pub fn new(window_size: &WindowSize) -> Self {
+ let window_size = window_size.inner();
+ let quarter_window_size = window_size / 4;
+ let three_quarters_window_size = 3 * quarter_window_size;
+ let window_size_f32 = window_size as f32;
+
+ let overlap_add = vec![0.0; window_size];
+
+ let previous = Vec::with_capacity(three_quarters_window_size);
+
+ let function = (0..window_size)
+ .map(|i| {
+ let i = i as f32;
+
+ let two = f32::cos((2.0 * PI * i) / (window_size_f32 - 1.0));
+ let four = f32::cos((4.0 * PI * i) / (window_size_f32 - 1.0));
+
+ Self::A_0 - (Self::A_1 * two) + (Self::A_2 * four)
+ })
+ .collect::<Vec<f32>>();
+
+ #[rustfmt::skip]
+ let normalize = (0..quarter_window_size)
+ .map(|i| {
+ (function[i] * function[i])
+ + (function[i + quarter_window_size] * function[i + quarter_window_size])
+ + (function[i + 2 * quarter_window_size] * function[i + 2 * quarter_window_size])
+ + (function[i + 3 * quarter_window_size] * function[i + 3 * quarter_window_size])
+ })
+ .collect::<Vec<f32>>();
+
+ Self {
+ window_size,
+ function,
+ normalize,
+ previous,
+ overlap_add,
+ }
+ }
+}
+
+impl WindowFunction for Sine4Window {
+ fn apply(&mut self, data: &mut VecDeque<f32>) {
+ let quarter_window_size = self.window_size / 4;
+
+ if self.previous.is_empty() {
+ for sample in data.iter().skip(quarter_window_size).copied() {
+ self.previous.push(sample);
+ }
+
+ for (i, sample) in data.iter_mut().enumerate() {
+ *sample *= self.function[i];
+ }
+
+ return;
+ }
+
+ for sample in self.previous.iter().rev().copied() {
+ data.push_front(sample);
+ }
+
+ self.previous.clear();
+
+ for sample in data.iter().skip(quarter_window_size).copied() {
+ self.previous.push(sample);
+ }
+
+ for (i, sample) in data.iter_mut().enumerate() {
+ *sample *= self.function[i];
+ }
+ }
+
+ fn reverse(&mut self, data: &mut [f32]) {
+ let quarter_window_size = self.window_size / 4;
+ let three_quarters_window_size = 3 * quarter_window_size;
+
+ for (i, sample) in data.iter().copied().enumerate() {
+ self.overlap_add[i] += sample * self.function[i];
+ }
+
+ for (i, sample) in data.iter_mut().enumerate().take(quarter_window_size) {
+ if self.normalize[i] > 1e-6 {
+ *sample = self.overlap_add[i] / self.normalize[i];
+ } else {
+ *sample = 0.0;
+ }
+ }
+
+ self.overlap_add.rotate_left(quarter_window_size);
+
+ for sample in &mut self.overlap_add[three_quarters_window_size..] {
+ *sample = 0.0;
+ }
+ }
+
+ fn needed(&self) -> usize {
+ if self.previous.is_empty() {
+ self.window_size
+ } else {
+ self.window_size / 4
+ }
+ }
+
+ fn window_size(&mut self, window_size: WindowSize) {
+ todo!()
+ }
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-07-18 09:58:13 +0000