mediatuna 1.21.11

package/lib/filename-dates.js

@@ -0,0 +1,155 @@
+import path from 'path';
+
+function validDate({ year, month, day }) {
+    const y = Number(year);
+    const mo = Number(month);
+    const d = Number(day);
+    if (y < 1970 || y > 2100) return false;
+    if (mo < 1 || mo > 12) return false;
+    if (d < 1 || d > 31) return false;
+    return true;
+}
+
+function validClock({ year, month, day, hour, minute, second }) {
+    if (!validDate({ year, month, day })) return false;
+    const h = Number(hour);
+    const mi = Number(minute);
+    const s = Number(second);
+    if (h > 23 || mi > 59 || s > 59) return false;
+    return true;
+}
+
+function pack(year, month, day, hour, minute, second, rest = '', extra = {}) {
+    const parsed = {
+        year: String(year).padStart(4, '0'),
+        month: String(month).padStart(2, '0'),
+        day: String(day).padStart(2, '0'),
+        hour: String(hour).padStart(2, '0'),
+        minute: String(minute).padStart(2, '0'),
+        second: String(second).padStart(2, '0'),
+        hasTime: true,
+    };
+    if (!validClock(parsed)) return null;
+    return {
+        parsed,
+        rest: rest.replace(/^[-_]+/, ''),
+        alreadyStandard: false,
+        source: 'filename',
+        hasZ: false,
+        ...extra,
+    };
+}
+
+function packDate(year, month, day, rest = '', extra = {}) {
+    const parsed = {
+        year: String(year).padStart(4, '0'),
+        month: String(month).padStart(2, '0'),
+        day: String(day).padStart(2, '0'),
+        hour: '00',
+        minute: '00',
+        second: '00',
+        hasTime: false,
+    };
+    if (!validDate(parsed)) return null;
+    return {
+        parsed,
+        rest: rest.replace(/^[-_]+/, ''),
+        alreadyStandard: false,
+        source: 'filename',
+        hasZ: false,
+        ...extra,
+    };
+}
+
+export function filenameStampPrefix(parsed, { z = false, mtime = false } = {}) {
+    const clock = parsed.hasTime
+        ? `_${parsed.hour}-${parsed.minute}-${parsed.second}${z ? 'Z' : ''}`
+        : '';
+    const tag = mtime ? 'MTIME_' : '';
+    return `${tag}${parsed.year}-${parsed.month}-${parsed.day}${clock}`;
+}
+
+export function parseFilenameDate(basename) {
+    const stem = path.basename(basename, path.extname(basename));
+
+    const dashed = stem.match(/^(MTIME_)?(\d{4})-(\d{2})-(\d{2})_(\d{2})-(\d{2})-(\d{2})(Z)?(?:_(.*))?$/);
+    if (dashed) {
+        const [, tag, year, month, day, hour, minute, second, z, rest] = dashed;
+        const packed = pack(year, month, day, hour, minute, second, rest || '', {
+            alreadyStandard: true,
+            source: tag ? 'mtime' : (z ? 'creation_time' : 'filename'),
+            hasZ: Boolean(z),
+        });
+        return packed;
+    }
+
+    const compact = stem.match(/^(MTIME_)?(\d{4})-(\d{2})-(\d{2})_(\d{6})(Z)?(?:_(.*))?$/);
+    if (compact) {
+        const [, tag, year, month, day, hms, z, rest] = compact;
+        return pack(year, month, day, hms.slice(0, 2), hms.slice(2, 4), hms.slice(4, 6), rest || '', {
+            alreadyStandard: false,
+            source: tag ? 'mtime' : (z ? 'creation_time' : 'filename'),
+            hasZ: Boolean(z),
+        });
+    }
+
+    const yyyyDash = stem.match(/^(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})(?:-(.+))?$/);
+    if (yyyyDash) {
+        return pack(yyyyDash[1], yyyyDash[2], yyyyDash[3], yyyyDash[4], yyyyDash[5], yyyyDash[6], yyyyDash[7] || '');
+    }
+
+    const yy = stem.match(/^(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})(?:-(.+))?$/);
+    if (yy) {
+        return pack(2000 + Number(yy[1]), yy[2], yy[3], yy[4], yy[5], yy[6], yy[7] || '');
+    }
+
+    const vr = stem.match(/^VR_(\d{4})-(\d{2})-(\d{2})_(\d{2})-(\d{2})-(\d{2})$/);
+    if (vr) return pack(vr[1], vr[2], vr[3], vr[4], vr[5], vr[6], '');
+
+    const note = stem.match(/^AudioNote-(\d{4})-(\d{2})-(\d{2})_(\d{6})$/);
+    if (note) {
+        return pack(note[1], note[2], note[3], note[4].slice(0, 2), note[4].slice(2, 4), note[4].slice(4, 6), '');
+    }
+
+    const us = stem.match(/^(\d{4})_(\d{2})_(\d{2})_(\d{2})_(\d{2})_(\d{2})$/);
+    if (us) return pack(us[1], us[2], us[3], us[4], us[5], us[6], '');
+
+    const compactDay = stem.match(/^(\d{8})[ _-](\d{6})(?:[ _-](.+))?$/);
+    if (compactDay) {
+        const day = compactDay[1];
+        const hms = compactDay[2];
+        return pack(
+            day.slice(0, 4), day.slice(4, 6), day.slice(6, 8),
+            hms.slice(0, 2), hms.slice(2, 4), hms.slice(4, 6),
+            compactDay[3] || '',
+        );
+    }
+
+    const dateOnly = stem.match(/^(MTIME_)?(\d{4})-(\d{2})-(\d{2})(?:([ _-])(.*))?$/);
+    if (dateOnly) {
+        const [, tag, year, month, day, sep, rest] = dateOnly;
+        const label = rest || '';
+        return packDate(year, month, day, label, {
+            alreadyStandard: !label || sep === '_',
+            source: tag ? 'mtime' : 'filename',
+        });
+    }
+
+    return null;
+}
+
+export function normalizeDatedBasename(basename) {
+    const parsed = parseFilenameDate(basename);
+    if (!parsed || parsed.alreadyStandard) return basename;
+    const ext = path.extname(basename);
+    const rest = parsed.rest ? `_${parsed.rest}` : '';
+    const prefix = filenameStampPrefix(parsed.parsed, {
+        z: parsed.hasZ,
+        mtime: parsed.source === 'mtime',
+    });
+    return `${prefix}${rest}${ext}`;
+}
+
+export function isStandardDatedName(basename) {
+    return Boolean(parseFilenameDate(basename)?.alreadyStandard);
+}

