nodejs-audio-visualizer 4.2.6 → 4.3.7

package/src/index.ts

@@ -1,9 +1,12 @@
 import path from 'path';
+import { readFileSync } from 'fs';
 import {
   getAudioFilePath,
   getBackgroundImagePath,
   getBackgroundVideoPath,
   getOutVideoPath,
+  getSubtitleRenderSpec,
+  subtitleAlignmentToAss,
   getFPS,
   getSpectrumBusMargin,
   getSpectrumWidthAbsolute,
@@ -34,7 +37,8 @@ import {
 } from './config';
 import { createAudioBuffer, bufferToUInt8, createSpectrumsProcessor } from './audio';
 import { parseImage, getImageColor, getVideoFrameColor, invertColor, Color, convertToBmp, createSpectrumVisualizerFrameGenerator, createPolarVisualizerFrameGenerator, CreatePolarVisualizerFrameProps, CreateVisualizerFrameProps, CommonVisualizerFrameProps } from './image';
-import { spawnFfmpegVideoWriter, waitDrain, getVideoInfo, spawnVideoFrameReader, readVideoFrame, detectSceneChanges, buildBeatSyncedSegments, writeConcatFile, spawnConcatVideoFrameReader, cleanupConcatFile } from './video';
+import { normalizeInlineSubtitlesToSrt, lrcToSrt } from './subtitleConvert';
+import { spawnFfmpegVideoWriter, waitDrain, getVideoInfo, spawnVideoFrameReader, readVideoFrame, detectSceneChanges, buildBeatSyncedSegments, writeConcatFile, writeSubtitlesFile, spawnConcatVideoFrameReader, cleanupConcatFile, cleanupTempFile } from './video';
 import { createBpmEncoder, createBgrFrameEncoder, EncodedBmp } from './bpmEncoder';
 import { createBeatDetector } from './beats';
 export { BeatInfo, BeatDetectorOptions } from './beats';
@@ -66,6 +70,13 @@ export interface Config {
   };
   outVideo: {
     path: string;
+    subtitles?:
+      | string
+      | {
+          path?: string;
+          rawContent?: string;
+          alignment?: 'top' | 'middle' | 'bottom';
+        };
     fps?: number;
     resolution?: {
       width: number;
@@ -375,257 +386,293 @@ export interface RenderAudioVisualizerResult {
 }
 
 export const renderAudioVisualizer = (config: Config, onProgress?: (progress: number) => any, shouldStop?: () => boolean) =>
-  new Promise<RenderAudioVisualizerResult>(async (resolve) => {
-    if (config.outVideo.spectrum && config.outVideo.polar) {
-      throw new Error('Cannot use both "spectrum" and "polar" options. Please specify only one visualizer type.');
-    }
-    if (!config.image && !config.video) {
-      throw new Error('Either "image" or "video" must be specified as the background source.');
-    }
-    if (config.image && config.video) {
-      throw new Error('Cannot use both "image" and "video" options. Please specify only one background source.');
-    }
-
-    const audioFilePath = getAudioFilePath(config);
-    const outVideoPath = getOutVideoPath(config);
-    const backgroundVideoPath = getBackgroundVideoPath(config);
-    const backgroundImagePath = getBackgroundImagePath(config);
-    const useVideoBackground = !!backgroundVideoPath;
-
-    const audioReader = await createAudioBuffer(audioFilePath, FFMPEG_FORMAT);
-    const audioBuffer = audioReader.audioBuffer;
-    const sampleRate = audioReader.sampleRate;
-    if (!sampleRate) {
-      throw new Error('ffmpeg didn\'t show audio sample rate');
-    }
-
-    const spectrumBusMargin = getSpectrumBusMargin();
-    const FPS = getFPS(config);
-    const ffmpeg_cfr = getFfmpeg_cfr(config);
-    const ffmpeg_preset = getFfmpeg_preset(config);
-    const frame_processing_delay = getFrame_processing_delay(config);
-
-    const audioDuration = audioBuffer.length / sampleRate;
-    const framesCount = Math.trunc(audioDuration * FPS);
-    const outputResolution = getOutputResolution(config);
+  new Promise<RenderAudioVisualizerResult>(async (resolve, reject) => {
+    try {
+      if (config.outVideo.spectrum && config.outVideo.polar) {
+        throw new Error('Cannot use both "spectrum" and "polar" options. Please specify only one visualizer type.');
+      }
+      if (!config.image && !config.video) {
+        throw new Error('Either "image" or "video" must be specified as the background source.');
+      }
+      if (config.image && config.video) {
+        throw new Error('Cannot use both "image" and "video" options. Please specify only one background source.');
+      }
 
-    let maxProgressReported = -1;
-    const reportProgress = (progress: number) => {
-      if (!onProgress) {
-        return;
+      const audioFilePath = getAudioFilePath(config);
+      const outVideoPath = getOutVideoPath(config);
+      const subtitleSpec = getSubtitleRenderSpec(config);
+      let subtitleFilePath: string | undefined;
+      let subtitleFileIsTemporary = false;
+      let subtitleAlignmentAss = 2;
+      if (subtitleSpec) {
+        subtitleAlignmentAss = subtitleAlignmentToAss(subtitleSpec.alignment);
+        if (subtitleSpec.source.kind === 'file') {
+          const absPath = subtitleSpec.source.path;
+          const ext = path.extname(absPath).toLowerCase();
+          if (ext === '.lrc') {
+            const raw = readFileSync(absPath, 'utf-8');
+            subtitleFilePath = writeSubtitlesFile(lrcToSrt(raw));
+            subtitleFileIsTemporary = true;
+          } else {
+            subtitleFilePath = absPath;
+          }
+        } else {
+          subtitleFilePath = writeSubtitlesFile(
+            normalizeInlineSubtitlesToSrt(subtitleSpec.source.text),
+          );
+          subtitleFileIsTemporary = true;
+        }
       }
-      const normalized = +Math.min(100, Math.max(0, progress)).toFixed(2);
-      if (normalized <= maxProgressReported) {
-        return;
+      const backgroundVideoPath = getBackgroundVideoPath(config);
+      const backgroundImagePath = getBackgroundImagePath(config);
+      const useVideoBackground = !!backgroundVideoPath;
+
+      const audioReader = await createAudioBuffer(audioFilePath, FFMPEG_FORMAT);
+      const audioBuffer = audioReader.audioBuffer;
+      const sampleRate = audioReader.sampleRate;
+      if (!sampleRate) {
+        throw new Error('ffmpeg didn\'t show audio sample rate');
       }
-      maxProgressReported = normalized;
-      onProgress(normalized);
-    };
-    reportProgress(0);
 
-    const preprocessed = await preProcessAudio(
-      audioBuffer,
-      sampleRate,
-      FPS,
-      framesCount,
-      (progress: number) => {
-        reportProgress(progress);
-      },
-    );
-    reportProgress(PRE_PROCESS_PROGRESS_SHARE);
-
-    const autoHighlight = getAudioAutoHighlight(config);
-    let spectrumsForRender = preprocessed.spectrums;
-    let beatIndicesForRender = preprocessed.beatFrameIndices;
-    let framesCountForRender = framesCount;
-    type HighlightSliceResult = ReturnType<typeof computeHighlightSlice> extends Promise<
-      infer R
-    >
-      ? R
-      : never;
-    let highlightSlice: HighlightSliceResult | undefined;
-
-    if (autoHighlight) {
-      reportProgress(PRE_PROCESS_PROGRESS_SHARE + 1);
-      highlightSlice = await computeHighlightSlice(
+      const spectrumBusMargin = getSpectrumBusMargin();
+      const FPS = getFPS(config);
+      const ffmpeg_cfr = getFfmpeg_cfr(config);
+      const ffmpeg_preset = getFfmpeg_preset(config);
+      const frame_processing_delay = getFrame_processing_delay(config);
+
+      const audioDuration = audioBuffer.length / sampleRate;
+      const framesCount = Math.trunc(audioDuration * FPS);
+      const outputResolution = getOutputResolution(config);
+
+      let maxProgressReported = -1;
+      const reportProgress = (progress: number) => {
+        if (!onProgress) {
+          return;
+        }
+        const normalized = +Math.min(100, Math.max(0, progress)).toFixed(2);
+        if (normalized <= maxProgressReported) {
+          return;
+        }
+        maxProgressReported = normalized;
+        onProgress(normalized);
+      };
+      reportProgress(0);
+
+      const preprocessed = await preProcessAudio(
+        audioBuffer,
+        sampleRate,
         FPS,
         framesCount,
-        preprocessed.spectrums,
-        preprocessed.beatEvents,
-        getAudioAutoHighlightCount(config),
+        (progress: number) => {
+          reportProgress(progress);
+        },
       );
-      spectrumsForRender = highlightSlice.spectrums;
-      beatIndicesForRender = highlightSlice.beatFrameIndices;
-      framesCountForRender = highlightSlice.highlightFrames;
-      reportProgress(PRE_PROCESS_PROGRESS_SHARE + POST_AUDIO_PROGRESS_SHARE);
-    } else {
-      reportProgress(PRE_PROCESS_PROGRESS_SHARE + POST_AUDIO_PROGRESS_SHARE);
-    }
-
-    const separateHighlightFiles =
-      autoHighlight &&
-      highlightSlice &&
-      highlightSlice.runs.length > 1;
-
-    type VideoRenderPass = {
-      outPath: string;
-      spectrums: number[][];
-      beatIndices: number[];
-      frameCount: number;
-      audioSegment: import('./highlight').HighlightAudioSegment | undefined;
-    };
+      reportProgress(PRE_PROCESS_PROGRESS_SHARE);
+
+      const autoHighlight = getAudioAutoHighlight(config);
+      let spectrumsForRender = preprocessed.spectrums;
+      let beatIndicesForRender = preprocessed.beatFrameIndices;
+      let framesCountForRender = framesCount;
+      type HighlightSliceResult = ReturnType<typeof computeHighlightSlice> extends Promise<
+        infer R
+      >
+        ? R
+        : never;
+      let highlightSlice: HighlightSliceResult | undefined;
+
+      if (autoHighlight) {
+        reportProgress(PRE_PROCESS_PROGRESS_SHARE + 1);
+        highlightSlice = await computeHighlightSlice(
+          FPS,
+          framesCount,
+          preprocessed.spectrums,
+          preprocessed.beatEvents,
+          getAudioAutoHighlightCount(config),
+        );
+        spectrumsForRender = highlightSlice.spectrums;
+        beatIndicesForRender = highlightSlice.beatFrameIndices;
+        framesCountForRender = highlightSlice.highlightFrames;
+        reportProgress(PRE_PROCESS_PROGRESS_SHARE + POST_AUDIO_PROGRESS_SHARE);
+      } else {
+        reportProgress(PRE_PROCESS_PROGRESS_SHARE + POST_AUDIO_PROGRESS_SHARE);
+      }
 
-    const passes: VideoRenderPass[] =
-      separateHighlightFiles && highlightSlice
-      ? highlightSlice.runs.map((run, i) => {
-          const dir = path.dirname(outVideoPath);
-          const ext = path.extname(outVideoPath);
-          const base = path.basename(outVideoPath, ext);
-          const numberedPath = path.resolve(dir, `${base}-${i + 1}${ext}`);
-          return {
-            outPath: numberedPath,
-            spectrums: run.spectrums,
-            beatIndices: run.beatFrameIndices,
-            frameCount: run.highlightFrames,
-            audioSegment: run.audioSegment,
-          };
-        })
-      : [
-          {
-            outPath: outVideoPath,
-            spectrums: spectrumsForRender,
-            beatIndices: beatIndicesForRender,
-            frameCount: framesCountForRender,
-            audioSegment:
-              autoHighlight &&
-              highlightSlice &&
-              highlightSlice.audioSegments.length > 0
-                ? highlightSlice.audioSegments[0]
-                : undefined,
-          },
-        ];
-
-    const totalPassFrames =
-      passes.reduce((sum, pass) => sum + pass.frameCount, 0);
-    const totalRenderMilestones = totalPassFrames + (passes.length * 2);
-    let renderMilestonesCompleted = 0;
-    const reportRenderProgress = (milestoneIncrement = 1) => {
-      renderMilestonesCompleted += milestoneIncrement;
-      reportProgress(
-        PRE_PROCESS_PROGRESS_SHARE
-          + POST_AUDIO_PROGRESS_SHARE
-          + (RENDER_PROGRESS_SHARE * renderMilestonesCompleted / Math.max(1, totalRenderMilestones)),
-      );
-    };
-    let lastExitCode = 0;
-    const outputVideoFiles: string[] = [];
-
-    passLoop: for (const pass of passes) {
-      const {
-        backgroundWidth,
-        backgroundHeight,
-        defaultColor,
-        staticBackgroundBuffer,
-        videoFrameReader,
-        videoFrameSize,
-        encodeVideoFrame,
-        concatFilePath,
-      } = await prepareBackgroundForRender({
-        useVideoBackground,
-        backgroundVideoPath,
-        backgroundImagePath,
-        beatFrameIndices: pass.beatIndices,
-        framesCount: pass.frameCount,
-        outputResolution,
-        fps: FPS,
-        autoEditVideo: getAutoEditVideo(config),
-      });
-      reportRenderProgress();
+      const separateHighlightFiles =
+        autoHighlight &&
+        highlightSlice &&
+        highlightSlice.runs.length > 1;
+
+      type VideoRenderPass = {
+        outPath: string;
+        spectrums: number[][];
+        beatIndices: number[];
+        frameCount: number;
+        audioSegment: import('./highlight').HighlightAudioSegment | undefined;
+      };
+
+      const passes: VideoRenderPass[] =
+        separateHighlightFiles && highlightSlice
+        ? highlightSlice.runs.map((run, i) => {
+            const dir = path.dirname(outVideoPath);
+            const ext = path.extname(outVideoPath);
+            const base = path.basename(outVideoPath, ext);
+            const numberedPath = path.resolve(dir, `${base}-${i + 1}${ext}`);
+            return {
+              outPath: numberedPath,
+              spectrums: run.spectrums,
+              beatIndices: run.beatFrameIndices,
+              frameCount: run.highlightFrames,
+              audioSegment: run.audioSegment,
+            };
+          })
+        : [
+            {
+              outPath: outVideoPath,
+              spectrums: spectrumsForRender,
+              beatIndices: beatIndicesForRender,
+              frameCount: framesCountForRender,
+              audioSegment:
+                autoHighlight &&
+                highlightSlice &&
+                highlightSlice.audioSegments.length > 0
+                  ? highlightSlice.audioSegments[0]
+                  : undefined,
+            },
+          ];
+
+      const totalPassFrames =
+        passes.reduce((sum, pass) => sum + pass.frameCount, 0);
+      const totalRenderMilestones = totalPassFrames + (passes.length * 2);
+      let renderMilestonesCompleted = 0;
+      const reportRenderProgress = (milestoneIncrement = 1) => {
+        renderMilestonesCompleted += milestoneIncrement;
+        reportProgress(
+          PRE_PROCESS_PROGRESS_SHARE
+            + POST_AUDIO_PROGRESS_SHARE
+            + (RENDER_PROGRESS_SHARE * renderMilestonesCompleted / Math.max(1, totalRenderMilestones)),
+        );
+      };
+      let lastExitCode = 0;
+      const outputVideoFiles: string[] = [];
+      try {
+        passLoop: for (const pass of passes) {
+          const {
+            backgroundWidth,
+            backgroundHeight,
+            defaultColor,
+            staticBackgroundBuffer,
+            videoFrameReader,
+            videoFrameSize,
+            encodeVideoFrame,
+            concatFilePath,
+          } = await prepareBackgroundForRender({
+            useVideoBackground,
+            backgroundVideoPath,
+            backgroundImagePath,
+            beatFrameIndices: pass.beatIndices,
+            framesCount: pass.frameCount,
+            outputResolution,
+            fps: FPS,
+            autoEditVideo: getAutoEditVideo(config),
+          });
+          reportRenderProgress();
+
+          const createVisualizerFrame = createVisualizerFrameGenerator(
+            config, backgroundWidth, backgroundHeight, defaultColor, spectrumBusMargin
+          );
+
+          const ffmpegVideoWriter = spawnFfmpegVideoWriter({
+            audioFilename: audioFilePath,
+            videoFileName: pass.outPath,
+            ...(subtitleFilePath && {
+              subtitleFilename: subtitleFilePath,
+              subtitleAlignmentAss,
+            }),
+            fps: FPS,
+            ...(pass.audioSegment && { audioSegment: pass.audioSegment }),
+            ...(ffmpeg_cfr && { crf: ffmpeg_cfr }),
+            ...(ffmpeg_preset && { preset: ffmpeg_preset }),
+          });
+
+          const exitPromise = new Promise<number>(res => {
+            let settled = false;
+            ffmpegVideoWriter.on('exit', (code: number | null) => {
+              if (settled) {
+                return;
+              }
+              settled = true;
+              res(code ?? 0);
+            });
+          });
+
+          let stoppedEarly = false;
+          for (let i = 0; i < pass.frameCount; i++) {
+            const spectrum = pass.spectrums[i];
+
+            const backgroundImageBuffer = await resolveBackgroundFrameBuffer({
+              frameIndex: i,
+              useVideoBackground,
+              videoFrameReader,
+              videoFrameSize,
+              encodeVideoFrame,
+              staticBackgroundBuffer,
+            });
+
+            const commonVisualizerFrameProps: CommonVisualizerFrameProps = {
+              backgroundImageBuffer,
+              spectrum,
+            };
+            const frameImage = createVisualizerFrame(commonVisualizerFrameProps);
+            const isFrameProcessed = ffmpegVideoWriter.stdin.write(frameImage.data);
+            if (!isFrameProcessed) {
+              const isDrained = await waitDrain(ffmpegVideoWriter.stdin, ffmpegVideoWriter);
+              if (!isDrained) {
+                stoppedEarly = true;
+                break;
+              }
+            }
+            if (shouldStop && shouldStop()) {
+              stoppedEarly = true;
+              break;
+            }
+            if (frame_processing_delay) {
+              await sleep(frame_processing_delay);
+            }
+            await waitForEventLoop();
+            reportRenderProgress();
+          }
 
-      const createVisualizerFrame = createVisualizerFrameGenerator(
-        config, backgroundWidth, backgroundHeight, defaultColor, spectrumBusMargin
-      );
+          if (videoFrameReader) {
+            videoFrameReader.kill();
+          }
+          if (concatFilePath) {
+            cleanupConcatFile(concatFilePath);
+          }
+          ffmpegVideoWriter.stdin.end();
 
-      const ffmpegVideoWriter = spawnFfmpegVideoWriter({
-        audioFilename: audioFilePath,
-        videoFileName: pass.outPath,
-        fps: FPS,
-        ...(pass.audioSegment && { audioSegment: pass.audioSegment }),
-        ...(ffmpeg_cfr && { crf: ffmpeg_cfr }),
-        ...(ffmpeg_preset && { preset: ffmpeg_preset }),
-      });
+          lastExitCode = await exitPromise;
+          reportRenderProgress();
 
-      const exitPromise = new Promise<number>(res => {
-        let settled = false;
-        ffmpegVideoWriter.on('exit', (code: number | null) => {
-          if (settled) {
-            return;
+          if (lastExitCode === 0 && !stoppedEarly) {
+            outputVideoFiles.push(pass.outPath);
           }
-          settled = true;
-          res(code ?? 0);
-        });
-      });
 
-      let stoppedEarly = false;
-      for (let i = 0; i < pass.frameCount; i++) {
-        const spectrum = pass.spectrums[i];
-
-        const backgroundImageBuffer = await resolveBackgroundFrameBuffer({
-          frameIndex: i,
-          useVideoBackground,
-          videoFrameReader,
-          videoFrameSize,
-          encodeVideoFrame,
-          staticBackgroundBuffer,
-        });
-
-        const commonVisualizerFrameProps: CommonVisualizerFrameProps = {
-          backgroundImageBuffer,
-          spectrum,
-        };
-        const frameImage = createVisualizerFrame(commonVisualizerFrameProps);
-        const isFrameProcessed = ffmpegVideoWriter.stdin.write(frameImage.data);
-        if (!isFrameProcessed) {
-          const isDrained = await waitDrain(ffmpegVideoWriter.stdin, ffmpegVideoWriter);
-          if (!isDrained) {
-            stoppedEarly = true;
-            break;
+          if (stoppedEarly || lastExitCode !== 0) {
+            break passLoop;
           }
         }
-        if (shouldStop && shouldStop()) {
-          stoppedEarly = true;
-          break;
-        }
-        if (frame_processing_delay) {
-          await sleep(frame_processing_delay);
-        }
-        await waitForEventLoop();
-        reportRenderProgress();
-      }
-
-      if (videoFrameReader) {
-        videoFrameReader.kill();
-      }
-      if (concatFilePath) {
-        cleanupConcatFile(concatFilePath);
-      }
-      ffmpegVideoWriter.stdin.end();
-
-      lastExitCode = await exitPromise;
-      reportRenderProgress();
 
-      if (lastExitCode === 0 && !stoppedEarly) {
-        outputVideoFiles.push(pass.outPath);
-      }
+        if (lastExitCode === 0 && outputVideoFiles.length === passes.length) {
+          reportProgress(100);
+        }
 
-      if (stoppedEarly || lastExitCode !== 0) {
-        break passLoop;
+        resolve({ exitCode: lastExitCode, outputVideoFiles });
+      } finally {
+        if (subtitleFilePath && subtitleFileIsTemporary) {
+          cleanupTempFile(subtitleFilePath);
+        }
       }
+    } catch (error) {
+      reject(error);
     }
-
-    if (lastExitCode === 0 && outputVideoFiles.length === passes.length) {
-      reportProgress(100);
-    }
-
-    resolve({ exitCode: lastExitCode, outputVideoFiles });
   });

package/src/subtitleConvert.ts

@@ -0,0 +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;