nodejs-audio-visualizer 1.0.6 → 1.3.0

package/dist/video.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var child_process_1 = require("child_process");
 var ffmpeg_static_1 = require("ffmpeg-static");
 exports.spawnFfmpegVideoWriter = function (config) {
+    var crf = config.crf || '23';
+    var preset = config.preset || 'medium';
     var args = [
         '-y',
         '-i', config.audioFilename,
-        '-crf', '18',
+        '-crf', crf,
         '-c:a', 'aac', '-b:a', '384k', '-profile:a', 'aac_low',
-        '-c:v', 'libx264', '-r', "" + config.fps, '-pix_fmt', 'yuv420p', config.videoFileName,
+        '-c:v', 'libx264', '-r', "" + config.fps, '-pix_fmt', 'yuv420p', '-preset', preset, config.videoFileName,
         '-r', "" + config.fps,
         '-i', '-'
     ];

package/dist/video.js.map

@@ -1 +1 @@
-{"version":3,"file":"video.js","sourceRoot":"","sources":["../src/video.ts"],"names":[],"mappings":";;AACA,+CAAsC;AACtC,+CAAmD;AAStC,QAAA,sBAAsB,GAAG,UAAC,MAA+B;IACpE,IAAM,IAAI,GAAG;QACX,IAAI;QACJ,IAAI,EAAE,MAAM,CAAC,aAAa;QAC1B,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS;QACtD,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,KAAG,MAAM,CAAC,GAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,CAAC,aAAa;QACrF,IAAI,EAAE,KAAG,MAAM,CAAC,GAAK;QACrB,IAAI,EAAE,GAAG;KACV,CAAC;IACF,IAAM,MAAM,GAAG,qBAAK,CAAC,oBAAU,EAAE,IAAI,CAAC,CAAC;IACvC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,MAAM,CAAC,QAAQ,EAAE;QACnB,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;KAC3C;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEW,QAAA,WAAW,GAAG,UAAC,UAAyC;IACnE,OAAA,UAAC,YAAoB;QACnB,IAAM,WAAW,GAAG,YAAY,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACrE,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO;SACR;QACD,IAAM,YAAY,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACrC,IAAI,KAAK,CAAC,YAAY,CAAC,EAAE;YACvB,OAAO;SACR;QACD,UAAU,CAAC,YAAY,CAAC,CAAC;IAC3B,CAAC;AAVD,CAUC,CAAC;AAES,QAAA,iBAAiB,GAAG,UAAC,WAAmB,EAAE,QAAmC;IACxF,OAAA,UAAC,YAAoB;QACnB,OAAA,QAAQ,CACN,CAAC,CAAC,YAAY,GAAG,WAAW,GAAG,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAC/C;IAFD,CAEC;AAHH,CAGG,CAAC;AAEO,QAAA,SAAS,GAAG,UAAC,MAAgB;IACxC,OAAA,IAAI,OAAO,CAAO,UAAA,OAAO,IAAI,OAAA,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAA7B,CAA6B,CAAC;AAA3D,CAA2D,CAAC"}
+{"version":3,"file":"video.js","sourceRoot":"","sources":["../src/video.ts"],"names":[],"mappings":";;AACA,+CAAsC;AACtC,+CAAmD;AAWtC,QAAA,sBAAsB,GAAG,UAAC,MAA+B;IACpE,IAAM,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC;IAC/B,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,QAAQ,CAAC;IACzC,IAAM,IAAI,GAAG;QACX,IAAI;QACJ,IAAI,EAAE,MAAM,CAAC,aAAa;QAC1B,MAAM,EAAE,GAAG;QACX,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS;QACtD,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,KAAG,MAAM,CAAC,GAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,aAAa;QACxG,IAAI,EAAE,KAAG,MAAM,CAAC,GAAK;QACrB,IAAI,EAAE,GAAG;KACV,CAAC;IACF,IAAM,MAAM,GAAG,qBAAK,CAAC,oBAAU,EAAE,IAAI,CAAC,CAAC;IACvC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,MAAM,CAAC,QAAQ,EAAE;QACnB,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;KAC3C;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEW,QAAA,WAAW,GAAG,UAAC,UAAyC;IACnE,OAAA,UAAC,YAAoB;QACnB,IAAM,WAAW,GAAG,YAAY,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACrE,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO;SACR;QACD,IAAM,YAAY,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACrC,IAAI,KAAK,CAAC,YAAY,CAAC,EAAE;YACvB,OAAO;SACR;QACD,UAAU,CAAC,YAAY,CAAC,CAAC;IAC3B,CAAC;AAVD,CAUC,CAAC;AAES,QAAA,iBAAiB,GAAG,UAAC,WAAmB,EAAE,QAAmC;IACxF,OAAA,UAAC,YAAoB;QACnB,OAAA,QAAQ,CACN,CAAC,CAAC,YAAY,GAAG,WAAW,GAAG,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAC/C;IAFD,CAEC;AAHH,CAGG,CAAC;AAEO,QAAA,SAAS,GAAG,UAAC,MAAgB;IACxC,OAAA,IAAI,OAAO,CAAO,UAAA,OAAO,IAAI,OAAA,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAA7B,CAA6B,CAAC;AAA3D,CAA2D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-audio-visualizer",
-  "version": "1.0.6",
+  "version": "1.3.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -53,7 +53,6 @@
     "@types/ffmpeg-static": "^2.0.0",
     "@types/node": "^12.12.3",
     "@types/sinon": "^7.5.0",
-    "array-smooth": "^1.0.0",
     "bmp-js": "^0.1.0",
     "ffmpeg-static": "^2.6.0",
     "jimp": "^0.9.3"

package/src/audio.ts

@@ -1,68 +1,90 @@
-/// <reference path="./vendor-typings/array-smooth.d.ts"/>
 import { spawn } from 'child_process';
 import ffmpeg from 'ffmpeg-static';
 import { getSpectrum } from './dsp';
-import smooth from 'array-smooth';
 
 export const skipEvery = <T>(skipIndex: number) => (element: T, index: number) =>
-  (index % skipIndex === 0) ? element : null;
+  index % skipIndex === 0;
 
-export const getSmoothBuses = (busValues: number[]) =>
-  smooth(busValues, 2);
-
-export const smoothSpectrums = (spectrums: number[][], FPS: number) => {
-  const scaleValues = (values: number[]) => {
-    const maxValue = Math.max.apply(null, values);
-    return values.map(value => value / maxValue);
-  };
-  const lengths = spectrums.map(spectrum => spectrum.length);
-  const maxLength = Math.max.apply(null, lengths);
-  const buses: number[][] = [];
-  for (let bus = 0; bus < maxLength; bus++) {
-    buses[bus] = [];
+export const getPeaks = (spectrums: number[], prevPeaks?: number[]) => {
+  if (!prevPeaks) {
+    return spectrums;
   }
+  const resultPeaks: number[] = [];
+  for (let i = 0; i < spectrums.length; i++) {
+    const currValue = spectrums[i];
+    const currPrevPeak = prevPeaks[i] || 0;
+    resultPeaks.push(
+      (currValue > currPrevPeak) ? currValue : currPrevPeak
+    );
+  }
+  return resultPeaks;
+};
 
-  spectrums.forEach((spectrum) => {
-    for (let bus = 0; bus < maxLength; bus++) {
-      buses[bus].push(spectrum[bus] || 0);
+export const correctPeaks = (spectrums: number[], peaks: number[]) => {
+  const resultSpectrum: number[] = [];
+  for (let i = 0; i < spectrums.length; i++) {
+    const value = spectrums[i];
+    const peakValue = peaks[i] || 0;
+    if (value < 3) {
+      resultSpectrum.push(value / 3);
+    } else {
+      resultSpectrum.push(value / peakValue);
     }
-  });
-
-  const smoothBuses = buses.map(bus => getSmoothBuses(scaleValues(bus)));
-  const smoothSpectrums: number[][] = [];
-  for (let spectrumIndex = 0; spectrumIndex < spectrums.length; spectrumIndex++) {
-    smoothSpectrums[spectrumIndex] = [];
   }
+  return resultSpectrum;
+};
 
-  for (let spectrumIndex = 0; spectrumIndex < spectrums.length; spectrumIndex++) {
-    for (let bus = 0; bus < maxLength; bus++) {
-      smoothSpectrums[spectrumIndex].push(smoothBuses[bus][spectrumIndex]);
-    }
+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 smoothSpectrums;
+  return resultSpectrum;
 };
 
-export const getSmoothSpectrums = (audioData: number[], FPS: number, audioDataStep: number) => {
-  const spectrums: number[][] = [];
-  for (let i = 0; i < audioData.length; i += audioDataStep) {
-    const normalizedAudioFrame = audioData.slice(i, i + audioDataStep);
-    const spectrum = getSpectrum(normalizedAudioFrame);
+export const createSpectrumsProcessor = (busesCount: number) => {
+  let prevAudioDataNormalized: number[] = [];
+  let prevPeaks: number[] = [];
+  let prevSpectrums: number[] = [];
+  const skipFrameIndex = 2;
 
-    spectrums.push(spectrum);
-  }
+  return (frameIndex: number, parseAudioData: () => number[]) => {
+    const isFrameSkiped = 
+      frameIndex && (frameIndex % skipFrameIndex === 0);
+    const audioDataNomrmalized = isFrameSkiped ?
+      prevAudioDataNormalized :
+      normalizeAudioData(parseAudioData());
+    prevAudioDataNormalized = audioDataNomrmalized;
 
-  return smoothSpectrums(spectrums, FPS);
+    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 smoothSpectrum;
+  };
 };
 
-export const bufferToUInt8 = (buffer: Buffer) => {
+export const bufferToUInt8 = (buffer: Buffer, start: number, end: number) => {
   const numbers = [];
-  for (let i = 0; i < buffer.length; i += 1) {
+  for (let i = start; i < end; i += 1) {
     numbers.push(buffer.readUInt8(i));
   }
   return numbers;
 };
 
-export const normalizeAudioData = (PCMData: number[]) => PCMData.map(num => (num - 128) / 128);
+export const normalizeAudioData = (PCMData: number[]) =>
+  PCMData.map(num => (num - 128) / 128);
 
 export const spawnFfmpegAudioReader = (filename: string, format: string) => {
   const ffmpegProcess = spawn(ffmpeg.path, ['-i', filename, '-f', format, '-ac', '1', '-']);
@@ -90,3 +112,4 @@ export const createAudioBuffer = (filename: string, format: string) =>
       resolve({ audioBuffer, sampleRate });
     });
   });
+

package/src/config.ts

@@ -0,0 +1,177 @@
+import path from 'path';
+import { Config, PositionAliasName } from './index';
+
+export const defaults = {
+  fps: 60,
+  spectrumWidth: 0.4,
+  spectrumHeight: 0.1,
+  spectrumX: 'center',
+  spectrumY: 'top'
+};
+
+type RelativePositionValue = 0 | 0.5 | 1;
+
+interface PositionAlias {
+  name: PositionAliasName;
+  value: RelativePositionValue;
+}
+
+const postitionAliases: PositionAlias[] = [
+  { name: 'left', value: 0 },
+  { name: 'center', value: 0.5 },
+  { name: 'right', value: 1 },
+  { name: 'top', value: 0 },
+  { name: 'middle', value: 0.5 },
+  { name: 'bottom', value: 1 },
+];
+
+const checkIsInt = (num: number) =>
+  num % 1 === 0;
+
+export const getAudioFilePath = (config: Config) =>
+  path.resolve(config.audio.path);
+
+export const getBackgroundImagePath = (config: Config) =>
+  path.resolve(config.image.path);
+
+export const getOutVideoPath = (config: Config) =>
+  path.resolve(config.outVideo.path);
+
+export const getFPS = (config: Config) =>
+  config.outVideo.fps || defaults.fps;
+
+const getSpectrumWidth = (config: Config) =>
+  (config.outVideo.spectrum && config.outVideo.spectrum.width) ||
+  defaults.spectrumWidth;
+
+export const getSpectrumWidthAbsolute = (
+  config: Config, backgroundImageWidth: number
+) => {
+  const spectrumWidth = getSpectrumWidth(config);
+  const isAbsoluteValue = checkIsInt(spectrumWidth);
+  if (isAbsoluteValue) {
+    return spectrumWidth;
+  }
+  return backgroundImageWidth * spectrumWidth;
+};
+
+const getSpectrumHeight = (config: Config) =>
+  (config.outVideo.spectrum && config.outVideo.spectrum.height) ||
+  defaults.spectrumHeight;
+
+export const getSpectrumHeightAbsolute = (
+  config: Config, backgroundImageHeight: number
+) => {
+  const spectrumHeight = getSpectrumHeight(config);
+  const isAbsoluteValue = checkIsInt(spectrumHeight);
+  if (isAbsoluteValue) {
+    return spectrumHeight;
+  }
+  return backgroundImageHeight * spectrumHeight;
+};
+
+const getSpectrumX = (config: Config) =>
+  parseNumberIfPossible(
+    (config.outVideo.spectrum && config.outVideo.spectrum.x) ||
+    defaults.spectrumX
+  );
+
+const getSpectrumY = (config: Config) =>
+  parseNumberIfPossible(
+    (config.outVideo.spectrum && config.outVideo.spectrum.y) ||
+    defaults.spectrumY
+  );
+
+const parseNumberIfPossible = (value: string | number) => {
+  const parsed = Number(value);
+  if (isNaN(parsed)) {
+    return value;
+  }
+  return parsed;
+};
+
+const parsePositionAlias = (aliasName: string): PositionAlias => {
+  const nameNormalized = aliasName.trim().toLowerCase();
+  const alias = postitionAliases.find(
+    als => als.name === nameNormalized
+  );
+  if (!alias) {
+    throw new Error();
+  }
+  return alias;
+};
+
+const getValidPositionAliasValues = () =>
+  postitionAliases.map(aliasEl => aliasEl.name).join(', ');
+
+const getSpectrumAbsolutePosition = (
+  relativePosition: RelativePositionValue,
+  spectrumSize: number,
+  backgroundImageSize: number
+) => {
+  switch (relativePosition) {
+    case 0:
+      return 0;
+    case 0.5:
+      return relativePosition * backgroundImageSize - spectrumSize / 2;
+    case 1:
+      return relativePosition * backgroundImageSize - spectrumSize;
+    default:
+      throw new Error();
+  }
+};
+
+export const getSpectrumXAbsolute = (
+  config: Config,
+  spectrumWidth: number,
+  backgroundImageWidth: number
+) => {
+  const spectrumX = getSpectrumX(config);
+  if (typeof spectrumX !== 'string') {
+    return spectrumX;
+  }
+  try {
+    const spectrumXParsed = parsePositionAlias(spectrumX);
+    return getSpectrumAbsolutePosition(
+      spectrumXParsed.value,
+      spectrumWidth,
+      backgroundImageWidth
+    );
+  } catch {
+    throw new Error(`Invalid spectrum x value: ${spectrumX}. Valid values: ${getValidPositionAliasValues()}.`);
+  }
+};
+
+export const getSpectrumYAbsolute = (
+  config: Config,
+  spectrumHeight: number,
+  backgroundImageHeight: number
+) => {
+  const spectrumY = getSpectrumY(config);
+  if (typeof spectrumY !== 'string') {
+    return spectrumY;
+  }
+  try {
+    const spectrumXParsed = parsePositionAlias(spectrumY);
+    return getSpectrumAbsolutePosition(
+      spectrumXParsed.value,
+      spectrumHeight,
+      backgroundImageHeight
+    );
+  } catch {
+    throw new Error(`Invalid spectrum y value: ${spectrumY}. Valid values: ${getValidPositionAliasValues()}.`);
+  }
+};
+
+export const getSpectrumColor = (config: Config) =>
+  (config.outVideo.spectrum && config.outVideo.spectrum.color);
+
+export const getFfmpeg_cfr = (config: Config) =>
+  config.tweaks && config.tweaks.ffmpeg_cfr;
+
+export const getFfmpeg_preset = (config: Config) =>
+  config.tweaks && config.tweaks.ffmpeg_preset;
+
+export const getFrame_processing_delay = (config: Config) =>
+  config.tweaks && config.tweaks.frame_processing_delay;
+

package/src/image.ts

@@ -29,9 +29,10 @@ export const drawRect = (imageDstBuffer: BmpDecoder, position: Position, size: S
   }
 };
 
-const drawSpectrum = (imageDstBuffer: BmpDecoder, spectrum: number[], size: Size, color: Color) => {
-  const paddingLeft = Math.trunc(imageDstBuffer.width / 2 - size.width / 2);
+const drawSpectrum = (imageDstBuffer: BmpDecoder, spectrum: number[], size: Size, position: Position, color: Color) => {
   const busWidth = Math.trunc(size.width / spectrum.length);
+  const left = Math.trunc(position.x);
+  const top = Math.trunc(position.y);
   const margin = 4;
 
   for (let spectrumX = 0; spectrumX < spectrum.length; spectrumX++) {
@@ -40,17 +41,17 @@ const drawSpectrum = (imageDstBuffer: BmpDecoder, spectrum: number[], size: Size
       throw new Error('Spectrum values must be in range from 0 to 1');
     }
 
-    const rectX = paddingLeft + busWidth * spectrumX;
+    const rectX = left + busWidth * spectrumX;
     const rectHeight = size.height * spectrumValue;
-    drawRect(imageDstBuffer, { x: rectX + margin, y: 0 }, { width: busWidth - margin / 2, height: rectHeight }, color);
+    drawRect(imageDstBuffer, { x: rectX + margin, y: top }, { width: busWidth - margin / 2, height: rectHeight }, color);
   }
 };
 
-export const createVisualizerFrame = (backgroundImageBuffer: BmpDecoder, spectrum: number[], size: Size, color: Color | string) => {
+export const createVisualizerFrame = (backgroundImageBuffer: BmpDecoder, spectrum: number[], size: Size, position: Position, color: Color | string) => {
   const image = Object.assign({}, backgroundImageBuffer);
   image.data = Buffer.from(image.data);
   const rgbSpectrumColor = (typeof color === 'string') ? hexToRgb(color) : color;
-  drawSpectrum(image, spectrum, size, rgbSpectrumColor);
+  drawSpectrum(image, spectrum, size, position, rgbSpectrumColor);
   return image;
 };
 

package/src/index.ts

@@ -1,5 +1,18 @@
-import path from 'path';
-import { createAudioBuffer, bufferToUInt8, normalizeAudioData, getSmoothSpectrums, skipEvery } from './audio';
+import {
+  getAudioFilePath,
+  getBackgroundImagePath,
+  getOutVideoPath,
+  getFPS,
+  getSpectrumWidthAbsolute,
+  getSpectrumHeightAbsolute,
+  getSpectrumXAbsolute,
+  getSpectrumYAbsolute,
+  getSpectrumColor,
+  getFfmpeg_cfr,
+  getFfmpeg_preset,
+  getFrame_processing_delay
+} from './config';
+import { createAudioBuffer, bufferToUInt8, createSpectrumsProcessor } from './audio';
 import { parseImage, createVisualizerFrame, createImageBuffer, getImageColor, invertColor, Color, convertToBmp } from './image';
 import { spawnFfmpegVideoWriter, getProgress, calculateProgress, waitDrain } from './video';
 
@@ -23,16 +36,34 @@ export interface Config {
     spectrum?: {
       width?: number;
       height?: number;
+      x?: number | PositionAliasName;
+      y?: number | PositionAliasName;
       color?: Color | string;
     }
-  }
+  };
+  tweaks?: {
+    ffmpeg_cfr?: string;
+    ffmpeg_preset?: string;
+    frame_processing_delay?: number;
+  };
 }
 
+export type PositionAliasName =
+  'left' |
+  'center' |
+  'right' |
+  'top' |
+  'middle' |
+  'bottom';
+
+const sleep = (timeout: number) =>
+  new Promise(resolve => setTimeout(resolve, timeout));
+
 export const renderAudioVisualizer = (config: Config, onProgress?: (progress: number) => any, shouldStop?: () => boolean) =>
   new Promise<number>(async (resolve) => {
-    const audioFilePath = path.resolve(config.audio.path);
-    const backgroundImagePath = path.resolve(config.image.path);
-    const outVideoPath = path.resolve(config.outVideo.path);
+    const audioFilePath = getAudioFilePath(config);
+    const backgroundImagePath = getBackgroundImagePath(config);
+    const outVideoPath = getOutVideoPath(config);
 
     const backgroundImageBmpBuffer = await convertToBmp(backgroundImagePath);
     const backgroundImage = parseImage(backgroundImageBmpBuffer);
@@ -42,39 +73,48 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
     if (!sampleRate) {
       throw new Error('ffmpeg didn\'t show audio sample rate');
     }
-    const audioData = PCM_FORMAT.parseFunction(audioBuffer);
-    const normalizedAudioData = normalizeAudioData(audioData);
 
-    const FPS = config.outVideo.fps || 60;
+    const FPS = getFPS(config);
     const spectrumWidth =
-      (config.outVideo.spectrum && config.outVideo.spectrum.width) ||
-      backgroundImage.width * 0.4;
+      getSpectrumWidthAbsolute(config, backgroundImage.width);
     const spectrumHeight =
-      (config.outVideo.spectrum && config.outVideo.spectrum.height) ||
-      backgroundImage.height * 0.1;
+      getSpectrumHeightAbsolute(config, backgroundImage.height);
+    const spectrumX =
+      getSpectrumXAbsolute(config, spectrumWidth, backgroundImage.width);
+    const spectrumY =
+      getSpectrumYAbsolute(config, spectrumHeight, backgroundImage.height);
     const spectrumColor =
-      (config.outVideo.spectrum && config.outVideo.spectrum.color) ||
+      getSpectrumColor(config) ||
       invertColor(getImageColor(backgroundImage));
+    const ffmpeg_cfr = getFfmpeg_cfr(config);
+    const ffmpeg_preset = getFfmpeg_preset(config);
+    const frame_processing_delay = getFrame_processing_delay(config);
+    const spectrumBusesCount = 64;
 
-    const audioDuration = audioData.length / sampleRate;
+    const audioDuration = audioBuffer.length / sampleRate;
     const framesCount = Math.trunc(audioDuration * FPS);
-    const audioDataStep = Math.trunc(audioData.length / framesCount);
-    const spectrums = getSmoothSpectrums(normalizedAudioData, FPS, audioDataStep);
-    const spectrumsReduced = spectrums.map(spectrum => spectrum.filter(skipEvery(4)));
+    const audioDataStep = Math.trunc(audioBuffer.length / framesCount);
 
     const ffmpegVideoWriter = spawnFfmpegVideoWriter({
       audioFilename: audioFilePath,
       videoFileName: outVideoPath,
       fps: FPS,
-      ...(!!onProgress && { onStderr: getProgress(calculateProgress(framesCount + 1, onProgress)) })
+      ...(!!onProgress && { onStderr: getProgress(calculateProgress(framesCount + 1, onProgress)) }),
+      ...(ffmpeg_cfr && { crf: ffmpeg_cfr }),
+      ...(ffmpeg_preset && { preset: ffmpeg_preset }),
     });
     ffmpegVideoWriter.on('exit', (code: number) => resolve(code));
 
+    const processSpectrum = createSpectrumsProcessor(spectrumBusesCount);
     for (let i = 0; i < framesCount; i++) {
+      const audioDataParser = () =>
+        PCM_FORMAT.parseFunction(audioBuffer, i * audioDataStep, i * audioDataStep + audioDataStep);
+      const spectrum = processSpectrum(i, audioDataParser);
       const frameImage = createVisualizerFrame(
         backgroundImage,
-        spectrumsReduced[i],
+        spectrum,
         { width: spectrumWidth, height: spectrumHeight },
+        { x: spectrumX, y: spectrumY },
         spectrumColor
       );
       const frameImageBuffer = createImageBuffer(frameImage);
@@ -85,6 +125,9 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
       if (shouldStop && shouldStop()) {
         break;
       }
+      if (frame_processing_delay) {
+        await sleep(frame_processing_delay);
+      }
     }
 
     ffmpegVideoWriter.stdin.end();

package/src/tests/audio.test.ts

@@ -5,9 +5,11 @@ import {
   bufferToUInt8,
   normalizeAudioData,
   spawnFfmpegAudioReader,
-  smoothSpectrums,
-  getSmoothSpectrums,
-  skipEvery
+  skipEvery,
+  getPeaks,
+  correctPeaks,
+  smoothValues,
+  createSpectrumsProcessor,
 } from '../audio';
 import { createSandbox } from 'sinon';
 
@@ -31,7 +33,7 @@ describe('audio', function () {
   it('bufferToUInt8', function () {
     const expected = [1, 2, 3, 4, 5];
     const buffer = Buffer.from(new Uint8Array(expected));
-    const result = bufferToUInt8(buffer);
+    const result = bufferToUInt8(buffer, 0, 5);
     expect(result).deep.equal(expected);
   });
 
@@ -58,22 +60,46 @@ describe('audio', function () {
     childProcessStream.stderr.emit('data', 'some data');
   });
 
-  it('smoothSpectrums', () => {
-    const result = smoothSpectrums([[1, 0, 3], [40, 50, 60]], 1);
-    const expected = [[0.5125, 0.5, 0.525], [0.5125, 0.5, 0.525]];
+  it('skipEvery', () => {
+    const sampleData = [1, 2, 3, 4];
+    const result = sampleData.filter(skipEvery(2));
+    const expected = [1, 3];
     expect(result).deep.equal(expected);
   });
 
-  it('getSmoothSpectrums', () => {
-    const result = getSmoothSpectrums([1, 2, 3, 4, 5, 6, 7, 8], 2, 2);
-    const expected = [[0.4666666666666666], [0.6], [0.6], [0.7333333333333334]];
+  it('getPeaks', () => {
+    const sampleData = [1, 2, 3, 4];
+    const prevPeaks = [2, 2, 2, 5];
+    const resultNoPrevPeaks = getPeaks(sampleData);
+    expect(resultNoPrevPeaks).deep.equal(sampleData);
+    const resultWithPrevPeaks = getPeaks(sampleData, prevPeaks);
+    const expectedWithPrevPeaks = [2, 2, 3, 5];
+    expect(resultWithPrevPeaks).deep.equal(expectedWithPrevPeaks);
+  });
+
+  it('correctPeaks', () => {
+    const spectrums = [1, 2, 3, 4];
+    const peaks = [2, 2, 3, 5];
+    const result = correctPeaks(spectrums, peaks);
+    const expected = [1 / 3, 2 / 3, 1, 0.8];
     expect(result).deep.equal(expected);
   });
 
-  it('skipEvery', () => {
-    const sampleData = [1, 2, 3, 4];
-    const result = sampleData.filter(skipEvery(2));
-    const expected = [1, 3];
+  it('smoothValues', () => {
+    const spectrums = [1, 2, 3, 4];
+    const prevSpectrums = [2, 4, 6, 3];
+    const result = smoothValues(spectrums, prevSpectrums);
+    const expected = [1.5, 3, 4.5, 3.5];
     expect(result).deep.equal(expected);
   });
+
+  it('createSpectrumsProcessor', () => {
+    const busesCount = 2;
+    const spectrumsProcessor = createSpectrumsProcessor(busesCount);
+    
+    const frame0 = spectrumsProcessor(0, () => ([1, 2, 3, 4]));
+    expect(frame0).to.have.length(2);
+    const frame1 = spectrumsProcessor(1, () => ([2, 2, 6, 2]));
+    expect(frame1).to.have.length(2);
+  });
 });