Update to rustfft 6.0 and Rust 2018 edition

.gitignore

@@ -1,3 +1,4 @@
 target
 **.DS_Store
 Cargo.lock
+.idea/

Cargo.toml

@@ -9,9 +9,18 @@ name = "stft"
 readme = "README.md"
 repository = "https://github.com/snd/stft.git"
 version = "0.2.0"
+edition = "2018"
 
 [dependencies]
-apodize = "0.3.1"
-num = "0.2.0"
-rustfft = "3.0.0"
+apodize = "1.0.0"
+num = "0.4.0"
+rustfft = "6.0.1"
 strider = "0.1.3"
+
+[dev-dependencies]
+criterion = "0.3.4"
+approx = "0.5.0"
+
+[[bench]]
+name = "lib"
+harness = false

benches/lib.rs

@@ -1,98 +1,134 @@
-#![feature(test)]
-extern crate test;
-
-extern crate num;
+use criterion::{criterion_group, criterion_main, Criterion};
 use num::complex::Complex;
-
-extern crate rustfft;
-use rustfft::FFT;
-
-extern crate stft;
-use stft::{STFT, WindowType};
+use rustfft::{FftDirection, FftPlanner};
+use stft::{WindowType, STFT};
 
 macro_rules! bench_fft_process {
- ($bencher:expr, $window_size:expr, $float:ty) => {{
- let inverse = false;
- let window_size = $window_size;
- let mut fft = FFT::<$float>::new(window_size, inverse);
- let input = std::iter::repeat(Complex::new(0., 0.))
- .take(window_size)
- .collect::<Vec<Complex<$float>>>();
+ ($c:expr, $window_size:expr, $float:ty) => {{
+ let mut planner = FftPlanner::new();
+ let fft = planner.plan_fft($window_size, FftDirection::Forward);
+ // input is processed in-place
  let mut output = std::iter::repeat(Complex::new(0., 0.))
- .take(window_size)
+ .take($window_size)
  .collect::<Vec<Complex<$float>>>();
- $bencher.iter(|| {
- fft.process(&input[..], &mut output[..])
- });
-
- }}
+ $c.bench_function(
+ concat!(
+ "bench_fft_process_",
+ stringify!($window_size),
+ "_",
+ stringify!($float)
+ ),
+ |b| b.iter(|| fft.process(&mut output[..])),
+ );
+ }};
 }
 
