lanczos-resampler 0.1.0 → 0.2.0

package/README.md

@@ -116,11 +116,11 @@ assert.equal(input.length, numProcessed);
 #### Resampling the whole audio track
 
 ```javascript
-import { WholeResampler, outputLength } as lanczos from 'lanczos-resampler';
+import { WholeResampler, numOutputFrames } as lanczos from 'lanczos-resampler';
 
 const input = new Float32Array(1024);
 input.fill(0.1);
-const outputLen = outputLength(1024, 44100, 48000);
+const outputLen = numOutputFrames(1024, 44100, 48000);
 const output = new Float32Array(outputLen);
 const resampler = new WholeResampler();
 const numProcessed = resampler.resampleInto(input, output);
@@ -131,9 +131,9 @@ console.log(output)
 
 ## Documentation
 
-Rust: <https://docs.rs/lanczos-resampler>
+Rust: <https://docs.rs/lanczos-resampler/latest/lanczos_resampler/>
 
-JS: <https://igankevich.github.com/lanczos-resampler>
+JS: <https://igankevich.github.io/lanczos-resampler>
 
 
 ## No-std support

package/lanczos_resampler.d.ts

@@ -7,7 +7,7 @@ export class ChunkedInterleavedResampler {
   /**
    * Get maximum output chunk length given the input chunk length.
    *
-   * Returns the same value as {@link outputLength} plus one.
+   * Returns the same value as {@link numOutputFrames} 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
@@ -34,7 +34,8 @@ export class ChunkedInterleavedResampler {
    * 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]_.
+   * Returns the number of processed input samples and the number of produced output 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
@@ -52,7 +53,7 @@ export class ChunkedInterleavedResampler {
    * 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;
+  resample(chunk: Float32Array, output: Float32Array): ResampleOutcome;
   /**
    * Get the number of channels.
    */
@@ -76,7 +77,7 @@ export class ChunkedResampler {
   /**
    * Get maximum output chunk length given the input chunk length.
    *
-   * Returns the same value as {@link outputLength} plus one.
+   * Returns the same value as {@link numOutputFrames} 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
@@ -101,7 +102,8 @@ export class ChunkedResampler {
    * 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]_.
+   * Returns the number of processed input samples and the number of produced output 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
@@ -119,7 +121,7 @@ export class ChunkedResampler {
    * 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;
+  resample(chunk: Float32Array, output: Float32Array): ResampleOutcome;
   /**
    * Get input sample rate in Hz.
    */
@@ -133,6 +135,20 @@ export class ChunkedResampler {
   outputSampleRate: number;
 }
 
+export class ResampleOutcome {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * How many samples were read from the input.
+   */
+  numRead: number;
+  /**
+   * How many samples were wrtten to the output.
+   */
+  numWritten: number;
+}
+
 export class WholeResampler {
   free(): void;
   [Symbol.dispose](): void;
@@ -149,7 +165,7 @@ export class WholeResampler {
    * #### 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.
+   * Use {@link numOutputFrames} to ensure that the buffer size is sufficient.
    */
   resampleInto(input: Float32Array, output: Float32Array): number;
   /**
@@ -162,7 +178,7 @@ export class WholeResampler {
    * #### 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.
+   *   Use {@link numOutputFrames} 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

package/lanczos_resampler_bg.js

@@ -91,6 +91,10 @@ const ChunkedResamplerFinalization = (typeof FinalizationRegistry === 'undefined
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_chunkedresampler_free(ptr >>> 0, 1));
 
+const ResampleOutcomeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_resampleoutcome_free(ptr >>> 0, 1));
+
 const WholeResamplerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wholeresampler_free(ptr >>> 0, 1));
@@ -150,7 +154,7 @@ export class ChunkedInterleavedResampler {
     /**
      * Get maximum output chunk length given the input chunk length.
      *
-     * Returns the same value as {@link outputLength} plus one.
+     * Returns the same value as {@link numOutputFrames} 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
@@ -195,7 +199,8 @@ export class ChunkedInterleavedResampler {
      * 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]_.
+     * Returns the number of processed input samples and the number of produced output 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
@@ -214,13 +219,13 @@ export class ChunkedInterleavedResampler {
      * be much larger than _2⋅A + 1_.
      * @param {Float32Array} chunk
      * @param {Float32Array} output
-     * @returns {number}
+     * @returns {ResampleOutcome}
      */
     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;
+        return ResampleOutcome.__wrap(ret);
     }
 }
 if (Symbol.dispose) ChunkedInterleavedResampler.prototype[Symbol.dispose] = ChunkedInterleavedResampler.prototype.free;
@@ -272,7 +277,7 @@ export class ChunkedResampler {
     /**
      * Get maximum output chunk length given the input chunk length.
      *
-     * Returns the same value as {@link outputLength} plus one.
+     * Returns the same value as {@link numOutputFrames} 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
@@ -315,7 +320,8 @@ export class ChunkedResampler {
      * 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]_.
+     * Returns the number of processed input samples and the number of produced output 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
@@ -334,17 +340,71 @@ export class ChunkedResampler {
      * be much larger than _2⋅A + 1_.
      * @param {Float32Array} chunk
      * @param {Float32Array} output
-     * @returns {number}
+     * @returns {ResampleOutcome}
      */
     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;
+        return ResampleOutcome.__wrap(ret);
     }
 }
 if (Symbol.dispose) ChunkedResampler.prototype[Symbol.dispose] = ChunkedResampler.prototype.free;
 
+/**
+ * Resampling outcome.
+ */
+export class ResampleOutcome {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ResampleOutcome.prototype);
+        obj.__wbg_ptr = ptr;
+        ResampleOutcomeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ResampleOutcomeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_resampleoutcome_free(ptr, 0);
+    }
+    /**
+     * How many samples were read from the input.
+     * @returns {number}
+     */
+    get numRead() {
+        const ret = wasm.__wbg_get_resampleoutcome_numRead(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * How many samples were read from the input.
+     * @param {number} arg0
+     */
+    set numRead(arg0) {
+        wasm.__wbg_set_resampleoutcome_numRead(this.__wbg_ptr, arg0);
+    }
+    /**
+     * How many samples were wrtten to the output.
+     * @returns {number}
+     */
+    get numWritten() {
+        const ret = wasm.__wbg_get_resampleoutcome_numWritten(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * How many samples were wrtten to the output.
+     * @param {number} arg0
+     */
+    set numWritten(arg0) {
+        wasm.__wbg_set_resampleoutcome_numWritten(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) ResampleOutcome.prototype[Symbol.dispose] = ResampleOutcome.prototype.free;
+
 /**
  * A resampler that processes audio input as a whole.
  *
@@ -382,7 +442,7 @@ export class WholeResampler {
      * #### 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.
+     * Use {@link numOutputFrames} to ensure that the buffer size is sufficient.
      * @param {Float32Array} input
      * @param {Float32Array} output
      * @returns {number}
@@ -407,7 +467,7 @@ export class WholeResampler {
      * #### 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.
+     *   Use {@link numOutputFrames} 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

package/package.json

@@ -2,7 +2,7 @@
   "name": "lanczos-resampler",
   "type": "module",
   "description": "Audio resampler for Rust/JS that uses Lanczos filter.",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -15,7 +15,7 @@
     "lanczos_resampler.d.ts"
   ],
   "main": "lanczos_resampler.js",
-  "homepage": "https://github.com/igankevich/lanczos-resampler",
+  "homepage": "https://igankevich.github.io/lanczos-resampler/",
   "types": "lanczos_resampler.d.ts",
   "sideEffects": [
     "./lanczos_resampler.js",