nodejs-audio-visualizer 4.3.7 → 4.3.9

package/src/tests/image.test.ts

@@ -1,222 +1,222 @@
-import { expect } from 'chai';
-import path from 'path';
-import {
-  drawRect,
-  Color,
-  createSpectrumVisualizerFrameGenerator,
-  createPolarVisualizerFrameGenerator,
-  parseImage,
-  convertToBmp,
-  mixValues,
-  mixColors,
-} from '../image';
-import { createBpmEncoder } from '../bpmEncoder';
-
-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;
-    const extraBytes = imageWidth % 4;
-    const rowBytes = 3 * imageWidth + extraBytes;
-    const imageDstBuffer = {
-      shiftPos: 54,
-      rowBytes,
-      width: imageWidth,
-      data: Array.from({ length: imageWidth * imageHeight * 4 }).fill(0)
-    };
-    const rectX = 4;
-    const rectY = 3;
-    const rectWidth = 4;
-    const rectHeight = 3;
-    const rectColor: Color = { red: 111, green: 112, blue: 123 };
-
-    const expectedImageData = Array.from({ length: imageWidth * imageWidth * 4 }).fill(0);
-    const imagePixelIndices = [162, 165, 168, 171, 194, 197, 200, 203, 226, 229, 232, 235];
-    imagePixelIndices.forEach((pixelIndex) => {
-      expectedImageData[pixelIndex] = rectColor.blue;
-      expectedImageData[pixelIndex + 1] = rectColor.green;
-      expectedImageData[pixelIndex + 2] = rectColor.red;
-    });
-
-    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);
-  });
-
-  it('createSpectrumVisualizerFrameGenerator', async function () {
-    const expectedImageLength = 6220854;
-    const backgroundImagePath = path.resolve('example/media/horses.png');
-    const backgroundImageBmpBuffer = await convertToBmp(backgroundImagePath);
-    const backgroundImage = parseImage(backgroundImageBmpBuffer);
-    const bpmEncoder = createBpmEncoder({ width: backgroundImage.width, height: backgroundImage.height });
-    const backgroundImageBuffer = bpmEncoder(backgroundImage.data);
-    const createVisualizerFrame = createSpectrumVisualizerFrameGenerator();
-    const frameSpectrumDown = createVisualizerFrame({
-      backgroundImageBuffer,
-      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).to.have.length(expectedImageLength);
-
-    const frameSpectrumUp = createVisualizerFrame({
-      backgroundImageBuffer,
-      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).to.have.length(expectedImageLength);
-
-    const frameSpectrumMirror = createVisualizerFrame({
-      backgroundImageBuffer,
-      spectrum: [0.1, 1, 0],
-      size: { width: 25, height: 23 },
-      position: { x: 10, y: 5 },
-      rotation: 'mirror',
-      margin: 4,
-      color: { red: 0, green: 123, blue: 69 },
-      opacity: 1,
-    });
-    const resultSpectrumMirror = frameSpectrumMirror.data.toJSON().data;
-    expect(resultSpectrumMirror).to.have.length(expectedImageLength);
-
-    const frameSpectrumUpOpacity50 = createVisualizerFrame({
-      backgroundImageBuffer,
-      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).to.have.length(expectedImageLength);
-  });
-
-  it('createPolarVisualizerFrameGenerator', async function () {
-    const expectedImageLength = 6220854;
-    const backgroundImagePath = path.resolve('example/media/horses.png');
-    const backgroundImageBmpBuffer = await convertToBmp(backgroundImagePath);
-    const backgroundImage = parseImage(backgroundImageBmpBuffer);
-    const bpmEncoder = createBpmEncoder({ width: backgroundImage.width, height: backgroundImage.height });
-    const backgroundImageBuffer = bpmEncoder(backgroundImage.data);
-    const createPolarVisualizerFrame = createPolarVisualizerFrameGenerator();
-
-    const framePolarBasic = createPolarVisualizerFrame({
-      backgroundImageBuffer,
-      spectrum: [0.5, 0.8, 0.3, 0.9, 0.6, 0.4, 0.7, 0.2],
-      centerX: 500,
-      centerY: 400,
-      innerRadius: 100,
-      maxBarLength: 150,
-      barWidth: 5,
-      color: { red: 255, green: 100, blue: 50 },
-      opacity: 1,
-    });
-    const resultPolarBasic = framePolarBasic.data.toJSON().data;
-    expect(resultPolarBasic).to.have.length(expectedImageLength);
-
-    const framePolarVolume = createPolarVisualizerFrame({
-      backgroundImageBuffer,
-      spectrum: [0.2, 0.5, 0.8, 0.3, 0.6, 0.9, 0.4, 0.7],
-      centerX: 500,
-      centerY: 400,
-      innerRadius: 80,
-      maxBarLength: 120,
-      barWidth: 4,
-      color: { red: 100, green: 200, blue: 255 },
-      opacity: 1,
-      spectrumEffect: 'volume',
-    });
-    const resultPolarVolume = framePolarVolume.data.toJSON().data;
-    expect(resultPolarVolume).to.have.length(expectedImageLength);
-
-    const framePolarSmooth = createPolarVisualizerFrame({
-      backgroundImageBuffer,
-      spectrum: [0.7, 0.4, 0.9, 0.2, 0.5, 0.8, 0.3, 0.6],
-      centerX: 500,
-      centerY: 400,
-      innerRadius: 90,
-      maxBarLength: 130,
-      barWidth: 6,
-      color: { red: 255, green: 255, blue: 0 },
-      opacity: 1,
-      spectrumEffect: 'smooth',
-    });
-    const resultPolarSmooth = framePolarSmooth.data.toJSON().data;
-    expect(resultPolarSmooth).to.have.length(expectedImageLength);
-
-    const framePolarOpacity50 = createPolarVisualizerFrame({
-      backgroundImageBuffer,
-      spectrum: [0.6, 0.3, 0.8, 0.5, 0.4, 0.7, 0.2, 0.9],
-      centerX: 500,
-      centerY: 400,
-      innerRadius: 100,
-      maxBarLength: 140,
-      barWidth: 5,
-      color: { red: 0, green: 255, blue: 128 },
-      opacity: 0.5,
-    });
-    const resultPolarOpacity50 = framePolarOpacity50.data.toJSON().data;
-    expect(resultPolarOpacity50).to.have.length(expectedImageLength);
-
-    const framePolarHexColor = createPolarVisualizerFrame({
-      backgroundImageBuffer,
-      spectrum: [0.5, 0.6, 0.7, 0.8, 0.9, 0.4, 0.3, 0.2],
-      centerX: 500,
-      centerY: 400,
-      innerRadius: 110,
-      maxBarLength: 160,
-      barWidth: 7,
-      color: '#FF5733',
-      opacity: 1,
-    });
-    const resultPolarHexColor = framePolarHexColor.data.toJSON().data;
-    expect(resultPolarHexColor).to.have.length(expectedImageLength);
-  });
-});
+import { expect } from 'chai';
+import path from 'path';
+import {
+  drawRect,
+  Color,
+  createSpectrumVisualizerFrameGenerator,
+  createPolarVisualizerFrameGenerator,
+  parseImage,
+  convertToBmp,
+  mixValues,
+  mixColors,
+} from '../image';
+import { createBpmEncoder } from '../bpmEncoder';
+
+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;
+    const extraBytes = imageWidth % 4;
+    const rowBytes = 3 * imageWidth + extraBytes;
+    const imageDstBuffer = {
+      shiftPos: 54,
+      rowBytes,
+      width: imageWidth,
+      data: Array.from({ length: imageWidth * imageHeight * 4 }).fill(0)
+    };
+    const rectX = 4;
+    const rectY = 3;
+    const rectWidth = 4;
+    const rectHeight = 3;
+    const rectColor: Color = { red: 111, green: 112, blue: 123 };
+
+    const expectedImageData = Array.from({ length: imageWidth * imageWidth * 4 }).fill(0);
+    const imagePixelIndices = [162, 165, 168, 171, 194, 197, 200, 203, 226, 229, 232, 235];
+    imagePixelIndices.forEach((pixelIndex) => {
+      expectedImageData[pixelIndex] = rectColor.blue;
+      expectedImageData[pixelIndex + 1] = rectColor.green;
+      expectedImageData[pixelIndex + 2] = rectColor.red;
+    });
+
+    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);
+  });
+
+  it('createSpectrumVisualizerFrameGenerator', async function () {
+    const expectedImageLength = 6220854;
+    const backgroundImagePath = path.resolve('example/media/horses.png');
+    const backgroundImageBmpBuffer = await convertToBmp(backgroundImagePath);
+    const backgroundImage = parseImage(backgroundImageBmpBuffer);
+    const bpmEncoder = createBpmEncoder({ width: backgroundImage.width, height: backgroundImage.height });
+    const backgroundImageBuffer = bpmEncoder(backgroundImage.data);
+    const createVisualizerFrame = createSpectrumVisualizerFrameGenerator();
+    const frameSpectrumDown = createVisualizerFrame({
+      backgroundImageBuffer,
+      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).to.have.length(expectedImageLength);
+
+    const frameSpectrumUp = createVisualizerFrame({
+      backgroundImageBuffer,
+      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).to.have.length(expectedImageLength);
+
+    const frameSpectrumMirror = createVisualizerFrame({
+      backgroundImageBuffer,
+      spectrum: [0.1, 1, 0],
+      size: { width: 25, height: 23 },
+      position: { x: 10, y: 5 },
+      rotation: 'mirror',
+      margin: 4,
+      color: { red: 0, green: 123, blue: 69 },
+      opacity: 1,
+    });
+    const resultSpectrumMirror = frameSpectrumMirror.data.toJSON().data;
+    expect(resultSpectrumMirror).to.have.length(expectedImageLength);
+
+    const frameSpectrumUpOpacity50 = createVisualizerFrame({
+      backgroundImageBuffer,
+      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).to.have.length(expectedImageLength);
+  });
+
+  it('createPolarVisualizerFrameGenerator', async function () {
+    const expectedImageLength = 6220854;
+    const backgroundImagePath = path.resolve('example/media/horses.png');
+    const backgroundImageBmpBuffer = await convertToBmp(backgroundImagePath);
+    const backgroundImage = parseImage(backgroundImageBmpBuffer);
+    const bpmEncoder = createBpmEncoder({ width: backgroundImage.width, height: backgroundImage.height });
+    const backgroundImageBuffer = bpmEncoder(backgroundImage.data);
+    const createPolarVisualizerFrame = createPolarVisualizerFrameGenerator();
+
+    const framePolarBasic = createPolarVisualizerFrame({
+      backgroundImageBuffer,
+      spectrum: [0.5, 0.8, 0.3, 0.9, 0.6, 0.4, 0.7, 0.2],
+      centerX: 500,
+      centerY: 400,
+      innerRadius: 100,
+      maxBarLength: 150,
+      barWidth: 5,
+      color: { red: 255, green: 100, blue: 50 },
+      opacity: 1,
+    });
+    const resultPolarBasic = framePolarBasic.data.toJSON().data;
+    expect(resultPolarBasic).to.have.length(expectedImageLength);
+
+    const framePolarVolume = createPolarVisualizerFrame({
+      backgroundImageBuffer,
+      spectrum: [0.2, 0.5, 0.8, 0.3, 0.6, 0.9, 0.4, 0.7],
+      centerX: 500,
+      centerY: 400,
+      innerRadius: 80,
+      maxBarLength: 120,
+      barWidth: 4,
+      color: { red: 100, green: 200, blue: 255 },
+      opacity: 1,
+      spectrumEffect: 'volume',
+    });
+    const resultPolarVolume = framePolarVolume.data.toJSON().data;
+    expect(resultPolarVolume).to.have.length(expectedImageLength);
+
+    const framePolarSmooth = createPolarVisualizerFrame({
+      backgroundImageBuffer,
+      spectrum: [0.7, 0.4, 0.9, 0.2, 0.5, 0.8, 0.3, 0.6],
+      centerX: 500,
+      centerY: 400,
+      innerRadius: 90,
+      maxBarLength: 130,
+      barWidth: 6,
+      color: { red: 255, green: 255, blue: 0 },
+      opacity: 1,
+      spectrumEffect: 'smooth',
+    });
+    const resultPolarSmooth = framePolarSmooth.data.toJSON().data;
+    expect(resultPolarSmooth).to.have.length(expectedImageLength);
+
+    const framePolarOpacity50 = createPolarVisualizerFrame({
+      backgroundImageBuffer,
+      spectrum: [0.6, 0.3, 0.8, 0.5, 0.4, 0.7, 0.2, 0.9],
+      centerX: 500,
+      centerY: 400,
+      innerRadius: 100,
+      maxBarLength: 140,
+      barWidth: 5,
+      color: { red: 0, green: 255, blue: 128 },
+      opacity: 0.5,
+    });
+    const resultPolarOpacity50 = framePolarOpacity50.data.toJSON().data;
+    expect(resultPolarOpacity50).to.have.length(expectedImageLength);
+
+    const framePolarHexColor = createPolarVisualizerFrame({
+      backgroundImageBuffer,
+      spectrum: [0.5, 0.6, 0.7, 0.8, 0.9, 0.4, 0.3, 0.2],
+      centerX: 500,
+      centerY: 400,
+      innerRadius: 110,
+      maxBarLength: 160,
+      barWidth: 7,
+      color: '#FF5733',
+      opacity: 1,
+    });
+    const resultPolarHexColor = framePolarHexColor.data.toJSON().data;
+    expect(resultPolarHexColor).to.have.length(expectedImageLength);
+  });
+});

package/src/tests/index.test.ts

@@ -1,63 +1,156 @@
-import { expect } from 'chai';
-import { createSandbox } from 'sinon';
-import { renderAudioVisualizer, Config } from '../index';
-import path from 'path';
-import fs from 'fs';
-import { Writable, Readable } from 'stream';
-import { ChildProcessWithoutNullStreams } from 'child_process';
-import * as image from '../image';
-import * as audio from '../audio';
-import * as video from '../video';
-
-const EXIT_CODE = 0;
-const sandbox = createSandbox();
-
-describe('index', function () {
-
-  this.beforeAll(function () {
-    sandbox.stub(fs, 'readFileSync').returns(Buffer.from([1, 1]));
-    sandbox.stub(audio, 'createAudioBuffer').returns(
-      new Promise(resolve => resolve({ audioBuffer: Buffer.from([1, 1]), sampleRate: 2 }))
-    );
-    sandbox.stub(image, 'getImageColor').returns({ red: 0, green: 0, blue: 0 });
-
-    let exitCallback: Function = () => { };
-    const stdin = new Writable({
-      write(_chunk: Buffer, _enc: string, cb: (error?: Error | null) => void) {
-        exitCallback(EXIT_CODE);
-        cb();
-      },
-    });
-    let childProcessStream: unknown = {
-      stdin,
-      stderr: new Readable(),
-      on: function (_: string, callback: Function) {
-        exitCallback = callback;
-      },
-    };
-    sandbox.stub(video, 'spawnFfmpegVideoWriter').returns(childProcessStream as ChildProcessWithoutNullStreams);
-  });
-
-  this.afterAll(function () {
-    sandbox.restore();
-  });
-
-  it('renderAudioVisualizer', async function () {
-    const config: Config = {
-      audio: {
-        path: 'audioPath'
-      },
-      image: {
-        path: 'example/media/horses.png'
-      },
-      outVideo: {
-        path: 'outVideoPath',
-        fps: 1
-      }
-    };
-
-    const { exitCode, outputVideoFiles } = await renderAudioVisualizer(config);
-    expect(exitCode).equal(EXIT_CODE);
-    expect(outputVideoFiles).deep.equal([path.resolve('outVideoPath')]);
-  });
-});
+import { expect } from 'chai';
+import { createSandbox } from 'sinon';
+import { renderAudioVisualizer, Config } from '../index';
+import path from 'path';
+import fs from 'fs';
+import { Writable, Readable } from 'stream';
+import { ChildProcessWithoutNullStreams } from 'child_process';
+import { EventEmitter } from 'events';
+import * as image from '../image';
+import * as audio from '../audio';
+import * as video from '../video';
+import * as bpmEncoder from '../bpmEncoder';
+
+const EXIT_CODE = 0;
+const sandbox = createSandbox();
+
+describe('index', function () {
+  const createMockWriter = (emitExitOnWrite: boolean): ChildProcessWithoutNullStreams => {
+    const eventBus = new EventEmitter();
+    const writable = new Writable({
+      write(_chunk: Buffer, _enc: string, cb: (error?: Error | null) => void) {
+        if (emitExitOnWrite) {
+          eventBus.emit('exit', EXIT_CODE);
+        }
+        cb();
+      },
+    });
+    const stderr = new Readable();
+    stderr._read = () => {};
+    return {
+      stdin: writable,
+      stderr,
+      on: eventBus.on.bind(eventBus),
+      once: eventBus.once.bind(eventBus),
+      removeListener: eventBus.removeListener.bind(eventBus),
+      emit: eventBus.emit.bind(eventBus),
+    } as unknown as ChildProcessWithoutNullStreams;
+  };
+
+  this.beforeEach(function () {
+    sandbox.stub(fs, 'readFileSync').returns(Buffer.from([1, 1]));
+    sandbox.stub(audio, 'createAudioBuffer').returns(
+      Promise.resolve({ audioBuffer: Buffer.from([1, 1]), sampleRate: 2 })
+    );
+    sandbox.stub(image, 'getImageColor').returns({ red: 0, green: 0, blue: 0 });
+
+    let childProcessStream = createMockWriter(true);
+    sandbox.stub(video, 'spawnFfmpegVideoWriter').callsFake(
+      () => childProcessStream
+    );
+    (this as any).setMockWriter = (emitExitOnWrite: boolean) => {
+      childProcessStream = createMockWriter(emitExitOnWrite);
+    };
+  });
+
+  this.afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('renderAudioVisualizer', async function () {
+    const config: Config = {
+      audio: {
+        path: 'audioPath'
+      },
+      image: {
+        path: 'example/media/horses.png'
+      },
+      outVideo: {
+        path: 'outVideoPath',
+        fps: 1
+      }
+    };
+
+    const { exitCode, outputVideoFiles } = await renderAudioVisualizer(config);
+    expect(exitCode).equal(EXIT_CODE);
+    expect(outputVideoFiles).deep.equal([path.resolve('outVideoPath')]);
+  });
+
+  it('resolves and does not report 100 when process completion times out', async function () {
+    (this as any).setMockWriter(false);
+    sandbox.stub(video, 'waitForProcessExit').callsFake(
+      () => Promise.resolve(1)
+    );
+    const progressValues: number[] = [];
+    const config: Config = {
+      audio: {
+        path: 'audioPath'
+      },
+      image: {
+        path: 'example/media/horses.png'
+      },
+      outVideo: {
+        path: 'outVideoPath',
+        fps: 1
+      }
+    };
+
+    const timeoutPromise = new Promise<never>((_resolve, reject) => {
+      setTimeout(() => reject(new Error('renderAudioVisualizer hung')), 200);
+    });
+
+    const { exitCode, outputVideoFiles } = await Promise.race([
+      renderAudioVisualizer(config, (progress) => progressValues.push(progress)),
+      timeoutPromise,
+    ]);
+
+    expect(exitCode).equal(1);
+    expect(outputVideoFiles).deep.equal([]);
+    expect(progressValues.some(progress => progress === 100)).equal(false);
+  });
+
+  it('aborts render when video frame reads fail repeatedly', async function () {
+    const videoFrameReaderOutput = new Readable();
+    videoFrameReaderOutput._read = () => {};
+    sandbox.stub(video, 'getVideoInfo').resolves({
+      width: 1,
+      height: 1,
+      duration: 1,
+    });
+    sandbox.stub(video, 'writeConcatFile').returns('fake-concat-path.txt');
+    sandbox.stub(video, 'spawnConcatVideoFrameReader').returns({
+      stdout: videoFrameReaderOutput,
+      kill: () => {},
+    } as any);
+    sandbox.stub(image, 'getVideoFrameColor').returns({ red: 0, green: 0, blue: 0 });
+    sandbox.stub(bpmEncoder, 'createBgrFrameEncoder').returns(
+      () => ({ shiftPos: 0, rowBytes: 0, data: Buffer.from([1, 2, 3]) }),
+    );
+    let frameReadCount = 0;
+    sandbox.stub(video, 'readVideoFrame').callsFake(async () => {
+      frameReadCount += 1;
+      if (frameReadCount === 1) {
+        return Buffer.from([1, 2, 3]);
+      }
+      return null;
+    });
+
+    const config: Config = {
+      audio: {
+        path: 'audioPath'
+      },
+      video: {
+        path: 'example/media/test-blur.mp4',
+      },
+      outVideo: {
+        path: 'outVideoPath',
+        fps: 10,
+      }
+    };
+
+    const { exitCode, outputVideoFiles } = await renderAudioVisualizer(config);
+    expect(exitCode).equal(1);
+    expect(outputVideoFiles).deep.equal([]);
+    expect(frameReadCount).greaterThan(1);
+  });
+});