#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct AudioSpec {
pub sample_rate: u32,
pub channels: u16,
}
impl AudioSpec {
pub const fn new(sample_rate: u32, channels: u16) -> Self {
Self {
sample_rate,
channels,
}
}
pub const fn mono(sample_rate: u32) -> Self {
Self::new(sample_rate, 1)
}
pub const fn is_mono(&self) -> bool {
self.channels == 1
}
pub const fn frames(&self, sample_count: usize) -> usize {
if self.channels == 0 {
0
} else {
sample_count / self.channels as usize
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct AudioBuffer {
spec: AudioSpec,
samples: Vec<f32>,
}
impl AudioBuffer {
pub const fn new(spec: AudioSpec) -> Self {
Self {
spec,
samples: Vec::new(),
}
}
pub fn with_capacity(spec: AudioSpec, capacity: usize) -> Self {
Self {
spec,
samples: Vec::with_capacity(capacity),
}
}
pub const fn from_samples(spec: AudioSpec, samples: Vec<f32>) -> Self {
Self { spec, samples }
}
pub const fn spec(&self) -> AudioSpec {
self.spec
}
pub const fn sample_rate(&self) -> u32 {
self.spec.sample_rate
}
pub const fn channels(&self) -> u16 {
self.spec.channels
}
pub fn samples(&self) -> &[f32] {
&self.samples
}
pub fn samples_mut(&mut self) -> &mut [f32] {
&mut self.samples
}
pub fn frames(&self) -> usize {
self.spec.frames(self.samples.len())
}
pub fn is_empty(&self) -> bool {
self.samples.is_empty()
}
pub fn extend_from_slice(&mut self, samples: &[f32]) {
self.samples.extend_from_slice(samples);
}
pub fn clear(&mut self) {
self.samples.clear();
}
pub fn into_samples(self) -> Vec<f32> {
self.samples
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_spec_carries_rate_and_layout_together() {
let spec = AudioSpec::new(48_000, 2);
assert_eq!(spec.sample_rate, 48_000);
assert_eq!(spec.channels, 2);
assert!(!spec.is_mono());
assert!(AudioSpec::mono(16_000).is_mono());
}
#[test]
fn frames_divide_by_the_channel_count() {
assert_eq!(AudioSpec::new(48_000, 2).frames(1000), 500);
assert_eq!(AudioSpec::new(48_000, 2).frames(1001), 500);
assert_eq!(AudioSpec::mono(48_000).frames(1000), 1000);
}
#[test]
fn a_zero_channel_spec_reports_no_frames_rather_than_dividing_by_zero() {
assert_eq!(AudioSpec::new(48_000, 0).frames(1000), 0);
let buffer = AudioBuffer::from_samples(AudioSpec::new(48_000, 0), vec![0.0; 8]);
assert_eq!(buffer.frames(), 0);
}
#[test]
fn a_buffer_keeps_its_spec_through_every_mutation() {
let spec = AudioSpec::mono(8_000);
let mut buffer = AudioBuffer::with_capacity(spec, 4);
assert!(buffer.is_empty());
buffer.extend_from_slice(&[0.25, -0.25]);
assert_eq!(buffer.spec(), spec);
assert_eq!(buffer.sample_rate(), 8_000);
assert_eq!(buffer.channels(), 1);
assert_eq!(buffer.frames(), 2);
assert_eq!(buffer.samples(), &[0.25, -0.25]);
buffer.samples_mut()[0] = 0.5;
assert_eq!(buffer.samples(), &[0.5, -0.25]);
buffer.clear();
assert!(buffer.is_empty());
assert_eq!(buffer.spec(), spec);
}
#[test]
fn samples_can_be_taken_out_and_bound_back_to_a_spec() {
let spec = AudioSpec::mono(16_000);
let buffer = AudioBuffer::from_samples(spec, vec![1.0, 2.0, 3.0]);
let samples = buffer.into_samples();
let rebound = AudioBuffer::from_samples(spec, samples);
assert_eq!(rebound.samples(), &[1.0, 2.0, 3.0]);
assert_eq!(rebound.spec(), spec);
}
#[test]
fn an_empty_buffer_still_declares_a_rate() {
let buffer = AudioBuffer::new(AudioSpec::mono(44_100));
assert!(buffer.is_empty());
assert_eq!(buffer.sample_rate(), 44_100);
}
}