package/lib/format.js

@@ -0,0 +1,33 @@
+export function formatSize(bytes) {
+    if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
+    if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)} MB`;
+    if (bytes >= 1e3) return `${(bytes / 1e3).toFixed(1)} KB`;
+    return `${bytes} B`;
+}
+
+export function padEnd(str, len) {
+    const s = String(str);
+    return s.length >= len ? s.slice(0, len) : s + ' '.repeat(len - s.length);
+}
+
+export function shellQuote(arg) {
+    return /[\s"'$`]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
+}
+
+export function formatDryRunProgress(index, total, status, filename) {
+    return `[${index + 1}/${total}] ${status}  ${filename}`;
+}
+
+export function formatFfmpegError(stderr, fallback) {
+    const lines = stderr
+        .split(/\r?\n/)
+        .map(l => l.trim())
+        .filter(Boolean)
+        .filter(l =>
+            !l.startsWith('ffmpeg version') &&
+            !l.startsWith('built with') &&
+            !l.startsWith('configuration:') &&
+            !/^lib\w+\s+\d/.test(l)
+        );
+    return lines.at(-1) || fallback;
+}

package/lib/globs.js

@@ -0,0 +1,58 @@
+import path from 'path';
+
+export function parseGlobList(values) {
+    if (!values) return [];
+    const items = Array.isArray(values) ? values : [values];
+    return items
+        .flatMap(value => String(value).split(/[,;\n]+/))
+        .map(value => value.trim())
+        .filter(Boolean);
+}
+
+export function toPosixPath(filePath) {
+    return String(filePath).replace(/\\/g, '/');
+}
+
+export function compileGlob(pattern) {
+    const normalized = toPosixPath(String(pattern).trim());
+    if (!normalized) return null;
+    let regex = '';
+    for (let i = 0; i < normalized.length; i++) {
+        const ch = normalized[i];
+        if (ch === '*' && normalized[i + 1] === '*') {
+            regex += '.*';
+            i += normalized[i + 2] === '/' ? 2 : 1;
+        } else if (ch === '*') {
+            regex += '[^/]*';
+        } else if (ch === '?') {
+            regex += '[^/]';
+        } else if ('+^$()[]{}|.'.includes(ch)) {
+            regex += `\\${ch}`;
+        } else {
+            regex += ch;
+        }
+    }
+    return new RegExp(`^${regex}$`, 'i');
+}
+
+export function pathMatchesGlob(filePath, pattern, rootDir) {
+    const re = compileGlob(pattern);
+    if (!re) return false;
+    const abs = path.resolve(filePath);
+    const root = rootDir ? path.resolve(rootDir) : path.dirname(abs);
+    const rel = toPosixPath(path.relative(root, abs));
+    const base = path.basename(abs);
+    if (re.test(rel) || re.test(base) || re.test(toPosixPath(abs))) return true;
+    if (!toPosixPath(pattern).includes('/')) {
+        return rel.split('/').some(part => re.test(part));
+    }
+    return false;
+}
+
+export function filterByGlobs(files, { include = [], exclude = [], rootDir = null } = {}) {
+    return files.filter(filePath => {
+        if (exclude.some(pattern => pathMatchesGlob(filePath, pattern, rootDir))) return false;
+        if (include.length === 0) return true;
+        return include.some(pattern => pathMatchesGlob(filePath, pattern, rootDir));
+    });
+}

