mediatuna 1.21.11

package/lib/archive.js

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import path from 'path';
+import { uniqueDestPath } from './paths.js';
+
+export function archiveDestPath(input, archiveDir, { rootDir = null } = {}) {
+    const abs = path.resolve(input);
+    const root = rootDir ? path.resolve(rootDir) : path.dirname(abs);
+    const rel = path.relative(root, abs);
+    const safeRel = !rel || rel.startsWith('..') || path.isAbsolute(rel) ? path.basename(abs) : rel;
+    return path.join(path.resolve(archiveDir), safeRel);
+}
+
+export function formatArchivePlanLines(candidates, { archiveDir, dryRun = false } = {}) {
+    const prefix = dryRun ? '[DRY] ' : '';
+    const lines = ['', `${prefix}Sources below will be moved to ${archiveDir} after a verified convert (or cleanup).`, ''];
+    const showMax = 25;
+    for (const [i, entry] of candidates.entries()) {
+        if (i >= showMax) {
+            lines.push(`  ... and ${candidates.length - showMax} more`);
+            break;
+        }
+        lines.push(`  ${entry.input}`);
+        lines.push(`    → ${entry.dest}`);
+    }
+    lines.push('');
+    lines.push(`${prefix}${candidates.length} file(s) ready to archive.`);
+    lines.push('');
+    return lines;
+}
+
+export function moveOriginalsToArchive(paths, archiveDir, {
+    rootDir = null,
+    logConsole = () => {},
+    existsFn = fs.existsSync,
+    mkdirFn = fs.mkdirSync,
+    renameFn = fs.renameSync,
+    copyFn = fs.copyFileSync,
+    unlinkFn = fs.unlinkSync,
+    statFn = fs.statSync,
+} = {}) {
+    let moved = 0;
+    let failed = 0;
+    for (const filePath of paths) {
+        try {
+            if (!existsFn(filePath)) continue;
+            const destBase = archiveDestPath(filePath, archiveDir, { rootDir });
+            mkdirFn(path.dirname(destBase), { recursive: true });
+            const dest = uniqueDestPath(destBase, existsFn);
+            try {
+                renameFn(filePath, dest);
+            } catch (err) {
+                if (err.code !== 'EXDEV') throw err;
+                copyFn(filePath, dest);
+                const stat = statFn(filePath);
+                fs.utimesSync(dest, stat.atime, stat.mtime);
+                unlinkFn(filePath);
+            }
+            logConsole(`Archived original: ${filePath} → ${dest}`);
+            moved++;
+        } catch (err) {
+            logConsole(`Error archiving ${filePath}: ${err.message}`);
+            failed++;
+        }
+    }
+    return { moved, failed };
+}

package/lib/audio-policy.js

@@ -0,0 +1,53 @@
+const MP3_BITRATE_FLOOR_KBPS = {
+    high: 224,
+    medium: 160,
+    fast: 128,
+};
+
+export function lameQuality(quality) {
+    if (quality === 'high') return '0';
+    if (quality === 'fast') return '4';
+    return '2';
+}
+
+export function mp3BitrateFloorKbps(quality) {
+    return MP3_BITRATE_FLOOR_KBPS[quality] ?? MP3_BITRATE_FLOOR_KBPS.medium;
+}
+
+export function isSourceMp3(inputPath, meta) {
+    return pathExtLower(inputPath) === '.mp3' && meta.audioCodec === 'mp3';
+}
+
+export function hasBasicTags(meta) {
+    if (!meta?.tags) return false;
+    const tags = meta.tags;
+    return Boolean(
+        findTag(tags, 'title') ||
+        findTag(tags, 'artist') ||
+        findTag(tags, 'album') ||
+        (meta.tagCount ?? 0) >= 2
+    );
+}
+
+export function isNormalizedMp3(inputPath, meta, quality) {
+    if (!isSourceMp3(inputPath, meta)) return false;
+    if (!hasBasicTags(meta)) return false;
+    const bitrate = meta.audioBitrate ?? 0;
+    if (bitrate <= 0) return false;
+    return bitrate >= mp3BitrateFloorKbps(quality) * 1000;
+}
+
+function pathExtLower(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf('.'));
+    return ext.includes('.') ? ext.toLowerCase() : '';
+}
+
+function findTag(tags, name) {
+    const target = name.toLowerCase();
+    for (const [key, value] of Object.entries(tags)) {
+        const k = key.toLowerCase();
+        const normalized = k.includes(':') ? k.slice(k.lastIndexOf(':') + 1) : k;
+        if (normalized === target && value != null && String(value).trim()) return String(value).trim();
+    }
+    return null;
+}

