waha-shared 1.0.343 → 1.0.345

package/dist/functions/ffmpeg.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIDEO_REMOTION_OVERRIDE_ARGS = exports.VIDEO_AUDIO_ENCODE_ARGS = exports.VIDEO_ENCODE_ARGS = exports.VIDEO_ENCODE_SETTINGS = void 0;
+exports.concatAudio = concatAudio;
+exports.generateSilence = generateSilence;
+exports.extractAudioSegment = extractAudioSegment;
+exports.extractVideoAudio = extractVideoAudio;
+exports.normalizeAudio = normalizeAudio;
+exports.compressVideo = compressVideo;
+exports.mixAudioWithMusic = mixAudioWithMusic;
+exports.getDurationFromFile = getDurationFromFile;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
+function exec(cmd, args) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)(cmd, args, { maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err)
+                reject(new Error(`${cmd} failed: ${stderr}`));
+            else
+                resolve({ stdout, stderr });
+        });
+    });
+}
+/** MP3 encoder used across all ffmpeg commands. */
+const CODEC = ['-c:a', 'libmp3lame'];
+/**
+ * Target audio bitrate — 64 kbps is a good balance of quality and file size for
+ * speech.
+ */
+const BITRATE = ['-b:a', '64k'];
+/** Sample rate — 22050 Hz is sufficient for speech content. */
+const SAMPLE_RATE = ['-ar', '22050'];
+/** Audio channels: stereo (2 channels). */
+const CHANNELS = ['-ac', '2'];
+/** Concatenate audio files using ffmpeg's concat demuxer. */
+async function concatAudio(files, output) {
+    const dir = await (0, promises_1.mkdtemp)((0, path_1.join)((0, os_1.tmpdir)(), 'ffconcat-'));
+    const listFile = (0, path_1.join)(dir, 'list.txt');
+    await (0, promises_1.writeFile)(listFile, files.map((f) => `file '${f}'`).join('\n'));
+    await exec('ffmpeg', [
+        // Use the concat demuxer to join multiple input files
+        '-f',
+        'concat',
+        // Allow absolute paths and paths outside the working directory in the list file
+        '-safe',
+        '0',
+        // Input: the generated list file containing paths to all audio segments
+        '-i',
+        listFile,
+        // FFmpeg 8.0 introduced stricter AVFrame buffer alignment requirements for
+        // libmp3lame. The concat demuxer produces frames that don't meet this new
+        // padding requirement, causing "inadequate AVFrame plane padding" errors.
+        // aresample forces frames to be reallocated with proper alignment as a workaround.
+        '-af',
+        'aresample=resampler=swr',
+        ...CODEC,
+        ...BITRATE,
+        ...SAMPLE_RATE,
+        ...CHANNELS,
+        '-y',
+        output,
+    ]);
+}
+/** Generate a silence MP3 of the given duration in seconds. */
+async function generateSilence(duration, output) {
+    await exec('ffmpeg', [
+        // Use the Libavfilter virtual device as the input format
+        '-f',
+        'lavfi',
+        // Input: null audio source generating silence at 22050 Hz in stereo
+        '-i',
+        'anullsrc=r=22050:cl=stereo',
+        // Duration: stop after this many seconds
+        '-t',
+        String(duration),
+        ...CODEC,
+        ...BITRATE,
+        ...CHANNELS,
+        '-y',
+        output,
+    ]);
+}
+/** Extract an audio segment from a file by start/end times (seconds). */
+async function extractAudioSegment({ endTime, input, output, startTime, }) {
+    await exec('ffmpeg', [
+        // Seek to this start time (seconds) before reading input — placed before -i for fast seeking
+        '-ss',
+        String(startTime),
+        // Duration: read this many seconds of audio (endTime - startTime)
+        '-t',
+        String(endTime - startTime),
+        // Input audio file to extract from
+        '-i',
+        input,
+        // FFmpeg 8.0 workaround: force frame reallocation to satisfy libmp3lame's
+        // stricter AVFrame buffer alignment requirements (see concatAudio).
+        '-af',
+        'aresample=resampler=swr',
+        ...CODEC,
+        ...BITRATE,
+        ...SAMPLE_RATE,
+        ...CHANNELS,
+        '-y',
+        output,
+    ]);
+}
+/** Extract the audio track from a video file and re-encode to MP3. */
+async function extractVideoAudio(input, output) {
+    await exec('ffmpeg', [
+        '-i',
+        input,
+        // Drop the video stream — we only want the audio track.
+        '-vn',
+        '-af',
+        'aresample=resampler=swr',
+        ...CODEC,
+        ...BITRATE,
+        ...SAMPLE_RATE,
+        ...CHANNELS,
+        '-y',
+        output,
+    ]);
+}
+/**
+ * Normalize audio to EBU R128 standard using ffmpeg-normalize. Returns the path
+ * to the normalized file. Skips if already exists.
+ */
+async function normalizeAudio(input) {
+    const output = input.replace(/\.mp3$/, '.normalized.mp3');
+    if ((0, fs_1.existsSync)(output))
+        return output;
+    await exec('ffmpeg-normalize', [
+        // Input file to normalize
+        input,
+        // Output file path
+        '-o',
+        output,
+        // Normalization type: EBU R128 loudness standard
+        '-nt',
+        'ebu',
+        // Target integrated loudness level: -15 LUFS
+        '-t',
+        '-15',
+        // True peak ceiling: -1.0 dBTP (prevents clipping after encoding)
+        '-tp',
+        '-1.0',
+        // Loudness range target: 7.0 LU (controls dynamic range)
+        '-lrt',
+        '7.0',
+        ...CODEC,
+        ...SAMPLE_RATE,
+    ]);
+    return output;
+}
+/**
+ * Source-of-truth for our standard H.264 / AAC video encode profile. Use these
+ * named values when calling APIs that take typed options (e.g. Remotion's
+ * `renderMedia`, which surfaces some flags as `codec` / `x264Preset` / `crf` /
+ * `pixelFormat` / `audioCodec` / `audioBitrate`). For direct ffmpeg shell-out,
+ * use the pre-flattened arg arrays below.
+ *
+ * The settings are tuned for concat-safe output:
+ *
+ * - `gop` of 30 puts a keyframe every 1s at 30fps, required for seekability and
+ *   `-c:v copy` concat
+ * - `bFrames: 0` prevents non-monotonic DTS at concat seams
+ * - `videoTrackTimescale` of 90000 matches Remotion's default timebase
+ */
+exports.VIDEO_ENCODE_SETTINGS = {
+    videoCodec: 'libx264',
+    /**
+     * Value for Remotion's `codec` option (which uses short names, not ffmpeg
+     * codec ids).
+     */
+    remotionCodec: 'h264',
+    crf: 23,
+    x264Preset: 'medium',
+    gop: 30,
+    bFrames: 0,
+    pixelFormat: 'yuv420p',
+    videoTrackTimescale: 90000,
+    audioCodec: 'aac',
+    audioSampleRate: 48000,
+    audioBitrate: '128k',
+};
+/**
+ * Ffmpeg args for H.264 video encoding (concat-safe). Includes `-movflags
+ * +faststart` so the muxed MP4 supports progressive HTTP playback.
+ */
+exports.VIDEO_ENCODE_ARGS = [
+    '-c:v',
+    exports.VIDEO_ENCODE_SETTINGS.videoCodec,
+    '-crf',
+    String(exports.VIDEO_ENCODE_SETTINGS.crf),
+    '-preset',
+    exports.VIDEO_ENCODE_SETTINGS.x264Preset,
+    '-g',
+    String(exports.VIDEO_ENCODE_SETTINGS.gop),
+    '-bf',
+    String(exports.VIDEO_ENCODE_SETTINGS.bFrames),
+    '-pix_fmt',
+    exports.VIDEO_ENCODE_SETTINGS.pixelFormat,
+    '-video_track_timescale',
+    String(exports.VIDEO_ENCODE_SETTINGS.videoTrackTimescale),
+    '-movflags',
+    '+faststart',
+];
+/** Standard AAC audio encode args to pair with {@link VIDEO_ENCODE_ARGS}. */
+exports.VIDEO_AUDIO_ENCODE_ARGS = [
+    '-c:a',
+    exports.VIDEO_ENCODE_SETTINGS.audioCodec,
+    '-ar',
+    String(exports.VIDEO_ENCODE_SETTINGS.audioSampleRate),
+    '-b:a',
+    exports.VIDEO_ENCODE_SETTINGS.audioBitrate,
+];
+/**
+ * Args for use inside Remotion's `ffmpegOverride` — just the flags that
+ * `renderMedia`'s typed options don't surface natively. Currently only `-bf 0`
+ * (no B-frames), which prevents non-monotonic DTS at concat seams between
+ * Remotion-rendered clips and the B-frame-free training videos compressed by
+ * {@link compressVideo}. Pair with the typed options fed from
+ * {@link VIDEO_ENCODE_SETTINGS} for a render that matches our standard profile.
+ *
+ * Example:
+ *
+ *     renderMedia({
+ *       codec: VIDEO_ENCODE_SETTINGS.remotionCodec,
+ *       x264Preset: VIDEO_ENCODE_SETTINGS.x264Preset,
+ *       crf: VIDEO_ENCODE_SETTINGS.crf,
+ *       pixelFormat: VIDEO_ENCODE_SETTINGS.pixelFormat,
+ *       audioCodec: VIDEO_ENCODE_SETTINGS.audioCodec,
+ *       audioBitrate: VIDEO_ENCODE_SETTINGS.audioBitrate,
+ *       ffmpegOverride: ({ args }) => {
+ *         const out = args[args.length - 1]
+ *         const yflag = args[args.length - 2]
+ *         return [...args.slice(0, -2), ...VIDEO_REMOTION_OVERRIDE_ARGS, yflag, out]
+ *       },
+ *       ...
+ *     })
+ */
+exports.VIDEO_REMOTION_OVERRIDE_ARGS = [
+    '-bf',
+    String(exports.VIDEO_ENCODE_SETTINGS.bFrames),
+];
+/**
+ * Compress a video using the standard H.264 settings. If `audio` is provided,
+ * its track replaces the source video's audio.
+ */
+async function compressVideo({ input, output, audio, }) {
+    const args = ['-i', input];
+    if (audio)
+        args.push('-i', audio, '-map', '0:v:0', '-map', '1:a:0');
+    args.push(...exports.VIDEO_ENCODE_ARGS, ...exports.VIDEO_AUDIO_ENCODE_ARGS, '-y', output);
+    await exec('ffmpeg', args);
+}
+/**
+ * Mix narration audio with background music at a fixed volume ratio. Music is
+ * trimmed to the shorter of the two inputs; if `targetDuration` is provided,
+ * the output is padded with silence to match exactly.
+ */
+async function mixAudioWithMusic({ music, narration, output, targetDuration, }) {
+    const narrationDuration = await getDurationFromFile(narration);
+    const musicDuration = await getDurationFromFile(music);
+    const minDuration = Math.min(narrationDuration, musicDuration);
+    const filterComplex = [
+        `[0:a]volume=1.0[a1]`,
+        `[1:a]atrim=0:${minDuration},volume=0.1[a2]`,
+        // duration=first keeps narration length; normalize=0 preserves its volume.
+        // apad pads the mix with silence to the exact target duration.
+        `[a1][a2]amix=inputs=2:duration=first:dropout_transition=0:normalize=0,apad=whole_dur=${targetDuration}`,
+    ].join(';');
+    await exec('ffmpeg', [
+        '-i',
+        narration,
+        '-i',
+        music,
+        '-filter_complex',
+        filterComplex,
+        ...CODEC,
+        ...BITRATE,
+        ...SAMPLE_RATE,
+        ...CHANNELS,
+        '-y',
+        output,
+    ]);
+}
+/** Get the duration of an audio file in seconds using ffprobe. */
+async function getDurationFromFile(file) {
+    const { stdout } = await exec('ffprobe', [
+        // Verbosity: only show errors (suppress informational output)
+        '-v',
+        'error',
+        // Only extract the duration field from the format section
+        '-show_entries',
+        'format=duration',
+        // Output format: plain value with no section wrappers or key name
+        '-of',
+        'default=noprint_wrappers=1:nokey=1',
+        // Input file to probe
+        file,
+    ]);
+    return parseFloat(stdout.trim());
+}

