rob
/
cpal
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

commenting and rustfmt for device

This commit is contained in:
Tom Gowan 2018-11-05 12:51:55 +11:00 committed by mitchmindtree
parent 5248455cb7
commit 1f24c76e6a
1 changed files with 81 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
src/platform/windows/asio/device.rs
View File

@ -3,21 +3,25 @@ use std;
pub type SupportedInputFormats = std::vec::IntoIter<SupportedFormat>;
pub type SupportedOutputFormats = std::vec::IntoIter<SupportedFormat>;
use std::hash::{Hash, Hasher};
use DefaultFormatError;
use Format;
use FormatsEnumerationError;
use DefaultFormatError;
use SupportedFormat;
use SampleFormat;
use SampleRate;
use std::hash::{Hash, Hasher};
use SupportedFormat;
/// A ASIO Device
#[derive(Debug, Clone)]
pub struct Device{
pub struct Device {
/// The drivers for this device
pub drivers: sys::Drivers,
/// The name of this device
pub name: String,
}
pub struct Devices{
/// All available devices
pub struct Devices {
drivers: std::vec::IntoIter<String>,
}
@ -40,40 +44,46 @@ impl Device {
self.name.clone()
}
// Just supporting default for now
pub fn supported_input_formats(&self) -> Result<SupportedInputFormats,
FormatsEnumerationError> {
match self.default_input_format() {
Ok(f) => {
/// Gets the supported input formats.
/// TODO currently only supports the default.
/// Need to find all possible formats.
pub fn supported_input_formats(
&self,
) -> Result<SupportedInputFormats, FormatsEnumerationError> {
match self.default_input_format() {
Ok(f) => {
// Can this device support both 44100 and 48000
let supported_formats: Vec<SupportedFormat> = [44100, 48000]
.into_iter()
.filter(|rate| self.drivers.can_sample_rate(**rate as u32) )
.filter(|rate| self.drivers.can_sample_rate(**rate as u32))
.map(|rate| {
let mut format = f.clone();
format.sample_rate = SampleRate(*rate);
SupportedFormat::from(format)
})
.collect();
//Ok(vec![SupportedFormat::from(f)].into_iter())
}).collect();
Ok(supported_formats.into_iter())
},
Err(_) => Err(FormatsEnumerationError::DeviceNotAvailable),
}
},
Err(_) => Err(FormatsEnumerationError::DeviceNotAvailable),
}
}
pub fn supported_output_formats(&self) -> Result<SupportedOutputFormats,
FormatsEnumerationError> {
/// Gets the supported output formats.
/// TODO currently only supports the default.
/// Need to find all possible formats.
pub fn supported_output_formats(
&self,
) -> Result<SupportedOutputFormats, FormatsEnumerationError> {
match self.default_output_format() {
Ok(f) => {
// Can this device support both 44100 and 48000
let supported_formats: Vec<SupportedFormat> = [44100, 48000]
.into_iter()
.filter(|rate| self.drivers.can_sample_rate(**rate as u32) )
.filter(|rate| self.drivers.can_sample_rate(**rate as u32))
.map(|rate| {
let mut format = f.clone();
format.sample_rate = SampleRate(*rate);
SupportedFormat::from(format)
})
.collect();
}).collect();
//Ok(vec![SupportedFormat::from(f)].into_iter())
Ok(supported_formats.into_iter())
},
@ -81,39 +91,42 @@ impl Device {
}
}
/// Returns the default input format
pub fn default_input_format(&self) -> Result<Format, DefaultFormatError> {
let channels = self.drivers.get_channels().ins as u16;
let sample_rate = SampleRate(self.drivers.get_sample_rate().rate);
// Map th ASIO sample type to a CPAL sample type
match self.drivers.get_data_type() {
Ok(sys::AsioSampleType::ASIOSTInt16MSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTInt32MSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTFloat32MSB) => Ok(SampleFormat::F32),
Ok(sys::AsioSampleType::ASIOSTInt16LSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTInt32LSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTFloat32LSB) => Ok(SampleFormat::F32),
_ => Err(DefaultFormatError::StreamTypeNotSupported),
}.map(|dt| {
Format{channels,
Ok(sys::AsioSampleType::ASIOSTInt16MSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTInt32MSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTFloat32MSB) => Ok(SampleFormat::F32),
Ok(sys::AsioSampleType::ASIOSTInt16LSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTInt32LSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTFloat32LSB) => Ok(SampleFormat::F32),
_ => Err(DefaultFormatError::StreamTypeNotSupported),
}.map(|dt| Format {
channels,
sample_rate,
data_type: dt }
data_type: dt,
})
}
/// Returns the default output format
pub fn default_output_format(&self) -> Result<Format, DefaultFormatError> {
let channels = self.drivers.get_channels().outs as u16;
let sample_rate = SampleRate(self.drivers.get_sample_rate().rate);
match self.drivers.get_data_type() {
// Map th ASIO sample type to a CPAL sample type
Ok(sys::AsioSampleType::ASIOSTInt16MSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTFloat32MSB) => Ok(SampleFormat::F32),
Ok(sys::AsioSampleType::ASIOSTInt16LSB) => Ok(SampleFormat::I16),
// TODO This should not be set to 16bit but is for testing
Ok(sys::AsioSampleType::ASIOSTInt32LSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTInt32LSB) => Ok(SampleFormat::I16),
Ok(sys::AsioSampleType::ASIOSTFloat32LSB) => Ok(SampleFormat::F32),
_ => Err(DefaultFormatError::StreamTypeNotSupported),
}.map(|dt|{
Format{channels,
}.map(|dt| Format {
channels,
sample_rate,
data_type: dt }
data_type: dt,
})
}
}
@ -125,25 +138,24 @@ impl Default for Devices {
.into_iter()
.filter(|name| sys::Drivers::load(&name).is_ok())
.collect();
Devices{ drivers: driver_names.into_iter() }
Devices {
drivers: driver_names.into_iter(),
}
}
}
impl Iterator for Devices {
type Item = Device;
/// Load drivers and return device
fn next(&mut self) -> Option<Device> {
match self.drivers.next() {
Some(name) => {
sys::Drivers::load(&name)
.or_else(|e| {
eprintln!("{}", e);
Err(e)
})
.ok()
.map(|drivers| Device{drivers, name} )
},
Some(name) => sys::Drivers::load(&name)
.or_else(|e| {
eprintln!("{}", e);
Err(e)
}).ok()
.map(|drivers| Device { drivers, name }),
None => None,
}
}
@ -153,36 +165,32 @@ impl Iterator for Devices {
}
}
// Asio doesn't have a concept of default
// so returning first in list as default
/// Asio doesn't have a concept of default
/// so returning first in list as default
pub fn default_input_device() -> Option<Device> {
let mut driver_list = sys::get_driver_list();
match driver_list.pop() {
Some(name) => {
sys::Drivers::load(&name)
.or_else(|e| {
eprintln!("{}", e);
Err(e)
})
.ok()
.map(|drivers| Device{drivers, name} )
},
Some(name) => sys::Drivers::load(&name)
.or_else(|e| {
eprintln!("{}", e);
Err(e)
}).ok()
.map(|drivers| Device { drivers, name }),
None => None,
}
}
/// Asio doesn't have a concept of default
/// so returning first in list as default
pub fn default_output_device() -> Option<Device> {
let mut driver_list = sys::get_driver_list();
match driver_list.pop() {
Some(name) => {
sys::Drivers::load(&name)
.or_else(|e| {
eprintln!("{}", e);
Err(e)
})
.ok()
.map(|drivers| Device{drivers, name} )
},
Some(name) => sys::Drivers::load(&name)
.or_else(|e| {
eprintln!("{}", e);
Err(e)
}).ok()
.map(|drivers| Device { drivers, name }),
None => None,
}
}