aether_timbre/
transfer.rs

1//! Timbre transfer — apply a target instrument's spectral envelope to a source signal.
2
3use rustfft::{FftPlanner, num_complex::Complex};
4use crate::analysis::SpectralEnvelope;
5
6/// Applies spectral envelope transfer in real time using overlap-add.
7pub struct TimbreTransfer {
8    fft_size: usize,
9    hop_size: usize,
10    /// Target spectral envelope to impose.
11    target_envelope: Option<SpectralEnvelope>,
12    /// Transfer amount: 0.0 = no transfer, 1.0 = full transfer.
13    pub amount: f32,
14    /// Input overlap buffer.
15    #[allow(dead_code)]
16    input_buffer: Vec<f32>,
17    /// Output overlap-add buffer.
18    #[allow(dead_code)]
19    output_buffer: Vec<f32>,
20    /// Analysis window.
21    window: Vec<f32>,
22    planner: FftPlanner<f32>,
23}
24
25impl TimbreTransfer {
26    pub fn new(fft_size: usize) -> Self {
27        let fft_size = fft_size.next_power_of_two();
28        let hop_size = fft_size / 4;
29        let window: Vec<f32> = (0..fft_size)
30            .map(|i| 0.5 * (1.0 - (2.0 * std::f32::consts::PI * i as f32 / (fft_size - 1) as f32).cos()))
31            .collect();
32        Self {
33            fft_size,
34            hop_size,
35            target_envelope: None,
36            amount: 1.0,
37            input_buffer: vec![0.0; fft_size * 2],
38            output_buffer: vec![0.0; fft_size * 2],
39            window,
40            planner: FftPlanner::new(),
41        }
42    }
43
44    /// Set the target spectral envelope.
45    pub fn set_target(&mut self, envelope: SpectralEnvelope) {
46        self.target_envelope = Some(envelope);
47    }
48
49    /// Clear the target (pass-through mode).
50    pub fn clear_target(&mut self) {
51        self.target_envelope = None;
52    }
53
54    /// Process a block of audio samples.
55    /// Returns the processed output (same length as input).
56    pub fn process_block(&mut self, input: &[f32]) -> Vec<f32> {
57        if self.target_envelope.is_none() || self.amount < 0.001 {
58            return input.to_vec();
59        }
60
61        let target = self.target_envelope.as_ref().unwrap();
62        let fft = self.planner.plan_fft_forward(self.fft_size);
63        let ifft = self.planner.plan_fft_inverse(self.fft_size);
64
65        let mut output = vec![0.0f32; input.len()];
66
67        // Simple single-frame processing for now (full overlap-add in v0.2)
68        // Process in fft_size chunks
69        let mut pos = 0;
70        while pos + self.fft_size <= input.len() {
71            // Apply window
72            let mut buf: Vec<Complex<f32>> = input[pos..pos + self.fft_size]
73                .iter()
74                .zip(self.window.iter())
75                .map(|(&s, &w)| Complex::new(s * w, 0.0))
76                .collect();
77
78            // Forward FFT
79            fft.process(&mut buf);
80
81            // Extract source envelope and apply target envelope
82            let n_bins = self.fft_size / 2 + 1;
83            let mut source_env = vec![0.0f32; n_bins];
84            for i in 0..n_bins {
85                source_env[i] = buf[i].norm().max(1e-10);
86            }
87            let smoothed_source = smooth(&source_env, 4);
88
89            for i in 0..n_bins {
90                let src_mag = smoothed_source[i];
91                let tgt_mag = target.magnitudes.get(i).copied().unwrap_or(1.0).max(1e-10);
92                let ratio = (tgt_mag / src_mag).powf(self.amount);
93                // Apply ratio to both positive and negative frequency bins
94                buf[i] *= ratio;
95                if i > 0 && i < self.fft_size - i {
96                    buf[self.fft_size - i] *= ratio;
97                }
98            }
99
100            // Inverse FFT
101            ifft.process(&mut buf);
102
103            // Normalize and overlap-add
104            let norm = 1.0 / self.fft_size as f32;
105            for (j, s) in buf.iter().enumerate().take(self.fft_size) {
106                if pos + j < output.len() {
107                    let dry = input[pos + j];
108                    let wet = s.re * norm;
109                    output[pos + j] = dry * (1.0 - self.amount) + wet * self.amount;
110                }
111            }
112
113            pos += self.hop_size;
114        }
115
116        // Copy remaining samples unchanged
117        if pos < input.len() {
118            output[pos..].copy_from_slice(&input[pos..]);
119        }
120
121        output
122    }
123}
124
125fn smooth(v: &[f32], w: usize) -> Vec<f32> {
126    let n = v.len();
127    let mut out = vec![0.0f32; n];
128    for (i, val) in out.iter_mut().enumerate() {
129        let s = i.saturating_sub(w / 2);
130        let e = (i + w / 2 + 1).min(n);
131        *val = v[s..e].iter().sum::<f32>() / (e - s) as f32;
132    }
133    out
134}
aether_timbre/transfer.rs

aether_timbre/
transfer.rs
