use crate::common::{compare_float_vectors, random_signal}; use rustdct::DctPlanner; macro_rules! dct_test_with_known_data { ($reference_fn:ident, $naive_struct:ident, $process_fn: ident, $known_data_fn:ident) => ( // Compare our naive struct and our reference_fn implementation against a bunch of known data let known_data = $known_data_fn(); for entry in known_data { let len = entry.input.len(); assert_eq!(len, entry.expected_output.len(), "Invalid test data -- input and known output are not the same length"); let mut naive_buffer = entry.input.clone(); let naive_dct = $naive_struct::new(len); naive_dct.$process_fn(&mut naive_buffer); let slow_output = $reference_fn(&entry.input); println!("input: {:?}", entry.input); println!("expected output:{:?}", entry.expected_output); println!("naive output: {:?}", naive_buffer); println!("slow output: {:?}", slow_output); assert!(compare_float_vectors(&entry.expected_output, &naive_buffer)); assert!(compare_float_vectors(&entry.expected_output, &slow_output)); } ) } macro_rules! dct_test_inverse { ($reference_fn:ident, $inverse_fn:ident, $inverse_scale_fn:ident, $first_size:expr) => ( // Test that the slow fn, paired with the correct inverse fn, actually yields the original data for len in $first_size..20 { let input = random_signal(len); let intermediate = $reference_fn(&input); let inverse = $inverse_fn(&intermediate); let inverse_scale = $inverse_scale_fn(len); let scaled_inverse: Vec = inverse.into_iter().map(|entry| entry * inverse_scale).collect(); println!("input: {:?}", input); println!("scaled inverse: {:?}", scaled_inverse); assert!(compare_float_vectors(&input, &scaled_inverse)); } ) } macro_rules! dct_test_with_planner { ($reference_fn:ident, $naive_struct:ident, $process_fn: ident, $planner_fn:ident, $first_size:expr) => { // Compare our naive struct against the output from the planner for len in $first_size..20 { let input = random_signal(len); let mut naive_buffer = input.clone(); let mut actual_buffer = input.clone(); let naive_dct = $naive_struct::new(len); let mut planner = DctPlanner::new(); let actual_dct = planner.$planner_fn(len); assert_eq!( actual_dct.len(), len, "Planner created a DCT of incorrect length. Expected {}, got {}", len, actual_dct.len() ); let reference_output = $reference_fn(&input); naive_dct.$process_fn(&mut naive_buffer); actual_dct.$process_fn(&mut actual_buffer); println!("input: {:?}", input); println!("reference output:{:?}", reference_output); println!("naive output: {:?}", naive_buffer); println!("planned output: {:?}", actual_buffer); assert!(compare_float_vectors(&reference_output, &naive_buffer)); assert!(compare_float_vectors(&reference_output, &actual_buffer)); } }; } pub mod test_mdct { use super::*; use rustdct::{ mdct::{Mdct, MdctNaive}, RequiredScratch, }; pub fn planned_matches_naive(len: usize, window_fn: F) where F: Fn(usize) -> Vec, { let input = random_signal(len * 2); println!("input: {:?}", input); let (input_a, input_b) = input.split_at(len); let mut naive_output = vec![0f32; len]; let mut actual_output = vec![0f32; len]; let naive_dct = MdctNaive::new(len, &window_fn); let mut planner = DctPlanner::new(); let actual_dct = planner.plan_mdct(len, window_fn); assert_eq!( actual_dct.len(), len, "Planner created a DCT of incorrect length" ); let mut naive_scratch = vec![0f32; naive_dct.get_scratch_len()]; let mut fast_scratch = vec![0f32; actual_dct.get_scratch_len()]; naive_dct.process_mdct_with_scratch( input_a, input_b, &mut naive_output, &mut naive_scratch, ); actual_dct.process_mdct_with_scratch( input_a, input_b, &mut actual_output, &mut fast_scratch, ); println!("Naive output: {:?}", naive_output); println!("Planned output: {:?}", actual_output); assert!( compare_float_vectors(&naive_output, &actual_output), "len = {}", len ); } pub fn test_tdac(len: usize, scale_factor: f32, window_fn: F) where F: Fn(usize) -> Vec, { let mut planner = DctPlanner::new(); let mdct = planner.plan_mdct(len, &window_fn); const NUM_SEGMENTS: usize = 5; let input = random_signal(len * (NUM_SEGMENTS + 1)); let mut output = vec![0f32; len * NUM_SEGMENTS]; let mut inverse = vec![0f32; len * (NUM_SEGMENTS + 1)]; let mut scratch = vec![0f32; mdct.get_scratch_len()]; for i in 0..NUM_SEGMENTS { let input_chunk = &input[len * i..(len * (i + 2))]; let output_chunk = &mut output[len * i..(len * (i + 1))]; let (input_a, input_b) = input_chunk.split_at(len); mdct.process_mdct_with_scratch(input_a, input_b, output_chunk, &mut scratch); } for i in 0..NUM_SEGMENTS { let input_chunk = &output[len * i..(len * (i + 1))]; let output_chunk = &mut inverse[len * i..(len * (i + 2))]; let (output_a, output_b) = output_chunk.split_at_mut(len); mdct.process_imdct_with_scratch(input_chunk, output_a, output_b, &mut scratch); } //we have to scale the inverse by 1/len for element in inverse.iter_mut() { *element = *element * scale_factor; } println!("scale: {:?}", scale_factor); println!("input: {:?}", &input[len..input.len() - len]); println!("inverse: {:?}", &inverse[len..input.len() - len]); assert!( compare_float_vectors( &input[len..input.len() - len], &inverse[len..inverse.len() - len], ), "len = {}", len ); } }