cqt-rs (Constant-Q Transform)

This library provides an implementation of the Constant-Q Transform (CQT) for time-frequency analysis of audio signals. The CQT is a method for analyzing a signal in the time-frequency domain, where the frequency resolution is logarithmic. This library provides the necessary functions to compute a CQT filterbank and apply it to an input audio signal.

Features

• Customizable CQT parameters, including:
  • Minimum and maximum frequencies
  • Number of bins
  • Sampling rate
  • Window length
• Custom error handling for invalid parameters and FFT computation errors
• Parallelization for performance optimization

Usage

1. Import the library:

[dependencies]
cqt-rs = "0.1.0"

use cqt_rs::{CQTParams, Cqt};

2. Create a CQTParams instance with the desired parameters:

let cqt_params = CQTParams::new(
    30.0, // Min frequency
    4000.0, // Max frequency
    12, // Number of bins
    44000.0, // Sampling rate
    4096.0 // Window length
).expect("Error creating CQTParams");

3. Create a Cqt instance using the CQTParams:

let cqt = Cqt::new(cqt_params);

4. Process an input audio signal using the Cqt instance:

let input_signal: Vec<f32> = vec![...]; // Your input audio signal
let hop_size = 512;
let cqt_features = cqt.process(&input_signal, hop_size).expect("Error computing CQT features");

Error Handling

The functions CQTParams::new and Cqt::process return Result types, which can be used to handle errors related to invalid parameters, FFT computation errors, or other issues:

match CQTParams::new(...) {
    Ok(cqt_params) => {
        // Use the CQTParams
    },
    Err(error) => {
        println!("Error creating CQTParams: {:?}", error);
        // or handle the error in your way
    },
}

match cqt.process(&input_signal, hop_size) {
    Ok(cqt_features) => {
        // Use the CQT features
    },
    Err(error) => {
        println!("Error computing CQT features: {:?}", error);
        // or handle the error in your way
    },
}

Dependencies

This library uses the following crates:

• ndarray for efficient array computations
• rustfft for FFT computation
• hann-rs crate for Hann window computation

Performance

This implementation of the CQT is optimized for performance using parallelization with the rayon crate. The performance will depend on the input signal size, the chosen parameters, and your hardware.

Benchmarks of APPROXIMATE results