package/lib/cleanup.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { moveToTrash } from './trash.js';
+
+export function formatDeletionPlanLines(candidates, { intro, countLabel, dryRun = false }) {
+    const prefix = dryRun ? '[DRY] ' : '';
+    const lines = ['', `${prefix}${intro}`, ''];
+    const showMax = 25;
+    for (const [i, entry] of candidates.entries()) {
+        if (i >= showMax) {
+            lines.push(`  ... and ${candidates.length - showMax} more`);
+            break;
+        }
+        lines.push(`  ${entry.input}`);
+        lines.push(`    → ${entry.out}`);
+    }
+    lines.push('');
+    lines.push(`${prefix}${candidates.length} file(s) ${countLabel}.`);
+    lines.push('');
+    return lines;
+}
+
+export function buildCleanupCandidates(preflight, verifyOutputFn) {
+    const eligible = [];
+    const skipped = [];
+
+    for (const entry of preflight) {
+        if (entry.status !== 'skip (exists)') {
+            if (entry.status.startsWith('convert')) {
+                skipped.push({ entry, reason: 'output does not exist yet' });
+            }
+            continue;
+        }
+
+        if (path.resolve(entry.input) === path.resolve(entry.out)) {
+            skipped.push({ entry, reason: 'already the converted output' });
+            continue;
+        }
+
+        const expectedType = entry.meta.mediaType === 'audio' ? 'audio' : 'video';
+        const check = verifyOutputFn(entry.out, entry.meta.duration, expectedType);
+        if (check.ok) {
+            eligible.push(entry);
+        } else {
+            skipped.push({ entry, reason: check.reason });
+        }
+    }
+
+    return { eligible, skipped };
+}
+
+export async function deleteOriginalFiles(paths, logConsole, {
+    permanent = false,
+    trashFn = moveToTrash,
+    unlinkFn = (filePath) => fs.unlinkSync(filePath),
+    existsFn = fs.existsSync,
+} = {}) {
+    let deleted = 0;
+    let deleteFailed = 0;
+    for (const filePath of paths) {
+        try {
+            if (!existsFn(filePath)) continue;
+            if (permanent) {
+                unlinkFn(filePath);
+                logConsole(`Deleted original (permanent): ${filePath}`);
+            } else {
+                await trashFn(filePath);
+                logConsole(`Moved original to Recycle Bin / trash: ${filePath}`);
+            }
+            deleted++;
+        } catch (err) {
+            logConsole(`Error deleting ${filePath}: ${err.message}`);
+            deleteFailed++;
+        }
+    }
+    return { deleted, deleteFailed };
+}

package/lib/cli-config.js

