@hyperframes/core 0.8.159 → 0.8.160

package/dist/audioSnap.js

@@ -0,0 +1,41 @@
+/** Moving reported times onto measured ones, one at a time, and saying how far they moved. */
+/** Index of the value in ascending `sorted` nearest `t`. */
+function nearestIndex(sorted, t) {
+    let low = 0;
+    let high = sorted.length - 1;
+    while (low < high) {
+        const mid = (low + high) >> 1;
+        if (sorted[mid] < t)
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    return low > 0 && t - sorted[low - 1] <= sorted[low] - t ? low - 1 : low;
+}
+/** Snaps each time to the nearest of `measured` (ascending) when one is within `toleranceSeconds`, else keeps it. */
+export function snapper(measured, toleranceSeconds, reference) {
+    const shifts = [];
+    const unsnapped = [];
+    return {
+        snap(t) {
+            const nearest = measured.length ? measured[nearestIndex(measured, t)] : null;
+            if (nearest === null || Math.abs(nearest - t) > toleranceSeconds) {
+                unsnapped.push(t);
+                return t;
+            }
+            shifts.push(Math.abs(nearest - t));
+            return nearest;
+        },
+        report() {
+            const sorted = [...shifts].sort((a, b) => a - b);
+            const median = sorted.length ? sorted[sorted.length >> 1] : null;
+            return {
+                reference,
+                toleranceMs: Math.round(toleranceSeconds * 1000),
+                snapped: shifts.length,
+                unsnapped: [...unsnapped],
+                medianShiftMs: median === null ? null : Math.round(median * 1000),
+            };
+        },
+    };
+}

package/dist/fft.d.ts

@@ -0,0 +1,2 @@
+/** In-place iterative radix-2 FFT. */
+export declare function fft(re: Float64Array, im: Float64Array): void;

package/dist/fft.js

@@ -0,0 +1,36 @@
+/** In-place iterative radix-2 FFT. */
+export function fft(re, im) {
+    const n = re.length;
+    for (let i = 1, j = 0; i < n; i++) {
+        let bit = n >> 1;
+        for (; j & bit; bit >>= 1)
+            j ^= bit;
+        j ^= bit;
+        if (i < j) {
+            [re[i], re[j]] = [re[j], re[i]];
+            [im[i], im[j]] = [im[j], im[i]];
+        }
+    }
+    for (let len = 2; len <= n; len <<= 1) {
+        const ang = (-2 * Math.PI) / len;
+        const wr = Math.cos(ang);
+        const wi = Math.sin(ang);
+        for (let i = 0; i < n; i += len) {
+            let cr = 1;
+            let ci = 0;
+            for (let k = 0; k < len / 2; k++) {
+                const ur = re[i + k];
+                const ui = im[i + k];
+                const vr = re[i + k + len / 2] * cr - im[i + k + len / 2] * ci;
+                const vi = re[i + k + len / 2] * ci + im[i + k + len / 2] * cr;
+                re[i + k] = ur + vr;
+                im[i + k] = ui + vi;
+                re[i + k + len / 2] = ur - vr;
+                im[i + k + len / 2] = ui - vi;
+                const ncr = cr * wr - ci * wi;
+                ci = cr * wi + ci * wr;
+                cr = ncr;
+            }
+        }
+    }
+}