Crate resampler 

Audio resampling library

Resampler is a small, zero-dependency crate for high-quality audio resampling between common sample rates. It provides both FFT-based and FIR-based resamplers optimized for different use cases.

Usage Examples

FFT-Based Resampler (Highest Quality)

use resampler::{ResamplerFft, SampleRate};

// Create a stereo resampler (2 channels) from 44.1 kHz to 48 kHz.
let mut resampler = ResamplerFft::new(2, SampleRate::Hz44100, SampleRate::Hz48000);

// Get required buffer sizes (already includes all channels).
let input_size = resampler.chunk_size_input();
let output_size = resampler.chunk_size_output();

// Create input and output buffers (interleaved format: [L0, R0, L1, R1, ...]).
let input = vec![0.0f32; input_size];
let mut output = vec![0.0f32; output_size];

resampler.resample(&input, &mut output).unwrap();

FIR-Based Resampler (Low Latency, Streaming)

use resampler::{Attenuation, Latency, ResamplerFir, SampleRate};

// Create a stereo resampler with configurable latency (16, 32, or 64 samples).
let mut resampler = ResamplerFir::new(
    2,
    SampleRate::Hz48000,
    SampleRate::Hz44100,
    Latency::Sample64,
    Attenuation::Db90,
);

// Streaming API - accepts arbitrary input buffer sizes.
let input = vec![0.0f32; 512];
let mut output = vec![0.0f32; resampler.buffer_size_output()];

let (consumed, produced) = resampler.resample(&input, &mut output).unwrap();
println!("Consumed {consumed} samples, produced {produced} samples");

Choosing a Resampler

Both resamplers provide good quality, but are optimized for different use cases:

Feature	ResamplerFft	ResamplerFir
Quality	Very good (sharp rolloff)	Good (slow rolloff)
Performance	Very fast	Fast (configurable)
Latency	~256 samples	16-64 samples (configurable)
API	Fixed chunk size	Flexible streaming
Best for	Non-latency sensitive processing	Low-latency processing

Use ResamplerFft when:

• You need the absolute highest quality
• Latency is not a concern
• Processing pre-recorded audio files

Use ResamplerFir when:

• You need low latency (real-time audio)
• You can live with a slower rolloff
• Working with streaming data

FFT-Based Implementation

The resampler uses an FFT-based overlap-add algorithm with Kaiser windowing for high-quality audio resampling. Key technical details:

• Custom mixed-radix FFT with the Stockham Autosort algorithm.
• SIMD optimizations: All butterflies have SSE2, SSE4.2, AVX+FMA, and ARM NEON implementations.
• Stopband attenuation of -100 dB using the Kaiser windows function.
• Latency around 256 samples.

FIR-Based Implementation

The FIR resampler uses a polyphase filter with linear interpolation for high-quality audio resampling with low latency. Key technical details:

• Polyphase decomposition: 1024 phases with linear interpolation between phases.
• SIMD optimizations: Convolution kernels optimized with SSE2, SSE4.2, AVX+FMA, AVX-512 and ARM NEON.
• Configurable filter length: 32, 64, or 128 taps (16, 32, or 64 samples latency).
• Adjustable rolloff and stopband attenuation,
• Streaming API: Accepts arbitrary input buffer sizes for flexible real-time processing,

Performance

Both resamplers include SIMD optimizations with runtime CPU feature detection for maximum performance and compatibility.

But for up to 25% better performance on x86_64, compile with target-cpu=x86-64-v3 (enables AVX2, FMA, and other optimizations).

Overall the SIMD for x86_64 have four levels implemented, targeting four possible CPU generations that build up on each other:

• x86-64-v1: 128-bit SSE2 (around 2003-2004)
• x86-64-v2: 128-bit SSE4.2 (around 2008-2011)
• x86-64-v3: 256-bit AVX+FMA (around 2013-2015)
• x86-64-v4: 512-bit AVX-512 (around 2017-2022)

no-std Compatibility

The library supports no-std environments with alloc. To use the library in a no-std environment, enable the no_std feature:

[dependencies]
resampler = { version = "0.2", features = ["no_std"] }

Behavior Differences

When the no_std feature is enabled:

• Caching: The library will not cache FFT and FIR objects globally to shorten resampler creation time and lower overall memory consumption for multiple resamplers.

• No runtime detection of SIMD functionality. You need to activate SIMD via compile time target features.

The default build (without no_std feature) has zero dependencies and uses the standard library for optimal performance and memory efficiency through global caching.

Alternatives

Other high-quality audio resampling libraries in Rust are:

• Rubato: The overlap-add resampling approach used in this library is based on Rubato’s implementation.

License

Licensed under either of

• Apache License, Version 2.0
• MIT license

at your option.

Structs

ResamplerFft

High-quality and high-performance FFT-based audio resampler supporting multi-channel audio.

ResamplerFir

High-quality polyphase FIR audio resampler supporting multi-channel audio with streaming API.

Enums

Attenuation

The desired stopband attenuation of the filter. Higher attenuation provides better stopband rejection but slightly wider transition bands.

Latency

Latency configuration for the FIR resampler.

ResampleError

Errors the process function can throw.

SampleRate

All sample rates the resampler can operate on.