@@ -0,0 +1,336 @@
+import os from 'os';
+import path from 'path';
+import { VALID_DEINTERLACE, VALID_QUALITY } from './constants.js';
+import { parseJobsValue } from './jobs.js';
+import { parseGlobList } from './globs.js';
+
+export class CliConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CliConfigError';
+    }
+}
+
+export const CLI_PARSE_OPTIONS = {
+    help: { type: 'boolean', short: 'h' },
+    version: { type: 'boolean', short: 'V' },
+    force: { type: 'boolean' },
+    'dry-run': { type: 'boolean' },
+    recursive: { type: 'boolean' },
+    flat: { type: 'boolean' },
+    output: { type: 'string' },
+    log: { type: 'string' },
+    'master-log': { type: 'string' },
+    'no-master-log': { type: 'boolean' },
+    'delete-originals': { type: 'boolean' },
+    'cleanup-originals': { type: 'boolean' },
+    quality: { type: 'string', default: 'medium' },
+    deinterlace: { type: 'string', default: 'auto' },
+    'no-verify': { type: 'boolean' },
+    'keep-partial': { type: 'boolean' },
+    verbose: { type: 'boolean' },
+    'video-only': { type: 'boolean' },
+    'audio-only': { type: 'boolean' },
+    'prefer-mtime': { type: 'boolean' },
+    'embed-art': { type: 'boolean' },
+    'no-embed-art': { type: 'boolean' },
+    'extract-audio': { type: 'boolean' },
+    'audio-quality': { type: 'string' },
+    resume: { type: 'boolean' },
+    jobs: { type: 'string' },
+    'stamp-dates': { type: 'boolean' },
+    'no-stamp-dates': { type: 'boolean' },
+    backup: { type: 'string' },
+    'dupe-report': { type: 'boolean' },
+    hash: { type: 'boolean' },
+    'recup-map': { type: 'boolean' },
+    ext: { type: 'string' },
+    apply: { type: 'boolean' },
+    yes: { type: 'boolean', short: 'y' },
+    'delete-permanent': { type: 'boolean' },
+    include: { type: 'string', multiple: true },
+    exclude: { type: 'string', multiple: true },
+    archive: { type: 'string' },
+    sample: { type: 'string' },
+    'reencode-audio': { type: 'boolean' },
+};
+
+export function buildCliConfig(values, positionals, { cwd = process.cwd(), homedir = os.homedir() } = {}) {
+    if (values.recursive && values.flat) {
+        throw new CliConfigError('--recursive and --flat cannot be used together.');
+    }
+
+    if (values['audio-only'] && values['video-only']) {
+        throw new CliConfigError('--audio-only and --video-only cannot be used together.');
+    }
+
+    if (values['embed-art'] && values['no-embed-art']) {
+        throw new CliConfigError('--embed-art and --no-embed-art cannot be used together.');
+    }
+
+    const mediaMode = values['audio-only']
+        ? { video: false, audio: true }
+        : values['video-only']
+            ? { video: true, audio: false }
+            : { video: true, audio: true };
+
+    const quality = values.quality.toLowerCase();
+    if (!VALID_QUALITY.has(quality)) {
+        throw new CliConfigError(`invalid quality "${values.quality}". Use: high, medium, fast`);
+    }
+
+    const audioQuality = values['audio-quality']
+        ? values['audio-quality'].toLowerCase()
+        : quality;
+    if (!VALID_QUALITY.has(audioQuality)) {
+        throw new CliConfigError(`invalid audio-quality "${values['audio-quality']}". Use: high, medium, fast`);
+    }
+
+    if (values['extract-audio'] && values['audio-only']) {
+        throw new CliConfigError('--extract-audio requires video sources; omit --audio-only.');
+    }
+
+    const deinterlace = values.deinterlace.toLowerCase();
+    if (!VALID_DEINTERLACE.has(deinterlace)) {
+        throw new CliConfigError(`invalid deinterlace mode "${values.deinterlace}". Use: auto, on, off`);
+    }
+
+    if (values.output !== undefined && !values.output.trim()) {
+        throw new CliConfigError('--output requires a folder path.');
+    }
+
+    if (values.log !== undefined && !values.log.trim()) {
+        throw new CliConfigError('--log requires a file path.');
+    }
+
+    if (values['master-log'] !== undefined && !values['master-log'].trim()) {
+        throw new CliConfigError('--master-log requires a file path.');
+    }
+
+    if (values['delete-originals'] && values['no-verify']) {
+        throw new CliConfigError('--delete-originals requires post-encode verification (omit --no-verify).');
+    }
+
+    if (values['delete-originals'] && values['cleanup-originals']) {
+        throw new CliConfigError('--delete-originals and --cleanup-originals cannot be used together.');
+    }
+
+    if (values['cleanup-originals'] && values['no-verify']) {
+        throw new CliConfigError('--cleanup-originals verifies outputs before deleting (omit --no-verify).');
+    }
+
+    if (values['cleanup-originals'] && values.force) {
+        throw new CliConfigError('--cleanup-originals skips conversion; omit --force (convert first in a separate run).');
+    }
+
+    if (values.resume && values['dry-run']) {
+        throw new CliConfigError('--resume cannot be used with --dry-run.');
+    }
+
+    if (values.resume && values['no-verify']) {
+        throw new CliConfigError('--resume requires post-encode verification (omit --no-verify).');
+    }
+
+    if (values.backup !== undefined && !values.backup.trim()) {
+        throw new CliConfigError('--backup requires a folder path.');
+    }
+
+    if (values.backup && !values['stamp-dates']) {
+        throw new CliConfigError('--backup is only valid with --stamp-dates.');
+    }
+
+    if (values['stamp-dates'] && values['delete-originals']) {
+        throw new CliConfigError('--stamp-dates cannot be used with --delete-originals.');
+    }
+
+    if (values['stamp-dates'] && values['cleanup-originals']) {
+        throw new CliConfigError('--stamp-dates cannot be used with --cleanup-originals.');
+    }
+
+    if (values['stamp-dates'] && values['extract-audio']) {
+        throw new CliConfigError('--stamp-dates cannot be used with --extract-audio.');
+    }
+
+    if (values['stamp-dates'] && values.resume) {
+        throw new CliConfigError('--stamp-dates cannot be used with --resume.');
+    }
+
+    if (values['stamp-dates'] && values.output) {
+        throw new CliConfigError('--stamp-dates renames in place; use --backup instead of --output.');
+    }
+
+    if (values['stamp-dates'] && values['no-stamp-dates']) {
+        throw new CliConfigError('--stamp-dates and --no-stamp-dates cannot be used together.');
+    }
+
+    if (values.hash && !values['dupe-report'] && !values['recup-map']) {
+        throw new CliConfigError('--hash is only valid with --dupe-report or --recup-map.');
+    }
+
+    if (values['delete-permanent'] && !values['delete-originals'] && !values['cleanup-originals']) {
+        throw new CliConfigError('--delete-permanent is only valid with --delete-originals or --cleanup-originals.');
+    }
+
+    if (values['dupe-report'] && values['stamp-dates']) {
+        throw new CliConfigError('--dupe-report cannot be used with --stamp-dates.');
+    }
+
+    if (values['dupe-report'] && values['delete-originals']) {
+        throw new CliConfigError('--dupe-report cannot be used with --delete-originals.');
+    }
+
+    if (values['dupe-report'] && values['cleanup-originals']) {
+        throw new CliConfigError('--dupe-report cannot be used with --cleanup-originals.');
+    }
+
+    if (values['dupe-report'] && values['extract-audio']) {
+        throw new CliConfigError('--dupe-report cannot be used with --extract-audio.');
+    }
+
+    if (values['dupe-report'] && values.resume) {
+        throw new CliConfigError('--dupe-report cannot be used with --resume.');
+    }
+
+    if (values['dupe-report'] && values.output) {
+        throw new CliConfigError('--dupe-report writes a text report in the folder; omit --output.');
+    }
+
+    if (values.ext && !values['recup-map']) {
+        throw new CliConfigError('--ext is only valid with --recup-map.');
+    }
+
+    if (values.apply && !values['recup-map']) {
+        throw new CliConfigError('--apply is only valid with --recup-map.');
+    }
+
+    if (values['recup-map'] && values['dupe-report']) {
+        throw new CliConfigError('--recup-map cannot be used with --dupe-report.');
+    }
+
+    if (values['recup-map'] && values['stamp-dates']) {
+        throw new CliConfigError('--recup-map cannot be used with --stamp-dates.');
+    }
+
+    if (values['recup-map'] && values['delete-originals']) {
+        throw new CliConfigError('--recup-map cannot be used with --delete-originals. Use --cleanup-originals after --apply.');
+    }
+
+    if (values['recup-map'] && values['extract-audio']) {
+        throw new CliConfigError('--recup-map cannot be used with --extract-audio.');
+    }
+
+    if (values['recup-map'] && values.resume) {
+        throw new CliConfigError('--recup-map cannot be used with --resume.');
+    }
+
+    if (values.archive !== undefined && !values.archive.trim()) {
+        throw new CliConfigError('--archive requires a folder path.');
+    }
+
+    if (values.archive && values['delete-originals']) {
+        throw new CliConfigError('--archive cannot be used with --delete-originals (move or delete, not both).');
+    }
+
+    if (values.archive && values['delete-permanent']) {
+        throw new CliConfigError('--archive moves files; omit --delete-permanent.');
+    }
+
+    if (values.archive && values['no-verify']) {
+        throw new CliConfigError('--archive requires post-encode verification (omit --no-verify).');
+    }
+
+    if (values.archive && values['stamp-dates']) {
+        throw new CliConfigError('--archive cannot be used with --stamp-dates.');
+    }
+
+    if (values.archive && values['dupe-report']) {
+        throw new CliConfigError('--archive cannot be used with --dupe-report.');
+    }
+
+    if (values.archive && values['recup-map']) {
+        throw new CliConfigError('--archive cannot be used with --recup-map.');
+    }
+
+    let sampleSeconds = null;
+    if (values.sample !== undefined) {
+        const n = Number(values.sample);
+        if (!Number.isInteger(n) || n < 1 || n > 600) {
+            throw new CliConfigError('--sample requires an integer number of seconds from 1 to 600.');
+        }
+        sampleSeconds = n;
+    }
+
+    if (sampleSeconds && (values['delete-originals'] || values['cleanup-originals'] || values.archive)) {
+        throw new CliConfigError('--sample writes a short preview only; omit delete/archive flags.');
+    }
+
+    if (sampleSeconds && values.resume) {
+        throw new CliConfigError('--sample cannot be used with --resume.');
+    }
+
+    if (sampleSeconds && values['stamp-dates']) {
+        throw new CliConfigError('--sample cannot be used with --stamp-dates.');
+    }
+
+    if (sampleSeconds && values['dupe-report']) {
+        throw new CliConfigError('--sample cannot be used with --dupe-report.');
+    }
+
+    if (sampleSeconds && values['recup-map']) {
+        throw new CliConfigError('--sample cannot be used with --recup-map.');
+    }
+
+    let jobs;
+    try {
+        jobs = parseJobsValue(values.jobs);
+    } catch (err) {
+        throw new CliConfigError(err.message);
+    }
+
+    const target = positionals[0] ?? null;
+    if (positionals.length > 1) {
+        throw new CliConfigError(`unexpected extra arguments: ${positionals.slice(1).join(' ')}`);
+    }
+
+    return {
+        force: values.force ?? false,
+        dryRun: values['dry-run'] ?? false,
+        recursive: values.recursive ?? false,
+        outputDir: values.output ? path.resolve(values.output) : null,
+        logFile: values.log ? path.resolve(values.log) : path.join(cwd, 'mediatuna-log.txt'),
+        masterLogEnabled: !(values['no-master-log'] ?? false),
+        masterLogFile: values['master-log']
+            ? path.resolve(values['master-log'])
+            : path.join(homedir, '.mediatuna', 'history.log'),
+        deleteOriginals: values['delete-originals'] ?? false,
+        cleanupOriginals: values['cleanup-originals'] ?? false,
+        quality,
+        audioQuality,
+        extractAudio: values['extract-audio'] ?? false,
+        deinterlace,
+        verify: !(values['no-verify'] ?? false),
+        keepPartial: values['keep-partial'] ?? false,
+        verbose: values.verbose ?? false,
+        mediaMode,
+        preferMtime: values['prefer-mtime'] ?? false,
+        embedArt: values['no-embed-art'] ? false : (values['embed-art'] ?? true),
+        resume: values.resume ?? false,
+        jobs,
+        stampDates: values['stamp-dates'] ?? false,
+        stampVideo: !(values['no-stamp-dates'] ?? false),
+        backupDir: values.backup ? path.resolve(values.backup) : null,
+        dupeReport: values['dupe-report'] ?? false,
+        dupeHash: values.hash ?? false,
+        recupMap: values['recup-map'] ?? false,
+        recupExt: values.ext ?? null,
+        recupApply: values.apply ?? false,
+        yes: values.yes ?? false,
+        deletePermanent: values['delete-permanent'] ?? false,
+        include: parseGlobList(values.include),
+        exclude: parseGlobList(values.exclude),
+        archiveDir: values.archive ? path.resolve(values.archive) : null,
+        sampleSeconds,
+        reencodeAudio: values['reencode-audio'] ?? false,
+        target,
+    };
+}

