Audio using HexoDSP

src/audio.rs

@@ -0,0 +1,150 @@
+// https://github.com/WeirdConstructor/HexoDSP/blob/master/examples/cpal_demo_node_api.rs
+
+use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
+use crossbeam_channel::Receiver;
+use hexodsp::{matrix_repr::MatrixRepr, *};
+use std::io::Read;
+use ticktock::Clock;
+
+pub enum AudioMsg {
+	Color([f32; 3]),
+	Jump,
+}
+
+pub fn setup(event_channel: Receiver<AudioMsg>) {
+	let mut buf = String::new();
+	std::fs::File::open("assets/init.hxy")
+		.unwrap()
+		.read_to_string(&mut buf)
+		.unwrap();
+	let matrix_repr: MatrixRepr = MatrixRepr::deserialize(&buf).unwrap();
+
+	let (node_conf, node_exec) = new_node_engine();
+
+	let mut matrix = Matrix::new(node_conf, 64, 64);
+	matrix.from_repr(&matrix_repr).unwrap();
+
+	start_backend(node_exec, move || {
+		let color_mix = NodeId::Mix3(0);
+		let color_mix_r_gain = color_mix.inp_param("gain1").unwrap();
+		let color_mix_g_gain = color_mix.inp_param("gain2").unwrap();
+		let color_mix_b_gain = color_mix.inp_param("gain3").unwrap();
+		let jump_ad = NodeId::Ad(0);
+		let jump_ad_trig = jump_ad.inp_param("trig").unwrap();
+
+		for (_tick, _now) in Clock::framerate(10.0).iter() {
+			matrix.set_param(jump_ad_trig, (0.0).into());
+
+			if let Ok(msg) = event_channel.try_recv() {
+				match msg {
+					AudioMsg::Color([r, g, b]) => {
+						matrix.set_param(color_mix_r_gain, r.into());
+						matrix.set_param(color_mix_g_gain, g.into());
+						matrix.set_param(color_mix_b_gain, b.into());
+					}
+					AudioMsg::Jump => matrix.set_param(jump_ad_trig, (1.0).into()),
+				}
+			}
+		}
+	});
+}
+
+pub fn run<T, F: FnMut()>(
+	device: &cpal::Device,
+	config: &cpal::StreamConfig,
+	mut node_exec: NodeExecutor,
+	mut frontend_loop: F,
+) 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);
+
+					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,
+		)
+		.unwrap();
+	stream.play().unwrap();
+
+	frontend_loop();
+}
+
+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),
+	};
+}