-#[bench]
-fn bench_fft_process_1024_f32(bencher: &mut test::Bencher) {
- bench_fft_process!(bencher, 1024, f32);
+fn bench_fft_process_1024_f32(c: &mut Criterion) {
+ bench_fft_process!(c, 1024, f32);
 }
 
-#[bench]
-fn bench_fft_process_1024_f64(bencher: &mut test::Bencher) {
- bench_fft_process!(bencher, 1024, f64);
+fn bench_fft_process_1024_f64(c: &mut Criterion) {
+ bench_fft_process!(c, 1024, f64);
 }
 
+criterion_group!(
+ benches_fft_process,
+ bench_fft_process_1024_f32,
+ bench_fft_process_1024_f64
+);
+
 macro_rules! bench_stft_compute {
- ($bencher:expr, $window_size:expr, $float:ty) => {{
- let mut stft = STFT::<$float>::new(WindowType::Hanning, $window_size, 0);
- let input = std::iter::repeat(1.).take($window_size).collect::<Vec<$float>>();
- let mut output = std::iter::repeat(0.).take(stft.output_size()).collect::<Vec<$float>>();
+ ($c:expr, $window_size:expr, $float:ty) => {{
+ let step_size: usize = 512;
+ let mut stft = STFT::<$float>::new(WindowType::Hanning, $window_size, step_size);
+ let input = std::iter::repeat(1.)
+ .take($window_size)
+ .collect::<Vec<$float>>();
+ let mut output = std::iter::repeat(0.)
+ .take(stft.output_size())
+ .collect::<Vec<$float>>();
  stft.append_samples(&input[..]);
- $bencher.iter(|| {
- stft.compute_column(&mut output[..])
- });
- }}
+ $c.bench_function(
+ concat!(
+ "bench_stft_compute_",
+ stringify!($window_size),
+ "_",
+ stringify!($float)
+ ),
+ |b| b.iter(|| stft.compute_column(&mut output[..])),
+ );
+ }};
 }
 
-#[bench]
-fn bench_stft_compute_1024_f32(bencher: &mut test::Bencher) {
- bench_stft_compute!(bencher, 1024, f32);
+fn bench_stft_compute_1024_f32(c: &mut Criterion) {
+ bench_stft_compute!(c, 1024, f32);
 }
 
-#[bench]
-fn bench_stft_compute_1024_f64(bencher: &mut test::Bencher) {
- bench_stft_compute!(bencher, 1024, f64);
+fn bench_stft_compute_1024_f64(c: &mut Criterion) {
+ bench_stft_compute!(c, 1024, f64);
 }
 
+criterion_group!(
+ benches_stft_compute,
+ bench_stft_compute_1024_f32,
+ bench_stft_compute_1024_f64
+);
+
 macro_rules! bench_stft_audio {
- ($bencher:expr, $seconds:expr, $float:ty) => {{
+ ($c:expr, $seconds:expr, $float:ty) => {{
  // let's generate some fake audio
  let sample_rate: usize = 44100;
  let seconds: usize = $seconds;
  let sample_count = sample_rate * seconds;
- let all_samples = (0..sample_count).map(|x| x as $float).collect::<Vec<$float>>();
- $bencher.iter(|| {
- // let's initialize our short-time fourier transform
- let window_type: WindowType = WindowType::Hanning;
- let window_size: usize = 1024;
- let step_size: usize = 512;
- let mut stft = STFT::<$float>::new(window_type, window_size, step_size);
- // we need a buffer to hold a computed column of the spectrogram
- let mut spectrogram_column: Vec<$float> =
- std::iter::repeat(0.).take(stft.output_size()).collect();
- for some_samples in (&all_samples[..]).chunks(3000) {
- stft.append_samples(some_samples);
- while stft.contains_enough_to_compute() {
- stft.compute_column(&mut spectrogram_column[..]);
- stft.move_to_next_column();
- }
- }
- });
- }}
+ let all_samples = (0..sample_count)
+ .map(|x| x as $float)
+ .collect::<Vec<$float>>();
+ $c.bench_function(
+ concat!(
+ "bench_stft_audio_",
+ stringify!($windowsize),
+ "_",
+ stringify!($float)
+ ),
+ |b| {
+ b.iter(|| {
+ // let's initialize our short-time fourier transform
+ let window_type: WindowType = WindowType::Hanning;
+ let window_size: usize = 1024;
+ let step_size: usize = 512;
+ let mut stft = STFT::<$float>::new(window_type, window_size, step_size);
+ // we need a buffer to hold a computed column of the spectrogram
+ let mut spectrogram_column: Vec<$float> =
+ std::iter::repeat(0.).take(stft.output_size()).collect();
+ for some_samples in (&all_samples[..]).chunks(3000) {
+ stft.append_samples(some_samples);
+ while stft.contains_enough_to_compute() {
+ stft.compute_column(&mut spectrogram_column[..]);
+ stft.move_to_next_column();
+ }
+ }
+ })
+ },
+ );
+ }};
 }
 
-#[bench]
-fn bench_stft_10_seconds_audio_f32(bencher: &mut test::Bencher) {
- bench_stft_audio!(bencher, 10, f32);
+fn bench_stft_10_seconds_audio_f32(c: &mut Criterion) {
+ bench_stft_audio!(c, 10, f32);
 }
 
-#[bench]
-fn bench_stft_10_seconds_audio_f64(bencher: &mut test::Bencher) {
- bench_stft_audio!(bencher, 10, f64);
+fn bench_stft_10_seconds_audio_f64(c: &mut Criterion) {
+ bench_stft_audio!(c, 10, f64);
 }
+
+criterion_group!(
+ benches_stft_audio,
+ bench_stft_10_seconds_audio_f32,
+ bench_stft_10_seconds_audio_f64
+);
+
+criterion_main!(
+ benches_fft_process,
+ benches_stft_compute,
+ benches_stft_audio
+);