package/lib/hash.js

@@ -0,0 +1,12 @@
+import { createHash } from 'crypto';
+import fs from 'fs';
+
+export function sha256File(filePath, readStreamFn = fs.createReadStream) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const stream = readStreamFn(filePath);
+        stream.on('data', chunk => hash.update(chunk));
+        stream.on('error', reject);
+        stream.on('end', () => resolve(hash.digest('hex')));
+    });
+}

package/lib/jobs.js

@@ -0,0 +1,51 @@
+import os from 'os';
+
+export const DEFAULT_JOBS = 1;
+export const MAX_JOBS = 8;
+
+export function parseJobsValue(raw) {
+    if (raw === undefined || raw === null) return DEFAULT_JOBS;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 1) {
+        throw new Error('--jobs requires a positive integer.');
+    }
+    if (n > MAX_JOBS) {
+        throw new Error(`--jobs cannot exceed ${MAX_JOBS}.`);
+    }
+    return n;
+}
+
+export function resolveEffectiveJobs(requested, { nvenc, mediaMode }) {
+    const jobs = requested ?? DEFAULT_JOBS;
+    if (jobs <= 1) return 1;
+
+    if (mediaMode.video && !nvenc) {
+        const cpuCap = Math.max(1, Math.min(MAX_JOBS, os.cpus().length));
+        return Math.min(jobs, cpuCap);
+    }
+
+    return jobs;
+}
+
+export async function runWithConcurrency(itemCount, concurrency, worker, { shouldStop = () => false } = {}) {
+    if (itemCount <= 0) return;
+    if (concurrency <= 1 || itemCount <= 1) {
+        for (let i = 0; i < itemCount; i++) {
+            if (shouldStop()) break;
+            await worker(i);
+        }
+        return;
+    }
+
+    let nextIndex = 0;
+    async function runWorker() {
+        while (!shouldStop()) {
+            const i = nextIndex++;
+            if (i >= itemCount) return;
+            await worker(i);
+        }
+    }
+
+    const workerCount = Math.min(concurrency, itemCount);
+    await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+}

