nodejs-audio-visualizer 1.1.1 → 2.0.0

package/src/image.ts

@@ -1,3 +1,4 @@
+import { RotationAliasName } from './index';
 import { decode, encode, BmpDecoder } from 'bmp-js';
 import Jimp from 'jimp';
 
@@ -29,9 +30,18 @@ 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,
+  rotation: RotationAliasName,
+  color: Color
+) => {
   const busWidth = Math.trunc(size.width / spectrum.length);
+  const left = Math.trunc(position.x);
+  const top = Math.trunc(position.y);
+  const height = Math.trunc(size.height);
   const margin = 4;
 
   for (let spectrumX = 0; spectrumX < spectrum.length; spectrumX++) {
@@ -40,17 +50,18 @@ 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 rectHeight = size.height * spectrumValue;
-    drawRect(imageDstBuffer, { x: rectX + margin, y: 0 }, { width: busWidth - margin / 2, height: rectHeight }, color);
+    const rectX = left + busWidth * spectrumX;
+    const rectHeight = Math.trunc(height * spectrumValue);
+    const rectY = (rotation === 'up') ? top + height - rectHeight : top;
+    drawRect(imageDstBuffer, { x: rectX + margin, y: rectY }, { 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, rotation: RotationAliasName, 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, rotation, rgbSpectrumColor);
   return image;
 };
 

package/src/index.ts

@@ -1,4 +1,19 @@
-import path from 'path';
+import {
+  getAudioFilePath,
+  getBackgroundImagePath,
+  getOutVideoPath,
+  getFPS,
+  getSpectrumWidthAbsolute,
+  getSpectrumHeightAbsolute,
+  getSpectrumXAbsolute,
+  getSpectrumYAbsolute,
+  getSpectrumColor,
+  getFfmpeg_cfr,
+  getFfmpeg_preset,
+  getFrame_processing_delay,
+  rotationAliasValues,
+  getSpectrumRotation
+} 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';
@@ -21,8 +36,11 @@ export interface Config {
     path: string;
     fps?: number;
     spectrum?: {
-      width?: number;
-      height?: number;
+      width?: SpectrumSizeValue;
+      height?: SpectrumSizeValue;
+      x?: number | PositionAliasName;
+      y?: number | PositionAliasName;
+      rotation?: RotationAliasName;
       color?: Color | string;
     }
   };
@@ -33,14 +51,26 @@ export interface Config {
   };
 }
 
+export type SpectrumSizeValue = number | string;
+
+export type PositionAliasName =
+  'left' |
+  'center' |
+  'right' |
+  'top' |
+  'middle' |
+  'bottom';
+
+export type RotationAliasName = typeof rotationAliasValues[number];
+
 const sleep = (timeout: number) =>
-  new Promise(resolve => setTimeout(resolve, 1000));
+  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);
@@ -51,22 +81,23 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
       throw new Error('ffmpeg didn\'t show audio sample rate');
     }
 
-    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 spectrumRotation =
+      getSpectrumRotation(config);
     const spectrumColor =
-      (config.outVideo.spectrum && config.outVideo.spectrum.color) ||
+      getSpectrumColor(config) ||
       invertColor(getImageColor(backgroundImage));
-    const ffmpeg_cfr =
-      config.tweaks && config.tweaks.ffmpeg_cfr;
-    const ffmpeg_preset =
-      config.tweaks && config.tweaks.ffmpeg_preset;
-    const frame_processing_delay =
-      config.tweaks && config.tweaks.frame_processing_delay;
+    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 = audioBuffer.length / sampleRate;
@@ -92,6 +123,8 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
         backgroundImage,
         spectrum,
         { width: spectrumWidth, height: spectrumHeight },
+        { x: spectrumX, y: spectrumY },
+        spectrumRotation,
         spectrumColor
       );
       const frameImageBuffer = createImageBuffer(frameImage);

package/src/tests/config.test.ts

