Skip to content

Commit

Permalink
Merge pull request #52 from b-ma/feature/buffer-size
Browse files Browse the repository at this point in the history 
changed BUFFER_SIZE to usize (cf. #49)
  • Loading branch information
@orottier
orottier committed Nov 17, 2021
2 parents 05b6afb + f989c3f commit a32309a
Show file tree
Hide file tree
Showing 16 changed files with 163 additions and 153 deletions.
80 changes: 40 additions & 40 deletions src/alloc.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,7 +14,7 @@ use std::rc::Rc;
use crate::buffer::ChannelInterpretation;

/// size of a buffer, 128 samples per spec
const BUFFER_SIZE: usize = crate::BUFFER_SIZE as usize;
use crate::BUFFER_SIZE;
use crate::MAX_CHANNELS;

pub(crate) struct Alloc {
Expand Down Expand Up @@ -683,7 +683,7 @@ mod tests {
let mut signal = alloc.silence();
signal.copy_from_slice(&[1.; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(signal.clone());
let mut buffer = AudioBuffer::new(signal);

// make sure 1 -> 1 does nothing
buffer.mix(1, ChannelInterpretation::Speakers);
Expand Down Expand Up @@ -715,7 +715,7 @@ mod tests {
let mut signal = alloc.silence();
signal.copy_from_slice(&[1.; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(signal.clone());
let mut buffer = AudioBuffer::new(signal);

buffer.mix(4, ChannelInterpretation::Speakers);
assert_eq!(buffer.number_of_channels(), 4);
Expand Down Expand Up @@ -748,7 +748,7 @@ mod tests {
let mut signal = alloc.silence();
signal.copy_from_slice(&[1.; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(signal.clone());
let mut buffer = AudioBuffer::new(signal);

buffer.mix(6, ChannelInterpretation::Speakers);
assert_eq!(buffer.number_of_channels(), 6);
Expand Down Expand Up @@ -793,8 +793,8 @@ mod tests {
let mut right_signal = alloc.silence();
right_signal.copy_from_slice(&[0.5; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);

assert_eq!(buffer.number_of_channels(), 2);
assert_float_eq!(
Expand Down Expand Up @@ -839,8 +839,8 @@ mod tests {
let mut right_signal = alloc.silence();
right_signal.copy_from_slice(&[0.5; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);

assert_eq!(buffer.number_of_channels(), 2);
assert_float_eq!(
Expand Down Expand Up @@ -899,10 +899,10 @@ mod tests {
let mut s_right_signal = alloc.silence();
s_right_signal.copy_from_slice(&[1.; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
buffer.channels.push(s_left_signal.clone());
buffer.channels.push(s_right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);
buffer.channels.push(s_left_signal);
buffer.channels.push(s_right_signal);

assert_eq!(buffer.number_of_channels(), 4);
assert_float_eq!(
Expand Down Expand Up @@ -972,8 +972,8 @@ mod tests {
let mut right_signal = alloc.silence();
right_signal.copy_from_slice(&[0.5; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);

assert_eq!(buffer.number_of_channels(), 2);
assert_float_eq!(
Expand Down Expand Up @@ -1007,10 +1007,10 @@ mod tests {
let mut s_right_signal = alloc.silence();
s_right_signal.copy_from_slice(&[0.25; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
buffer.channels.push(s_left_signal.clone());
buffer.channels.push(s_right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);
buffer.channels.push(s_left_signal);
buffer.channels.push(s_right_signal);

assert_eq!(buffer.number_of_channels(), 4);
assert_float_eq!(
Expand Down Expand Up @@ -1058,12 +1058,12 @@ mod tests {
let mut s_right_signal = alloc.silence();
s_right_signal.copy_from_slice(&[0.5; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
buffer.channels.push(center_signal.clone());
buffer.channels.push(low_freq_signal.clone());
buffer.channels.push(s_left_signal.clone());
buffer.channels.push(s_right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);
buffer.channels.push(center_signal);
buffer.channels.push(low_freq_signal);
buffer.channels.push(s_left_signal);
buffer.channels.push(s_right_signal);

assert_eq!(buffer.number_of_channels(), 6);
assert_float_eq!(
Expand Down Expand Up @@ -1119,10 +1119,10 @@ mod tests {
let mut s_right_signal = alloc.silence();
s_right_signal.copy_from_slice(&[1.; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
buffer.channels.push(s_left_signal.clone());
buffer.channels.push(s_right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);
buffer.channels.push(s_left_signal);
buffer.channels.push(s_right_signal);

assert_eq!(buffer.number_of_channels(), 4);
assert_float_eq!(
Expand Down Expand Up @@ -1175,12 +1175,12 @@ mod tests {
let mut s_right_signal = alloc.silence();
s_right_signal.copy_from_slice(&[0.5; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
buffer.channels.push(center_signal.clone());
buffer.channels.push(low_freq_signal.clone());
buffer.channels.push(s_left_signal.clone());
buffer.channels.push(s_right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);
buffer.channels.push(center_signal);
buffer.channels.push(low_freq_signal);
buffer.channels.push(s_left_signal);
buffer.channels.push(s_right_signal);

assert_eq!(buffer.number_of_channels(), 6);
assert_float_eq!(
Expand Down Expand Up @@ -1246,12 +1246,12 @@ mod tests {
let mut s_right_signal = alloc.silence();
s_right_signal.copy_from_slice(&[0.5; BUFFER_SIZE]);

let mut buffer = AudioBuffer::new(left_signal.clone());
buffer.channels.push(right_signal.clone());
buffer.channels.push(center_signal.clone());
buffer.channels.push(low_freq_signal.clone());
buffer.channels.push(s_left_signal.clone());
buffer.channels.push(s_right_signal.clone());
let mut buffer = AudioBuffer::new(left_signal);
buffer.channels.push(right_signal);
buffer.channels.push(center_signal);
buffer.channels.push(low_freq_signal);
buffer.channels.push(s_left_signal);
buffer.channels.push(s_right_signal);

assert_eq!(buffer.number_of_channels(), 6);
assert_float_eq!(
Expand Down
75 changes: 47 additions & 28 deletions src/analysis.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@ use realfft::{num_complex::Complex, RealFftPlanner};
use std::f32::consts::PI;

const MAX_QUANTA: usize = 256;
const MAX_SAMPLES: usize = MAX_QUANTA * BUFFER_SIZE as usize;
const MAX_SAMPLES: usize = MAX_QUANTA * BUFFER_SIZE;

/// Blackman window values iterator with alpha = 0.16
pub fn generate_blackman(size: usize) -> impl Iterator<Item = f32> {
Expand Down Expand Up @@ -52,7 +52,7 @@ impl TimeAnalyser {
fn check_complete_cycle(&mut self, fft_size: usize) -> bool {
// number of buffers processed since last complete cycle
let processed = self.index.wrapping_sub(self.previous_cycle_index);
let processed_samples = processed as usize * BUFFER_SIZE as usize;
let processed_samples = processed as usize * BUFFER_SIZE;

// cycle is complete when divisible by fft_size
if processed_samples % fft_size == 0 {
Expand Down Expand Up @@ -80,7 +80,7 @@ impl TimeAnalyser {

// split the output buffer in same sized chunks
let true_size = fft_size.min(buffer.len());
let buf_chunks = buffer[0..true_size].chunks_mut(BUFFER_SIZE as usize).rev();
let buf_chunks = buffer[0..true_size].chunks_mut(BUFFER_SIZE).rev();

// copy data from internal buffer to output buffer
buf_chunks
Expand Down Expand Up @@ -214,7 +214,6 @@ mod tests {
use super::*;

use crate::alloc::Alloc;
const LEN: usize = BUFFER_SIZE as usize;

#[test]
fn assert_index_size() {
Expand All @@ -228,38 +227,58 @@ mod tests {
let alloc = Alloc::with_capacity(256);

let mut analyser = TimeAnalyser::new();
let mut buffer = vec![-1.; LEN * 5];
let mut buffer = vec![-1.; BUFFER_SIZE * 5];

// feed single data buffer
analyser.add_data(alloc.silence());

// get data, should be padded with zeroes
analyser.get_float_time(&mut buffer[..], LEN * 5);
assert_float_eq!(&buffer[..], &[0.; 5 * LEN][..], ulps_all <= 0);
analyser.get_float_time(&mut buffer[..], BUFFER_SIZE * 5);
assert_float_eq!(&buffer[..], &[0.; 5 * BUFFER_SIZE][..], ulps_all <= 0);

// feed data for more than 256 times (the ring buffer size)
for i in 0..258 {
let mut signal = alloc.silence();
// signal = i
signal.copy_from_slice(&[i as f32; LEN]);
signal.copy_from_slice(&[i as f32; BUFFER_SIZE]);
analyser.add_data(signal);
}

// this should return non-zero data now
analyser.get_float_time(&mut buffer[..], LEN * 4);
analyser.get_float_time(&mut buffer[..], BUFFER_SIZE * 4);

// taken from the end of the ring buffer
assert_float_eq!(&buffer[0..LEN], &[254.; LEN][..], ulps_all <= 0);
assert_float_eq!(&buffer[LEN..2 * LEN], &[255.; LEN][..], ulps_all <= 0);
assert_float_eq!(
&buffer[0..BUFFER_SIZE],
&[254.; BUFFER_SIZE][..],
ulps_all <= 0
);
assert_float_eq!(
&buffer[BUFFER_SIZE..2 * BUFFER_SIZE],
&[255.; BUFFER_SIZE][..],
ulps_all <= 0
);
// taken from the start of the ring buffer
assert_float_eq!(&buffer[2 * LEN..3 * LEN], &[256.; LEN][..], ulps_all <= 0);
assert_float_eq!(&buffer[3 * LEN..4 * LEN], &[257.; LEN][..], ulps_all <= 0);
assert_float_eq!(
&buffer[2 * BUFFER_SIZE..3 * BUFFER_SIZE],
&[256.; BUFFER_SIZE][..],
ulps_all <= 0
);
assert_float_eq!(
&buffer[3 * BUFFER_SIZE..4 * BUFFER_SIZE],
&[257.; BUFFER_SIZE][..],
ulps_all <= 0
);
// excess capacity should be left unaltered
assert_float_eq!(&buffer[4 * LEN..5 * LEN], &[0.; LEN][..], ulps_all <= 0);
assert_float_eq!(
&buffer[4 * BUFFER_SIZE..5 * BUFFER_SIZE],
&[0.; BUFFER_SIZE][..],
ulps_all <= 0
);

// check for small fft_size
buffer.resize(32, 0.);
analyser.get_float_time(&mut buffer[..], LEN);
analyser.get_float_time(&mut buffer[..], BUFFER_SIZE);
assert_float_eq!(&buffer[..], &[257.; 32][..], ulps_all <= 0);
}

Expand All @@ -268,28 +287,28 @@ mod tests {
let alloc = Alloc::with_capacity(256);
let mut analyser = TimeAnalyser::new();

// check values smaller than LEN
// check values smaller than BUFFER_SIZE
analyser.add_data(alloc.silence());
assert!(analyser.check_complete_cycle(32));

// check LEN
// check BUFFER_SIZE
analyser.add_data(alloc.silence());
assert!(analyser.check_complete_cycle(LEN));
assert!(analyser.check_complete_cycle(BUFFER_SIZE));

// check multiple of LEN
// check multiple of BUFFER_SIZE
analyser.add_data(alloc.silence());
assert!(!analyser.check_complete_cycle(LEN * 2));
assert!(!analyser.check_complete_cycle(BUFFER_SIZE * 2));
analyser.add_data(alloc.silence());
assert!(analyser.check_complete_cycle(LEN * 2));
assert!(analyser.check_complete_cycle(BUFFER_SIZE * 2));
analyser.add_data(alloc.silence());
assert!(!analyser.check_complete_cycle(LEN * 2));
assert!(!analyser.check_complete_cycle(BUFFER_SIZE * 2));
}

#[test]
fn test_freq_domain() {
let alloc = Alloc::with_capacity(256);

let fft_size: usize = LEN * 4;
let fft_size: usize = BUFFER_SIZE * 4;
let mut analyser = Analyser::new(fft_size);
let mut buffer = vec![-1.; fft_size];

Expand All @@ -301,25 +320,25 @@ mod tests {
analyser.get_float_frequency(&mut buffer[..]);

// only N / 2 + 1 values should contain frequency data, rest is unaltered
assert!(buffer[0..LEN * 2 + 1] == [f32::NEG_INFINITY; LEN * 2 + 1]);
assert!(buffer[0..BUFFER_SIZE * 2 + 1] == [f32::NEG_INFINITY; BUFFER_SIZE * 2 + 1]);
assert_float_eq!(
&buffer[2 * LEN + 1..],
&[-1.; 2 * LEN - 1][..],
&buffer[2 * BUFFER_SIZE + 1..],
&[-1.; 2 * BUFFER_SIZE - 1][..],
ulps_all <= 0
);

// feed data for more than 256 times (the ring buffer size)
for i in 0..258 {
let mut signal = alloc.silence();
// signal = i
signal.copy_from_slice(&[i as f32; LEN]);
signal.copy_from_slice(&[i as f32; BUFFER_SIZE]);
analyser.add_data(signal);
}

// this should return other data now
analyser.calculate_float_frequency(fft_size, 0.8);
analyser.get_float_frequency(&mut buffer[..]);
assert!(buffer[0..LEN * 2 + 1] != [f32::NEG_INFINITY; LEN * 2 + 1]);
assert!(buffer[0..BUFFER_SIZE * 2 + 1] != [f32::NEG_INFINITY; BUFFER_SIZE * 2 + 1]);
}

#[test]
Expand Down
12 changes: 6 additions & 6 deletions src/buffer.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -407,15 +407,15 @@ pub struct Resampler<I> {
/// desired sample rate
sample_rate: SampleRate,
/// desired sample length
sample_len: u32,
sample_len: usize,
/// input stream
input: I,
/// internal buffer
buffer: Option<AudioBuffer>,
}

impl<M: MediaStream> Resampler<M> {
pub fn new(sample_rate: SampleRate, sample_len: u32, input: M) -> Self {
pub fn new(sample_rate: SampleRate, sample_len: usize, input: M) -> Self {
Self {
sample_rate,
sample_len,
Expand All @@ -441,13 +441,13 @@ impl<M: MediaStream> Iterator for Resampler<M> {
Some(data) => data,
};

while (buffer.sample_len() as u32) < self.sample_len {
while buffer.sample_len() < self.sample_len {
// buffer is smaller than desired len
match self.input.next() {
None => {
let padding = AudioBuffer::new(
buffer.number_of_channels(),
self.sample_len as usize - buffer.sample_len(),
self.sample_len - buffer.sample_len(),
self.sample_rate,
);
buffer.extend(&padding);
Expand All @@ -462,11 +462,11 @@ impl<M: MediaStream> Iterator for Resampler<M> {
}
}

if buffer.sample_len() as u32 == self.sample_len {
if buffer.sample_len() == self.sample_len {
return Some(Ok(buffer));
}

self.buffer = Some(buffer.split_off(self.sample_len as usize));
self.buffer = Some(buffer.split_off(self.sample_len));

Some(Ok(buffer))
}
Expand Down

0 comments on commit a32309a

Please sign in to comment.