package/lib/log.js

@@ -0,0 +1,61 @@
+import fs from 'fs';
+import path from 'path';
+
+export function createLogger({ logFile: logFilePath, masterLogFile: masterLogFilePath, masterLogEnabled, verbose, getMultibar = () => null }) {
+    let masterLogWarningShown = false;
+
+    function appendLog(msg) {
+        const ts = new Date().toISOString();
+        const line = `[${ts}] ${msg}\n`;
+        fs.appendFileSync(logFilePath, line);
+        if (masterLogEnabled) {
+            try {
+                fs.appendFileSync(masterLogFilePath, line);
+            } catch (err) {
+                if (!masterLogWarningShown) {
+                    masterLogWarningShown = true;
+                    console.error(`Warning: could not write master log (${masterLogFilePath}): ${err.message}`);
+                }
+            }
+        }
+    }
+
+    function logToConsole(msg) {
+        const multibar = getMultibar();
+        if (multibar?.isActive) multibar.log(msg + '\n');
+        else console.log(msg);
+    }
+
+    function logFile(msg) {
+        appendLog(msg);
+    }
+
+    function logConsole(msg) {
+        logFile(msg);
+        logToConsole(msg);
+    }
+
+    function logVerbose(msg) {
+        logFile(msg);
+        if (verbose) logToConsole(msg);
+    }
+
+    function fileLog(msg, index, total) {
+        const prefix = total > 1 ? `[${index + 1}/${total}] ` : '';
+        logVerbose(prefix + msg);
+    }
+
+    function printLines(lines) {
+        for (const line of lines) {
+            if (line === '') console.log('');
+            else console.log(line);
+            appendLog(line);
+        }
+    }
+
+    return { appendLog, logFile, logConsole, logVerbose, fileLog, printLines, logToConsole };
+}
+
+export function ensureLogDir(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}

package/lib/paths.js

@@ -0,0 +1,38 @@
+import fs from 'fs';
+import path from 'path';
+import { stampedOutputStem } from './stamp-dates.js';
+
+export function uniqueDestPath(dest, existsFn = fs.existsSync) {
+    if (!existsFn(dest)) return dest;
+    const ext = path.extname(dest);
+    const stem = dest.slice(0, dest.length - ext.length);
+    for (let n = 2; n < 1000; n++) {
+        const candidate = `${stem}-${n}${ext}`;
+        if (!existsFn(candidate)) return candidate;
+    }
+    return `${stem}-${Date.now()}${ext}`;
+}
+
+export function outputDirFor(input, outputDir, { rootDir = null } = {}) {
+    if (!outputDir) return path.dirname(input);
+    if (!rootDir) return outputDir;
+    const rel = path.relative(path.resolve(rootDir), path.dirname(path.resolve(input)));
+    if (!rel || rel === '.' || rel.startsWith('..') || path.isAbsolute(rel)) return outputDir;
+    return path.join(outputDir, rel);
+}
+
+export function outputPath(input, outputDir, mediaType, {
+    stamp = false, meta = null, preferMtime = false, rootDir = null, sample = false,
+} = {}) {
+    const ext = mediaType === 'audio' ? '.mp3' : '.mp4';
+    const dir = outputDirFor(input, outputDir, { rootDir });
+    const name = stamp
+        ? stampedOutputStem(path.basename(input), meta, { preferMtime })
+        : path.basename(input, path.extname(input));
+    const suffix = sample ? '.sample' : '';
+    return path.join(dir, `${name}${suffix}${ext}`);
+}
+
+export function formatMtimeDate(input) {
+    return fs.statSync(input).mtime.toISOString().slice(0, 10);
+}