package/lib/constants.js

@@ -0,0 +1,17 @@
+export const VIDEO_EXTS = new Set(['.avi', '.mov', '.mod', '.vob', '.mts', '.m2ts', '.mpg', '.mpeg', '.wmv', '.3gp', '.3g2']);
+export const AUDIO_EXTS = new Set([
+    '.mp3', '.flac', '.wav', '.aiff', '.aif', '.ape', '.m4a', '.aac', '.alac',
+    '.ogg', '.opus', '.wma', '.ac3', '.dts', '.amr', '.qcp',
+]);
+export const LOSSLESS_AUDIO_EXTS = new Set(['.flac', '.wav', '.aiff', '.aif', '.ape']);
+export const VIDEO_GLOB_PATTERN = '**/*.{avi,mov,mod,vob,mts,m2ts,mpg,mpeg,wmv,3gp,3g2}';
+export const AUDIO_GLOB_PATTERN = '**/*.{mp3,flac,wav,aiff,aif,ape,m4a,aac,alac,ogg,opus,wma,ac3,dts,amr,qcp}';
+/** Converted MP4s are not re-encoded, but --stamp-dates still rewrites their names. */
+export const STAMP_EXTRA_EXTS = new Set(['.mp4']);
+export const STAMP_VIDEO_GLOB_PATTERN = '**/*.{avi,mov,mod,vob,mts,m2ts,mpg,mpeg,wmv,3gp,3g2,mp4}';
+export const VALID_QUALITY = new Set(['high', 'medium', 'fast']);
+export const VALID_DEINTERLACE = new Set(['auto', 'on', 'off']);
+export const INTERLACED_FIELD_ORDERS = new Set(['tt', 'bb', 'tb', 'bt']);
+/** NVIDIA H.264 NVENC rejects frames below this size (seen as "Frame Dimension less than the minimum"). */
+export const NVENC_MIN_WIDTH = 145;
+export const NVENC_MIN_HEIGHT = 49;

