nodejs-audio-visualizer 2.1.4 → 4.0.0

package/src/audio.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
 import ffmpegPath from 'ffmpeg-static';
-import { getSpectrum } from './dsp';
+import { FREQUENCY_BANDS, getSpectrum } from './dsp';
 
 export const skipEvery = <T>(skipIndex: number) => (element: T, index: number) =>
   index % skipIndex === 0;
@@ -34,44 +34,46 @@ export const correctPeaks = (spectrums: number[], peaks: number[]) => {
   return resultSpectrum;
 };
 
-export const smoothValues = (spectrums: number[], prevSpectrums?: number[]) => {
-  if (!prevSpectrums) {
-    return spectrums;
-  }
-  const resultSpectrum: number[] = [];
-  for(let i = 0; i < spectrums.length; i++) {
-    const currValue = spectrums[i];
-    const currPrevValue = prevSpectrums[i] || 0;
-    const avgValue = (currValue + currPrevValue) / 2;
-    resultSpectrum.push(avgValue);
-  }
-  return resultSpectrum;
+const oldMax = 1;
+const newMin = 0.6;
+const getInterpolationFactor = (skippedFramesCount: number, skipFramesCount: number) => {
+  const interpolationFactor = 1 - (skippedFramesCount / skipFramesCount);
+  const interpolationFactorInRange = (interpolationFactor * (oldMax - newMin)) + newMin;
+  return interpolationFactorInRange;
 };
 
-export const createSpectrumsProcessor = (busesCount: number) => {
+export const createSpectrumsProcessor = (sampleRate: number, skipFramesCount: number) => {
   let prevAudioDataNormalized: number[] = [];
   let prevPeaks: number[] = [];
-  let prevSpectrums: number[] = [];
-  const skipFrameIndex = 2;
-
-  return (frameIndex: number, parseAudioData: () => number[]) => {
-    const isFrameSkiped = 
-      frameIndex && (frameIndex % skipFrameIndex === 0);
-    const audioDataNomrmalized = isFrameSkiped ?
-      prevAudioDataNormalized :
-      normalizeAudioData(parseAudioData());
-    prevAudioDataNormalized = audioDataNomrmalized;
+  let skippedFramesCount = 0;
+  let targetSpectrum: number[] = [];
+  let previousSpectrum: number[] = [];
 
-    const spectrum = getSpectrum(audioDataNomrmalized);
-    const skipIndex = Math.trunc(spectrum.length / busesCount);
-    const spectrumReduced = spectrum.filter(skipEvery(skipIndex));
-    const peaks = getPeaks(spectrumReduced, prevPeaks);
-    const correctedSpectrum = correctPeaks(spectrumReduced, peaks);
-    const smoothSpectrum = smoothValues(correctedSpectrum, prevSpectrums);
-    prevSpectrums = smoothSpectrum;
-    prevPeaks = peaks;
+  return (parseAudioData: () => number[]) => {
+    if (skippedFramesCount === 0) {
+      skippedFramesCount = skipFramesCount;
+      const audioDataNomrmalized = normalizeAudioData(parseAudioData());
+      prevAudioDataNormalized = audioDataNomrmalized;
 
-    return smoothSpectrum;
+      const spectrum = getSpectrum(audioDataNomrmalized, sampleRate);
+      const peaks = getPeaks(spectrum, prevPeaks);
+      const correctedSpectrum =
+        prevPeaks.length === 0 ?
+          Array(FREQUENCY_BANDS.length).fill(0) :
+          correctPeaks(spectrum, peaks);
+     
+      prevPeaks = peaks;
+      previousSpectrum = [...targetSpectrum];
+      targetSpectrum = correctedSpectrum;
+    } else {
+      skippedFramesCount--;
+    }
+    const interpolationFactor = getInterpolationFactor(skippedFramesCount, skipFramesCount);
+    const interpolatedSpectrum = targetSpectrum.map((target, i) => {
+      const prev = previousSpectrum[i] || target;
+      return prev + (target - prev) * interpolationFactor;
+    });
+    return interpolatedSpectrum;
   };
 };
 

package/src/config.ts

@@ -1,20 +1,27 @@
 import path from 'path';
 import { Config, SpectrumSizeValue, PositionAliasName, RotationAliasName } from './index';
+import { FREQUENCY_BANDS } from './dsp';
 
 export const defaults = {
-  fps: 60,
-  spectrumWidth: '40%',
-  spectrumHeight: '10%',
+  fps: 30,
+  spectrumWidth: '33%',
+  spectrumHeight: 160,
   spectrumX: 'center',
-  spectrumY: 'top',
-  spectrumRotation: 'down',
-  spectrumBusesCount: 64,
-  spectrumBusMargin: 4,
-  spectrumOpacity: '100%',
+  spectrumY: 'middle',
+  spectrumRotation: 'mirror',
+  spectrumBusMargin: 12,
+  spectrumOpacity: '80%',
+  polarX: 'center',
+  polarY: 'middle',
+  polarInnerRadius: 100,
+  polarMaxBarLength: 160,
+  polarBarWidth: 15,
 };
 
 type RelativePositionValue = 0 | 0.5 | 1;
 
+export type SpectrumEffect = 'volume' | 'smooth';
+
 interface PositionAlias {
   name: PositionAliasName;
   value: RelativePositionValue;
@@ -29,7 +36,7 @@ const postitionAliases: PositionAlias[] = [
   { name: 'bottom', value: 1 },
 ];
 
-export const rotationAliasValues = ['up', 'down'] as const;
+export const rotationAliasValues = ['up', 'down', 'mirror'] as const;
 
 export const checkIsPercentValue = (value: string) =>
   RegExp(/\d+%/).test(value)
@@ -46,14 +53,15 @@ export const getOutVideoPath = (config: Config) =>
 export const getFPS = (config: Config) =>
   config.outVideo.fps || defaults.fps;
 
-export const getSpectrumBusesCount = () => defaults.spectrumBusesCount;
-
 export const getSpectrumBusMargin = () => defaults.spectrumBusMargin;
 
 const getSpectrumWidth = (config: Config) =>
   (config.outVideo.spectrum && config.outVideo.spectrum.width) ||
   defaults.spectrumWidth;
 
+export const getSpectrumEffect = (config: Config) =>
+  config.outVideo.spectrum?.effect;
+
 const getSpectrumSizeAbsolute = (
   spectrumSize: SpectrumSizeValue,
   backgroundImageSize: number,
@@ -81,7 +89,7 @@ export const getSpectrumWidthAbsolute = (
   const spectrumWidth = getSpectrumWidth(config);
   const spectrumWidthAbsolute = getSpectrumSizeAbsolute(spectrumWidth, backgroundImageWidth, 'width');
   const spectrumWidthWithoutMargin =
-    Math.trunc(spectrumWidthAbsolute / defaults.spectrumBusesCount) - defaults.spectrumBusMargin / 2;
+    Math.trunc(spectrumWidthAbsolute / FREQUENCY_BANDS.length) - defaults.spectrumBusMargin / 2;
   if (spectrumWidthWithoutMargin <= 0) {
     throw new Error(`Spectrum width '${spectrumWidth}' is too small.`);
   }
@@ -240,3 +248,105 @@ export const getFfmpeg_preset = (config: Config) =>
 export const getFrame_processing_delay = (config: Config) =>
   config.tweaks && config.tweaks.frame_processing_delay;
 
+// Polar visualizer config getters
+const getPolarX = (config: Config) =>
+  parseNumberIfPossible(
+    (config.outVideo.polar && config.outVideo.polar.x) ||
+    defaults.polarX
+  );
+
+const getPolarY = (config: Config) =>
+  parseNumberIfPossible(
+    (config.outVideo.polar && config.outVideo.polar.y) ||
+    defaults.polarY
+  );
+
+export const getPolarXAbsolute = (
+  config: Config,
+  backgroundImageWidth: number
+) => {
+  const polarX = getPolarX(config);
+  if (typeof polarX !== 'string') {
+    return polarX;
+  }
+  try {
+    const polarXParsed = parsePositionAlias(polarX);
+    if (polarXParsed.value === 0) {
+      const polarLength = getPolarMaxBarLength(config);
+      const polarRadius = getPolarInnerRadius(config);
+      return polarRadius + polarLength;
+    }
+    if (polarXParsed.value === 1) {
+      const polarLength = getPolarMaxBarLength(config);
+      const polarRadius = getPolarInnerRadius(config);
+      return backgroundImageWidth - polarRadius - polarLength;
+    }
+    return polarXParsed.value * backgroundImageWidth;
+  } catch {
+    throw new Error(`Invalid polar x value: ${polarX}. Valid values: ${getValidPositionAliasValues()}.`);
+  }
+};
+
+export const getPolarYAbsolute = (
+  config: Config,
+  backgroundImageHeight: number
+) => {
+  const polarY = getPolarY(config);
+  if (typeof polarY !== 'string') {
+    return polarY;
+  }
+  try {
+    const polarYParsed = parsePositionAlias(polarY);
+    if (polarYParsed.value === 0) {
+      const polarLength = getPolarMaxBarLength(config);
+      const polarRadius = getPolarInnerRadius(config);
+      return polarRadius + polarLength;
+    }
+    if (polarYParsed.value === 1) {
+      const polarLength = getPolarMaxBarLength(config);
+      const polarRadius = getPolarInnerRadius(config);
+      return backgroundImageHeight - polarRadius - polarLength;
+    }
+    return polarYParsed.value * backgroundImageHeight;
+  } catch {
+    throw new Error(`Invalid polar y value: ${polarY}. Valid values: ${getValidPositionAliasValues()}.`);
+  }
+};
+
+export const getPolarInnerRadius = (config: Config) =>
+  (config.outVideo.polar && config.outVideo.polar.innerRadius) ||
+  defaults.polarInnerRadius;
+
+export const getPolarMaxBarLength = (config: Config) =>
+  (config.outVideo.polar && config.outVideo.polar.maxBarLength) ||
+  defaults.polarMaxBarLength;
+
+export const getPolarBarWidth = (config: Config) =>
+  (config.outVideo.polar && config.outVideo.polar.barWidth) ||
+  defaults.polarBarWidth;
+
+export const getPolarEffect = (config: Config) =>
+  config.outVideo.polar?.effect;
+
+export const getPolarColor = (config: Config) =>
+  config.outVideo.polar && config.outVideo.polar.color;
+
+export const getPolarOpacity = (config: Config) =>
+  (config.outVideo.polar && config.outVideo.polar.opacity) ||
+  defaults.spectrumOpacity;
+
+export const getPolarOpacityParsed = (config: Config) => {
+  const polarOpacity = getPolarOpacity(config);
+  if (!checkIsPercentValue(polarOpacity)) {
+    throw new Error(`Invalid polar opacity value: '${polarOpacity}'. Use string percent value, for example '80%'.`);
+  }
+  const percentValue = parseInt(polarOpacity);
+  if (
+    (percentValue < 0) ||
+    (percentValue > 100)
+  ) {
+    throw new Error(`Invalid polar opacity value: '${polarOpacity}'. Percent values must be in range from '0%' to '100%'.`);
+  }
+  return percentValue / 100;
+};
+

package/src/dsp.ts

@@ -1,4 +1,62 @@
-import { createSpectrumAnalyzer } from './spectrum';
+import { fft, util } from 'fft-js';
+
+export interface SpectrumPoint {
+  frequency: number;
+  magnitude: number;
+}
+
+export interface FrequencyBus {
+  startFreq: number;
+  endFreq: number;
+  magnitude: number;
+}
+
+// Common frequency bands (in Hz)
+export const FREQUENCY_BANDS = [
+  { name: 'Sub Bass 1', start: 20, end: 30 },
+  { name: 'Sub Bass 2', start: 30, end: 40 },
+  { name: 'Sub Bass 3', start: 50, end: 60 },
+  { name: 'Sub Bass 4', start: 20, end: 60 },
+  { name: 'Bass 1', start: 60, end: 107.5 },
+  { name: 'Bass 2', start: 107.5, end: 155 },
+  { name: 'Bass 3', start: 155, end: 202.5 },
+  { name: 'Bass 4', start: 202.5, end: 250 },
+  { name: 'Low Mids 1', start: 250, end: 312.5 },
+  { name: 'Low Mids 2', start: 312.5, end: 375 },
+  { name: 'Low Mids 3', start: 375, end: 437.5 },
+  { name: 'Low Mids 4', start: 437.5, end: 500 },
+  { name: 'Mids 1', start: 500, end: 875 },
+  { name: 'Mids 2', start: 875, end: 1250 },
+  { name: 'Mids 3', start: 1250, end: 1625 },
+  { name: 'Mids 4', start: 1625, end: 2000 },
+  { name: 'High Mids 1', start: 2000, end: 2500 },
+  { name: 'High Mids 2', start: 2500, end: 3000 },
+  { name: 'High Mids 3', start: 3000, end: 3500 },
+  { name: 'High Mids 4', start: 3500, end: 4000 },
+  { name: 'Presence 1', start: 4000, end: 5000 },
+  { name: 'Presence 2', start: 5000, end: 6000 },
+  { name: 'Brilliance 1', start: 6000, end: 13000 },
+  { name: 'Brilliance 2', start: 13000, end: 20000 },
+];
+
+const combineToBuses = (spectrum: SpectrumPoint[]): number[] => {
+  return FREQUENCY_BANDS.map(band => {
+    const pointsInBand = spectrum.filter(point => 
+      point.frequency >= band.start && point.frequency < band.end
+    );
+    
+    // If no points found in this band, return zero magnitude
+    if (pointsInBand.length === 0) {
+      return 0;
+    }
+
+    // Average the magnitudes in this frequency band
+    const avgMagnitude = pointsInBand.reduce((sum, point) => 
+      sum + point.magnitude, 0) / pointsInBand.length;
+
+    return avgMagnitude;
+  });
+};
 
 export const brutForceFFTSignalLength = (PCMDataLength: number) => {
   let exponent = 1;
@@ -11,16 +69,27 @@ export const brutForceFFTSignalLength = (PCMDataLength: number) => {
   }
 };
 
-export const getSpectrum = (PCMData: number[]) => {
+export const getSpectrum = (PCMData: number[], sampleRate: number): number[] => {
   const signalLength = brutForceFFTSignalLength(PCMData.length);
   const signalStartIndex = Math.trunc(PCMData.length / 2 - signalLength / 2);
   const signal = PCMData.slice(signalStartIndex, signalStartIndex + signalLength);
 
-  const spectrumAnalyzer = createSpectrumAnalyzer(signalLength);
-  const spectrum = spectrumAnalyzer(signal);
+  // Use fft-js to compute the FFT
+  const phasors = fft(signal);
+  const frequencies = util.fftFreq(phasors, sampleRate);
+  const magnitudes = util.fftMag(phasors);
+
+  // Create combined spectrum array with both frequency and magnitude
+  let spectrum: SpectrumPoint[] = frequencies.map((freq: number, i: number) => ({
+    frequency: freq,
+    magnitude: magnitudes[i]
+  }));
+
+  // Apply frequency-dependent scaling
   for (let i = 0; i < spectrum.length; i++) {
-    // attenuates low freqs and boosts highs
-    spectrum[i] *= -1 * Math.log((signalLength / 2 - i) * (0.5 / signalLength / 2)) * signalLength;
+    spectrum[i].magnitude *= -1 * Math.log((signalLength / 2 - i) * (0.5 / signalLength / 2)) * signalLength;
   }
-  return spectrum;
+
+  // Combine frequencies into buses
+  return combineToBuses(spectrum);
 }