package/lib/preflight.js

@@ -0,0 +1,75 @@
+import path from 'path';
+import {
+    classifyStatus,
+    classifyExtractStatus,
+    formatEntryStatus,
+} from './status.js';
+import { isLossyAudioSource } from './extensions.js';
+import { formatSize, padEnd } from './format.js';
+import { outputPath } from './paths.js';
+import { getMetadata } from './probe.js';
+import { secondsToHMS } from './time.js';
+
+export function buildPreflightTableLines(entries, dryRun) {
+    const nameW = Math.min(40, Math.max(20, ...entries.map(e => path.basename(e.input).length)));
+    const header = `  ${padEnd('File', nameW)}  ${padEnd('Type', 5)}  ${padEnd('Duration', 10)}  ${padEnd('Size', 10)}  Status`;
+    const rule = '  ' + '─'.repeat(nameW + 44);
+    const lines = ['', rule, header, rule];
+
+    const counts = { convert: 0, skip: 0, unreadable: 0, wrong: 0 };
+
+    for (const e of entries) {
+        let status = e.status;
+        if (dryRun && status.startsWith('convert')) status = status.replace('convert', 'would convert');
+        if (status === 'unreadable') counts.unreadable++;
+        else if (status.includes('skip (exists)') || status.includes('skip (normalized)') || status.includes('skip (resumed)')) counts.skip++;
+        else if (status.includes('skip (wrong type)')) counts.wrong++;
+        else counts.convert++;
+
+        lines.push(
+            `  ${padEnd(path.basename(e.input), nameW)}  ${padEnd(e.meta.mediaType, 5)}  ${padEnd(secondsToHMS(e.meta.duration), 10)}  ${padEnd(formatSize(e.meta.size), 10)}  ${status}`
+        );
+    }
+
+    lines.push(rule);
+    const action = dryRun ? 'would convert' : 'to convert';
+    const wrongNote = counts.wrong > 0 ? `, ${counts.wrong} wrong type` : '';
+    lines.push(`  ${entries.length} file(s): ${counts.convert} ${action}, ${counts.skip} skip, ${counts.unreadable} unreadable${wrongNote}`);
+    lines.push('');
+
+    return { lines, counts };
+}
+
+export async function buildPreflightEntries(fileList, outputDir, force, mediaMode, {
+    audioQuality, extractAudio, onProbeProgress, stampVideo = true, preferMtime = false,
+    rootDir = null, sampleSeconds = null,
+} = {}) {
+    const entries = [];
+    for (let i = 0; i < fileList.length; i++) {
+        const input = fileList[i];
+        onProbeProgress?.(i + 1, fileList.length);
+        const meta = getMetadata(input);
+        const isVideo = meta.mediaType === 'video';
+        const stamp = stampVideo && isVideo;
+        const pathOpts = { stamp, meta, preferMtime, rootDir, sample: Boolean(sampleSeconds) };
+        const out = outputPath(input, outputDir, isVideo ? 'video' : 'audio', pathOpts);
+        const videoStatus = classifyStatus(input, meta, out, force, mediaMode, audioQuality);
+        let audioOut = null;
+        let extractStatus = null;
+        if (extractAudio && isVideo && mediaMode.video) {
+            audioOut = outputPath(input, outputDir, 'audio', pathOpts);
+            extractStatus = classifyExtractStatus(input, meta, audioOut, force, audioQuality);
+        }
+        entries.push({
+            input,
+            out,
+            audioOut,
+            meta,
+            status: formatEntryStatus(videoStatus, extractStatus),
+            videoStatus,
+            extractStatus,
+            lossy: meta.mediaType === 'audio' && isLossyAudioSource(input),
+        });
+    }
+    return entries;
+}

package/lib/probe.js

