lanczos-resampler 0.1.0

package/README.md

@@ -0,0 +1,143 @@
+# Lanczos resampler
+
+[![Crates.io Version](https://img.shields.io/crates/v/lanczos-resampler)](https://crates.io/crates/lanczos-resampler)
+[![Docs](https://docs.rs/lanczos-resampler/badge.svg)](https://docs.rs/lanczos-resampler)
+[![dependency status](https://deps.rs/repo/github/igankevich/lanczos-resampler/status.svg)](https://deps.rs/repo/github/igankevich/lanczos-resampler)
+
+An audio resampler that uses [Lanczos filter](https://en.wikipedia.org/wiki/Lanczos_resampling)
+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.
+
+
+## Features
+
+#### Small memory footprint
+
+The library doesn't use memory allocation by default,
+and resampler's internal state occupies less than a hundred bytes.
+
+#### High performance
+
+Thanks to small kernel size the processing time of a typical audio chunk is very fast (below 100 μs on a typical laptop).
+
+#### Robustness
+
+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?
+
+#### JS-compatible
+
+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.
+
+
+## Usage
+
+### Kernel parameters
+
+This library uses [Lanczos kernel](https://en.wikipedia.org/wiki/Lanczos_resampling)
+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).
+
+### Interleaved vs. non-interleaved format
+
+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.
+
+
+### Rust
+
+#### Resampling audio stream in chunks
+
+```rust
+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);
+```
+
+#### Resampling the whole audio track
+
+```rust
+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());
+```
+
+### JS
+
+#### Installation
+
+```bash
+npm install lanczos-resampler
+```
+
+#### Resampling audio stream in chunks
+
+```javascript
+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 numProcessed = resampler.resample(input, output);
+assert.equal(input.length, numProcessed);
+```
+
+#### Resampling the whole audio track
+
+```javascript
+import { WholeResampler, outputLength } as lanczos from 'lanczos-resampler';
+
+const input = new Float32Array(1024);
+input.fill(0.1);
+const outputLen = outputLength(1024, 44100, 48000);
+const output = new Float32Array(outputLen);
+const resampler = new WholeResampler();
+const numProcessed = resampler.resampleInto(input, output);
+assert.equal(input.length, numProcessed);
+console.log(output)
+```
+
+
+## Documentation
+
+Rust: <https://docs.rs/lanczos-resampler>
+
+JS: <https://igankevich.github.com/lanczos-resampler>
+
+
+## No-std support
+
+This crate supports `no_std` via [`libm`](https://docs.rs/libm/latest/libm/).
+When `std` feature is enabled (the default), it uses built-in mathematical functions
+which are typically much faster than `libm`.

package/lanczos_resampler.d.ts

@@ -0,0 +1,208 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class ChunkedInterleavedResampler {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get maximum output chunk length given the input chunk length.
+   *
+   * Returns the same value as {@link outputLength} plus one.
+   * This additional sample is used to compensate for unevenly divisible sample rates.
+   *
+   * You should consider updating buffer size every time you change output sample rate via
+   * {@link ChunkedInterleavedResampler.outputSampleRate}.
+   */
+  maxNumOutputFrames(numInputFrames: number): number;
+  /**
+   * Creates new instance of resampler with the specified input and output sample rates and the
+   * number of channels.
+   * @param inputSampleRate - input sample rate in Hz
+   * @param outputSampleRate - output sample rate in Hz
+   * @param numChannels - number of channels
+   */
+  constructor(inputSampleRate: number, outputSampleRate: number, numChannels: number);
+  /**
+   * Resets internal state.
+   *
+   * Erases any information about the previous chunk.
+   *
+   * Use this method when you want to reuse resampler for another audio stream.
+   */
+  reset(): void;
+  /**
+   * Resamples input signal chunk from the source to the target sample rate and appends the
+   * resulting signal to the output.
+   *
+   * Returns the number of processed input samples. The output is clamped to _[-1; 1]_.
+   *
+   * For each {@link ChunkedInterleavedResampler.inputSampleRate} input samples this method produces exactly
+   * {@link ChunkedInterleavedResampler.outputSampleRate} output samples  even if it is called multiple times with a smaller
+   * amount of input samples; the only exception is when the output sample rate was changed in the process.
+   *
+   * #### Edge cases
+   *
+   * Returns 0 when either the number of input or output frames is less than _max(2, A-1)_, adjusted in
+   * accordance with sample rate ratio.
+   *
+   * #### Limitations
+   *
+   * The output depends on the chunk size, hence resampling the same audio track all at once and
+   * in chunks will produce slightly different results. This a consequence of the fact that Lanczos kernel
+   * isn't an interpolation function, but a filter. To minimize such discrepancies chunk size should
+   * be much larger than _2⋅A + 1_.
+   */
+  resample(chunk: Float32Array, output: Float32Array): number;
+  /**
+   * Get the number of channels.
+   */
+  readonly numChannels: number;
+  /**
+   * Get input sample rate in Hz.
+   */
+  readonly inputSampleRate: number;
+  /**
+   * Get/set output sample rate in Hz.
+   *
+   * After changing the sample rate you should consider updating buffer size to
+   * {@link ChunkedInterleavedResampler.maxNumOutputFrames}.
+   */
+  outputSampleRate: number;
+}
+
+export class ChunkedResampler {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get maximum output chunk length given the input chunk length.
+   *
+   * Returns the same value as {@link outputLength} plus one.
+   * This additional sample is used to compensate for unevenly divisible sample rates.
+   *
+   * You should consider updating buffer size every time you change output sample rate via
+   * {@link ChunkedResampler.outputSampleRate}.
+   */
+  maxNumOutputFrames(numInputFrames: number): number;
+  /**
+   * Create new resampler with the specified input and output sample rates.
+   * @param inputSampleRate - input sample rate in Hz
+   * @param outputSampleRate - output sample rate in Hz
+   */
+  constructor(inputSampleRate: number, outputSampleRate: number);
+  /**
+   * Resets internal state.
+   *
+   * Erases any information about the previous chunk.
+   *
+   * Use this method when you want to reuse resampler for another audio stream.
+   */
+  reset(): void;
+  /**
+   * Resamples input signal chunk from the source to the target sample rate and appends the
+   * resulting signal to the output.
+   *
+   * Returns the number of processed input samples. The output is clamped to _[-1; 1]_.
+   *
+   * For each {@link ChunkedResampler.inputSampleRate} input samples this method produces exactly
+   * {@link ChunkedResampler.outputSampleRate} output samples  even if it is called multiple times with a smaller
+   * amount of input samples; the only exception is when the output sample rate was changed in the process.
+   *
+   * #### Edge cases
+   *
+   * Returns 0 when either the input length or output length is less than _max(2, A-1)_, adjusted in
+   * accordance with sample rate ratio.
+   *
+   * #### Limitations
+   *
+   * The output depends on the chunk size, hence resampling the same audio track all at once and
+   * in chunks will produce slightly different results. This a consequence of the fact that Lanczos kernel
+   * isn't an interpolation function, but a filter. To minimize such discrepancies chunk size should
+   * be much larger than _2⋅A + 1_.
+   */
+  resample(chunk: Float32Array, output: Float32Array): number;
+  /**
+   * Get input sample rate in Hz.
+   */
+  readonly inputSampleRate: number;
+  /**
+   * Get/set output sample rate in Hz.
+   *
+   * After changing the sample rate you should consider updating buffer size to
+   * {@link ChunkedResampler.maxNumOutputFrames}.
+   */
+  outputSampleRate: number;
+}
+
+export class WholeResampler {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * This is a variant of {@link WholeResampler.resample} that doesn't use memory allocation.
+   *
+   * Returns the number of samples read from the input. Currently this is either 0 (see "Panics") or
+   * the input length.
+   *
+   * #### Edge cases
+   *
+   * Returns 0 when either the input length or remaining output length is less than 2.
+   *
+   * #### Panics
+   *
+   * Panics when the output isn't large enough to hold all the resampled points.
+   * Use {@link outputLength} to ensure that the buffer size is sufficient.
+   */
+  resampleInto(input: Float32Array, output: Float32Array): number;
+  /**
+   * This is a variant of {@link resampleInto} that processes several audio channels (one audio frame) at a time.
+   *
+   * #### Edge cases
+   *
+   * Returns 0 when either the number of input frames or the number of remaining output frames is less than 2.
+   *
+   * #### Panics
+   *
+   * - Panics when the output isn't large enough to hold all the resampled points.
+   *   Use {@link outputLength} to ensure that the buffer size is sufficient.
+   * - Panics when either the input or the output length isn't evenly divisible by the number of
+   *   channels.
+   * @param input - input frames
+   * @param numChannels - number of channels
+   * @param output
+   */
+  resampleInterleavedInto(input: Float32Array, numChannels: number, output: Float32Array): number;
+  /**
+   * Create new resampler.
+   */
+  constructor();
+  /**
+   * Resample input signal from the source to the target sample rate and
+   * returns the resulting output signal as a vector.
+   *
+   * #### Edge cases
+   *
+   * - Returns an empty array when either the input length or calculated output length is less than 2.
+   * - Returns an empty array when either the input length or the output sample rate is too large.
+   * @param input - input samples
+   * @param inputSampleRate - input sample rate in Hz
+   * @param outputSampleRate - output sample rate in Hz
+   */
+  resample(input: Float32Array, inputSampleRate: number, outputSampleRate: number): Float32Array;
+}
+
+/**
+ * Calculates resampled length of the input for the given input/output sample
+ * rates.
+ *
+ * #### Edge cases
+ *
+ * Returns `Number.NAN` when the input length or the output sample rate is too large.
+ *
+ * #### Limitations
+ *
+ * This function shouldn't be used when processing audio track in chunks;
+ * use {@link ChunkedResampler.maxNumOutputFrames} instead.
+ * @param inputLength - input length
+ * @param inputSampleRate - input sample rate in Hz
+ * @param outputSampleRate - output sample rate in Hz
+ */
+export function numOutputFrames(inputLength: number, inputSampleRate: number, outputSampleRate: number): number;

package/lanczos_resampler.js

@@ -0,0 +1,4 @@
+import * as wasm from "./lanczos_resampler_bg.wasm";
+export * from "./lanczos_resampler_bg.js";
+import { __wbg_set_wasm } from "./lanczos_resampler_bg.js";
+__wbg_set_wasm(wasm);

package/lanczos_resampler_bg.js

@@ -0,0 +1,507 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let stack_pointer = 128;
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const ChunkedInterleavedResamplerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunkedinterleavedresampler_free(ptr >>> 0, 1));
+
+const ChunkedResamplerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunkedresampler_free(ptr >>> 0, 1));
+
+const WholeResamplerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wholeresampler_free(ptr >>> 0, 1));
+
+/**
+ * A resampler that processes audio input in chunks; the channels are interleaved with each other.
+ *
+ * Use it to process audio streams.
+ *
+ * ## Parameters
+ *
+ * This resampler uses default parameters: _N = 16, A = 3_.
+ *
+ * ## Limitations
+ *
+ * `ChunkedInterleavedResampler` produces slightly different output compared to processing the whole input at once.
+ * If this is undesired, consider using {@link WholeResampler}.
+ */
+export class ChunkedInterleavedResampler {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkedInterleavedResamplerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunkedinterleavedresampler_free(ptr, 0);
+    }
+    /**
+     * Get the number of channels.
+     * @returns {number}
+     */
+    get numChannels() {
+        const ret = wasm.chunkedinterleavedresampler_numChannels(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get input sample rate in Hz.
+     * @returns {number}
+     */
+    get inputSampleRate() {
+        const ret = wasm.chunkedinterleavedresampler_inputSampleRate(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get/set output sample rate in Hz.
+     *
+     * After changing the sample rate you should consider updating buffer size to
+     * {@link ChunkedInterleavedResampler.maxNumOutputFrames}.
+     * @returns {number}
+     */
+    get outputSampleRate() {
+        const ret = wasm.chunkedinterleavedresampler_outputSampleRate(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get maximum output chunk length given the input chunk length.
+     *
+     * Returns the same value as {@link outputLength} plus one.
+     * This additional sample is used to compensate for unevenly divisible sample rates.
+     *
+     * You should consider updating buffer size every time you change output sample rate via
+     * {@link ChunkedInterleavedResampler.outputSampleRate}.
+     * @param {number} numInputFrames
+     * @returns {number}
+     */
+    maxNumOutputFrames(numInputFrames) {
+        const ret = wasm.chunkedinterleavedresampler_maxNumOutputFrames(this.__wbg_ptr, numInputFrames);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} value - new sample rate in Hz
+     */
+    set outputSampleRate(value) {
+        wasm.chunkedinterleavedresampler_set_outputSampleRate(this.__wbg_ptr, value);
+    }
+    /**
+     * Creates new instance of resampler with the specified input and output sample rates and the
+     * number of channels.
+     * @param {number} inputSampleRate - input sample rate in Hz
+     * @param {number} outputSampleRate - output sample rate in Hz
+     * @param {number} numChannels - number of channels
+     */
+    constructor(inputSampleRate, outputSampleRate, numChannels) {
+        const ret = wasm.chunkedinterleavedresampler_new(inputSampleRate, outputSampleRate, numChannels);
+        this.__wbg_ptr = ret >>> 0;
+        ChunkedInterleavedResamplerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Resets internal state.
+     *
+     * Erases any information about the previous chunk.
+     *
+     * Use this method when you want to reuse resampler for another audio stream.
+     */
+    reset() {
+        wasm.chunkedinterleavedresampler_reset(this.__wbg_ptr);
+    }
+    /**
+     * Resamples input signal chunk from the source to the target sample rate and appends the
+     * resulting signal to the output.
+     *
+     * Returns the number of processed input samples. The output is clamped to _[-1; 1]_.
+     *
+     * For each {@link ChunkedInterleavedResampler.inputSampleRate} input samples this method produces exactly
+     * {@link ChunkedInterleavedResampler.outputSampleRate} output samples  even if it is called multiple times with a smaller
+     * amount of input samples; the only exception is when the output sample rate was changed in the process.
+     *
+     * #### Edge cases
+     *
+     * Returns 0 when either the number of input or output frames is less than _max(2, A-1)_, adjusted in
+     * accordance with sample rate ratio.
+     *
+     * #### Limitations
+     *
+     * The output depends on the chunk size, hence resampling the same audio track all at once and
+     * in chunks will produce slightly different results. This a consequence of the fact that Lanczos kernel
+     * isn't an interpolation function, but a filter. To minimize such discrepancies chunk size should
+     * be much larger than _2⋅A + 1_.
+     * @param {Float32Array} chunk
+     * @param {Float32Array} output
+     * @returns {number}
+     */
+    resample(chunk, output) {
+        const ptr0 = passArrayF32ToWasm0(chunk, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.chunkedinterleavedresampler_resample(this.__wbg_ptr, ptr0, len0, addHeapObject(output));
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ChunkedInterleavedResampler.prototype[Symbol.dispose] = ChunkedInterleavedResampler.prototype.free;
+
+/**
+ * A resampler that processes audio input in chunks.
+ *
+ * Use it to process audio streams.
+ *
+ * ## Parameters
+ *
+ * This resampler uses default parameters: _N = 16, A = 3_.
+ *
+ * ## Limitations
+ *
+ * `ChunkedResampler` produces slightly different output compared to processing the whole input at once.
+ * If this is undesired, consider using {@link WholeResampler}.
+ */
+export class ChunkedResampler {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkedResamplerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunkedresampler_free(ptr, 0);
+    }
+    /**
+     * Get input sample rate in Hz.
+     * @returns {number}
+     */
+    get inputSampleRate() {
+        const ret = wasm.chunkedresampler_inputSampleRate(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get/set output sample rate in Hz.
+     *
+     * After changing the sample rate you should consider updating buffer size to
+     * {@link ChunkedResampler.maxNumOutputFrames}.
+     * @returns {number}
+     */
+    get outputSampleRate() {
+        const ret = wasm.chunkedresampler_outputSampleRate(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get maximum output chunk length given the input chunk length.
+     *
+     * Returns the same value as {@link outputLength} plus one.
+     * This additional sample is used to compensate for unevenly divisible sample rates.
+     *
+     * You should consider updating buffer size every time you change output sample rate via
+     * {@link ChunkedResampler.outputSampleRate}.
+     * @param {number} numInputFrames
+     * @returns {number}
+     */
+    maxNumOutputFrames(numInputFrames) {
+        const ret = wasm.chunkedresampler_maxNumOutputFrames(this.__wbg_ptr, numInputFrames);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} value - new sample rate in Hz
+     */
+    set outputSampleRate(value) {
+        wasm.chunkedresampler_set_outputSampleRate(this.__wbg_ptr, value);
+    }
+    /**
+     * Create new resampler with the specified input and output sample rates.
+     * @param {number} inputSampleRate - input sample rate in Hz
+     * @param {number} outputSampleRate - output sample rate in Hz
+     */
+    constructor(inputSampleRate, outputSampleRate) {
+        const ret = wasm.chunkedresampler_new(inputSampleRate, outputSampleRate);
+        this.__wbg_ptr = ret >>> 0;
+        ChunkedResamplerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Resets internal state.
+     *
+     * Erases any information about the previous chunk.
+     *
+     * Use this method when you want to reuse resampler for another audio stream.
+     */
+    reset() {
+        wasm.chunkedresampler_reset(this.__wbg_ptr);
+    }
+    /**
+     * Resamples input signal chunk from the source to the target sample rate and appends the
+     * resulting signal to the output.
+     *
+     * Returns the number of processed input samples. The output is clamped to _[-1; 1]_.
+     *
+     * For each {@link ChunkedResampler.inputSampleRate} input samples this method produces exactly
+     * {@link ChunkedResampler.outputSampleRate} output samples  even if it is called multiple times with a smaller
+     * amount of input samples; the only exception is when the output sample rate was changed in the process.
+     *
+     * #### Edge cases
+     *
+     * Returns 0 when either the input length or output length is less than _max(2, A-1)_, adjusted in
+     * accordance with sample rate ratio.
+     *
+     * #### Limitations
+     *
+     * The output depends on the chunk size, hence resampling the same audio track all at once and
+     * in chunks will produce slightly different results. This a consequence of the fact that Lanczos kernel
+     * isn't an interpolation function, but a filter. To minimize such discrepancies chunk size should
+     * be much larger than _2⋅A + 1_.
+     * @param {Float32Array} chunk
+     * @param {Float32Array} output
+     * @returns {number}
+     */
+    resample(chunk, output) {
+        const ptr0 = passArrayF32ToWasm0(chunk, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.chunkedresampler_resample(this.__wbg_ptr, ptr0, len0, addHeapObject(output));
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ChunkedResampler.prototype[Symbol.dispose] = ChunkedResampler.prototype.free;
+
+/**
+ * A resampler that processes audio input as a whole.
+ *
+ * Use it to process audio streams.
+ *
+ * ## Parameters
+ *
+ * This resampler uses default parameters: _N = 16, A = 3_.
+ *
+ * ## Limitations
+ *
+ * `WholeResampler` shouldn't be used to process audio track in chunks; use {@link ChunkedResampler} instead.
+ */
+export class WholeResampler {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WholeResamplerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wholeresampler_free(ptr, 0);
+    }
+    /**
+     * This is a variant of {@link WholeResampler.resample} that doesn't use memory allocation.
+     *
+     * Returns the number of samples read from the input. Currently this is either 0 (see "Panics") or
+     * the input length.
+     *
+     * #### Edge cases
+     *
+     * Returns 0 when either the input length or remaining output length is less than 2.
+     *
+     * #### Panics
+     *
+     * Panics when the output isn't large enough to hold all the resampled points.
+     * Use {@link outputLength} to ensure that the buffer size is sufficient.
+     * @param {Float32Array} input
+     * @param {Float32Array} output
+     * @returns {number}
+     */
+    resampleInto(input, output) {
+        try {
+            const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wholeresampler_resampleInto(this.__wbg_ptr, ptr0, len0, addBorrowedObject(output));
+            return ret >>> 0;
+        } finally {
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * This is a variant of {@link resampleInto} that processes several audio channels (one audio frame) at a time.
+     *
+     * #### Edge cases
+     *
+     * Returns 0 when either the number of input frames or the number of remaining output frames is less than 2.
+     *
+     * #### Panics
+     *
+     * - Panics when the output isn't large enough to hold all the resampled points.
+     *   Use {@link outputLength} to ensure that the buffer size is sufficient.
+     * - Panics when either the input or the output length isn't evenly divisible by the number of
+     *   channels.
+     * @param {Float32Array} input - input frames
+     * @param {number} numChannels - number of channels
+     * @param {Float32Array} output
+     * @returns {number}
+     */
+    resampleInterleavedInto(input, numChannels, output) {
+        try {
+            const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wholeresampler_resampleInterleavedInto(this.__wbg_ptr, ptr0, len0, numChannels, addBorrowedObject(output));
+            return ret >>> 0;
+        } finally {
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Create new resampler.
+     */
+    constructor() {
+        const ret = wasm.wholeresampler_new();
+        this.__wbg_ptr = ret >>> 0;
+        WholeResamplerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Resample input signal from the source to the target sample rate and
+     * returns the resulting output signal as a vector.
+     *
+     * #### Edge cases
+     *
+     * - Returns an empty array when either the input length or calculated output length is less than 2.
+     * - Returns an empty array when either the input length or the output sample rate is too large.
+     * @param {Float32Array} input - input samples
+     * @param {number} inputSampleRate - input sample rate in Hz
+     * @param {number} outputSampleRate - output sample rate in Hz
+     * @returns {Float32Array}
+     */
+    resample(input, inputSampleRate, outputSampleRate) {
+        const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wholeresampler_resample(this.__wbg_ptr, ptr0, len0, inputSampleRate, outputSampleRate);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) WholeResampler.prototype[Symbol.dispose] = WholeResampler.prototype.free;
+
+/**
+ * Calculates resampled length of the input for the given input/output sample
+ * rates.
+ *
+ * #### Edge cases
+ *
+ * Returns `Number.NAN` when the input length or the output sample rate is too large.
+ *
+ * #### Limitations
+ *
+ * This function shouldn't be used when processing audio track in chunks;
+ * use {@link ChunkedResampler.maxNumOutputFrames} instead.
+ * @param {number} inputLength - input length
+ * @param {number} inputSampleRate - input sample rate in Hz
+ * @param {number} outputSampleRate - output sample rate in Hz
+ * @returns {number}
+ */
+export function numOutputFrames(inputLength, inputSampleRate, outputSampleRate) {
+    const ret = wasm.numOutputFrames(inputLength, inputSampleRate, outputSampleRate);
+    return takeObject(ret);
+}
+
+export function __wbg___wbindgen_throw_dd24417ed36fc46e(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg_length_86ce4877baf913bb(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+};
+
+export function __wbg_new_with_length_95ba657dfb7d3dfb(arg0) {
+    const ret = new Float32Array(arg0 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_set_index_165b46b0114d368c(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = arg2;
+};
+
+export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "lanczos-resampler",
+  "type": "module",
+  "description": "Audio resampler for Rust/JS that uses Lanczos filter.",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/igankevich/lanczos-resampler"
+  },
+  "files": [
+    "lanczos_resampler_bg.wasm",
+    "lanczos_resampler.js",
+    "lanczos_resampler_bg.js",
+    "lanczos_resampler.d.ts"
+  ],
+  "main": "lanczos_resampler.js",
+  "homepage": "https://github.com/igankevich/lanczos-resampler",
+  "types": "lanczos_resampler.d.ts",
+  "sideEffects": [
+    "./lanczos_resampler.js",
+    "./snippets/*"
+  ],
+  "keywords": [
+    "upsampling",
+    "downsampling",
+    "interpolation",
+    "webaudio"
+  ]
+}