nodejs-audio-visualizer 5.0.0 → 5.2.0

package/src/index.ts

@@ -3,7 +3,7 @@ import { readFileSync } from 'fs';
 import {
   getAudioFilePath,
   getBackgroundImagePath,
-  getBackgroundVideoPath,
+  getBackgroundVideoPaths,
   getOutVideoPath,
   getSubtitleRenderSpec,
   subtitleAlignmentToAss,
@@ -33,16 +33,17 @@ import {
   getPolarColor,
   getPolarOpacityParsed,
   getAutoEditVideo,
+  getCameraShakeEnabled,
   getAudioAutoHighlight,
   getAudioAutoHighlightCount,
 } from './config';
-import { createAudioBuffer, bufferToUInt8, createSpectrumsProcessor } from './audio';
-import { parseImage, getImageColor, getVideoFrameColor, invertColor, Color, convertToBmp, createSpectrumVisualizerFrameGenerator, createPolarVisualizerFrameGenerator, CreatePolarVisualizerFrameProps, CreateVisualizerFrameProps, CommonVisualizerFrameProps } from './image';
+import { createAudioBuffer, bufferToUInt8, createSpectrumsProcessor, pcmU8ToFloatSamples } from './audio';
+import { parseImage, getImageColor, getVideoFrameColor, invertColor, Color, convertToBmp, createSpectrumVisualizerFrameGenerator, createPolarVisualizerFrameGenerator, CreatePolarVisualizerFrameProps, CreateVisualizerFrameProps, CommonVisualizerFrameProps, applyCameraShake, getCutShakeOffset, buildCutShakeAmplitudes, CAMERA_SHAKE_DELAY_SECONDS, CAMERA_SHAKE_EVERY_BEATS } from './image';
 import { normalizeInlineSubtitlesToSrt, lrcToSrt } from './subtitleConvert';
-import { spawnFfmpegVideoWriter, waitDrain, waitForProcessExit, getVideoInfo, spawnVideoFrameReader, readVideoFrame, detectSceneChanges, buildBeatSyncedSegments, writeConcatFile, writeSubtitlesFile, spawnConcatVideoFrameReader, cleanupConcatFile, cleanupTempFile } from './video';
+import { spawnFfmpegVideoWriter, waitDrain, waitForProcessExit, getVideoInfo, spawnVideoFrameReader, readVideoFrame, detectSceneChanges, buildBeatSyncedSegments, buildSequentialVideoSegments, buildShuffledVideoSegments, getCutFrameIndices, writeConcatFile, writeSubtitlesFile, spawnConcatVideoFrameReader, cleanupConcatFile, cleanupTempFile, VideoSegment } from './video';
 import { createBpmEncoder, createBgrFrameEncoder, EncodedBmp } from './bpmEncoder';
-import { createBeatDetector } from './beats';
-export { BeatInfo, BeatDetectorOptions } from './beats';
+import { createBeatDetector, estimateTempo, TempoEstimate, beatGridFrameIndices, tempoForWindow, MAX_TEMPO_ANALYSIS_SECONDS } from './beats';
+export { BeatInfo, BeatDetectorOptions, TempoEstimate, estimateTempo, beatGridFrameIndices, shiftTempoPhase, tempoForWindow } from './beats';
 import { computeHighlightSlice, HIGHLIGHT_DURATION_SEC } from './highlight';
 import { waitForEventLoop } from './waitForEventLoop';
 export { computeHighlightSlice, HIGHLIGHT_DURATION_SEC, BeatFrameEvent, HighlightAudioSegment, HighlightRun } from './highlight';
@@ -66,8 +67,16 @@ export interface Config {
     path: string;
   };
   video?: {
-    path: string;
+    /**
+     * A single video path, or an array of video paths.
+     * With an array: when `autoEdit` is false, the videos play one after another (looping the
+     * sequence as needed); when `autoEdit` is true, cuts switch (shuffle) between the given
+     * videos instead of auto-detecting scene changes within a single video.
+     */
+    path: string | string[];
     autoEdit?: boolean;
+    /** When `autoEdit` is true, disables the brief camera shake applied on cuts, or every 2 beats when there are no cuts (default true). */
+    cameraShake?: boolean;
   };
   outVideo: {
     path: string;
@@ -263,14 +272,18 @@ const preProcessAudio = async (
 
 async function prepareBackgroundForRender(params: {
   useVideoBackground: boolean;
-  backgroundVideoPath: string | undefined;
+  backgroundVideoPaths: string[] | undefined;
   backgroundImagePath: string | undefined;
   beatFrameIndices: number[];
+  beatIntensities?: number[];
   framesCount: number;
   outputResolution: ReturnType<typeof getOutputResolution>;
   fps: number;
   autoEditVideo: boolean;
   readVideoFrameTimeout: number;
+  tempo?: TempoEstimate | null;
+  /** First video to play for `video.path` arrays without `autoEdit`. */
+  startVideoIndex?: number;
 }): Promise<{
   backgroundWidth: number;
   backgroundHeight: number;
@@ -280,38 +293,71 @@ async function prepareBackgroundForRender(params: {
   videoFrameSize: number;
   encodeVideoFrame?: (bgrBuffer: Buffer) => EncodedBmp;
   concatFilePath?: string;
+  cutFrameIndices: number[];
 }> {
   const {
     useVideoBackground,
-    backgroundVideoPath,
+    backgroundVideoPaths,
     backgroundImagePath,
     beatFrameIndices,
+    beatIntensities,
     framesCount,
     outputResolution,
     fps,
     autoEditVideo,
     readVideoFrameTimeout,
+    tempo,
+    startVideoIndex = 0,
   } = params;
 
-  if (useVideoBackground && backgroundVideoPath) {
-    const videoInfo = await getVideoInfo(backgroundVideoPath);
-    const sceneChanges = autoEditVideo
-      ? await detectSceneChanges(backgroundVideoPath)
-      : [];
-    const backgroundWidth = outputResolution?.width ?? videoInfo.width;
-    const backgroundHeight = outputResolution?.height ?? videoInfo.height;
+  if (useVideoBackground && backgroundVideoPaths && backgroundVideoPaths.length > 0) {
+    const videoInfos = await Promise.all(backgroundVideoPaths.map(videoPath => getVideoInfo(videoPath)));
+    const primaryVideoInfo = videoInfos[0];
+    const backgroundWidth = outputResolution?.width ?? primaryVideoInfo.width;
+    const backgroundHeight = outputResolution?.height ?? primaryVideoInfo.height;
 
     const videoFrameSize = backgroundWidth * backgroundHeight * 3;
     const encodeVideoFrame = createBgrFrameEncoder({ width: backgroundWidth, height: backgroundHeight });
 
-    const segments = buildBeatSyncedSegments(
-      beatFrameIndices,
-      framesCount,
-      sceneChanges,
-      videoInfo.duration,
-    );
+    let segments: VideoSegment[];
+    if (backgroundVideoPaths.length > 1) {
+      segments = autoEditVideo
+        ? buildShuffledVideoSegments(
+            beatFrameIndices,
+            framesCount,
+            backgroundVideoPaths.length,
+            fps,
+            {
+              beatIntensities,
+              ...(tempo ? { tempo } : {}),
+            },
+          )
+        : buildSequentialVideoSegments(
+            framesCount,
+            videoInfos.map(info => info.duration),
+            fps,
+            startVideoIndex % backgroundVideoPaths.length,
+          );
+    } else {
+      const sceneChanges = autoEditVideo
+        ? await detectSceneChanges(backgroundVideoPaths[0])
+        : [];
+      segments = buildBeatSyncedSegments(
+        beatFrameIndices,
+        framesCount,
+        sceneChanges,
+        primaryVideoInfo.duration,
+        fps,
+        {
+          beatIntensities,
+          ...(autoEditVideo && tempo ? { tempo } : {}),
+        },
+      );
+    }
 
-    const concatFilePath = writeConcatFile(segments, backgroundVideoPath, videoInfo.duration, fps);
+    const videoSources = videoInfos.map((info, i) => ({ path: backgroundVideoPaths[i], duration: info.duration }));
+    const concatFilePath = writeConcatFile(segments, videoSources, fps);
+    const cutFrameIndices = autoEditVideo ? getCutFrameIndices(segments) : [];
 
     const videoFrameReader = spawnConcatVideoFrameReader({
       concatFilePath,
@@ -320,8 +366,8 @@ async function prepareBackgroundForRender(params: {
       ...(outputResolution && {
         width: backgroundWidth,
         height: backgroundHeight,
-        sourceWidth: videoInfo.width,
-        sourceHeight: videoInfo.height,
+        sourceWidth: primaryVideoInfo.width,
+        sourceHeight: primaryVideoInfo.height,
       }),
     });
 
@@ -331,7 +377,7 @@ async function prepareBackgroundForRender(params: {
       readVideoFrameTimeout,
     );
     if (!firstFrame) {
-      throw new Error(`Could not read frames from video: ${backgroundVideoPath}`);
+      throw new Error(`Could not read frames from video: ${backgroundVideoPaths.join(', ')}`);
     }
     const defaultColor = getVideoFrameColor(firstFrame, backgroundWidth, backgroundHeight);
     const staticBackgroundBuffer = encodeVideoFrame(firstFrame);
@@ -344,6 +390,7 @@ async function prepareBackgroundForRender(params: {
       videoFrameSize,
       encodeVideoFrame,
       concatFilePath,
+      cutFrameIndices,
     };
   }
 
@@ -368,6 +415,7 @@ async function prepareBackgroundForRender(params: {
     defaultColor,
     staticBackgroundBuffer,
     videoFrameSize: 0,
+    cutFrameIndices: [],
   };
 }
 
@@ -452,9 +500,9 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
         subtitleFileIsTemporary = true;
       }
     }
-    const backgroundVideoPath = getBackgroundVideoPath(config);
+    const backgroundVideoPaths = getBackgroundVideoPaths(config);
     const backgroundImagePath = getBackgroundImagePath(config);
-    const useVideoBackground = !!backgroundVideoPath;
+    const useVideoBackground = !!backgroundVideoPaths && backgroundVideoPaths.length > 0;
 
     const audioReader = await createAudioBuffer(audioFilePath, FFMPEG_FORMAT);
     const audioBuffer = audioReader.audioBuffer;
@@ -502,6 +550,7 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
     const autoHighlight = getAudioAutoHighlight(config);
     let spectrumsForRender = preprocessed.spectrums;
     let beatIndicesForRender = preprocessed.beatFrameIndices;
+    let beatIntensitiesForRender = preprocessed.beatEvents.map(event => event.intensity);
     let framesCountForRender = framesCount;
     type HighlightSliceResult = ReturnType<typeof computeHighlightSlice> extends Promise<
       infer R
@@ -521,12 +570,26 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
       );
       spectrumsForRender = highlightSlice.spectrums;
       beatIndicesForRender = highlightSlice.beatFrameIndices;
+      beatIntensitiesForRender = highlightSlice.beatIntensities;
       framesCountForRender = highlightSlice.highlightFrames;
       reportProgress(PRE_PROCESS_PROGRESS_SHARE + POST_AUDIO_PROGRESS_SHARE);
     } else {
       reportProgress(PRE_PROCESS_PROGRESS_SHARE + POST_AUDIO_PROGRESS_SHARE);
     }
 
+    const autoEditVideo = getAutoEditVideo(config);
+    const cameraShakeEnabled = getCameraShakeEnabled(config);
+    const shakeDelayFrames = Math.round(FPS * CAMERA_SHAKE_DELAY_SECONDS);
+    let trackTempo: TempoEstimate | null = null;
+    if (autoEditVideo) {
+      const sampleRateNum = Number(sampleRate);
+      const maxSamples = Math.floor(sampleRateNum * MAX_TEMPO_ANALYSIS_SECONDS);
+      const tempoBuffer = audioBuffer.length > maxSamples
+        ? audioBuffer.slice(0, maxSamples)
+        : audioBuffer;
+      trackTempo = estimateTempo(pcmU8ToFloatSamples(tempoBuffer), sampleRateNum, FPS);
+    }
+
     const separateHighlightFiles =
       autoHighlight &&
       highlightSlice &&
@@ -536,7 +599,9 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
       outPath: string;
       spectrums: number[][];
       beatIndices: number[];
+      beatIntensities: number[];
       frameCount: number;
+      startFrame: number;
       audioSegment: import('./highlight').HighlightAudioSegment | undefined;
     };
 
@@ -551,7 +616,9 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
             outPath: numberedPath,
             spectrums: run.spectrums,
             beatIndices: run.beatFrameIndices,
+            beatIntensities: run.beatIntensities,
             frameCount: run.highlightFrames,
+            startFrame: run.startFrame,
             audioSegment: run.audioSegment,
           };
         })
@@ -560,7 +627,9 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
             outPath: outVideoPath,
             spectrums: spectrumsForRender,
             beatIndices: beatIndicesForRender,
+            beatIntensities: beatIntensitiesForRender,
             frameCount: framesCountForRender,
+            startFrame: highlightSlice?.startFrame ?? 0,
             audioSegment:
               autoHighlight &&
               highlightSlice &&
@@ -586,7 +655,14 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
     let exitReason: string | undefined;
     const outputVideoFiles: string[] = [];
     try {
-      passLoop: for (const pass of passes) {
+      passLoop: for (let passIndex = 0; passIndex < passes.length; passIndex++) {
+        const pass = passes[passIndex];
+        const tempo = trackTempo
+          ? tempoForWindow(trackTempo, pass.startFrame, FPS, pass.frameCount, pass.beatIndices)
+          : null;
+        const shakeAmplitudes = tempo
+          ? buildCutShakeAmplitudes(tempo.periodFrames)
+          : undefined;
         const {
           backgroundWidth,
           backgroundHeight,
@@ -596,19 +672,32 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
           videoFrameSize,
           encodeVideoFrame,
           concatFilePath,
+          cutFrameIndices,
         } = await prepareBackgroundForRender({
           useVideoBackground,
-          backgroundVideoPath,
+          backgroundVideoPaths,
           backgroundImagePath,
           beatFrameIndices: pass.beatIndices,
+          beatIntensities: pass.beatIntensities,
           framesCount: pass.frameCount,
           outputResolution,
           fps: FPS,
-          autoEditVideo: getAutoEditVideo(config),
+          autoEditVideo,
           readVideoFrameTimeout: videoTimeouts.readVideoFrame,
+          ...(tempo ? { tempo } : {}),
+          // Each separate highlight output opens with a different video from the array.
+          startVideoIndex: passIndex,
         });
         reportRenderProgress();
 
+        const beatShakeFrames = () => (tempo
+          ? beatGridFrameIndices(tempo, pass.frameCount, CAMERA_SHAKE_EVERY_BEATS)
+          : pass.beatIndices.filter(frameIndex => frameIndex > 0).filter((_, i) => i % CAMERA_SHAKE_EVERY_BEATS === 0));
+        const shakeFrames = new Set(
+          autoEditVideo && cameraShakeEnabled
+            ? (cutFrameIndices.length > 0 ? cutFrameIndices : beatShakeFrames())
+            : [],
+        );
         const createVisualizerFrame = createVisualizerFrameGenerator(
           config, backgroundWidth, backgroundHeight, defaultColor, spectrumBusMargin
         );
@@ -648,6 +737,10 @@ export const renderAudioVisualizer = (config: Config, onProgress?: (progress: nu
             spectrum,
           };
           const frameImage = createVisualizerFrame(commonVisualizerFrameProps);
+          const shakeOffset = getCutShakeOffset(i, shakeFrames, shakeAmplitudes, shakeDelayFrames);
+          if (shakeOffset.x !== 0 || shakeOffset.y !== 0) {
+            applyCameraShake(frameImage, backgroundWidth, backgroundHeight, shakeOffset.x, shakeOffset.y);
+          }
           const isFrameProcessed = ffmpegVideoWriter.stdin.write(frameImage.data);
           if (!isFrameProcessed) {
             const isDrained = await waitDrain(

package/src/subtitleConvert.ts

@@ -1,63 +1,63 @@
-/** LRC timestamp line: [mm:ss.xx] text — hundredths optional after dot. */
-const LRC_LINE = /^\[(\d+):(\d+)(?:\.(\d+))?\]\s*(.*)$/;
-
-export const isLikelyLrc = (text: string): boolean => {
-  const body = text.replace(/^\uFEFF/, '');
-  for (const line of body.split(/\r?\n/)) {
-    const t = line.trim();
-    if (t.length === 0) {
-      continue;
-    }
-    return LRC_LINE.test(t);
-  }
-  return false;
-};
-
-const msToSrtTime = (ms: number): string => {
-  const h = Math.floor(ms / 3600000);
-  const m = Math.floor((ms % 3600000) / 60000);
-  const s = Math.floor((ms % 60000) / 1000);
-  const milli = ms % 1000;
-  const pad = (n: number, w: number) => String(n).padStart(w, '0');
-  return `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)},${pad(milli, 3)}`;
-};
-
-const DEFAULT_TAIL_MS = 2000;
-
-export const lrcToSrt = (lrc: string): string => {
-  const body = lrc.replace(/^\uFEFF/, '');
-  const entries: { startMs: number; text: string }[] = [];
-  for (const line of body.split(/\r?\n/)) {
-    const match = line.trim().match(LRC_LINE);
-    if (!match) {
-      continue;
-    }
-    const min = parseInt(match[1], 10);
-    const sec = parseInt(match[2], 10);
-    const centisec =
-      match[3] !== undefined
-        ? parseInt(match[3].padEnd(2, '0').slice(0, 2), 10)
-        : 0;
-    const startMs = (min * 60 + sec) * 1000 + centisec * 10;
-    const text = (match[4] || '').trim();
-    if (text.length > 0) {
-      entries.push({ startMs, text });
-    }
-  }
-  entries.sort((a, b) => a.startMs - b.startMs);
-  let out = '';
-  for (let i = 0; i < entries.length; i++) {
-    const start = entries[i].startMs;
-    const end =
-      i + 1 < entries.length
-        ? Math.max(entries[i + 1].startMs, start + 1)
-        : start + DEFAULT_TAIL_MS;
-    out += `${i + 1}\n`;
-    out += `${msToSrtTime(start)} --> ${msToSrtTime(end)}\n`;
-    out += `${entries[i].text}\n\n`;
-  }
-  return out.length > 0 ? out.replace(/\n*$/, '\n') : '';
-};
-
-export const normalizeInlineSubtitlesToSrt = (text: string): string =>
-  isLikelyLrc(text) ? lrcToSrt(text) : text;
+/** LRC timestamp line: [mm:ss.xx] text — hundredths optional after dot. */
+const LRC_LINE = /^\[(\d+):(\d+)(?:\.(\d+))?\]\s*(.*)$/;
+
+export const isLikelyLrc = (text: string): boolean => {
+  const body = text.replace(/^\uFEFF/, '');
+  for (const line of body.split(/\r?\n/)) {
+    const t = line.trim();
+    if (t.length === 0) {
+      continue;
+    }
+    return LRC_LINE.test(t);
+  }
+  return false;
+};
+
+const msToSrtTime = (ms: number): string => {
+  const h = Math.floor(ms / 3600000);
+  const m = Math.floor((ms % 3600000) / 60000);
+  const s = Math.floor((ms % 60000) / 1000);
+  const milli = ms % 1000;
+  const pad = (n: number, w: number) => String(n).padStart(w, '0');
+  return `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)},${pad(milli, 3)}`;
+};
+
+const DEFAULT_TAIL_MS = 2000;
+
+export const lrcToSrt = (lrc: string): string => {
+  const body = lrc.replace(/^\uFEFF/, '');
+  const entries: { startMs: number; text: string }[] = [];
+  for (const line of body.split(/\r?\n/)) {
+    const match = line.trim().match(LRC_LINE);
+    if (!match) {
+      continue;
+    }
+    const min = parseInt(match[1], 10);
+    const sec = parseInt(match[2], 10);
+    const centisec =
+      match[3] !== undefined
+        ? parseInt(match[3].padEnd(2, '0').slice(0, 2), 10)
+        : 0;
+    const startMs = (min * 60 + sec) * 1000 + centisec * 10;
+    const text = (match[4] || '').trim();
+    if (text.length > 0) {
+      entries.push({ startMs, text });
+    }
+  }
+  entries.sort((a, b) => a.startMs - b.startMs);
+  let out = '';
+  for (let i = 0; i < entries.length; i++) {
+    const start = entries[i].startMs;
+    const end =
+      i + 1 < entries.length
+        ? Math.max(entries[i + 1].startMs, start + 1)
+        : start + DEFAULT_TAIL_MS;
+    out += `${i + 1}\n`;
+    out += `${msToSrtTime(start)} --> ${msToSrtTime(end)}\n`;
+    out += `${entries[i].text}\n\n`;
+  }
+  return out.length > 0 ? out.replace(/\n*$/, '\n') : '';
+};
+
+export const normalizeInlineSubtitlesToSrt = (text: string): string =>
+  isLikelyLrc(text) ? lrcToSrt(text) : text;

package/src/tests/audio.test.ts

@@ -1,96 +1,102 @@
-import { expect } from 'chai';
-import { Readable, Writable, Pipe } from 'stream';
-import child_process, { ChildProcessWithoutNullStreams } from 'child_process';
-import {
-  bufferToUInt8,
-  normalizeAudioData,
-  spawnFfmpegAudioReader,
-  skipEvery,
-  getPeaks,
-  correctPeaks,
-  createSpectrumsProcessor,
-} from '../audio';
-import { createSandbox } from 'sinon';
-
-let childProcessStream = {
-  stdin: new Writable(),
-  stderr: new Readable(),
-};
-
-const videoSandbox = createSandbox();
-
-describe('audio', function () {
-
-  this.beforeAll(function () {
-    videoSandbox.stub(child_process, 'spawn').returns(childProcessStream as ChildProcessWithoutNullStreams);
-  });
-
-  this.afterAll(function () {
-    videoSandbox.restore();
-  });
-
-  it('bufferToUInt8', function () {
-    const expected = [1, 2, 3, 4, 5];
-    const buffer = Buffer.from(new Uint8Array(expected));
-    const result = bufferToUInt8(buffer, 0, 5);
-    expect(result).deep.equal(expected);
-  });
-
-  it('normalizeAudioData', function () {
-    const result = normalizeAudioData([4, 5, 23, 78, 2]);
-    const expected = [-0.96875, -0.9609375, -0.8203125, -0.390625, -0.984375];
-    expect(result).deep.equal(expected);
-  });
-
-  it('spawnFfmpegAudioReader', function (done) {
-    const childProcessReadableStream = new Readable();
-    const childProcessWritableStream = new Writable();
-    childProcessReadableStream._read = () => { done(); };
-    (<Pipe>childProcessWritableStream.pipe) = () => childProcessWritableStream;
-
-    childProcessStream.stdin = childProcessWritableStream;
-    childProcessStream.stderr = childProcessReadableStream;
-
-    const ffmpegProcess = spawnFfmpegAudioReader('filename', 'format');
-    ffmpegProcess.stderr.on('data', (data) => {
-      expect(data).equal('some data');
-    });
-
-    childProcessStream.stderr.emit('data', 'some data');
-  });
-
-  it('skipEvery', () => {
-    const sampleData = [1, 2, 3, 4];
-    const result = sampleData.filter(skipEvery(2));
-    const expected = [1, 3];
-    expect(result).deep.equal(expected);
-  });
-
-  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('createSpectrumsProcessor', () => {
-    const spectrumsProcessor = createSpectrumsProcessor(44100);
-    
-    const frame0 = spectrumsProcessor(() => ([1, 2, 3, 4]));
-    expect(frame0).to.have.length(24);
-    const frame1 = spectrumsProcessor(() => ([2, 2, 6, 2]));
-    expect(frame1).to.have.length(24);
-  });
-});
+import { expect } from 'chai';
+import { Readable, Writable, Pipe } from 'stream';
+import child_process, { ChildProcessWithoutNullStreams } from 'child_process';
+import {
+  bufferToUInt8,
+  normalizeAudioData,
+  pcmU8ToFloatSamples,
+  spawnFfmpegAudioReader,
+  skipEvery,
+  getPeaks,
+  correctPeaks,
+  createSpectrumsProcessor,
+} from '../audio';
+import { createSandbox } from 'sinon';
+
+let childProcessStream = {
+  stdin: new Writable(),
+  stderr: new Readable(),
+};
+
+const videoSandbox = createSandbox();
+
+describe('audio', function () {
+
+  this.beforeAll(function () {
+    videoSandbox.stub(child_process, 'spawn').returns(childProcessStream as ChildProcessWithoutNullStreams);
+  });
+
+  this.afterAll(function () {
+    videoSandbox.restore();
+  });
+
+  it('bufferToUInt8', function () {
+    const expected = [1, 2, 3, 4, 5];
+    const buffer = Buffer.from(new Uint8Array(expected));
+    const result = bufferToUInt8(buffer, 0, 5);
+    expect(result).deep.equal(expected);
+  });
+
+  it('normalizeAudioData', function () {
+    const result = normalizeAudioData([4, 5, 23, 78, 2]);
+    const expected = [-0.96875, -0.9609375, -0.8203125, -0.390625, -0.984375];
+    expect(result).deep.equal(expected);
+  });
+
+  it('pcmU8ToFloatSamples', function () {
+    const buffer = Buffer.from([128, 255, 0]);
+    expect(pcmU8ToFloatSamples(buffer)).deep.equal([0, 127 / 128, -1]);
+  });
+
+  it('spawnFfmpegAudioReader', function (done) {
+    const childProcessReadableStream = new Readable();
+    const childProcessWritableStream = new Writable();
+    childProcessReadableStream._read = () => { done(); };
+    (<Pipe>childProcessWritableStream.pipe) = () => childProcessWritableStream;
+
+    childProcessStream.stdin = childProcessWritableStream;
+    childProcessStream.stderr = childProcessReadableStream;
+
+    const ffmpegProcess = spawnFfmpegAudioReader('filename', 'format');
+    ffmpegProcess.stderr.on('data', (data) => {
+      expect(data).equal('some data');
+    });
+
+    childProcessStream.stderr.emit('data', 'some data');
+  });
+
+  it('skipEvery', () => {
+    const sampleData = [1, 2, 3, 4];
+    const result = sampleData.filter(skipEvery(2));
+    const expected = [1, 3];
+    expect(result).deep.equal(expected);
+  });
+
+  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('createSpectrumsProcessor', () => {
+    const spectrumsProcessor = createSpectrumsProcessor(44100);
+    
+    const frame0 = spectrumsProcessor(() => ([1, 2, 3, 4]));
+    expect(frame0).to.have.length(24);
+    const frame1 = spectrumsProcessor(() => ([2, 2, 6, 2]));
+    expect(frame1).to.have.length(24);
+  });
+});