@@ -0,0 +1,115 @@
+import fs from 'fs';
+import { execFileSync } from 'child_process';
+import { INTERLACED_FIELD_ORDERS } from './constants.js';
+import { extractTagInfo } from './tags.js';
+
+function pickCreationTag(tags = {}) {
+    return tags.creation_time || tags.date || tags.DATE || tags.year || null;
+}
+
+function pickStreamCreationTag(streams = []) {
+    for (const stream of streams) {
+        const value = pickCreationTag(stream.tags || {});
+        if (value) return value;
+    }
+    return null;
+}
+
+export function parseProbeResult(data, stats) {
+    let duration = 0;
+    let creation = 'N/A';
+    let mediaType = 'unreadable';
+    let interlaced = false;
+    let fieldOrder = 'unknown';
+    let tags = {};
+    let tagCount = 0;
+    let hasCoverArt = false;
+    let audioCodec = 'unknown';
+    let audioBitrate = 0;
+    let audioProfile = '';
+    let audioChannels = 0;
+    let width = 0;
+    let height = 0;
+
+    duration = parseFloat(data.format?.duration) || 0;
+    tags = data.format?.tags || {};
+    tagCount = extractTagInfo(tags).tagCount;
+    creation = pickCreationTag(tags) || pickStreamCreationTag(data.streams) || 'N/A';
+
+    const videoStreams = data.streams?.filter(s => s.codec_type === 'video') ?? [];
+    const audioStream = data.streams?.find(s => s.codec_type === 'audio');
+
+    if (audioStream) {
+        audioCodec = (audioStream.codec_name || 'unknown').toLowerCase();
+        audioBitrate = parseInt(audioStream.bit_rate, 10)
+            || parseInt(data.format?.bit_rate, 10)
+            || 0;
+        audioProfile = String(audioStream.profile || '').trim();
+        audioChannels = parseInt(audioStream.channels, 10) || 0;
+    }
+
+    hasCoverArt = videoStreams.some(s => Number(s.disposition?.attached_pic) === 1);
+    const primaryVideo = videoStreams.find(s => Number(s.disposition?.attached_pic) !== 1);
+
+    if (primaryVideo) {
+        mediaType = 'video';
+        fieldOrder = (primaryVideo.field_order || 'unknown').toLowerCase();
+        interlaced = INTERLACED_FIELD_ORDERS.has(fieldOrder);
+        width = parseInt(primaryVideo.width, 10) || 0;
+        height = parseInt(primaryVideo.height, 10) || 0;
+    } else if (audioStream) {
+        mediaType = 'audio';
+    }
+
+    return {
+        duration,
+        creation_time: creation,
+        modified_time: stats.mtime.toISOString(),
+        size: stats.size,
+        valid: mediaType !== 'unreadable',
+        mediaType,
+        interlaced,
+        field_order: fieldOrder,
+        tags,
+        tagCount,
+        hasCoverArt,
+        audioCodec,
+        audioBitrate,
+        audioProfile,
+        audioChannels,
+        width,
+        height,
+    };
+}
+
+export function probeFile(input) {
+    const stats = fs.statSync(input);
+    try {
+        const out = execFileSync(
+            'ffprobe',
+            ['-v', 'error', '-print_format', 'json', '-show_format', '-show_streams', input],
+            { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
+        );
+        return parseProbeResult(JSON.parse(out), stats);
+    } catch {
+        return parseProbeResult({}, stats);
+    }
+}
+
+export function getMetadata(input) {
+    return probeFile(input);
+}
+
+export function getFormatTags(filePath) {
+    try {
+        const out = execFileSync(
+            'ffprobe',
+            ['-v', 'error', '-print_format', 'json', '-show_format', filePath],
+            { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
+        );
+        const data = JSON.parse(out);
+        return extractTagInfo(data.format?.tags || {});
+    } catch {
+        return extractTagInfo({});
+    }
+}