@remotion/media-utils 4.0.81 → 4.0.83

package/dist/fft/fft-accurate.d.ts

@@ -0,0 +1 @@
+export declare const fftAccurate: (vector: Int16Array) => [number, number][];

package/dist/fft/fft-accurate.js

@@ -0,0 +1,33 @@
+"use strict";
+// Adapted from node-fft project by Joshua Wong and Ben Bryan
+// https://github.com/vail-systems/node-fft
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fftAccurate = void 0;
+const complex_1 = require("./complex");
+const exponent_1 = require("./exponent");
+const fftAccurate = function (vector) {
+    const X = [];
+    const N = vector.length;
+    // Base case is X = x + 0i since our input is assumed to be real only.
+    if (N === 1) {
+        if (Array.isArray(vector[0])) {
+            // If input vector contains complex numbers
+            return [[vector[0][0], vector[0][1]]];
+        }
+        return [[vector[0], 0]];
+    }
+    // Recurse: all even samples
+    const X_evens = (0, exports.fftAccurate)(vector.filter((_, ix) => ix % 2 === 0));
+    // Recurse: all odd samples
+    const X_odds = (0, exports.fftAccurate)(vector.filter((__, ix) => ix % 2 === 1));
+    // Now, perform N/2 operations!
+    for (let k = 0; k < N / 2; k++) {
+        // t is a complex number!
+        const t = X_evens[k];
+        const e = (0, complex_1.complexMultiply)((0, exponent_1.exponent)(k, N), X_odds[k]);
+        X[k] = (0, complex_1.complexAdd)(t, e);
+        X[k + N / 2] = (0, complex_1.complexSubtract)(t, e);
+    }
+    return X;
+};
+exports.fftAccurate = fftAccurate;

package/dist/fft/fft-fast.d.ts

@@ -0,0 +1 @@
+export declare const fftFast: (vector: Int16Array) => [number, number][];

package/dist/fft/fft-fast.js

@@ -0,0 +1,76 @@
+"use strict";
+// https://pastebin.com/raw/D42RbPe5
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fftFast = void 0;
+// Function to reverse bits in an integer
+function reverseBits(num, numBits) {
+    let result = 0;
+    for (let i = 0; i < numBits; i++) {
+        result = (result << 1) | ((num >> i) & 1);
+    }
+    return result;
+}
+// Hamming window function
+function hammingWindow(N) {
+    const win = new Array(N);
+    for (let i = 0; i < N; i++) {
+        win[i] = 0.8 - 0.46 * Math.cos((2 * Math.PI * i) / (N - 1));
+    }
+    return win;
+}
+// Function to calculate the bit-reversed permutation indices
+function bitReversePermutation(N) {
+    const bitReversed = new Array(N);
+    for (let i = 0; i < N; i++) {
+        bitReversed[i] = reverseBits(i, Math.log2(N));
+    }
+    return bitReversed;
+}
+const fftFast = function (vector) {
+    const N = vector.length;
+    const X = new Array(N);
+    if (N <= 1) {
+        for (let i = 0; i < vector.length; i++) {
+            const value = vector[i];
+            X[i] = [value * 2, 0];
+        }
+        return X;
+    }
+    // Apply a windowing function to the input data
+    const window = hammingWindow(N); // You can choose a different window function if needed
+    for (let i = 0; i < N; i++) {
+        X[i] = [vector[i] * window[i], 0];
+    }
+    // Bit-Reversal Permutation
+    const bitReversed = bitReversePermutation(N);
+    for (let i = 0; i < N; i++) {
+        X[i] = [vector[bitReversed[i]], 0];
+    }
+    // Cooley-Tukey FFT
+    for (let s = 1; s <= Math.log2(N); s++) {
+        const m = 1 << s; // Number of elements in each subarray
+        const mHalf = m / 2; // Half the number of elements in each subarray
+        const angleIncrement = (2 * Math.PI) / m;
+        for (let k = 0; k < N; k += m) {
+            let omegaReal = 1.0;
+            let omegaImag = 0.0;
+            for (let j = 0; j < mHalf; j++) {
+                const tReal = omegaReal * X[k + j + mHalf][0] - omegaImag * X[k + j + mHalf][1];
+                const tImag = omegaReal * X[k + j + mHalf][1] + omegaImag * X[k + j + mHalf][0];
+                const uReal = X[k + j][0];
+                const uImag = X[k + j][1];
+                X[k + j] = [uReal + tReal, uImag + tImag];
+                X[k + j + mHalf] = [uReal - tReal, uImag - tImag];
+                // Twiddle factor update
+                const tempReal = omegaReal * Math.cos(angleIncrement) -
+                    omegaImag * Math.sin(angleIncrement);
+                omegaImag =
+                    omegaReal * Math.sin(angleIncrement) +
+                        omegaImag * Math.cos(angleIncrement);
+                omegaReal = tempReal;
+            }
+        }
+    }
+    return X;
+};
+exports.fftFast = fftFast;

package/dist/fft/fft.d.ts

@@ -1 +1 @@
-export declare const fft: (vector: Int16Array) => [number, number][];
+export declare const fftAccurate: (vector: Int16Array) => [number, number][];

package/dist/fft/fft.js

