extern crate portaudio;
use portaudio::pa;
use std::error::Error;
const SAMPLE_RATE: f64 = 44_100.0;
const FRAMES: u32 = 256;
fn main() {
println!("PortAudio version : {}", pa::get_version());
println!("PortAudio version text : {}", pa::get_version_text());
match pa::initialize() {
Ok(()) => println!("Successfully initialized PortAudio"),
Err(err) => println!("An error occurred while initializing PortAudio: {}", err.description()),
}
println!("PortAudio host count : {}", pa::host::get_api_count() as isize);
let default_host = pa::host::get_default_api();
println!("PortAudio default host : {}", default_host as isize);
match pa::host::get_api_info(default_host) {
None => println!("Couldn't retrieve api info for the default host."),
Some(info) => println!("PortAudio host name : {}", info.name),
}
let def_input = pa::device::get_default_input();
let input_info = match pa::device::get_info(def_input) {
Ok(info) => info,
Err(err) => panic!("An error occurred while retrieving input info: {}", err.description()),
};
println!("Default input device info :");
println!("\tversion : {}", input_info.struct_version);
println!("\tname : {}", input_info.name);
println!("\tmax input channels : {}", input_info.max_input_channels);
println!("\tmax output channels : {}", input_info.max_output_channels);
println!("\tdefault sample rate : {}", input_info.default_sample_rate);
let input_stream_params = pa::StreamParameters {
device : def_input,
channel_count : 2,
sample_format : pa::SampleFormat::Float32,
suggested_latency : input_info.default_low_input_latency
};
let def_output = pa::device::get_default_output();
let output_info = match pa::device::get_info(def_output) {
Ok(info) => info,
Err(err) => panic!("An error occurred while retrieving output info: {}", err.description()),
};
println!("Default output device name : {}", output_info.name);
let output_stream_params = pa::StreamParameters {
device : def_output,
channel_count : 2,
sample_format : pa::SampleFormat::Float32,
suggested_latency : output_info.default_low_output_latency
};
if let Err(err) = pa::is_format_supported(Some(&input_stream_params), Some(&output_stream_params), SAMPLE_RATE) {
panic!("The given stream format is unsupported: {:?}", err.description());
}
let mut stream : pa::Stream<f32, f32> = pa::Stream::new();
let mut count_down = 3.0;
let mut maybe_last_time = None;
let (sender, receiver) = ::std::sync::mpsc::channel();
let callback = Box::new(move |
input: &[f32],
output: &mut[f32],
frames: u32,
time_info: &pa::StreamCallbackTimeInfo,
_flags: pa::StreamCallbackFlags,
| -> pa::StreamCallbackResult {
let current_time = time_info.current_time;
let prev_time = maybe_last_time.unwrap_or(current_time);
let dt = current_time - prev_time;
count_down -= dt;
maybe_last_time = Some(current_time);
assert!(frames == FRAMES);
sender.send(count_down).ok();
for (output_sample, input_sample) in output.iter_mut().zip(input.iter()) {
*output_sample = *input_sample;
}
if count_down > 0.0 {
pa::StreamCallbackResult::Continue
} else {
pa::StreamCallbackResult::Complete
}
});
match stream.open(Some(&input_stream_params),
Some(&output_stream_params),
SAMPLE_RATE,
FRAMES,
pa::StreamFlags::empty(),
Some(callback)) {
Ok(()) => println!("Successfully opened the stream."),
Err(err) => println!("An error occurred while opening the stream: {}", err.description()),
}
match stream.start() {
Ok(()) => println!("Successfully started the stream."),
Err(err) => println!("An error occurred while starting the stream: {}", err.description()),
}
while let Ok(true) = stream.is_active() {
while let Ok(count_down) = receiver.try_recv() {
println!("count_down: {:?}", count_down);
}
}
match stream.close() {
Ok(()) => println!("Successfully closed the stream."),
Err(err) => println!("An error occurred while closing the stream: {}", err.description()),
}
println!("");
match pa::terminate() {
Ok(()) => println!("Successfully terminated PortAudio."),
Err(err) => println!("An error occurred while terminating PortAudio: {}", err.description()),
}
}