extern crate anyhow; extern crate cpal; extern crate structopt; use cpal::traits::{DeviceTrait, HostTrait, StreamTrait}; use structopt::StructOpt; #[derive(Debug, StructOpt)] #[structopt(name = "beep", about = "Simple example of audio playback.")] struct Opt { #[cfg(all( any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd"), feature = "jack" ))] #[structopt(short, long)] jack: bool, #[structopt(default_value = "default")] device: String, } fn main() -> anyhow::Result<()> { let opt = Opt::from_args(); // Conditionally compile with jack if the feature is specified. #[cfg(all( any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd"), feature = "jack" ))] // Manually check for flags. Can be passed through cargo with -- e.g. // cargo run --release --example beep --features jack -- --jack let host = if opt.jack { cpal::host_from_id(cpal::available_hosts() .into_iter() .find(|id| *id == cpal::HostId::Jack) .expect( "make sure --features jack is specified. only works on OSes where jack is available", )).expect("jack host unavailable") } else { cpal::default_host() }; #[cfg(any( not(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd")), not(feature = "jack") ))] let host = cpal::default_host(); let device = if opt.device == "default" { host.default_output_device() } else { host.output_devices()? .find(|x| x.name().map(|y| y == opt.device).unwrap_or(false)) } .expect("failed to find output device"); println!("Output device: {}", device.name()?); let config = device.default_output_config().unwrap(); println!("Default output config: {:?}", config); match config.sample_format() { cpal::SampleFormat::F32 => run::(&device, &config.into()), cpal::SampleFormat::I16 => run::(&device, &config.into()), cpal::SampleFormat::U16 => run::(&device, &config.into()), } } pub fn run(device: &cpal::Device, config: &cpal::StreamConfig) -> Result<(), anyhow::Error> where T: cpal::Sample, { let sample_rate = config.sample_rate.0 as f32; let channels = config.channels as usize; // Produce a sinusoid of maximum amplitude. let mut sample_clock = 0f32; let mut next_value = move || { sample_clock = (sample_clock + 1.0) % sample_rate; (sample_clock * 440.0 * 2.0 * std::f32::consts::PI / sample_rate).sin() }; let err_fn = |err| eprintln!("an error occurred on stream: {}", err); let stream = device.build_output_stream( config, move |data: &mut [T], _: &cpal::OutputCallbackInfo| { write_data(data, channels, &mut next_value) }, err_fn, )?; stream.play()?; std::thread::sleep(std::time::Duration::from_millis(1000)); Ok(()) } fn write_data(output: &mut [T], channels: usize, next_sample: &mut dyn FnMut() -> f32) where T: cpal::Sample, { for frame in output.chunks_mut(channels) { let value: T = cpal::Sample::from::(&next_sample()); for sample in frame.iter_mut() { *sample = value; } } }