use crate::{stream, Buffer, Device, Receiver, Stream, StreamError};
use cpal::traits::{DeviceTrait, EventLoopTrait, HostTrait};
use sample::{FromSample, Sample, ToSample};
use std::sync::atomic::AtomicBool;
use std::sync::mpsc;
use std::sync::{Arc, Mutex};
pub type Result<'a, S = f32> = std::result::Result<&'a Buffer<S>, StreamError>;
pub trait CaptureFn<M, S>: Fn(&mut M, &Buffer<S>) {}
pub trait CaptureResultFn<M, S>: Fn(&mut M, Result<S>) {}
pub type DefaultCaptureFn<M, S> = fn(&mut M, &Buffer<S>);
pub type DefaultCaptureResultFn<M, S> = fn(&mut M, Result<S>);
pub(crate) fn default_capture_fn<M, S>(_: &mut M, _: &Buffer<S>) {}
pub enum Capture<A, B> {
BufferFn(A),
ResultFn(B),
}
pub struct Builder<M, FA, FB, S = f32> {
pub builder: super::Builder<M, S>,
pub capture: Capture<FA, FB>,
}
pub type BuilderInit<M, S = f32> =
Builder<M, DefaultCaptureFn<M, S>, DefaultCaptureResultFn<M, S>, S>;
type InputDevices = cpal::InputDevices<cpal::Devices>;
pub struct Devices {
pub(crate) devices: InputDevices,
}
impl<M, S, F> CaptureFn<M, S> for F where F: Fn(&mut M, &Buffer<S>) {}
impl<M, S, F> CaptureResultFn<M, S> for F where F: Fn(&mut M, Result<S>) {}
impl<A, B> Capture<A, B> {
pub(crate) fn capture<M, S>(&self, model: &mut M, result: Result<S>)
where
A: CaptureFn<M, S>,
B: CaptureResultFn<M, S>,
{
match *self {
Capture::BufferFn(ref f) => {
let buffer = match result {
Ok(b) => b,
Err(err) => {
panic!(
"An input stream error occurred: {}\nIf you wish to handle this \
error within your code, consider building your input stream with \
a `capture_result` function rather than a `capture` function.",
err,
);
}
};
f(model, buffer);
}
Capture::ResultFn(ref f) => f(model, result),
}
}
}
impl<M, FA, FB, S> Builder<M, FA, FB, S> {
pub fn capture<G>(self, capture: G) -> Builder<M, G, DefaultCaptureResultFn<M, S>, S> {
let Builder { builder, .. } = self;
let capture = Capture::BufferFn(capture);
Builder { capture, builder }
}
pub fn capture_result<G>(self, capture_result: G) -> Builder<M, DefaultCaptureFn<M, S>, G, S> {
let Builder { builder, .. } = self;
let capture = Capture::ResultFn(capture_result);
Builder { capture, builder }
}
pub fn sample_rate(mut self, sample_rate: u32) -> Self {
assert!(sample_rate > 0);
self.builder.sample_rate = Some(sample_rate);
self
}
pub fn channels(mut self, channels: usize) -> Self {
assert!(channels > 0);
self.builder.channels = Some(channels);
self
}
pub fn device(mut self, device: Device) -> Self {
self.builder.device = Some(device);
self
}
pub fn frames_per_buffer(mut self, frames_per_buffer: usize) -> Self {
assert!(frames_per_buffer > 0);
self.builder.frames_per_buffer = Some(frames_per_buffer);
self
}
pub fn build(self) -> std::result::Result<Stream<M>, super::BuildError>
where
S: 'static + Send + Sample + FromSample<u16> + FromSample<i16> + FromSample<f32>,
M: 'static + Send,
FA: 'static + CaptureFn<M, S> + Send,
FB: 'static + CaptureResultFn<M, S> + Send,
{
let Builder {
capture,
builder:
stream::Builder {
host,
event_loop,
process_fn_tx,
model,
sample_rate,
channels,
frames_per_buffer,
device,
..
},
} = self;
let sample_rate = sample_rate
.map(|sr| cpal::SampleRate(sr))
.or(Some(cpal::SampleRate(super::DEFAULT_SAMPLE_RATE)));
let sample_format = super::cpal_sample_format::<S>();
let device = match device {
None => host
.default_input_device()
.ok_or(super::BuildError::DefaultDevice)?,
Some(Device { device }) => device,
};
let format = super::find_best_matching_format(
&device,
sample_format,
channels,
sample_rate,
device.default_input_format().ok(),
|device| device.supported_input_formats().map(|fs| fs.collect()),
)?
.expect("no matching supported audio input formats for the target device");
let stream_id = event_loop.build_input_stream(&device, &format)?;
let (update_tx, update_rx) = mpsc::channel();
let model = Arc::new(Mutex::new(Some(model)));
let model_2 = model.clone();
let num_channels = format.channels as usize;
let sample_rate = format.sample_rate.0;
let mut pending_updates: Vec<Box<dyn FnMut(&mut M) + 'static + Send>> = Vec::new();
let frames_per_buffer = frames_per_buffer.unwrap_or(Buffer::<S>::DEFAULT_LEN_FRAMES);
let mut receiver = Receiver::new(frames_per_buffer, num_channels);
let mut samples = vec![S::equilibrium(); frames_per_buffer * num_channels];
let proc_input = move |data: cpal::StreamDataResult| {
macro_rules! process_pending_updates {
() => {
pending_updates.extend(update_rx.try_iter());
if !pending_updates.is_empty() {
if let Ok(mut guard) = model_2.lock() {
let mut model = guard.take().unwrap();
for mut update in pending_updates.drain(..) {
update(&mut model);
}
*guard = Some(model);
}
}
};
}
process_pending_updates!();
let input = match data {
Err(err) => {
if let Ok(mut guard) = model_2.lock() {
let mut m = guard.take().unwrap();
capture.capture(&mut m, Err(err));
}
return;
}
Ok(cpal::StreamData::Input { buffer }) => buffer,
_ => unreachable!(),
};
samples.clear();
samples.resize(input.len(), S::equilibrium());
fn fill_input<I, S>(input: &mut [I], buffer: &[S])
where
I: Sample,
S: Sample + ToSample<I>,
{
for (in_sample, sample) in input.iter_mut().zip(buffer) {
*in_sample = sample.to_sample();
}
}
match input {
cpal::UnknownTypeInputBuffer::U16(buffer) => {
fill_input(&mut samples, &buffer);
}
cpal::UnknownTypeInputBuffer::I16(buffer) => {
fill_input(&mut samples, &buffer);
}
cpal::UnknownTypeInputBuffer::F32(buffer) => {
fill_input(&mut samples, &buffer);
}
}
if let Ok(mut guard) = model_2.lock() {
let mut m = guard.take().unwrap();
m = receiver.read_buffer(m, &capture, &samples, num_channels, sample_rate);
*guard = Some(m);
}
process_pending_updates!();
};
process_fn_tx
.send((stream_id.clone(), Box::new(proc_input)))
.unwrap();
let shared = Arc::new(super::Shared {
model,
stream_id,
event_loop,
is_paused: AtomicBool::new(false),
});
let stream = Stream {
shared,
process_fn_tx,
update_tx,
cpal_format: format,
};
Ok(stream)
}
}
impl<M, S> Default for Capture<DefaultCaptureFn<M, S>, DefaultCaptureResultFn<M, S>> {
fn default() -> Self {
Capture::BufferFn(default_capture_fn)
}
}
impl Iterator for Devices {
type Item = Device;
fn next(&mut self) -> Option<Self::Item> {
self.devices.next().map(|device| Device { device })
}
}