mediatuna 1.21.11

package/lib/run.js

@@ -0,0 +1,288 @@
+import fs from 'fs';
+import path from 'path';
+import { lameQuality } from './audio-policy.js';
+import { NVENC_MIN_HEIGHT, NVENC_MIN_WIDTH } from './constants.js';
+import {
+    applyOutputTimestamps,
+    buildAudioFfmpegArgs,
+    buildExtractAudioFfmpegArgs,
+    buildFfmpegArgs,
+    canCopyAacAudio,
+    removePartialOutput,
+    nvencSupportsFrame,
+    runFfmpeg,
+    sampleDuration,
+    shouldDeinterlace,
+} from './encode.js';
+import { formatMtimeDate } from './paths.js';
+import { isSkippableStatus } from './status.js';
+import { hasDateTag } from './tags.js';
+import { formatDryRunProgress, shellQuote } from './format.js';
+import { secondsToHMS, formatHMSValue, formatTimeHMS, timeToSeconds } from './time.js';
+import { verifyOutput } from './verify.js';
+import { runWithConcurrency } from './jobs.js';
+
+export async function runConversion({
+    preflight,
+    config,
+    logger,
+    progress,
+    resumeState = null,
+}) {
+    const {
+        dryRun, verify, keepPartial, quality, audioQuality, deinterlace, nvenc,
+        preferMtime, embedArt, extractAudio, mediaMode, verbose, jobs = 1,
+        sampleSeconds = null, reencodeAudio = false,
+    } = config;
+
+    const stats = { done: 0, skipped: 0, failed: 0, resumed: 0 };
+    const failedPaths = [];
+    const convertedInputs = [];
+
+    function encodeWithFfmpeg(args, { activeFileBar, knownDuration } = {}) {
+        let activeProc = null;
+        return runFfmpeg(args, {
+            setActiveProc: (proc) => {
+                if (activeProc && !proc) {
+                    progress.unregisterProc?.(activeProc);
+                    activeProc = null;
+                } else if (proc) {
+                    activeProc = proc;
+                    progress.registerProc?.(proc);
+                }
+            },
+            onProgress: (chunk) => {
+                if (!activeFileBar || !chunk.includes('time=')) return;
+                const timeMatch = chunk.match(/time=([\d:.]+)/);
+                if (!timeMatch) return;
+                const current = timeToSeconds(timeMatch[1]);
+                if (Number.isNaN(current)) return;
+                if (!knownDuration && current > activeFileBar.getTotal()) {
+                    activeFileBar.setTotal(current + 60);
+                }
+                activeFileBar.update(current);
+            },
+        });
+    }
+
+    async function runEncodePass({
+        input, out, meta, jobStatus, jobLabel, mode, lossyWarn, index, total,
+    }) {
+        const base = path.basename(input);
+        const passName = jobLabel ? `${base} [${jobLabel}]` : base;
+        const isAudioJob = mode === 'audio' || mode === 'extract';
+
+        if (jobStatus === 'skip (normalized)' || jobStatus === 'skip (exists)' || jobStatus === 'skip (resumed)') {
+            stats.skipped++;
+            logger.logFile(`Skipped${jobStatus.includes('normalized') ? ' (normalized)' : jobStatus.includes('resumed') ? ' (resumed)' : ''}: ${passName}`);
+            return true;
+        }
+
+        if (dryRun) {
+            if (jobStatus.startsWith('convert')) {
+                stats.done++;
+                if (verbose) {
+                    const suffix = mode === 'video'
+                        ? ` (deinterlace: ${shouldDeinterlace(deinterlace, meta) ? 'yadif' : 'none'})`
+                        : mode === 'extract' ? ' (extract)' : lossyWarn ? ' (lossy)' : '';
+                    logger.fileLog(`Would convert: ${passName} → ${path.basename(out)}${suffix}`, index, total);
+                }
+            }
+            return true;
+        }
+
+        if (lossyWarn) {
+            const msg = `[WARN] ${passName} → ${path.basename(out)} (lossy; source cannot be recovered from MP3)`;
+            logger.logFile(msg);
+            if (verbose) logger.logConsole(msg);
+        }
+
+        if (meta.duration <= 0) {
+            logger.logFile(`[WARN] ${passName}: zero duration reported; progress may be approximate`);
+        }
+
+        if (!fs.existsSync(path.dirname(out))) fs.mkdirSync(path.dirname(out), { recursive: true });
+        if (fs.existsSync(out)) {
+            fs.unlinkSync(out);
+            logger.logFile(`Removed existing output before encode: ${out}`);
+        }
+
+        const expectedDuration = sampleDuration(meta.duration, sampleSeconds);
+        const knownDuration = expectedDuration > 0;
+        const barTotal = knownDuration ? Math.floor(expectedDuration) : 3600;
+        let activeFileBar = null;
+        let encodeStart = Date.now();
+
+        try {
+            activeFileBar = progress.createFileBar(barTotal, passName, {
+                format: 'Current [{bar}] {percentage}% | {value} / {total} | ETA {eta_formatted} | {filename}',
+                formatValue: formatHMSValue,
+                formatTime: formatTimeHMS,
+            });
+            activeFileBar.start(barTotal, 0, { filename: passName });
+
+            const args = mode === 'video'
+                ? buildFfmpegArgs(input, out, meta, {
+                    quality, nvenc, deinterlaceMode: deinterlace, sampleSeconds, reencodeAudio,
+                })
+                : mode === 'extract'
+                    ? buildExtractAudioFfmpegArgs(input, out, { audioQuality, preferMtime, meta, sampleSeconds })
+                    : buildAudioFfmpegArgs(input, out, { audioQuality, embedArt, preferMtime, meta, sampleSeconds });
+
+            logger.logFile(`--- ${passName} ---`);
+            if (mode === 'video') {
+                const deinterlaceApplied = shouldDeinterlace(deinterlace, meta);
+                logger.logFile(`Deinterlace: ${deinterlaceApplied ? 'yadif' : 'off'} (mode=${deinterlace}, field_order=${meta.field_order})`);
+                if (nvenc && !nvencSupportsFrame(meta)) {
+                    logger.logFile(`NVENC skipped: ${meta.width}x${meta.height} is below the ${NVENC_MIN_WIDTH}x${NVENC_MIN_HEIGHT} minimum; using libx264`);
+                }
+                if (canCopyAacAudio(meta, { reencodeAudio })) {
+                    logger.logFile('Audio: copy (source AAC is compatible)');
+                } else {
+                    logger.logFile(reencodeAudio
+                        ? 'Audio: aac 192k (--reencode-audio)'
+                        : 'Audio: aac 192k');
+                }
+            } else {
+                const artNote = embedArt ? (meta.hasCoverArt ? 'embed cover' : 'embed cover if present') : 'no cover';
+                const dateNote = preferMtime && !hasDateTag(meta.tags) ? `date=${formatMtimeDate(input)} from mtime` : 'tags as-is';
+                logger.logFile(`Encode: libmp3lame -q:a ${lameQuality(audioQuality)} | ${artNote} | ${dateNote}${mode === 'extract' ? ' | extract from video' : ''}`);
+            }
+            logger.logFile(`Command: ffmpeg ${args.map(shellQuote).join(' ')}`);
+
+            encodeStart = Date.now();
+            const expectedType = mode === 'video' ? 'video' : 'audio';
+            await encodeWithFfmpeg(args, { activeFileBar, knownDuration });
+            const elapsedSec = (Date.now() - encodeStart) / 1000;
+            const elapsedStr = elapsedSec >= 60
+                ? `${Math.floor(elapsedSec / 60)}m ${Math.round(elapsedSec % 60)}s`
+                : `${elapsedSec.toFixed(1)}s`;
+
+            if (verify) {
+                const verifyContext = isAudioJob ? { sourceMeta: meta, sourceSize: meta.size } : null;
+                const check = verifyOutput(out, expectedDuration, expectedType, verifyContext);
+                if (!check.ok) throw new Error(`verification failed: ${check.reason}`);
+                for (const warning of check.warnings ?? []) {
+                    logger.logFile(`[WARN] ${passName}: ${warning}`);
+                    if (verbose) logger.logConsole(`[WARN] ${passName}: ${warning}`);
+                }
+                try {
+                    applyOutputTimestamps(input, out);
+                } catch { }
+                const outBase = path.basename(out);
+                const detail = `✓ ${outBase} | Verified (${secondsToHMS(check.duration)}) | Metadata copied`;
+                logger.logFile(`${detail} | --- end ${passName} (${elapsedStr}) ---`);
+                logger.logToConsole(verbose ? detail : `✓ ${outBase}`);
+            } else {
+                try {
+                    applyOutputTimestamps(input, out);
+                } catch { }
+                const outBase = path.basename(out);
+                logger.logFile(`✓ ${outBase} | --- end ${passName} (${elapsedStr}) ---`);
+                logger.logToConsole(verbose ? `✓ ${outBase}` : `✓ ${outBase}`);
+            }
+
+            stats.done++;
+            activeFileBar.update(knownDuration ? Math.floor(expectedDuration) : activeFileBar.value);
+            return true;
+        } catch (err) {
+            const elapsedSec = (Date.now() - encodeStart) / 1000;
+            logger.logConsole(`Error: ${passName} - ${err.message}`);
+            logger.logFile(`--- end ${passName} (${elapsedSec.toFixed(1)}s, failed) ---`);
+            removePartialOutput(out, keepPartial, (msg) => logger.logFile(msg));
+            stats.failed++;
+            if (!failedPaths.includes(input)) failedPaths.push(input);
+            return false;
+        } finally {
+            activeFileBar?.stop();
+        }
+    }
+
+    async function processFile(entry, index) {
+        if (progress.isShuttingDown()) return;
+
+        const { input, out, audioOut, meta, videoStatus, extractStatus, lossy } = entry;
+        const total = preflight.length;
+        const base = path.basename(input);
+
+        logger.logFile(`Processing: ${base} | Type: ${meta.mediaType} | Duration: ${secondsToHMS(meta.duration)} | Created: ${meta.creation_time} | Updated: ${meta.modified_time}`);
+
+        if (videoStatus === 'unreadable') {
+            stats.failed++;
+            failedPaths.push(input);
+            logger.logConsole(`Unreadable: ${base}`);
+            progress.overallBar?.increment();
+            return;
+        }
+
+        if (videoStatus === 'skip (wrong type)' && !extractStatus) {
+            stats.skipped++;
+            logger.logFile(`Skipped (wrong type): ${base}`);
+            progress.overallBar?.increment();
+            return;
+        }
+
+        if (dryRun) {
+            if (isSkippableStatus(videoStatus)) {
+                stats.skipped++;
+            } else if (videoStatus.startsWith('convert')) stats.done++;
+            if (extractStatus) {
+                if (isSkippableStatus(extractStatus)) {
+                    stats.skipped++;
+                } else if (extractStatus.startsWith('convert')) stats.done++;
+            }
+            if (videoStatus === 'skip (resumed)' || extractStatus === 'skip (resumed)') {
+                stats.resumed++;
+                convertedInputs.push(input);
+            }
+            if (total > 1) {
+                logger.logConsole(formatDryRunProgress(index, total, entry.status, base));
+            } else if (verbose && (videoStatus.startsWith('convert') || extractStatus?.startsWith('convert'))) {
+                logger.fileLog(`Would process: ${base} (${entry.status})`, index, total);
+            }
+            progress.overallBar?.increment();
+            return;
+        }
+
+        let primaryConverted = false;
+        const encodeJobs = [];
+
+        if (meta.mediaType === 'video' && mediaMode.video && videoStatus !== 'skip (wrong type)') {
+            encodeJobs.push({ out, jobStatus: videoStatus, jobLabel: null, mode: 'video', lossyWarn: false });
+        } else if (meta.mediaType === 'audio' && mediaMode.audio) {
+            encodeJobs.push({ out, jobStatus: videoStatus, jobLabel: null, mode: 'audio', lossyWarn: lossy });
+        }
+        if (extractStatus && extractAudio && audioOut) {
+            encodeJobs.push({ out: audioOut, jobStatus: extractStatus, jobLabel: 'extract', mode: 'extract', lossyWarn: false });
+        }
+
+        let allOk = true;
+        for (const job of encodeJobs) {
+            const ok = await runEncodePass({ input, meta, index, total, ...job });
+            if (!ok) allOk = false;
+            if (ok && job.jobStatus.startsWith('convert') && job.mode !== 'extract') {
+                primaryConverted = true;
+            }
+        }
+
+        if (allOk && encodeJobs.length > 0) {
+            resumeState?.markCompleted?.(input);
+        }
+        if (videoStatus === 'skip (resumed)' || extractStatus === 'skip (resumed)') {
+            stats.resumed++;
+        }
+        if (primaryConverted || (allOk && encodeJobs.some(j => j.jobStatus === 'skip (resumed)'))) {
+            convertedInputs.push(input);
+        }
+        progress.overallBar?.increment();
+    }
+
+    await runWithConcurrency(
+        preflight.length,
+        dryRun ? 1 : jobs,
+        (i) => processFile(preflight[i], i),
+        { shouldStop: () => progress.isShuttingDown() },
+    );
+
+    return { stats, failedPaths, convertedInputs };
+}

