lanczos-resampler
    Preparing search index...

    lanczos-resampler

    Lanczos resampler

    crates.io docs.rs npmjs.com JS docs

    An audio resampler that uses Lanczos filter as an alternative to traditional windowed sinc filters. The main advantage of such approach is small number of coefficients required to store the filter state; this results in small memory footprint and high performance.

    The library doesn't use memory allocation by default, and resampler's internal state occupies less than a hundred bytes.

    Thanks to small kernel size the processing time of a typical audio chunk is very fast (below 100 μs on a typical laptop).

    When you're resampling from N Hz to M Hz, for each N input samples you will get exactly M output samples[^1]. This results in predictable audio stream playback and simplifies time synchronization between different streams (e.g. video and audio).

    [^1]: Seriously, why other libraries don't have this feature?

    This library can be used in web browsers and in general in any JS engine that supports WASM. All of the abovementioned features are inherent to both Rust and WASM versions of the library.

    This library uses Lanczos kernel approximated by 2N - 1 points and defined on interval [-A; A]. The kernel is interpolated using cubic Hermite splines with second-order finite differences at spline endpoints. The output is clamped to [-1; 1].

    The recommended parameters are N = 16, A = 3. Using A = 2 might improve performance a little bit. Using larger N will techincally improve precision, but precision isn't a good metric for audio signal. With N = 16 the kernel fits into exactly 64 B (the size of a cache line).

    Non-interleaved format means that audio samples for each channel are stored in separate arrays. To resample such data you need to call resample for each channel individually.

    Interleaved format on the other hand means that samples for each channel are stored in a single array using frames; a frame is a sequence of samples, one sample for each channel. To resample such data you need to call resample only once.

    Usually resampling interleaved data is much faster than processing each channel individually because a CPU can process such data efficiently with SIMD instructions.

    use lanczos_resampler::ChunkedResampler;

    let n = 1024;
    let chunk = vec![0.1; n];
    let mut resampler = ChunkedResampler::new(44100, 48000);
    let mut output: Vec<f32> = Vec::with_capacity(resampler.max_num_output_frames(n));
    let num_processed = resampler.resample(&chunk[..], &mut output);
    assert_eq!(n, num_processed);

    use lanczos_resampler::WholeResampler;

    let n = 1024;
    let track = vec![0.1; n];
    let output_len = lanczos_resampler::num_output_frames(n, 44100, 48000);
    let mut output = vec![0.0; output_len];
    let resampler = WholeResampler::new();
    let mut output_slice = &mut output[..];
    let num_processed = resampler.resample_into(&track[..], &mut output_slice);
    assert_eq!(n, num_processed);
    assert!(output_slice.is_empty());

    npm install lanczos-resampler

    import { ChunkedResampler } from 'lanczos-resampler';

    const resampler = new ChunkedResampler(44100, 48000);
    const input = new Float32Array(1024);
    input.fill(0.1);
    const output = new Float32Array(resampler.maxNumOutputFrames(input.length));
    const { numRead, numWritten } = resampler.resample(input, output);
    assert.equal(input.length, numRead);

    import { WholeResampler, numOutputFrames } as lanczos from 'lanczos-resampler';

    const input = new Float32Array(1024);
    input.fill(0.1);
    const outputLen = numOutputFrames(1024, 44100, 48000);
    const output = new Float32Array(outputLen);
    const resampler = new WholeResampler();
    const { numRead, numWritten } = resampler.resampleInto(input, output);
    assert.equal(input.length, numRead);
    console.log(output)

    Rust: https://docs.rs/lanczos-resampler/latest/lanczos_resampler/

    JS: https://igankevich.github.io/lanczos-resampler

    This crate supports no_std via libm. When std feature is enabled (the default), it uses built-in mathematical functions which are typically much faster than libm.

    Settings

    Member Visibility

    On This Page

    Lanczos resampler