225 lines
8 KiB
Rust
225 lines
8 KiB
Rust
use hexodsp::*;
|
|
|
|
use anyhow;
|
|
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
|
|
|
fn main() {
|
|
let (mut node_conf, node_exec) = new_node_engine();
|
|
|
|
start_backend(node_exec, move || {
|
|
// To get an overview of the existing nodes you can
|
|
// take a look in the file src/dsp/mod.rs
|
|
// where the `macro_rules! node_list` definition
|
|
// is.
|
|
//
|
|
// This defines all supported nodes and their
|
|
// parameters/inputs ports and their outputs.
|
|
let sin = NodeId::Sin(0);
|
|
let amp = NodeId::Amp(0);
|
|
let out = NodeId::Out(0);
|
|
|
|
let amp_gain_param = amp.inp_param("gain").unwrap();
|
|
let sin_freq_param = sin.inp_param("freq").unwrap();
|
|
|
|
// Create the nodes in the frontend and in the
|
|
// audio backend. You only have to do this once
|
|
// and it's up to you to track which nodes you
|
|
// already created.
|
|
//
|
|
// Keep in mind, that the only way to deallocate
|
|
// notes is to call `node_conf.delete_nodes()`,
|
|
// which deletes all nodes.
|
|
//
|
|
// You can't delete only one specific node.
|
|
node_conf.create_node(sin);
|
|
node_conf.create_node(amp);
|
|
node_conf.create_node(out);
|
|
|
|
// Silence the Amp for the start
|
|
node_conf.set_param(amp_gain_param, (0.0).into());
|
|
|
|
// Create a NodeProg from the currently created nodes:
|
|
let mut prog = node_conf.rebuild_node_ports();
|
|
|
|
// The order you add the nodes to the NodeProg determines
|
|
// the order they will be executed by the audio thread.
|
|
// You will have to take care that all nodes get their
|
|
// data in the right order here.
|
|
node_conf.add_prog_node(&mut prog, &NodeId::Sin(0));
|
|
node_conf.add_prog_node(&mut prog, &NodeId::Amp(0));
|
|
node_conf.add_prog_node(&mut prog, &NodeId::Out(0));
|
|
|
|
// Define the connections between the nodes in the NodeProg:
|
|
node_conf.set_prog_node_exec_connection(
|
|
&mut prog,
|
|
// first the input:
|
|
(amp, amp.inp("inp").unwrap()),
|
|
// then the output that is assigned to it:
|
|
(sin, sin.out("sig").unwrap()),
|
|
);
|
|
|
|
node_conf.set_prog_node_exec_connection(
|
|
&mut prog,
|
|
(out, out.inp("ch1").unwrap()),
|
|
(amp, amp.out("sig").unwrap()),
|
|
);
|
|
|
|
node_conf.set_prog_node_exec_connection(
|
|
&mut prog,
|
|
(out, out.inp("ch2").unwrap()),
|
|
(amp, amp.out("sig").unwrap()),
|
|
);
|
|
|
|
// Finally upload the NodeProg to the audio thread.
|
|
node_conf.upload_prog(prog, true);
|
|
|
|
// You can repeatedly create new NodeProgs with `rebuild_node_ports`
|
|
// and change the graph all the way you like at runtime.
|
|
|
|
let mut amp_counter = 0;
|
|
let mut pitch_counter = 0;
|
|
loop {
|
|
// In this loop we simulate someone adjusting the paramter
|
|
// knobs of the amplifier gain and sine oscillator pitch.
|
|
//
|
|
// Please note, that for sample accurate modulation you should
|
|
// use the built in tracker or receive MIDI data from
|
|
// different application (MIDI processing has not been
|
|
// implemented yet though).
|
|
|
|
let new_gain = match amp_counter {
|
|
0 => 0.2,
|
|
1 => 0.3,
|
|
2 => 0.35,
|
|
3 => 0.3,
|
|
4 => 0.1,
|
|
_ => {
|
|
amp_counter = 0;
|
|
// Pitch is defined in 0.1 per octave.
|
|
// 0.0 is A4,
|
|
// 0.1 is A5
|
|
// -0.1 is A3
|
|
let new_pitch = match pitch_counter {
|
|
0 => 0.0, // A4
|
|
1 => -0.1, // A3
|
|
2 => 0.1, // A5
|
|
3 => -0.1, // A3
|
|
4 => -0.2, // A2
|
|
_ => {
|
|
pitch_counter = 0;
|
|
// -0.15 is 6 semitones above A3 => D#3
|
|
-0.15
|
|
}
|
|
};
|
|
pitch_counter += 1;
|
|
|
|
println!("set pitch={:4.2}", new_pitch);
|
|
node_conf.set_param(sin_freq_param, new_pitch.into());
|
|
|
|
0.1
|
|
}
|
|
};
|
|
amp_counter += 1;
|
|
|
|
println!("set gain={:4.2}", new_gain);
|
|
node_conf.set_param(amp_gain_param, new_gain.into());
|
|
|
|
std::thread::sleep(std::time::Duration::from_millis(300));
|
|
}
|
|
});
|
|
}
|
|
|
|
pub fn run<T, F: FnMut()>(
|
|
device: &cpal::Device,
|
|
config: &cpal::StreamConfig,
|
|
mut node_exec: NodeExecutor,
|
|
mut frontend_loop: F,
|
|
) -> Result<(), anyhow::Error>
|
|
where
|
|
T: cpal::Sample,
|
|
{
|
|
let sample_rate = config.sample_rate.0 as f32;
|
|
let channels = config.channels as usize;
|
|
|
|
node_exec.set_sample_rate(sample_rate);
|
|
|
|
let input_bufs = [[0.0; hexodsp::dsp::MAX_BLOCK_SIZE]; 2];
|
|
let mut outputbufs = [[0.0; hexodsp::dsp::MAX_BLOCK_SIZE]; 2];
|
|
|
|
let err_fn = |err| eprintln!("an error occurred on stream: {}", err);
|
|
let stream = device.build_output_stream(
|
|
config,
|
|
move |data: &mut [T], _: &cpal::OutputCallbackInfo| {
|
|
let mut frames_left = data.len() / channels;
|
|
|
|
let mut out_iter = data.chunks_mut(channels);
|
|
|
|
node_exec.process_graph_updates();
|
|
|
|
while frames_left > 0 {
|
|
let cur_nframes = if frames_left >= hexodsp::dsp::MAX_BLOCK_SIZE {
|
|
hexodsp::dsp::MAX_BLOCK_SIZE
|
|
} else {
|
|
frames_left
|
|
};
|
|
|
|
let input = &[&input_bufs[0][0..cur_nframes], &input_bufs[1][0..cur_nframes]];
|
|
|
|
let split = outputbufs.split_at_mut(1);
|
|
|
|
let mut output =
|
|
[&mut ((split.0[0])[0..cur_nframes]), &mut ((split.1[0])[0..cur_nframes])];
|
|
|
|
let mut context = Context { nframes: cur_nframes, output: &mut output[..], input };
|
|
|
|
context.output[0].fill(0.0);
|
|
context.output[1].fill(0.0);
|
|
|
|
node_exec.process(&mut context);
|
|
|
|
// This copy loop is a bit inefficient, it's likely you can
|
|
// pass the right array slices directly into node_exec.process()
|
|
// via the Context structure. But I was too lazy at this point
|
|
// to figure this out. Check also the Jack example for a more
|
|
// efficient solution.
|
|
for i in 0..cur_nframes {
|
|
if let Some(frame) = out_iter.next() {
|
|
let mut ctx_chan = 0;
|
|
for sample in frame.iter_mut() {
|
|
let value: T = cpal::Sample::from::<f32>(&context.output[ctx_chan][i]);
|
|
*sample = value;
|
|
|
|
ctx_chan += 1;
|
|
if ctx_chan > context.output.len() {
|
|
ctx_chan = context.output.len() - 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
frames_left -= cur_nframes;
|
|
}
|
|
},
|
|
err_fn,
|
|
)?;
|
|
stream.play()?;
|
|
|
|
frontend_loop();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// This function starts the CPAL backend and
|
|
// runs the audio loop with the NodeExecutor.
|
|
fn start_backend<F: FnMut()>(node_exec: NodeExecutor, frontend_loop: F) {
|
|
let host = cpal::default_host();
|
|
let device = host.default_output_device().expect("Finding useable audio device");
|
|
let config = device.default_output_config().expect("A workable output config");
|
|
|
|
match config.sample_format() {
|
|
cpal::SampleFormat::F32 => run::<f32, F>(&device, &config.into(), node_exec, frontend_loop),
|
|
cpal::SampleFormat::I16 => run::<i16, F>(&device, &config.into(), node_exec, frontend_loop),
|
|
cpal::SampleFormat::U16 => run::<u16, F>(&device, &config.into(), node_exec, frontend_loop),
|
|
}
|
|
.expect("cpal works fine");
|
|
}
|