nodejs-audio-visualizer 1.2.0 → 2.1.0

package/src/tests/config.test.ts

@@ -9,10 +9,16 @@ import {
   getFPS,
   getSpectrumWidthAbsolute,
   getSpectrumHeightAbsolute,
+  getSpectrumXAbsolute,
+  getSpectrumYAbsolute,
   getSpectrumColor,
+  getSpectrumOpacity,
+  getSpectrumOpacityParsed,
   getFfmpeg_cfr,
   getFfmpeg_preset,
-  getFrame_processing_delay
+  getFrame_processing_delay,
+  checkIsValidRotationAlias,
+  checkIsPercentValue
 } from '../config';
 
 describe('config', function() {
@@ -52,13 +58,24 @@ describe('config', function() {
     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 * defaults.spectrumWidth
+      backgroundImageWidth * (parseInt(defaults.spectrumWidth) / 100)
     );
 
     const result2 = getSpectrumWidthAbsolute({
@@ -67,9 +84,36 @@ describe('config', function() {
     expect(result2).equal(420);
 
     const result3 = getSpectrumWidthAbsolute({
-      outVideo: { spectrum: { width: 0.69 }}
+      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%\'.');
+
+    const result5 = getSpectrumWidthAbsolute.bind(
+      undefined,
+      {
+        outVideo: { spectrum: { width: 1 }}
+      } as Config,
+      backgroundImageWidth
+    );
+    expect(result5).to.throw('Spectrum width \'1\' is too small.');
+
+    const result6 = getSpectrumWidthAbsolute.bind(
+      undefined,
+      {
+        outVideo: { spectrum: { width: '1%' }}
+      } as Config,
+      backgroundImageWidth
+    );
+    expect(result6).to.throw('Spectrum width \'1%\' is too small.');
   });
 
   it('getSpectrumHeightAbsolute', function() {
@@ -78,7 +122,7 @@ describe('config', function() {
       outVideo: {}
     } as Config, backgroundImageHeight);
     expect(result1).equal(
-      backgroundImageHeight * defaults.spectrumHeight
+      backgroundImageHeight * (parseInt(defaults.spectrumHeight) / 100)
     );
 
     const result2 = getSpectrumHeightAbsolute({
@@ -87,9 +131,148 @@ describe('config', function() {
     expect(result2).equal(420);
 
     const result3 = getSpectrumHeightAbsolute({
-      outVideo: { spectrum: { height: 0.69 }}
+      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() {
@@ -104,6 +287,46 @@ describe('config', function() {
     expect(result2).equal('#cccc99');
   });
 
+  it('getSpectrumOpacity', function() {
+    const result1 = getSpectrumOpacity({
+      outVideo: {}
+    } as Config);
+    expect(result1).equal(defaults.spectrumOpacity);
+
+    const result2 = getSpectrumOpacity({
+      outVideo: { spectrum: { opacity: '69%' } }
+    } as Config);
+    expect(result2).equal('69%');
+  });
+
+  it('getSpectrumOpacityParsed', function() {
+    const result1 = getSpectrumOpacityParsed({
+      outVideo: {}
+    } as Config);
+    expect(result1).equal(parseInt(defaults.spectrumOpacity) / 100);
+
+    const result2 = getSpectrumOpacityParsed({
+      outVideo: { spectrum: { opacity: '69%' } }
+    } as Config);
+    expect(result2).equal(0.69);
+
+    const result3 = getSpectrumOpacityParsed.bind(
+      undefined,
+      {
+        outVideo: { spectrum: { opacity: 'fake value' } }
+      } as Config
+    );
+    expect(result3).to.throw('Invalid spectrum opacity value: \'fake value\'. Use string percent value, for example \'80%\'.');
+
+    const result4 = getSpectrumOpacityParsed.bind(
+      undefined,
+      {
+        outVideo: { spectrum: { opacity: '103%' } }
+      } as Config
+    );
+    expect(result4).to.throw('Invalid spectrum opacity value: \'103%\'. Percent values must be in range from \'0%\' to \'100%\'.');
+  });
+
   it('getFfmpeg_cfr', function() {
     const result1 = getFfmpeg_cfr({
       tweaks: {}
@@ -139,4 +362,15 @@ describe('config', function() {
     } 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

@@ -1,8 +1,50 @@
 import { expect } from 'chai';
 import path from 'path';
-import { drawRect, Color, createVisualizerFrame, parseImage, convertToBmp } from '../image';
+import fs from 'fs';
+import {
+  drawRect,
+  Color,
+  createVisualizerFrame,
+  parseImage,
+  convertToBmp,
+  mixValues,
+  mixColors,
+} from '../image';
+
+import frameSnapshotSpectrumDown from './snapshots/frameSnapshotSpectrumDown.json';
+import frameSnapshotSpectrumUp from './snapshots/frameSnapshotSpectrumUp.json';
+import frameSnapshotSpectrumUpOpacity50 from './snapshots/frameSnapshotSpectrumUpOpacity50.json';
 
 describe('image', function () {
+  it('mixValues', function () {
+    expect(mixValues(420, 0.69, 96)).equal(320);
+    expect(mixValues(420, 1, 96)).equal(420);
+    expect(mixValues(420, 0, 96)).equal(96);
+  });
+
+  it('mixColors', function () {
+    const result1 = mixColors({
+      color: { red: 123, green: 69, blue: 96 },
+      colorOpacity: 0.24,
+      backgroundColor: { red: 69, green: 123, blue: 42 },
+    });
+    expect(result1).deep.equal({ red: 82, green: 110, blue: 55 });
+
+    const result2 = mixColors({
+      color: { red: 123, green: 69, blue: 96 },
+      colorOpacity: 0,
+      backgroundColor: { red: 69, green: 123, blue: 42 },
+    });
+    expect(result2).deep.equal({ red: 69, green: 123, blue: 42 });
+
+    const result3 = mixColors({
+      color: { red: 123, green: 69, blue: 96 },
+      colorOpacity: 1,
+      backgroundColor: { red: 69, green: 123, blue: 42 },
+    });
+    expect(result3).deep.equal({ red: 123, green: 69, blue: 96 });
+  });
+
   it('drawRect', function () {
     const imageWidth = 10;
     const imageHeight = 10;
@@ -24,7 +66,13 @@ describe('image', function () {
       expectedImageData[pixelIndex + 3] = rectColor.red;
     });
 
-    drawRect(imageDstBuffer as any, { x: rectX, y: rectY }, { width: rectWidth, height: rectHeight }, rectColor);
+    drawRect({
+      imageDstBuffer: imageDstBuffer as any,
+      position: { x: rectX, y: rectY },
+      size: { width: rectWidth, height: rectHeight },
+      color: rectColor,
+      opacity: 1
+    });
     expect(imageDstBuffer.data).deep.equal(expectedImageData);
   });
 
@@ -32,12 +80,43 @@ describe('image', function () {
     const backgroundImagePath = path.resolve('example/media/background.png');
     const backgroundImageBmpBuffer = await convertToBmp(backgroundImagePath);
     const backgroundImage = parseImage(backgroundImageBmpBuffer);
-    const frame = await createVisualizerFrame(
-      backgroundImage,
-      [0.5, 0, 1],
-      { width: 15, height: 20 },
-      { red: 1, green: 1, blue: 1 }
-    );
-    expect(frame.data.toJSON().data.length).equal(1090560);
+    const frameSpectrumDown = createVisualizerFrame({
+      backgroundImageBuffer: backgroundImage,
+      spectrum: [0.5, 0, 1],
+      size: { width: 15, height: 20 },
+      position: { x: 15, y: 0 },
+      rotation: 'down',
+      margin: 4,
+      color: { red: 1, green: 1, blue: 1 },
+      opacity: 1,
+    });
+    const resultSpectrumDown = frameSpectrumDown.data.toJSON().data;
+    expect(resultSpectrumDown).deep.equal(frameSnapshotSpectrumDown);
+
+    const frameSpectrumUp = createVisualizerFrame({
+      backgroundImageBuffer: backgroundImage,
+      spectrum: [0.1, 1, 0],
+      size: { width: 25, height: 23 },
+      position: { x: 10, y: 5 },
+      rotation: 'up',
+      margin: 4,
+      color: { red: 0, green: 123, blue: 69 },
+      opacity: 1,
+    });
+    const resultSpectrumUp = frameSpectrumUp.data.toJSON().data;
+    expect(resultSpectrumUp).deep.equal(frameSnapshotSpectrumUp);
+
+    const frameSpectrumUpOpacity50 = createVisualizerFrame({
+      backgroundImageBuffer: backgroundImage,
+      spectrum: [0.1, 1, 0],
+      size: { width: 25, height: 23 },
+      position: { x: 10, y: 5 },
+      rotation: 'up',
+      margin: 4,
+      color: { red: 0, green: 123, blue: 69 },
+      opacity: 0.5,
+    });
+    const resultSpectrumUpOpacity50 = frameSpectrumUpOpacity50.data.toJSON().data;
+    expect(resultSpectrumUpOpacity50).deep.equal(frameSnapshotSpectrumUpOpacity50);
   });
 });