101 lines
2.8 KiB
Rust
101 lines
2.8 KiB
Rust
#![allow(incomplete_features)]
|
|
#![feature(generic_associated_types)]
|
|
|
|
use baseplug::{Plugin, ProcessContext};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use utils::threeband::*;
|
|
|
|
baseplug::model! {
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
struct ThreeBandFoldingModel {
|
|
#[model(min = 0.0, max = 15000.0)]
|
|
#[parameter(name = "low band")]
|
|
low_band: f32,
|
|
#[model(min = 0.0, max = 15000.0)]
|
|
#[parameter(name = "mid band")]
|
|
high_band: f32,
|
|
|
|
#[model(min = 0.0, max = 100.0)]
|
|
#[parameter(name = "low folding freq", gradient = "Power(3.0)")]
|
|
low_freq: f32,
|
|
#[model(min = 0.0, max = 100.0)]
|
|
#[parameter(name = "mid folding freq", gradient = "Power(3.0)")]
|
|
mid_freq: f32,
|
|
#[model(min = 0.0, max = 100.0)]
|
|
#[parameter(name = "high folding freq", gradient = "Power(3.0)")]
|
|
high_freq: f32,
|
|
}
|
|
}
|
|
|
|
impl Default for ThreeBandFoldingModel {
|
|
fn default() -> Self {
|
|
Self {
|
|
low_band: 800.0,
|
|
high_band: 5000.0,
|
|
|
|
low_freq: 1.0,
|
|
mid_freq: 1.0,
|
|
high_freq: 1.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct ThreeBandFolding {
|
|
l: ThreeBandSplitter,
|
|
r: ThreeBandSplitter,
|
|
}
|
|
|
|
impl Plugin for ThreeBandFolding {
|
|
const NAME: &'static str = "threebandfolding";
|
|
const PRODUCT: &'static str = "threebandfolding";
|
|
const VENDOR: &'static str = "unnieversal";
|
|
|
|
const INPUT_CHANNELS: usize = 2;
|
|
const OUTPUT_CHANNELS: usize = 2;
|
|
|
|
type Model = ThreeBandFoldingModel;
|
|
|
|
#[inline]
|
|
fn new(_sample_rate: f32, _model: &ThreeBandFoldingModel) -> Self {
|
|
// Default cause we want to start with 0s in everything
|
|
Self::default()
|
|
}
|
|
|
|
#[inline]
|
|
fn process(&mut self, model: &ThreeBandFoldingModelProcess, ctx: &mut ProcessContext<Self>) {
|
|
let input = &ctx.inputs[0].buffers;
|
|
let output = &mut ctx.outputs[0].buffers;
|
|
|
|
let sr = ctx.sample_rate;
|
|
|
|
for i in 0..ctx.nframes {
|
|
// frequencies
|
|
let lf = model.low_band[i];
|
|
let hf = model.high_band[i];
|
|
|
|
// split into bands
|
|
let (low_l, mid_l, high_l) = self.l.process(input[0][i], lf, hf, sr);
|
|
let (low_r, mid_r, high_r) = self.r.process(input[1][i], lf, hf, sr);
|
|
|
|
// widen each band
|
|
let (low_l, low_r) = fold(model.low_freq[i], low_l, low_r);
|
|
let (mid_l, mid_r) = fold(model.mid_freq[i], mid_l, mid_r);
|
|
let (high_l, high_r) = fold(model.high_freq[i], high_l, high_r);
|
|
|
|
output[0][i] = low_l + mid_l + high_l;
|
|
output[1][i] = low_r + mid_r + high_r;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn fold(freq: f32, l: f32, r: f32) -> (f32, f32) {
|
|
let l = (l * freq).sin();
|
|
let r = (r * freq).sin();
|
|
|
|
(l, r)
|
|
}
|
|
|
|
baseplug::vst2!(ThreeBandFolding, b"3bsf");
|