@@ -0,0 +1,316 @@
+import path from 'path';
+import { expect } from 'chai';
+import { Config } from '../index';
+import {
+  defaults,
+  getAudioFilePath,
+  getBackgroundImagePath,
+  getOutVideoPath,
+  getFPS,
+  getSpectrumWidthAbsolute,
+  getSpectrumHeightAbsolute,
+  getSpectrumXAbsolute,
+  getSpectrumYAbsolute,
+  getSpectrumColor,
+  getFfmpeg_cfr,
+  getFfmpeg_preset,
+  getFrame_processing_delay,
+  checkIsValidRotationAlias,
+  checkIsPercentValue
+} from '../config';
+
+describe('config', function() {
+  it('getAudioFilePath', function() {
+    const result = getAudioFilePath({
+      audio: { path: 'test/path' }
+    } as Config);
+    const expected = path.resolve('test/path');
+    expect(result).equal(expected);
+  });
+
+  it('getBackgroundImagePath', function() {
+    const result = getBackgroundImagePath({
+      image: { path: 'test/path' }
+    } as Config);
+    const expected = path.resolve('test/path');
+    expect(result).equal(expected);
+  });
+
+  it('getOutVideoPath', function() {
+    const result = getOutVideoPath({
+      outVideo: { path: 'test/path' }
+    } as Config);
+    const expected = path.resolve('test/path');
+    expect(result).equal(expected);
+  });
+
+  it('getFPS', function() {
+    const result1 = getFPS({
+      outVideo: {}
+    } as Config);
+    expect(result1).equal(defaults.fps);
+
+    const result2 = getFPS({
+      outVideo: { fps: 15 }
+    } as Config);
+    expect(result2).equal(15);
+  });
+
+  it('checkIsPercentValue', function() {
+    const result1 = checkIsPercentValue('69%');
+    expect(result1).equal(true);
+
+    const result2 = checkIsPercentValue('69');
+    expect(result2).equal(false);
+
+    const result3 = checkIsPercentValue('fake value');
+    expect(result3).equal(false);
+  });
+
+  it('getSpectrumWidthAbsolute', function() {
+    const backgroundImageWidth = 1366;
+    const result1 = getSpectrumWidthAbsolute({
+      outVideo: {}
+    } as Config, backgroundImageWidth);
+    expect(result1).equal(
+      backgroundImageWidth * (parseInt(defaults.spectrumWidth) / 100)
+    );
+
+    const result2 = getSpectrumWidthAbsolute({
+      outVideo: { spectrum: { width: 420 }}
+    } as Config, backgroundImageWidth);
+    expect(result2).equal(420);
+
+    const result3 = getSpectrumWidthAbsolute({
+      outVideo: { spectrum: { width: '69%' }}
+    } as Config, backgroundImageWidth);
+    expect(result3).equal(backgroundImageWidth * 0.69);
+
+    const result4 = getSpectrumWidthAbsolute.bind(
+      undefined,
+      {
+        outVideo: { spectrum: { width: '69' }}
+      } as Config,
+      backgroundImageWidth
+    );
+    expect(result4).to.throw('Invalid spectrum width value: \'69\'. Use number value or percent value in string, for example: \'30%\'.');
+  });
+
+  it('getSpectrumHeightAbsolute', function() {
+    const backgroundImageHeight = 768;
+    const result1 = getSpectrumHeightAbsolute({
+      outVideo: {}
+    } as Config, backgroundImageHeight);
+    expect(result1).equal(
+      backgroundImageHeight * (parseInt(defaults.spectrumHeight) / 100)
+    );
+
+    const result2 = getSpectrumHeightAbsolute({
+      outVideo: { spectrum: { height: 420 }}
+    } as Config, backgroundImageHeight);
+    expect(result2).equal(420);
+
+    const result3 = getSpectrumHeightAbsolute({
+      outVideo: { spectrum: { height: '69%' }}
+    } as Config, backgroundImageHeight);
+    expect(result3).equal(backgroundImageHeight * 0.69);
+
+    const result4 = getSpectrumHeightAbsolute.bind(
+      undefined,
+      {
+        outVideo: { spectrum: { height: '69' }}
+      } as Config,
+      backgroundImageHeight
+    );
+    expect(result4).to.throw('Invalid spectrum height value: \'69\'. Use number value or percent value in string, for example: \'30%\'.');
+  });
+
+  it('getSpectrumXAbsolute', function() {
+    const spectrumWidth = 420;
+    const backgroundImageWidth = 1366;
+    const result1 = getSpectrumXAbsolute(
+      {
+        outVideo: {},
+      } as Config,
+      spectrumWidth,
+      backgroundImageWidth
+    );
+    expect(result1).equal(
+      0.5 * backgroundImageWidth - spectrumWidth / 2
+    );
+
+    const result2 = getSpectrumXAbsolute(
+      {
+        outVideo: { spectrum: { x: 420 } }
+      } as Config,
+      spectrumWidth,
+      backgroundImageWidth
+    );
+    expect(result2).equal(420);
+
+    const result3 = getSpectrumXAbsolute(
+      {
+        outVideo: { spectrum: { x: 'left' } }
+      } as Config,
+      spectrumWidth,
+      backgroundImageWidth
+    );
+    expect(result3).equal(0);
+
+    const result4 = getSpectrumXAbsolute(
+      {
+        outVideo: { spectrum: { x: 'center' } }
+      } as Config,
+      spectrumWidth,
+      backgroundImageWidth
+    );
+    expect(result4).equal(
+      0.5 * backgroundImageWidth - spectrumWidth / 2
+    );
+
+    const result5 = getSpectrumXAbsolute(
+      {
+        outVideo: { spectrum: { x: 'right' } }
+      } as Config,
+      spectrumWidth,
+      backgroundImageWidth
+    );
+    expect(result5).equal(
+      1 * backgroundImageWidth - spectrumWidth
+    );
+
+    const result6 = getSpectrumXAbsolute.bind(
+      undefined,
+      {
+        outVideo: { spectrum: { x: 'sagewklkg' } }
+      } as unknown as Config,
+      spectrumWidth,
+      backgroundImageWidth
+    );
+    expect(result6).to.throw('Invalid spectrum x value: sagewklkg. Valid values: left, center, right, top, middle, bottom.');
+  });
+
+  it('getSpectrumYAbsolute', function() {
+    const spectrumHeight = 125;
+    const backgroundImageHeight = 768;
+    const result1 = getSpectrumYAbsolute(
+      {
+        outVideo: {},
+      } as Config,
+      spectrumHeight,
+      backgroundImageHeight
+    );
+    expect(result1).equal(
+      0
+    );
+
+    const result2 = getSpectrumYAbsolute(
+      {
+        outVideo: { spectrum: { y: 69 } }
+      } as Config,
+      spectrumHeight,
+      backgroundImageHeight
+    );
+    expect(result2).equal(69);
+
+    const result3 = getSpectrumYAbsolute(
+      {
+        outVideo: { spectrum: { y: 'top' } }
+      } as Config,
+      spectrumHeight,
+      backgroundImageHeight
+    );
+    expect(result3).equal(0);
+
+    const result4 = getSpectrumYAbsolute(
+      {
+        outVideo: { spectrum: { y: 'middle' } }
+      } as Config,
+      spectrumHeight,
+      backgroundImageHeight
+    );
+    expect(result4).equal(
+      0.5 * backgroundImageHeight - spectrumHeight / 2
+    );
+
+    const result5 = getSpectrumYAbsolute(
+      {
+        outVideo: { spectrum: { y: 'bottom' } }
+      } as Config,
+      spectrumHeight,
+      backgroundImageHeight
+    );
+    expect(result5).equal(
+      1 * backgroundImageHeight - spectrumHeight
+    );
+
+    const result6 = getSpectrumYAbsolute.bind(
+      undefined,
+      {
+        outVideo: { spectrum: { y: 'asokosckm' } }
+      } as unknown as Config,
+      spectrumHeight,
+      backgroundImageHeight
+    );
+    expect(result6).to.throw('Invalid spectrum y value: asokosckm. Valid values: left, center, right, top, middle, bottom.');
+  });
+
+  it('getSpectrumColor', function() {
+    const result1 = getSpectrumColor({
+      outVideo: {}
+    } as Config);
+    expect(result1).equal(undefined);
+
+    const result2 = getSpectrumColor({
+      outVideo: { spectrum: { color: '#cccc99' } }
+    } as Config);
+    expect(result2).equal('#cccc99');
+  });
+
+  it('getFfmpeg_cfr', function() {
+    const result1 = getFfmpeg_cfr({
+      tweaks: {}
+    } as Config);
+    expect(result1).equal(undefined);
+
+    const result2 = getFfmpeg_cfr({
+      tweaks: { ffmpeg_cfr: '69' }
+    } as Config);
+    expect(result2).equal('69');
+  });
+
+  it('getFfmpeg_preset', function() {
+    const result1 = getFfmpeg_preset({
+      tweaks: {}
+    } as Config);
+    expect(result1).equal(undefined);
+
+    const result2 = getFfmpeg_preset({
+      tweaks: { ffmpeg_preset: 'quality' }
+    } as Config);
+    expect(result2).equal('quality');
+  });
+
+  it('getFrame_processing_delay', function() {
+    const result1 = getFrame_processing_delay({
+      tweaks: {}
+    } as Config);
+    expect(result1).equal(undefined);
+
+    const result2 = getFrame_processing_delay({
+      tweaks: { frame_processing_delay: 420 }
+    } as Config);
+    expect(result2).equal(420);
+  });
+
+  it('checkIsValidRotationAlias', function() {
+    const result1 = checkIsValidRotationAlias('up');
+    expect(result1).equal(true);
+
+    const result2 = checkIsValidRotationAlias('down');
+    expect(result2).equal(true);
+
+    const result3 = checkIsValidRotationAlias('fake value');
+    expect(result3).equal(false);
+  });
+});

