cpal/src/lib.rs

229 lines
8.0 KiB
Rust
Raw Normal View History

2014-12-17 07:39:00 +00:00
#![feature(macro_rules)]
2014-12-11 16:23:33 +00:00
#![feature(unsafe_destructor)]
2014-12-17 08:13:58 +00:00
#![unstable]
2014-12-11 13:22:55 +00:00
2014-12-16 15:45:45 +00:00
#[cfg(all(not(windows), not(unix)))]
2014-12-11 13:22:55 +00:00
use this_platform_is_not_supported;
2014-12-17 07:47:19 +00:00
pub use samples_formats::{SampleFormat, Sample};
2014-12-15 10:45:38 +00:00
mod conversions;
2014-12-17 07:47:19 +00:00
mod samples_formats;
2014-12-15 10:45:38 +00:00
2014-12-16 15:45:45 +00:00
#[cfg(unix)]
#[path="alsa/mod.rs"]
2014-12-17 08:13:58 +00:00
mod cpal_impl;
2014-12-11 13:22:55 +00:00
#[cfg(windows)]
#[path="wasapi/mod.rs"]
2014-12-17 08:13:58 +00:00
mod cpal_impl;
2014-12-11 16:23:33 +00:00
2014-12-17 08:13:58 +00:00
/// Controls a sound output.
2014-12-11 17:09:48 +00:00
///
2014-12-17 08:13:58 +00:00
/// Create one `Channel` for each sound that you want to play.
///
/// A channel must be periodically filled with new data by calling `append_data`, or the sound
/// will stop playing.
2014-12-11 16:23:33 +00:00
pub struct Channel(cpal_impl::Channel);
2014-12-11 18:02:04 +00:00
/// Number of channels.
pub type ChannelsCount = u16;
2014-12-15 10:45:38 +00:00
///
#[deriving(Show, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct SamplesRate(pub u32);
2014-12-15 10:45:38 +00:00
2014-12-11 17:09:48 +00:00
/// Represents a buffer that must be filled with audio data.
///
/// A `Buffer` object borrows the channel.
2014-12-15 14:29:59 +00:00
pub struct Buffer<'a, T> {
// also contains something, taken by `Drop`
target: Option<cpal_impl::Buffer<'a, T>>,
// if this is non-none, then the data will be written to `conversion.intermediate_buffer`
// instead of `target`, and the conversion will be done in buffer's destructor
conversion: Option<RequiredConversion<T>>,
}
2014-12-15 10:45:38 +00:00
struct RequiredConversion<T> {
intermediate_buffer: Vec<T>,
from_sample_rate: SamplesRate,
to_sample_rate: SamplesRate,
to_format: SampleFormat,
from_channels: ChannelsCount,
to_channels: ChannelsCount,
}
2014-12-11 16:23:33 +00:00
impl Channel {
2014-12-17 08:13:58 +00:00
/// Builds a new channel.
2014-12-11 16:23:33 +00:00
pub fn new() -> Channel {
let channel = cpal_impl::Channel::new();
Channel(channel)
}
2014-12-11 17:09:48 +00:00
/// Returns the number of channels.
///
/// 1 for mono, 2 for stereo, etc.
2014-12-11 18:02:04 +00:00
pub fn get_channels(&self) -> ChannelsCount {
2014-12-11 16:23:33 +00:00
self.0.get_channels()
}
2014-12-11 18:07:58 +00:00
/// Returns the number of samples that are played per second.
///
/// Common values are 22050 Hz or 44100 Hz.
2014-12-15 10:45:38 +00:00
pub fn get_samples_rate(&self) -> SamplesRate {
self.0.get_samples_rate()
2014-12-11 18:07:58 +00:00
}
/// Returns the number of samples that are played per second.
///
/// Common values are 22050 Hz or 44100 Hz.
pub fn get_samples_format(&self) -> SampleFormat {
self.0.get_samples_format()
}
2014-12-11 17:09:48 +00:00
/// Adds some PCM data to the channel's buffer.
///
/// This function returns a `Buffer` object that must be filled with the audio data.
/// You can't know in advance the size of the buffer, as it depends on the current state
/// of the backend.
2014-12-15 15:26:55 +00:00
///
/// ## Panic
///
/// Panics if `max_elements` is 0 or is not a multiple of `channels`.
///
2014-12-15 10:45:38 +00:00
pub fn append_data<'a, T>(&'a mut self, channels: ChannelsCount,
2014-12-15 15:26:55 +00:00
samples_rate: SamplesRate, max_elements: uint)
2014-12-15 10:45:38 +00:00
-> Buffer<'a, T> where T: Sample + Clone
{
2014-12-15 15:26:55 +00:00
assert!(max_elements != 0);
assert!(max_elements % channels as uint == 0);
2014-12-15 10:45:38 +00:00
let target_samples_rate = self.0.get_samples_rate();
let target_channels = self.0.get_channels();
let source_samples_format = Sample::get_format(None::<T>);
let target_samples_format = self.0.get_samples_format();
// if we need to convert the incoming data
if samples_rate != target_samples_rate || channels != target_channels ||
source_samples_format != target_samples_format
{
let max_elements = max_elements * target_channels as uint / channels as uint;
2014-12-17 07:39:00 +00:00
let max_elements = max_elements * target_samples_rate.0 as uint /
samples_rate.0 as uint;
let max_elements = max_elements * target_samples_format.get_sample_size() /
source_samples_format.get_sample_size();
2014-12-15 15:26:55 +00:00
let mut target_buffer = self.0.append_data(max_elements);
2014-12-15 10:45:38 +00:00
// computing the length of the intermediary buffer
let intermediate_buffer_length = target_buffer.get_buffer().len();
let intermediate_buffer_length = intermediate_buffer_length * channels as uint /
target_channels as uint;
let intermediate_buffer_length = intermediate_buffer_length * samples_rate.0 as uint /
target_samples_rate.0 as uint;
2014-12-17 07:39:00 +00:00
let intermediate_buffer_length = intermediate_buffer_length *
source_samples_format.get_sample_size() /
target_samples_format.get_sample_size();
2014-12-15 15:41:57 +00:00
let intermediate_buffer = Vec::from_elem(intermediate_buffer_length, unsafe { std::mem::uninitialized() });
2014-12-15 10:45:38 +00:00
2014-12-15 14:29:59 +00:00
Buffer {
target: Some(target_buffer),
conversion: Some(RequiredConversion {
2014-12-15 10:45:38 +00:00
intermediate_buffer: intermediate_buffer,
from_sample_rate: samples_rate,
to_sample_rate: target_samples_rate,
to_format: target_samples_format,
from_channels: channels,
to_channels: target_channels,
2014-12-15 14:29:59 +00:00
}),
}
2014-12-15 10:45:38 +00:00
} else {
2014-12-15 14:29:59 +00:00
Buffer {
2014-12-15 15:26:55 +00:00
target: Some(self.0.append_data(max_elements)),
2014-12-15 14:29:59 +00:00
conversion: None,
}
2014-12-15 10:45:38 +00:00
}
2014-12-11 16:23:33 +00:00
}
}
2014-12-15 15:32:13 +00:00
impl<'a, T> Deref<[T]> for Buffer<'a, T> {
fn deref(&self) -> &[T] {
panic!("It is forbidden to read from the audio buffer");
2014-12-11 16:23:33 +00:00
}
}
2014-12-15 15:32:13 +00:00
impl<'a, T> DerefMut<[T]> for Buffer<'a, T> {
fn deref_mut(&mut self) -> &mut [T] {
if let Some(ref mut conversion) = self.conversion {
conversion.intermediate_buffer.as_mut_slice()
} else {
self.target.as_mut().unwrap().get_buffer()
}
2014-12-15 10:45:38 +00:00
}
}
#[unsafe_destructor]
impl<'a, T> Drop for Buffer<'a, T> where T: Sample {
fn drop(&mut self) {
2014-12-15 14:29:59 +00:00
if let Some(conversion) = self.conversion.take() {
2014-12-15 10:45:38 +00:00
let buffer = conversion.intermediate_buffer;
let buffer = if conversion.from_channels != conversion.to_channels {
conversions::convert_channels(buffer.as_slice(), conversion.from_channels,
conversion.to_channels)
} else {
buffer
};
let buffer = if conversion.from_sample_rate != conversion.to_sample_rate {
conversions::convert_samples_rate(buffer.as_slice(), conversion.from_sample_rate,
conversion.to_sample_rate)
} else {
buffer
};
2014-12-15 14:29:59 +00:00
let output = self.target.as_mut().unwrap().get_buffer();
2014-12-15 10:45:38 +00:00
assert!(buffer.len() == output.len(), "Buffers length mismatch: {} vs {}", buffer.len(), output.len());
2014-12-17 07:39:00 +00:00
macro_rules! write_to_buf(
($buf:expr, $output:expr, $ty:ty) => ({
use std::borrow::Cow;
2014-12-17 07:39:00 +00:00
let output: &mut [$ty] = unsafe { std::mem::transmute($output) };
match $buf {
Cow::Borrowed(buf) => {
for (i, o) in buf.iter().zip(output.iter_mut()) {
*o = *i;
}
},
Cow::Owned(buf) => {
for (i, o) in buf.into_iter().zip(output.iter_mut()) {
*o = i;
}
}
2014-12-17 07:39:00 +00:00
}
})
)
match conversion.to_format {
SampleFormat::I16 => {
2014-12-17 07:47:19 +00:00
let buffer = Sample::to_vec_i16(buffer.as_slice());
write_to_buf!(buffer, output, i16);
2014-12-17 07:39:00 +00:00
},
SampleFormat::U16 => {
let buffer = Sample::to_vec_u16(buffer.as_slice());
write_to_buf!(buffer, output, u16);
},
2014-12-17 07:47:19 +00:00
SampleFormat::F32 => {
let buffer = Sample::to_vec_f32(buffer.as_slice());
write_to_buf!(buffer, output, f32);
},
2014-12-15 10:45:38 +00:00
}
}
2014-12-15 14:29:59 +00:00
2014-12-15 15:32:13 +00:00
self.target.take().unwrap().finish();
2014-12-11 16:23:33 +00:00
}
}