rusty-chromaprint-wasm 0.1.4 → 0.1.5

package/dist/rusty_chromaprint_wasm.d.ts

@@ -42,6 +42,31 @@ export class Fingerprinter {
     start(sample_rate: number, channels: number): void;
 }
 
+/**
+ * Result of matching two fingerprints.
+ */
+export class MatchFingerprintsResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    segments: MatchSegment[];
+}
+
+/**
+ * A matched segment between two fingerprints.
+ */
+export class MatchSegment {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly duration: number;
+    readonly end1: number;
+    readonly end2: number;
+    readonly score: number;
+    readonly start1: number;
+    readonly start2: number;
+}
+
 /**
  * One-shot: compute fingerprint from interleaved i16 samples.
  */
@@ -49,6 +74,5 @@ export function fingerprintFromSamples(sample_rate: number, channels: number, sa
 
 /**
  * Match two raw fingerprints (u32 arrays). Returns segments of similar audio.
- * Each segment has start1, end1, start2, end2, duration (seconds) and score.
  */
-export function matchFingerprints(raw1: Uint32Array, raw2: Uint32Array): any;
+export function matchFingerprints(raw1: Uint32Array, raw2: Uint32Array): MatchFingerprintsResult;

package/dist/rusty_chromaprint_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./rusty_chromaprint_wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    FingerprintFromSamplesResult, Fingerprinter, fingerprintFromSamples, matchFingerprints
+    FingerprintFromSamplesResult, Fingerprinter, MatchFingerprintsResult, MatchSegment, fingerprintFromSamples, matchFingerprints
 } from "./rusty_chromaprint_wasm_bg.js";

package/dist/rusty_chromaprint_wasm_bg.js

@@ -141,6 +141,119 @@ export class Fingerprinter {
 }
 if (Symbol.dispose) Fingerprinter.prototype[Symbol.dispose] = Fingerprinter.prototype.free;
 