package/src/tests/image.test.ts

@@ -2,6 +2,9 @@ import { expect } from 'chai';
 import path from 'path';
 import { drawRect, Color, createVisualizerFrame, parseImage, convertToBmp } from '../image';
 
+import frameSnapshotSpectrumDown from './snapshots/frameSnapshotSpectrumDown.json';
+import frameSnapshotSpectrumUp from './snapshots/frameSnapshotSpectrumUp.json';
+
 describe('image', function () {
   it('drawRect', function () {
     const imageWidth = 10;
@@ -32,12 +35,26 @@ describe('image', function () {
     const backgroundImagePath = path.resolve('example/media/background.png');
     const backgroundImageBmpBuffer = await convertToBmp(backgroundImagePath);
     const backgroundImage = parseImage(backgroundImageBmpBuffer);
-    const frame = await createVisualizerFrame(
+    const frameSpectrumDown = createVisualizerFrame(
       backgroundImage,
       [0.5, 0, 1],
       { width: 15, height: 20 },
+      { x: 15, y: 0 },
+      'down',
       { red: 1, green: 1, blue: 1 }
     );
-    expect(frame.data.toJSON().data.length).equal(1090560);
+    const resultSpectrumDown = frameSpectrumDown.data.toJSON().data;
+    expect(resultSpectrumDown).deep.equal(frameSnapshotSpectrumDown);
+
+    const frameSpectrumUp = createVisualizerFrame(
+      backgroundImage,
+      [0.1, 1, 0],
+      { width: 25, height: 23 },
+      { x: 10, y: 5 },
+      'up',
+      { red: 0, green: 123, blue: 69 }
+    );
+    const resultSpectrumUp = frameSpectrumUp.data.toJSON().data;
+    expect(resultSpectrumUp).deep.equal(frameSnapshotSpectrumUp);
   });
 });