use std::sync::Arc; use rustfft::Length; use crate::common::mdct_error_inplace; use crate::mdct::Mdct; use crate::RequiredScratch; use crate::{DctNum, TransformType4}; /// MDCT implementation that converts the problem to a DCT Type 4 of the same size. /// /// It is much easier to express a MDCT as a DCT Type 4 than it is to express it as a FFT, so converting the MDCT /// to a DCT4 before converting it to a FFT results in greatly simplified code /// /// ~~~ /// // Computes a MDCT of input size 1234 via a DCT4, using the MP3 window function /// use rustdct::mdct::{Mdct, MdctViaDct4, window_fn}; /// use rustdct::{DctPlanner, RequiredScratch}; /// /// let len = 1234; /// /// let mut planner = DctPlanner::new(); /// let inner_dct4 = planner.plan_dct4(len); /// /// let dct = MdctViaDct4::new(inner_dct4, window_fn::mp3); /// /// let input = vec![0f32; len * 2]; /// let (input_a, input_b) = input.split_at(len); /// let mut output = vec![0f32; len]; /// let mut scratch = vec![0f32; dct.get_scratch_len()]; /// /// dct.process_mdct_with_scratch(input_a, input_b, &mut output, &mut scratch); /// ~~~ pub struct MdctViaDct4 { dct: Arc>, window: Box<[T]>, scratch_len: usize, } impl MdctViaDct4 { /// Creates a new MDCT context that will process signals of length `inner_dct.len() * 2`, with an output of length `inner_dct.len()` /// /// `inner_dct.len()` must be even. /// /// `window_fn` is a function that takes a `size` and returns a `Vec` containing `size` window values. /// See the [`window_fn`](mdct/window_fn/index.html) module for provided window functions. pub fn new(inner_dct: Arc>, window_fn: F) -> Self where F: FnOnce(usize) -> Vec, { let len = inner_dct.len(); assert!(len % 2 == 0, "The MDCT inner_dct.len() must be even"); let window = window_fn(len * 2); assert_eq!( window.len(), len * 2, "Window function returned incorrect number of values" ); Self { scratch_len: len + inner_dct.get_scratch_len(), dct: inner_dct, window: window.into_boxed_slice(), } } } impl Mdct for MdctViaDct4 { fn process_mdct_with_scratch( &self, input_a: &[T], input_b: &[T], output: &mut [T], scratch: &mut [T], ) { let scratch = validate_buffers_mdct!( input_a, input_b, output, scratch, self.len(), self.get_scratch_len() ); let group_size = self.len() / 2; //we're going to divide input_a into two subgroups, (a,b), and input_b into two subgroups: (c,d) //then scale them by the window function, then combine them into two subgroups: (-D-Cr, A-Br) where R means reversed let group_a_iter = input_a .iter() .zip(self.window.iter()) .map(|(a, window_val)| *a * *window_val) .take(group_size); let group_b_rev_iter = input_a .iter() .zip(self.window.iter()) .map(|(b, window_val)| *b * *window_val) .rev() .take(group_size); let group_c_rev_iter = input_b .iter() .zip(&self.window[self.len()..]) .map(|(c, window_val)| *c * *window_val) .rev() .skip(group_size); let group_d_iter = input_b .iter() .zip(&self.window[self.len()..]) .map(|(d, window_val)| *d * *window_val) .skip(group_size); //the first half of the dct input is -Cr - D for (element, (cr_val, d_val)) in output.iter_mut().zip(group_c_rev_iter.zip(group_d_iter)) { *element = -cr_val - d_val; } //the second half of the dct input is is A - Br for (element, (a_val, br_val)) in output[group_size..] .iter_mut() .zip(group_a_iter.zip(group_b_rev_iter)) { *element = a_val - br_val; } self.dct.process_dct4_with_scratch(output, scratch); } fn process_imdct_with_scratch( &self, input: &[T], output_a: &mut [T], output_b: &mut [T], scratch: &mut [T], ) { let scratch = validate_buffers_mdct!( input, output_a, output_b, scratch, self.len(), self.get_scratch_len() ); let (dct_buffer, dct_scratch) = scratch.split_at_mut(self.len()); dct_buffer.copy_from_slice(input); self.dct.process_dct4_with_scratch(dct_buffer, dct_scratch); let group_size = self.len() / 2; //copy the second half of the DCT output into the result for ((output, window_val), val) in output_a .iter_mut() .zip(&self.window[..]) .zip(dct_buffer[group_size..].iter()) { *output = *output + *val * *window_val; } //copy the second half of the DCT output again, but this time reversed and negated for ((output, window_val), val) in output_a .iter_mut() .zip(&self.window[..]) .skip(group_size) .zip(dct_buffer[group_size..].iter().rev()) { *output = *output - *val * *window_val; } //copy the first half of the DCT output into the result, reversde+negated for ((output, window_val), val) in output_b .iter_mut() .zip(&self.window[self.len()..]) .zip(dct_buffer[..group_size].iter().rev()) { *output = *output - *val * *window_val; } //copy the first half of the DCT output again, but this time not reversed for ((output, window_val), val) in output_b .iter_mut() .zip(&self.window[self.len()..]) .skip(group_size) .zip(dct_buffer[..group_size].iter()) { *output = *output - *val * *window_val; } } } impl Length for MdctViaDct4 { fn len(&self) -> usize { self.dct.len() } } impl RequiredScratch for MdctViaDct4 { fn get_scratch_len(&self) -> usize { self.scratch_len } } #[cfg(test)] mod unit_tests { use super::*; use crate::algorithm::Type4Naive; use crate::mdct::window_fn; use crate::mdct::MdctNaive; use crate::test_utils::{compare_float_vectors, random_signal}; /// Verify that our fast implementation of the MDCT and IMDCT gives the same output as the slow version, for many different inputs #[test] fn test_mdct_via_dct4() { for current_window_fn in &[window_fn::one, window_fn::mp3, window_fn::vorbis] { for i in 1..11 { let input_len = i * 4; let output_len = i * 2; let input = random_signal(input_len); let (input_a, input_b) = input.split_at(output_len); let mut naive_output = vec![0f32; output_len]; let mut fast_output = vec![0f32; output_len]; let naive_mdct = MdctNaive::new(output_len, current_window_fn); let inner_dct4 = Arc::new(Type4Naive::new(output_len)); let fast_mdct = MdctViaDct4::new(inner_dct4, current_window_fn); let mut naive_scratch = vec![0f32; naive_mdct.get_scratch_len()]; let mut fast_scratch = vec![0f32; fast_mdct.get_scratch_len()]; naive_mdct.process_mdct_with_scratch( &input_a, &input_b, &mut naive_output, &mut naive_scratch, ); fast_mdct.process_mdct_with_scratch( &input_a, &input_b, &mut fast_output, &mut fast_scratch, ); assert!( compare_float_vectors(&naive_output, &fast_output), "i = {}", i ); } } } /// Verify that our fast implementation of the MDCT and IMDCT gives the same output as the slow version, for many different inputs #[test] fn test_imdct_via_dct4() { for current_window_fn in &[window_fn::one, window_fn::mp3, window_fn::vorbis] { for i in 1..11 { let input_len = i * 2; let output_len = i * 4; let input = random_signal(input_len); // Fill both output buffers with ones, instead of zeroes, to verify that the IMDCT doesn't overwrite the output buffer let mut naive_output = vec![1f32; output_len]; let (naive_output_a, naive_output_b) = naive_output.split_at_mut(input_len); let mut fast_output = vec![1f32; output_len]; let (fast_output_a, fast_output_b) = fast_output.split_at_mut(input_len); let naive_mdct = MdctNaive::new(input_len, current_window_fn); let inner_dct4 = Arc::new(Type4Naive::new(input_len)); let fast_mdct = MdctViaDct4::new(inner_dct4, current_window_fn); let mut naive_scratch = vec![0f32; naive_mdct.get_scratch_len()]; let mut fast_scratch = vec![0f32; fast_mdct.get_scratch_len()]; naive_mdct.process_imdct_with_scratch( &input, naive_output_a, naive_output_b, &mut naive_scratch, ); fast_mdct.process_imdct_with_scratch( &input, fast_output_a, fast_output_b, &mut fast_scratch, ); assert!( compare_float_vectors(&naive_output, &fast_output), "i = {}", i ); } } } }