+/**
+ * Result of matching two fingerprints.
+ */
+export class MatchFingerprintsResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MatchFingerprintsResult.prototype);
+        obj.__wbg_ptr = ptr;
+        MatchFingerprintsResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MatchFingerprintsResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_matchfingerprintsresult_free(ptr, 0);
+    }
+    /**
+     * @returns {MatchSegment[]}
+     */
+    get segments() {
+        const ret = wasm.__wbg_get_matchfingerprintsresult_segments(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {MatchSegment[]} arg0
+     */
+    set segments(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_matchfingerprintsresult_segments(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) MatchFingerprintsResult.prototype[Symbol.dispose] = MatchFingerprintsResult.prototype.free;
+
+/**
+ * A matched segment between two fingerprints.
+ */
+export class MatchSegment {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MatchSegment.prototype);
+        obj.__wbg_ptr = ptr;
+        MatchSegmentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof MatchSegment)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MatchSegmentFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_matchsegment_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get duration() {
+        const ret = wasm.matchsegment_duration(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get end1() {
+        const ret = wasm.matchsegment_end1(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get end2() {
+        const ret = wasm.matchsegment_end2(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get score() {
+        const ret = wasm.matchsegment_score(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get start1() {
+        const ret = wasm.matchsegment_start1(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get start2() {
+        const ret = wasm.matchsegment_start2(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MatchSegment.prototype[Symbol.dispose] = MatchSegment.prototype.free;
+
 /**
  * One-shot: compute fingerprint from interleaved i16 samples.
  * @param {number} sample_rate
@@ -160,10 +273,9 @@ export function fingerprintFromSamples(sample_rate, channels, samples) {
 
 /**
  * Match two raw fingerprints (u32 arrays). Returns segments of similar audio.
- * Each segment has start1, end1, start2, end2, duration (seconds) and score.
  * @param {Uint32Array} raw1
  * @param {Uint32Array} raw2
- * @returns {any}
+ * @returns {MatchFingerprintsResult}
  */
 export function matchFingerprints(raw1, raw2) {
     const ptr0 = passArray32ToWasm0(raw1, wasm.__wbindgen_malloc);
@@ -174,7 +286,7 @@ export function matchFingerprints(raw1, raw2) {
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    return MatchFingerprintsResult.__wrap(ret[0]);
 }
 export function __wbg_Error_83742b46f01ce22d(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
@@ -183,30 +295,12 @@ export function __wbg_Error_83742b46f01ce22d(arg0, arg1) {
 export function __wbg___wbindgen_throw_6ddd609b62940d55(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_new_a70fbab9066b301f() {
-    const ret = new Array();
-    return ret;
-}
-export function __wbg_new_ab79df5bd7c26067() {
-    const ret = new Object();
+export function __wbg_matchsegment_new(arg0) {
+    const ret = MatchSegment.__wrap(arg0);
     return ret;
 }
-export function __wbg_push_e87b0e732085a946(arg0, arg1) {
-    const ret = arg0.push(arg1);
-    return ret;
-}
-export function __wbg_set_7eaa4f96924fd6b3() { return handleError(function (arg0, arg1, arg2) {
-    const ret = Reflect.set(arg0, arg1, arg2);
-    return ret;
-}, arguments); }
-export function __wbindgen_cast_0000000000000001(arg0) {
-    // Cast intrinsic for `F64 -> Externref`.
-    const ret = arg0;
-    return ret;
-}
-export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Ref(String) -> Externref`.
-    const ret = getStringFromWasm0(arg0, arg1);
+export function __wbg_matchsegment_unwrap(arg0) {
+    const ret = MatchSegment.__unwrap(arg0);
     return ret;
 }
 export function __wbindgen_init_externref_table() {
@@ -221,6 +315,12 @@ export function __wbindgen_init_externref_table() {
 const FingerprintFromSamplesResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fingerprintfromsamplesresult_free(ptr >>> 0, 1));
+const MatchFingerprintsResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_matchfingerprintsresult_free(ptr >>> 0, 1));
+const MatchSegmentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_matchsegment_free(ptr >>> 0, 1));
 const FingerprinterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fingerprinter_free(ptr >>> 0, 1));
@@ -231,11 +331,30 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function getArrayU32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return decodeText(ptr, len);
@@ -265,15 +384,6 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
-}
-
 function passArray16ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 2, 2) >>> 0;
     getUint16ArrayMemory0().set(arg, ptr / 2);
@@ -288,6 +398,16 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/dist/rusty_chromaprint_wasm_bg.wasm.d.ts

@@ -5,8 +5,12 @@ export const __wbg_fingerprinter_free: (a: number, b: number) => void;
 export const __wbg_fingerprintfromsamplesresult_free: (a: number, b: number) => void;
 export const __wbg_get_fingerprintfromsamplesresult_compressed: (a: number) => [number, number];
 export const __wbg_get_fingerprintfromsamplesresult_raw: (a: number) => [number, number];
+export const __wbg_get_matchfingerprintsresult_segments: (a: number) => [number, number];
+export const __wbg_matchfingerprintsresult_free: (a: number, b: number) => void;
+export const __wbg_matchsegment_free: (a: number, b: number) => void;
 export const __wbg_set_fingerprintfromsamplesresult_compressed: (a: number, b: number, c: number) => void;
 export const __wbg_set_fingerprintfromsamplesresult_raw: (a: number, b: number, c: number) => void;
+export const __wbg_set_matchfingerprintsresult_segments: (a: number, b: number, c: number) => void;
 export const fingerprintFromSamples: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const fingerprinter_consume: (a: number, b: number, c: number) => void;
 export const fingerprinter_finish: (a: number) => void;
@@ -15,11 +19,17 @@ export const fingerprinter_getFingerprint: (a: number) => [number, number];
 export const fingerprinter_new: () => [number, number, number];
 export const fingerprinter_start: (a: number, b: number, c: number) => [number, number];
 export const matchFingerprints: (a: number, b: number, c: number, d: number) => [number, number, number];
-export const __wbindgen_exn_store: (a: number) => void;
-export const __externref_table_alloc: () => number;
+export const matchsegment_duration: (a: number) => number;
+export const matchsegment_end1: (a: number) => number;
+export const matchsegment_end2: (a: number) => number;
+export const matchsegment_score: (a: number) => number;
+export const matchsegment_start1: (a: number) => number;
+export const matchsegment_start2: (a: number) => number;
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __externref_table_dealloc: (a: number) => void;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __externref_drop_slice: (a: number, b: number) => void;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __externref_table_alloc: () => number;
 export const __wbindgen_start: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rusty-chromaprint-wasm",
-	"version": "0.1.4",
+	"version": "0.1.5",
 	"private": false,
 	"type": "module",
 	"description": "WASM bindings for rusty-chromaprint audio fingerprinting",