package/dist/functions/scripturePassages.js

@@ -12,11 +12,11 @@ exports.enrichSections = enrichSections;
 exports.normalizeVerseTimings = normalizeVerseTimings;
 const bibleStatuses_1 = require("../data/bibleStatuses");
 const firebase_1 = require("../data/firebase");
-const mediaDurations_1 = require("../data/mediaDurations");
 const languages_1 = require("../functions/languages");
 const sets_1 = require("../types/sets");
 const bibleBooks_1 = require("./bibleBooks");
 const bibles_1 = require("./bibles");
+const utils_1 = require("./utils");
 var bibleBooks_2 = require("./bibleBooks");
 Object.defineProperty(exports, "parseVerseRange", { enumerable: true, get: function () { return bibleBooks_2.parseVerseRange; } });
 function getChapterUrl(params) {
@@ -211,11 +211,11 @@ function verseToSuperscript(num) {
  * section has no FTB.
  */
 function getFtbDuration(section, lessonInfo) {
-    if (!section.ftbFileName)
+    if (!section.ftbPath)
         return 0;
-    const ftbDuration = mediaDurations_1.mediaDurations[lessonInfo.contentLanguages.ftbs]?.[section.ftbFileName];
+    const ftbDuration = (0, utils_1.getCachedDuration)(section.ftbPath);
     if (ftbDuration == null) {
-        console.warn(`FTB duration not found for ${section.ftbFileName}`);
+        console.warn(`FTB duration not found for ${(0, utils_1.basename)(section.ftbPath)}`);
     }
     return (ftbDuration ?? 0) + lessonInfo.lessonPauses.afterFtb;
 }
@@ -243,7 +243,7 @@ function enrichSections(lessonInfo, scripture) {
         const ignoreTimings = isStory && priorStoryLengthUnknown ? true : undefined;
         const startTime = currentTime;
         if (!isStory) {
-            length = mediaDurations_1.mediaDurations[section.languageId]?.[section.fileName];
+            length = (0, utils_1.getCachedDuration)(section.path);
         }
         else {
             currentTime += getFtbDuration(section, lessonInfo);
@@ -263,7 +263,7 @@ function enrichSections(lessonInfo, scripture) {
                 priorStoryLengthUnknown = true;
         }
         if (length == null) {
-            console.warn(`Missing duration for section ${section.id} (${section.chapter}, ${section.fileName})`);
+            console.warn(`Missing duration for section ${section.id} (${section.chapter}, ${(0, utils_1.basename)(section.path)})`);
         }
         currentTime += length ?? 0;
         return { ...section, length: length ?? 0, startTime, ignoreTimings };
@@ -271,11 +271,9 @@ function enrichSections(lessonInfo, scripture) {
     // Backward pass: compute application section start times from the end of the
     // lesson file, so they are always correct even if story durations are
     // slightly off.
-    const fullFileName = lessonInfo.type === 'dbs'
-        ? lessonInfo.full.localFileName
-        : lessonInfo.video.localFileName;
-    const totalDuration = mediaDurations_1.mediaDurations[lessonInfo.languageId]?.[fullFileName] ?? 0;
-    if (totalDuration > 0) {
+    const path = lessonInfo.type === 'dbs' ? lessonInfo.fullPath : lessonInfo.videoPath;
+    const totalDuration = (0, utils_1.getCachedDuration)(path);
+    if (totalDuration) {
         let timeFromEnd = totalDuration;
         const applicationSections = enriched.filter((s) => s.chapter === sets_1.Chapter.APPLICATION);
         for (const section of [...applicationSections].reverse()) {

package/dist/functions/sets.d.ts

@@ -1,12 +1,24 @@
 import { TranslationsApp } from '../data/translationsApp/translationsApp.zod';
-import type { LanguageInfo, MeetTranslations } from '../types/languages';
-import { DbsInfo, EnrichedSection, Lesson, LessonInfo, SetInfo, VideoInfo } from '../types/sets';
+import type { AppTranslations, LanguageInfo, MeetTranslations } from '../types/languages';
+import { DbsInfo, EnrichedSection, Lesson, LessonInfo, SetInfo, VideoInfo, type Section } from '../types/sets';
 export declare function getSetInfo({ setId, languageId, setIds, t, }: {
     setId: string;
     languageId: string;
     t: MeetTranslations & TranslationsApp[string];
     setIds: string[];
 }): SetInfo | undefined;
+/** Assembles all of the audio sections for a lesson. */
+export declare function assembleLessonSections({ languageInfo, setInfo, lesson, t, useSpokenQuestions, }: {
+    languageInfo: LanguageInfo;
+    setInfo: SetInfo;
+    lesson: Lesson;
+    t: MeetTranslations & AppTranslations;
+    useSpokenQuestions: boolean | undefined;
+}): {
+    sections: Section[];
+    fellowshipDuration: number;
+    applicationDuration: number;
+};
 export declare function getLessonInfo({ lessonId, languageInfo, setInfo, t, useSpokenQuestions, }: {
     lessonId: Lesson['lessonId'] | undefined;
     languageInfo: LanguageInfo;
@@ -14,9 +26,8 @@ export declare function getLessonInfo({ lessonId, languageInfo, setInfo, t, useS
     t: MeetTranslations & TranslationsApp[string];
     useSpokenQuestions?: boolean;
 }): LessonInfo | undefined;
-export declare function convertSToString(time: number): string;
 /** Determines whether a lesson should be visible in Waha. */
-export declare function shouldShowLesson(lessonInfo: LessonInfo | undefined, languageInfo: LanguageInfo): boolean;
+export declare function shouldShowLesson(lessonInfo: LessonInfo | undefined): boolean;
 /**
  * Validates that the computed lesson duration (from section lengths) matches
  * the actual audio file duration. Sections must be enriched (all have `length`)