package/lib/discover.js

@@ -0,0 +1,38 @@
+import fs from 'fs';
+import path from 'path';
+import { glob } from 'glob';
+import { VIDEO_GLOB_PATTERN, AUDIO_GLOB_PATTERN, STAMP_VIDEO_GLOB_PATTERN } from './constants.js';
+import { hasMediaExt } from './extensions.js';
+import { filterByGlobs } from './globs.js';
+
+export function getFlatFiles(target, mediaMode, { stampDates = false } = {}) {
+    const files = [];
+    for (const item of fs.readdirSync(target)) {
+        const full = path.join(target, item);
+        if (fs.statSync(full).isFile() && hasMediaExt(full, mediaMode, { stampDates })) files.push(full);
+    }
+    return files;
+}
+
+export function dedupeFiles(fileList) {
+    return [...new Set(fileList.map(f => path.resolve(f)))].sort();
+}
+
+export async function discoverFiles(target, recursive, mediaMode, {
+    stampDates = false, include = [], exclude = [],
+} = {}) {
+    let files = getFlatFiles(target, mediaMode, { stampDates });
+    if (recursive) {
+        const patterns = [];
+        if (mediaMode.video) patterns.push(stampDates ? STAMP_VIDEO_GLOB_PATTERN : VIDEO_GLOB_PATTERN);
+        if (mediaMode.audio) patterns.push(AUDIO_GLOB_PATTERN);
+        for (const pattern of patterns) {
+            const recFiles = await glob(pattern, { cwd: target, absolute: true, nocase: true });
+            files = [...files, ...recFiles];
+        }
+        files = dedupeFiles(files);
+    } else {
+        files = dedupeFiles(files);
+    }
+    return filterByGlobs(files, { include, exclude, rootDir: target });
+}