From 32bca93cc9834f461b2699ae317a75ba0cbd88f4 Mon Sep 17 00:00:00 2001 From: Pierre Krieger Date: Mon, 15 Dec 2014 11:45:38 +0100 Subject: [PATCH] Implement some basic data conversion --- examples/beep.rs | 8 +-- src/conversions.rs | 41 +++++++++++++ src/lib.rs | 140 +++++++++++++++++++++++++++++++++++++++++++-- src/wasapi/mod.rs | 4 +- 4 files changed, 180 insertions(+), 13 deletions(-) create mode 100644 src/conversions.rs diff --git a/examples/beep.rs b/examples/beep.rs index 5d98410..a19ced3 100644 --- a/examples/beep.rs +++ b/examples/beep.rs @@ -3,8 +3,6 @@ extern crate cpal; fn main() { let mut channel = cpal::Channel::new(); - assert!(channel.get_samples_format() == cpal::SampleFormat::U16); - // producing a sinusoid let mut data_source = std::iter::iterate(0.0f32, |f| f + 0.03) @@ -20,13 +18,13 @@ fn main() { }); loop { - let mut buffer = channel.append_data(); + let mut buffer = channel.append_data(1, cpal::SamplesRate(44100)); - for sample in buffer.chunks_mut(2) { + for sample in buffer.chunks_mut(1) { let value = data_source.next().unwrap(); sample[0] = value; - sample[1] = value; + //sample[1] = value; } } } diff --git a/src/conversions.rs b/src/conversions.rs new file mode 100644 index 0000000..a70cbe8 --- /dev/null +++ b/src/conversions.rs @@ -0,0 +1,41 @@ +/*! +This module contains function that will convert from one PCM format to another. + +This includes conversion between samples formats, channels or sample rates. + +*/ +pub fn convert_samples_rate(input: &[T], from: ::SamplesRate, to: ::SamplesRate) -> Vec + where T: Copy +{ + unimplemented!() +} + +pub fn convert_channels(input: &[T], from: ::ChannelsCount, to: ::ChannelsCount) -> Vec + where T: Copy +{ + assert!(input.len() % from as uint == 0); + + let mut result = Vec::new(); + + for element in input.chunks(from as uint) { + // copying the common channels + for i in range(0, ::std::cmp::min(from, to)) { + result.push(element[i as uint]); + } + + // adding extra ones + for i in range(0, ::std::cmp::max(0, to - from)) { + result.push(element[i as uint % element.len()]); + } + } + + result +} + +#[cfg(test)] +mod test { + #[test] + fn test_convert_channels() { + + } +} diff --git a/src/lib.rs b/src/lib.rs index 0a44a7a..472948d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,6 +3,8 @@ #[cfg(all(not(windows)))] use this_platform_is_not_supported; +mod conversions; + #[cfg(windows)] #[path="wasapi/mod.rs"] pub mod cpal_impl; @@ -16,10 +18,24 @@ pub struct Channel(cpal_impl::Channel); /// Number of channels. pub type ChannelsCount = u16; +/// +#[deriving(Show, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub struct SamplesRate(pub u16); + /// Represents a buffer that must be filled with audio data. /// /// A `Buffer` object borrows the channel. -pub struct Buffer<'a, T>(cpal_impl::Buffer<'a, T>); +pub struct Buffer<'a, T>(cpal_impl::Buffer<'a, T>, Option>); + +struct RequiredConversion { + intermediate_buffer: Vec, + from_sample_rate: SamplesRate, + to_sample_rate: SamplesRate, + from_format: SampleFormat, + to_format: SampleFormat, + from_channels: ChannelsCount, + to_channels: ChannelsCount, +} /// Format that each sample has. #[deriving(Clone, Copy, Show, PartialEq, Eq)] @@ -30,6 +46,37 @@ pub enum SampleFormat { U16, } +/// Trait for containers that contain PCM data. +#[unstable = "Will be rewritten with associated types"] +pub trait Sample: Copy { + fn get_format(Option) -> SampleFormat; + + /// Turns the data into a `Vec` where each element is a sample. + fn to_vec_u16(&[Self]) -> Vec; + + fn convert_channels_count(&[Self], from: u16, to: u16) -> Vec; + + fn convert_samples_rate(&[Self], from: SamplesRate, to: SamplesRate) -> Vec; +} + +impl Sample for u16 { + fn get_format(_: Option) -> SampleFormat { + SampleFormat::U16 + } + + fn to_vec_u16(input: &[u16]) -> Vec { + input.to_vec() + } + + fn convert_channels_count(input: &[u16], from: u16, to: u16) -> Vec { + unimplemented!() + } + + fn convert_samples_rate(input: &[u16], _from: SamplesRate, _to: SamplesRate) -> Vec { + unimplemented!() + } +} + impl Channel { pub fn new() -> Channel { let channel = cpal_impl::Channel::new(); @@ -46,8 +93,8 @@ impl Channel { /// Returns the number of samples that are played per second. /// /// Common values are 22050 Hz or 44100 Hz. - pub fn get_samples_per_second(&self) -> u32 { - self.0.get_samples_per_second() + pub fn get_samples_rate(&self) -> SamplesRate { + self.0.get_samples_rate() } /// Returns the number of samples that are played per second. @@ -62,8 +109,47 @@ impl Channel { /// 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. - pub fn append_data<'a, T>(&'a mut self) -> Buffer<'a, T> { - Buffer(self.0.append_data()) + pub fn append_data<'a, T>(&'a mut self, channels: ChannelsCount, + samples_rate: SamplesRate) + -> Buffer<'a, T> where T: Sample + Clone + { + let target_samples_rate = self.0.get_samples_rate(); + let target_channels = self.0.get_channels(); + + let source_samples_format = Sample::get_format(None::); + 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 mut target_buffer = self.0.append_data(); + + // 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; + // TODO: adapt size to samples format too + let mut intermediate_buffer = Vec::from_elem(intermediate_buffer_length, unsafe { std::mem::uninitialized() }); + + Buffer( + target_buffer, + Some(RequiredConversion { + intermediate_buffer: intermediate_buffer, + from_sample_rate: samples_rate, + to_sample_rate: target_samples_rate, + from_format: source_samples_format, + to_format: target_samples_format, + from_channels: channels, + to_channels: target_channels, + }) + ) + + } else { + Buffer(self.0.append_data(), None) + } } } @@ -75,6 +161,48 @@ impl<'a, T> Deref<[T]> for Buffer<'a, T> { impl<'a, T> DerefMut<[T]> for Buffer<'a, T> { fn deref_mut(&mut self) -> &mut [T] { - self.0.get_buffer() + match self.1 { + Some(ref mut conv) => conv.intermediate_buffer.as_mut_slice(), + None => self.0.get_buffer() + } + } +} + +#[unsafe_destructor] +impl<'a, T> Drop for Buffer<'a, T> where T: Sample { + fn drop(&mut self) { + if let Some(conversion) = self.1.take() { + 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 + }; + + /*let buffer = if conversion.from_format != conversion.to_format { + match conversion.to_format { + SampleFormat::U16 => Sample::to_vec_u16(buffer.as_slice()), + _ => unimplemented!(), + } + } else { + buffer + };*/ + if conversion.from_format != conversion.to_format { unimplemented!() } + + let output = self.0.get_buffer(); + assert!(buffer.len() == output.len(), "Buffers length mismatch: {} vs {}", buffer.len(), output.len()); + for (i, o) in buffer.into_iter().zip(output.iter_mut()) { + *o = i; + } + } } } diff --git a/src/wasapi/mod.rs b/src/wasapi/mod.rs index d198fb1..52a605b 100644 --- a/src/wasapi/mod.rs +++ b/src/wasapi/mod.rs @@ -32,8 +32,8 @@ impl Channel { self.num_channels as ::ChannelsCount } - pub fn get_samples_per_second(&self) -> u32 { - self.samples_per_second as u32 + pub fn get_samples_rate(&self) -> ::SamplesRate { + ::SamplesRate(self.samples_per_second as u16) } pub fn get_samples_format(&self) -> ::SampleFormat {