Struct rustdct::algorithm::Type4ConvertToFFTOdd

pub struct Type4ConvertToFFTOdd<T> { /* fields omitted */ }

DCT Type 4 and DST Type 4 implementation that converts the problem into a FFT of the same size.

This algorithm can only be used if the problem size is odd.

// Computes a DCT Type 4 and DST Type 4 of size 1233
use rustdct::{DCT4, DST4};
use rustdct::algorithm::Type4ConvertToFFTOdd;
use rustdct::rustfft::FFTplanner;
 
let len = 1233;
let mut planner = FFTplanner::new(false);
let fft = planner.plan_fft(len);
let dct = Type4ConvertToFFTOdd::new(fft);

let mut dct4_input:  Vec<f32> = vec![0f32; len];
let mut dct4_output: Vec<f32> = vec![0f32; len];
dct.process_dct4(&mut dct4_input, &mut dct4_output);
 
let mut dst4_input:  Vec<f32> = vec![0f32; len];
let mut dst4_output: Vec<f32> = vec![0f32; len];
dct.process_dst4(&mut dst4_input, &mut dst4_output);

Methods

impl<T: DCTnum> Type4ConvertToFFTOdd<T>

pub fn new(inner_fft: Arc<dyn FFT<T>>) -> Self

Creates a new DCT4 context that will process signals of length inner_fft.len(). inner_fft.len() must be odd.

Trait Implementations

impl<T: DCTnum> DCT4<T> for Type4ConvertToFFTOdd<T>

fn process_dct4(&self, input: &mut [T], output: &mut [T])

Computes the DCT Type 4 on the input buffer and places the result in the output buffer.

impl<T: DCTnum> DST4<T> for Type4ConvertToFFTOdd<T>

fn process_dst4(&self, input: &mut [T], output: &mut [T])

Computes the DST Type 4 on the input buffer and places the result in the output buffer.

impl<T: DCTnum> TransformType4<T> for Type4ConvertToFFTOdd<T>

impl<T> Length for Type4ConvertToFFTOdd<T>

fn len(&self) -> usize

The FFT size that this algorithm can process