package/lib/safety.js

@@ -0,0 +1,84 @@
+import fs from 'fs';
+import path from 'path';
+import { isConvertStatus } from './status.js';
+
+export const LARGE_BATCH_THRESHOLD = 50;
+export const STAMP_BACKUP_WARN_THRESHOLD = 10;
+export const DISK_RESERVE_BYTES = 200 * 1024 * 1024;
+export const VIDEO_OUTPUT_FACTOR = 1.2;
+export const AUDIO_OUTPUT_FACTOR = 0.3;
+export const EXTRACT_OUTPUT_FACTOR = 0.15;
+
+export const LOSSY_BANNER = 'Outputs are lossy (H.264/AAC MP4 or LAME MP3). Keep sources until you have checked playback.';
+
+export function formatWriteLocationBanner({ count, outputDir, sourceDir }) {
+    if (outputDir) return `Writing ${count} output(s) under ${outputDir} (source subfolders kept).`;
+    return `Writing ${count} file(s) beside sources in ${sourceDir}.`;
+}
+
+export function formatLargeBatchPrompt({ count, root, threshold = LARGE_BATCH_THRESHOLD }) {
+    return `${count} files under ${root} (more than ${threshold}). Press Enter to continue, or Ctrl+C to stop: `;
+}
+
+export function formatStampBackupWarn(count, threshold = STAMP_BACKUP_WARN_THRESHOLD) {
+    return `--stamp-dates will rename ${count} sources in place with no --backup (more than ${threshold}). Press Enter to continue, or Ctrl+C to stop: `;
+}
+
+export function formatForceOverwritePrompt(count) {
+    return `--force will overwrite ${count} existing output(s). Continue? [y/N]: `;
+}
+
+export function shouldShowLossyBanner(entries) {
+    return entries.some(entry =>
+        isConvertStatus(entry.videoStatus) || (entry.extractStatus && isConvertStatus(entry.extractStatus)));
+}
+
+export function countOverwriteTargets(entries, { existsFn = fs.existsSync } = {}) {
+    let count = 0;
+    for (const entry of entries) {
+        if (isConvertStatus(entry.videoStatus) && existsFn(entry.out)) count++;
+        if (entry.extractStatus && isConvertStatus(entry.extractStatus) && entry.audioOut && existsFn(entry.audioOut)) {
+            count++;
+        }
+    }
+    return count;
+}
+
+export function estimateNeededBytes(entries, { sampleSeconds = null } = {}) {
+    let bytes = 0;
+    for (const entry of entries) {
+        const size = Number(entry.meta?.size) || 0;
+        const duration = Number(entry.meta?.duration) || 0;
+        const sampleFactor = sampleSeconds && duration > 0 ? Math.min(1, sampleSeconds / duration) : 1;
+        if (isConvertStatus(entry.videoStatus)) {
+            bytes += (entry.meta?.mediaType === 'audio'
+                ? size * AUDIO_OUTPUT_FACTOR
+                : size * VIDEO_OUTPUT_FACTOR) * sampleFactor;
+        }
+        if (entry.extractStatus && isConvertStatus(entry.extractStatus)) {
+            bytes += size * EXTRACT_OUTPUT_FACTOR * sampleFactor;
+        }
+    }
+    return Math.ceil(bytes);
+}
+
+export function checkFreeSpace(destDir, neededBytes, {
+    statfsFn = fs.statfsSync,
+    reserveBytes = DISK_RESERVE_BYTES,
+} = {}) {
+    const resolved = path.resolve(destDir);
+    const stats = statfsFn(resolved);
+    const free = Number(stats.bavail) * Number(stats.bsize);
+    const needed = neededBytes + reserveBytes;
+    return {
+        ok: free >= needed,
+        free,
+        needed,
+        destDir: resolved,
+    };
+}
+
+export function formatDiskSpaceError(check) {
+    const gb = n => `${(n / 1024 / 1024 / 1024).toFixed(1)} GB`;
+    return `Not enough free space on ${check.destDir}: need about ${gb(check.needed)} (including reserve), ${gb(check.free)} available. Free disk space, use --output on another volume, or pass --yes to continue anyway.`;
+}