@@ -2,10 +2,10 @@
 // Adapted from node-fft project by Joshua Wong and Ben Bryan
 // https://github.com/vail-systems/node-fft
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fft = void 0;
+exports.fftAccurate = void 0;
 const complex_1 = require("./complex");
 const exponent_1 = require("./exponent");
-const fft = function (vector) {
+const fftAccurate = function (vector) {
     const X = [];
     const N = vector.length;
     // Base case is X = x + 0i since our input is assumed to be real only.
@@ -17,9 +17,9 @@ const fft = function (vector) {
         return [[vector[0], 0]];
     }
     // Recurse: all even samples
-    const X_evens = (0, exports.fft)(vector.filter((_, ix) => ix % 2 === 0));
+    const X_evens = (0, exports.fftAccurate)(vector.filter((_, ix) => ix % 2 === 0));
     // Recurse: all odd samples
-    const X_odds = (0, exports.fft)(vector.filter((__, ix) => ix % 2 === 1));
+    const X_odds = (0, exports.fftAccurate)(vector.filter((__, ix) => ix % 2 === 1));
     // Now, perform N/2 operations!
     for (let k = 0; k < N / 2; k++) {
         // t is a complex number!
@@ -30,4 +30,4 @@ const fft = function (vector) {
     }
     return X;
 };
-exports.fft = fft;
+exports.fftAccurate = fftAccurate;

package/dist/fft/get-visualization.d.ts

@@ -1,8 +1,10 @@
-export declare const getVisualization: ({ sampleSize, data, sampleRate, frame, fps, maxInt, }: {
+export type OptimizeFor = 'accuracy' | 'speed';
+export declare const getVisualization: ({ sampleSize, data, sampleRate, frame, fps, maxInt, optimizeFor, }: {
     sampleSize: number;
     data: Float32Array;
     frame: number;
     sampleRate: number;
     fps: number;
     maxInt: number;
+    optimizeFor: OptimizeFor;
 }) => number[];

package/dist/fft/get-visualization.js

@@ -3,11 +3,12 @@
 // https://github.com/vail-systems/node-fft
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVisualization = void 0;
-const fft_1 = require("./fft");
+const fft_accurate_1 = require("./fft-accurate");
+const fft_fast_1 = require("./fft-fast");
 const mag_1 = require("./mag");
 const smoothing_1 = require("./smoothing");
 const to_int_16_1 = require("./to-int-16");
-const getVisualization = ({ sampleSize, data, sampleRate, frame, fps, maxInt, }) => {
+const getVisualization = ({ sampleSize, data, sampleRate, frame, fps, maxInt, optimizeFor = 'accuracy', }) => {
     const isPowerOfTwo = sampleSize > 0 && (sampleSize & (sampleSize - 1)) === 0;
     if (!isPowerOfTwo) {
         throw new TypeError(`The argument "bars" must be a power of two. For example: 64, 128. Got instead: ${sampleSize}`);
@@ -24,7 +25,8 @@ const getVisualization = ({ sampleSize, data, sampleRate, frame, fps, maxInt, })
         length: sampleSize,
     });
     ints.set(data.subarray(actualStart, actualStart + sampleSize).map((x) => (0, to_int_16_1.toInt16)(x)));
-    const phasors = (0, fft_1.fft)(ints);
+    const alg = optimizeFor === 'accuracy' ? fft_accurate_1.fftAccurate : fft_fast_1.fftFast;
+    const phasors = alg(ints);
     const magnitudes = (0, mag_1.fftMag)(phasors).map((p) => p);
     return (0, smoothing_1.smoothen)(magnitudes).map((m) => m / (sampleSize / 2) / maxInt);
 };

package/dist/visualize-audio.d.ts

@@ -4,6 +4,7 @@ type FnParameters = {
     frame: number;
     fps: number;
     numberOfSamples: number;
+    optimizeFor?: 'accuracy' | 'speed';
 };
 export declare const visualizeAudio: ({ smoothing, ...parameters }: FnParameters & {
     smoothing?: boolean | undefined;

package/dist/visualize-audio.js

@@ -9,7 +9,7 @@ const cache = {};
  * @description part of @remotion/media-utils
  * @see [Documentation](https://www.remotion.dev/docs/visualize-audio)
  */
-const visualizeAudioFrame = ({ audioData: metadata, frame, fps, numberOfSamples, }) => {
+const visualizeAudioFrame = ({ audioData: metadata, frame, fps, numberOfSamples, optimizeFor, }) => {
     const cacheKey = metadata.resultId + frame + fps + numberOfSamples;
     if (cache[cacheKey]) {
         return cache[cacheKey];
@@ -22,6 +22,7 @@ const visualizeAudioFrame = ({ audioData: metadata, frame, fps, numberOfSamples,
         fps,
         sampleRate: metadata.sampleRate,
         maxInt,
+        optimizeFor: optimizeFor !== null && optimizeFor !== void 0 ? optimizeFor : 'accuracy',
     });
 };
 const visualizeAudio = ({ smoothing = true, ...parameters }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/media-utils",
-  "version": "4.0.81",
+  "version": "4.0.83",
   "description": "Utility functions for audio and video",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -13,7 +13,7 @@
     "url": "https://github.com/remotion-dev/remotion/issues"
   },
   "dependencies": {
-    "remotion": "4.0.81"
+    "remotion": "4.0.83"
   },
   "peerDependencies": {
     "react": ">=16.8.0",