mediatuna 1.21.11

package/lib/dupe-report.js

@@ -0,0 +1,223 @@
+import fs from 'fs';
+import path from 'path';
+import {
+    buildNameSizeQuery,
+    buildSizeHashQuery,
+    buildSizeQuery,
+    detectEverything,
+    isEverything15,
+    searchEverything,
+} from './everything.js';
+import { formatSize } from './format.js';
+import { sha256File } from './hash.js';
+
+export { sha256File };
+
+const SIZE_HIT_CAP = 25;
+
+export function sameResolvedPath(a, b) {
+    return path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+}
+
+export function classifyHits(inputPath, nameHits, sizeHits) {
+    const ext = path.extname(inputPath).toLowerCase();
+    const sameNameAndSize = nameHits.filter(hit => !sameResolvedPath(hit.path, inputPath));
+    const known = [inputPath, ...sameNameAndSize.map(hit => hit.path)];
+    const sizeOnly = sizeHits.filter(hit => {
+        if (known.some(item => sameResolvedPath(item, hit.path))) return false;
+        if (ext && path.extname(hit.path).toLowerCase() !== ext) return false;
+        return true;
+    });
+    return { sameNameAndSize, sizeOnly };
+}
+
+export function formatDupeReportLines({
+    folder,
+    everythingVersion,
+    hashEnabled,
+    rows,
+}) {
+    const withName = rows.filter(row => row.sameNameAndSize.length > 0);
+    const withSize = rows.filter(row => row.sameNameAndSize.length === 0 && row.sizeOnly.length > 0);
+    const unique = rows.filter(row => row.sameNameAndSize.length === 0 && row.sizeOnly.length === 0);
+    const errors = rows.filter(row => row.error);
+
+    const lines = [
+        'MediaTuna duplicate report (Everything)',
+        `Folder: ${folder}`,
+        `Everything: ${everythingVersion}${hashEnabled ? ' | hash confirm' : ''}`,
+        `Files: ${rows.length}  name+size copies: ${withName.length}  size-only: ${withSize.length}  unique: ${unique.length}${errors.length ? `  errors: ${errors.length}` : ''}`,
+        '',
+    ];
+
+    const section = (title, list, pick) => {
+        if (list.length === 0) return;
+        lines.push(`## ${title}`);
+        for (const row of list) {
+            lines.push(`${path.basename(row.input)}  (${formatSize(row.size)})`);
+            for (const hit of pick(row).slice(0, SIZE_HIT_CAP)) {
+                const note = hit.hashMatch === true
+                    ? '  [hash match]'
+                    : hit.hashMatch === false
+                        ? '  [hash differs]'
+                        : '';
+                lines.push(`  ${hit.path}${note}`);
+            }
+            if (pick(row).length > SIZE_HIT_CAP) {
+                lines.push(`  … ${pick(row).length - SIZE_HIT_CAP} more`);
+            }
+            lines.push('');
+        }
+    };
+
+    const hashedMatches = hashEnabled
+        ? rows.filter(row => row.sizeOnly.some(hit => hit.hashMatch === true) || row.sameNameAndSize.some(hit => hit.hashMatch === true))
+        : [];
+
+    section(
+        'Same name and size (not hashed)',
+        withName,
+        row => row.sameNameAndSize,
+    );
+    section(
+        'Size + same extension (not hashed — possible renamed copy)',
+        withSize.filter(row => !hashEnabled || row.sizeOnly.every(hit => hit.hashMatch !== true)),
+        row => row.sizeOnly.filter(hit => hit.hashMatch !== true),
+    );
+    if (hashedMatches.length > 0) {
+        section(
+            'SHA-256 match (whole-file bytes)',
+            hashedMatches,
+            row => [...row.sameNameAndSize, ...row.sizeOnly].filter(hit => hit.hashMatch === true),
+        );
+    }
+
+    if (unique.length > 0) {
+        lines.push('## No other copies found');
+        for (const row of unique) {
+            lines.push(`${path.basename(row.input)}  (${formatSize(row.size)})`);
+        }
+        lines.push('');
+    }
+
+    if (errors.length > 0) {
+        lines.push('## Errors');
+        for (const row of errors) {
+            lines.push(`${path.basename(row.input)}: ${row.error}`);
+        }
+        lines.push('');
+    }
+
+    return lines;
+}
+
+export async function buildDupeRows(files, {
+    searchFn,
+    hashFn = null,
+    useEverythingHash = false,
+} = {}) {
+    const rows = [];
+    for (const input of files) {
+        let size;
+        try {
+            size = fs.statSync(input).size;
+        } catch (err) {
+            rows.push({
+                input, size: 0, sameNameAndSize: [], sizeOnly: [],
+                error: `stat failed: ${err.message}`,
+            });
+            continue;
+        }
+
+        try {
+            const ext = path.extname(input).replace(/^\./, '').toLowerCase();
+            const nameHits = searchFn(buildNameSizeQuery(path.basename(input), size));
+            const sizeHits = searchFn(buildSizeQuery(size, ext));
+            const classified = classifyHits(input, nameHits, sizeHits);
+
+            if (hashFn && classified.sizeOnly.length > 0) {
+                if (useEverythingHash) {
+                    const digest = await hashFn(input);
+                    const hashHits = searchFn(buildSizeHashQuery(size, digest, ext));
+                    classified.sizeOnly = classified.sizeOnly.map(hit => ({
+                        ...hit,
+                        hashMatch: hashHits.some(other => sameResolvedPath(other.path, hit.path)),
+                    }));
+                } else {
+                    const sourceHash = await hashFn(input);
+                    const confirmed = [];
+                    for (const hit of classified.sizeOnly.slice(0, SIZE_HIT_CAP)) {
+                        try {
+                            const digest = await hashFn(hit.path);
+                            confirmed.push({ ...hit, hashMatch: digest === sourceHash });
+                        } catch (err) {
+                            confirmed.push({ ...hit, hashMatch: null, error: err.message });
+                        }
+                    }
+                    classified.sizeOnly = confirmed;
+                }
+            }
+
+            rows.push({
+                input,
+                size,
+                sameNameAndSize: classified.sameNameAndSize,
+                sizeOnly: classified.sizeOnly,
+                error: null,
+            });
+        } catch (err) {
+            rows.push({
+                input, size, sameNameAndSize: [], sizeOnly: [],
+                error: err.message,
+            });
+        }
+    }
+    return rows;
+}
+
+export async function runDupeReport({
+    files,
+    rootDir,
+    hash = false,
+    dryRun = false,
+    detectFn = detectEverything,
+    searchFn = null,
+    hashFn = sha256File,
+    writeFileFn = fs.writeFileSync,
+} = {}) {
+    const everything = detectFn();
+    const query = searchFn ?? ((q) => searchEverything(q, {
+        esPath: everything.esPath,
+        instance: everything.instance,
+    }));
+
+    const rows = await buildDupeRows(files, {
+        searchFn: query,
+        hashFn: hash ? hashFn : null,
+        useEverythingHash: hash && isEverything15(everything.version),
+    });
+
+    const lines = formatDupeReportLines({
+        folder: rootDir,
+        everythingVersion: everything.version.raw,
+        hashEnabled: hash,
+        rows,
+    });
+
+    const reportPath = path.join(rootDir, 'mediatuna-dupe-report.txt');
+    if (!dryRun) writeFileFn(reportPath, lines.join('\n') + '\n');
+
+    return {
+        lines,
+        rows,
+        reportPath: dryRun ? null : reportPath,
+        everything,
+        stats: {
+            files: rows.length,
+            nameCopies: rows.filter(r => r.sameNameAndSize.length > 0).length,
+            sizeOnly: rows.filter(r => r.sameNameAndSize.length === 0 && r.sizeOnly.length > 0).length,
+            unique: rows.filter(r => !r.error && r.sameNameAndSize.length === 0 && r.sizeOnly.length === 0).length,
+            errors: rows.filter(r => r.error).length,
+        },
+    };
+}

package/lib/encode.js

@@ -0,0 +1,194 @@
+import fs from 'fs';
+import { execFile, execFileSync } from 'child_process';
+import { lameQuality } from './audio-policy.js';
+import { formatFfmpegError } from './format.js';
+import { formatMtimeDate } from './paths.js';
+import { hasDateTag } from './tags.js';
+import { NVENC_MIN_HEIGHT, NVENC_MIN_WIDTH } from './constants.js';
+import { copyAndRepairTimestamps } from './timestamps.js';
+import { timeToSeconds } from './time.js';
+
+export function nvencSupportsFrame(meta) {
+    const width = Number(meta?.width) || 0;
+    const height = Number(meta?.height) || 0;
+    if (width <= 0 || height <= 0) return true;
+    return width >= NVENC_MIN_WIDTH && height >= NVENC_MIN_HEIGHT;
+}
+
+export function shouldDeinterlace(mode, meta) {
+    if (mode === 'on') return true;
+    if (mode === 'off') return false;
+    return meta.interlaced;
+}
+
+export function buildVideoFilter(deinterlaceMode, meta) {
+    if (!shouldDeinterlace(deinterlaceMode, meta)) return null;
+    return 'yadif';
+}
+
+export function withSampleLimit(args, sampleSeconds) {
+    if (!sampleSeconds) return args;
+    const inputFlag = args.indexOf('-i');
+    if (inputFlag < 0) return [...args, '-t', String(sampleSeconds)];
+    const afterInput = inputFlag + 2;
+    return [...args.slice(0, afterInput), '-t', String(sampleSeconds), ...args.slice(afterInput)];
+}
+
+export function sampleDuration(sourceDuration, sampleSeconds) {
+    if (!sampleSeconds) return sourceDuration;
+    if (!sourceDuration || sourceDuration <= 0) return sampleSeconds;
+    return Math.min(sourceDuration, sampleSeconds);
+}
+
+const COPYABLE_AAC_PROFILES = new Set(['', 'unknown', 'lc', 'low complexity', 'aac lc']);
+
+export function canCopyAacAudio(meta, { reencodeAudio = false } = {}) {
+    if (reencodeAudio) return false;
+    const codec = (meta?.audioCodec || '').toLowerCase();
+    if (codec !== 'aac') return false;
+    const profile = (meta?.audioProfile || '').toLowerCase().trim();
+    if (profile && !COPYABLE_AAC_PROFILES.has(profile)) return false;
+    const channels = Number(meta?.audioChannels) || 0;
+    if (channels > 2) return false;
+    return true;
+}
+
+export function videoAudioEncodeArgs(meta, { reencodeAudio = false } = {}) {
+    if (canCopyAacAudio(meta, { reencodeAudio })) return ['-c:a', 'copy'];
+    return ['-c:a', 'aac', '-b:a', '192k'];
+}
+
+export function buildFfmpegArgs(input, out, meta, {
+    quality, nvenc, deinterlaceMode, sampleSeconds = null, reencodeAudio = false,
+}) {
+    const args = ['-hide_banner', '-loglevel', 'info', '-n', '-i', input, '-map_metadata', '0'];
+
+    const vf = buildVideoFilter(deinterlaceMode, meta);
+    if (vf) args.push('-vf', vf);
+
+    args.push('-pix_fmt', 'yuv420p', '-movflags', '+faststart');
+
+    if (nvenc && nvencSupportsFrame(meta)) {
+        const p = quality === 'high' ? 'p7' : quality === 'fast' ? 'p4' : 'p6';
+        const cq = quality === 'high' ? '15' : '18';
+        args.push('-c:v', 'h264_nvenc', '-preset', p, '-cq', cq);
+    } else {
+        const crf = quality === 'high' ? '16' : quality === 'fast' ? '23' : '18';
+        args.push('-c:v', 'libx264', '-crf', crf, '-preset', quality === 'fast' ? 'medium' : 'slow');
+    }
+
+    args.push(...videoAudioEncodeArgs(meta, { reencodeAudio }), out);
+    return withSampleLimit(args, sampleSeconds);
+}
+
+export function buildAudioFfmpegArgs(input, out, { audioQuality, embedArt, preferMtime, meta, sampleSeconds = null }) {
+    const args = [
+        '-hide_banner', '-loglevel', 'info', '-n', '-i', input,
+        '-map_metadata', '0',
+        '-id3v2_version', '3',
+        '-write_id3v1', '0',
+    ];
+
+    if (preferMtime && !hasDateTag(meta.tags)) {
+        args.push('-metadata', `date=${formatMtimeDate(input)}`);
+    }
+
+    args.push('-map', '0:a:0', '-c:a', 'libmp3lame', '-q:a', lameQuality(audioQuality));
+
+    if (embedArt) {
+        args.push('-map', '0:v?', '-c:v', 'copy', '-disposition:v:0', 'attached_pic');
+    }
+
+    args.push(out);
+    return withSampleLimit(args, sampleSeconds);
+}
+
+export function buildExtractAudioFfmpegArgs(input, out, { audioQuality, preferMtime, meta, sampleSeconds = null }) {
+    const args = [
+        '-hide_banner', '-loglevel', 'info', '-n', '-i', input,
+        '-map_metadata', '0',
+        '-id3v2_version', '3',
+        '-write_id3v1', '0',
+    ];
+
+    if (preferMtime && !hasDateTag(meta.tags)) {
+        args.push('-metadata', `date=${formatMtimeDate(input)}`);
+    }
+
+    args.push('-map', '0:a:0', '-c:a', 'libmp3lame', '-q:a', lameQuality(audioQuality), out);
+    return withSampleLimit(args, sampleSeconds);
+}
+
+export function copyWindowsTimestamps(input, output) {
+    execFileSync('powershell', [
+        '-NoProfile', '-Command',
+        `$i = ${JSON.stringify(input)}; $o = ${JSON.stringify(output)}; `
+        + '$src = Get-Item -LiteralPath $i; $dst = Get-Item -LiteralPath $o; '
+        + '$dst.CreationTime = $src.CreationTime; $dst.LastWriteTime = $src.LastWriteTime',
+    ], { stdio: 'ignore' });
+}
+
+export function removePartialOutput(outPath, keepPartial, onRemoved) {
+    if (keepPartial || !fs.existsSync(outPath)) return;
+    try {
+        fs.unlinkSync(outPath);
+        onRemoved?.(`Removed incomplete output: ${outPath}`);
+    } catch (err) {
+        onRemoved?.(`Could not remove incomplete output: ${outPath} (${err.message})`);
+    }
+}
+
+export function runFfmpeg(args, { onProgress, setActiveProc } = {}) {
+    return new Promise((resolve, reject) => {
+        let stderrBuf = '';
+        const proc = execFile('ffmpeg', args, { maxBuffer: 1024 * 1024 * 100 }, (err) => {
+            setActiveProc?.(null);
+            if (err) reject(new Error(formatFfmpegError(stderrBuf, err.message)));
+            else resolve(stderrBuf);
+        });
+        setActiveProc?.(proc);
+        proc.stderr?.on('data', (data) => {
+            const chunk = data.toString();
+            stderrBuf += chunk;
+            onProgress?.(chunk, stderrBuf);
+        });
+    });
+}
+
+export function nvencEncoderListed(encodersText) {
+    return typeof encodersText === 'string' && encodersText.includes('h264_nvenc');
+}
+
+/** Tiny lavfi encode: encoder-list alone is true on apt ffmpeg with no GPU. */
+export const NVENC_PROBE_ARGS = [
+    '-hide_banner', '-loglevel', 'error',
+    '-f', 'lavfi', '-i', 'color=c=black:s=160x120:d=0.05',
+    '-frames:v', '1',
+    '-c:v', 'h264_nvenc',
+    '-f', 'null', '-',
+];
+
+export function detectNvenc() {
+    try {
+        const encoders = execFileSync('ffmpeg', ['-hide_banner', '-encoders'], {
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        if (!nvencEncoderListed(encoders)) return false;
+        execFileSync('ffmpeg', NVENC_PROBE_ARGS, { stdio: 'pipe', timeout: 15_000 });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export function applyOutputTimestamps(input, out) {
+    try {
+        copyAndRepairTimestamps(input, out);
+        return;
+    } catch {
+        const s = fs.statSync(input);
+        fs.utimesSync(out, s.atime, s.mtime);
+        if (process.platform === 'win32') copyWindowsTimestamps(input, out);
+    }
+}

package/lib/everything.js

@@ -0,0 +1,154 @@
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+const WELL_KNOWN_ES = [
+    path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Everything', 'es.exe'),
+    path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Everything 1.5a', 'es.exe'),
+    path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Everything 1.5b', 'es.exe'),
+];
+
+const INSTANCES = [null, '1.5a', '1.5b'];
+
+export function parseEverythingVersion(text) {
+    const match = String(text ?? '').trim().match(/(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?/);
+    if (!match) return null;
+    return {
+        raw: match[0],
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        build: match[4] != null ? Number(match[4]) : 0,
+    };
+}
+
+export function isEverything15(version) {
+    const parsed = typeof version === 'string' ? parseEverythingVersion(version) : version;
+    return Boolean(parsed && (parsed.major > 1 || (parsed.major === 1 && parsed.minor >= 5)));
+}
+
+export function quoteEverythingTerm(value) {
+    const text = String(value).replace(/"/g, '');
+    return /[\s&|<>^]/.test(text) ? `"${text}"` : text;
+}
+
+export function extensionTerm(filePath) {
+    const ext = path.extname(filePath).replace(/^\./, '').toLowerCase();
+    return ext || null;
+}
+
+export function buildNameSizeQuery(basename, size) {
+    return ['file:', `size:${size}`, `nopath:exact:${quoteEverythingTerm(basename)}`];
+}
+
+export function buildSizeQuery(size, ext) {
+    const terms = ['file:', `size:${size}`];
+    if (ext) terms.push(`ext:${String(ext).replace(/^\./, '').toLowerCase()}`);
+    return terms;
+}
+
+export function buildSizeHashQuery(size, sha256, ext) {
+    const terms = ['file:', `size:${size}`, `sha256:${String(sha256).toLowerCase()}`];
+    if (ext) terms.push(`ext:${String(ext).replace(/^\./, '').toLowerCase()}`);
+    return terms;
+}
+
+export function searchTerms(query) {
+    return Array.isArray(query) ? query : String(query).split(/\s+/).filter(Boolean);
+}
+
+export function parseCsvRow(line) {
+    const cells = [];
+    let current = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (inQuotes) {
+            if (ch === '"' && line[i + 1] === '"') {
+                current += '"';
+                i++;
+            } else if (ch === '"') {
+                inQuotes = false;
+            } else {
+                current += ch;
+            }
+        } else if (ch === '"') {
+            inQuotes = true;
+        } else if (ch === ',') {
+            cells.push(current);
+            current = '';
+        } else {
+            current += ch;
+        }
+    }
+    cells.push(current);
+    return cells;
+}
+
+export function parseEsCsv(text) {
+    const hits = [];
+    for (const line of String(text).split(/\r?\n/)) {
+        if (!line.trim()) continue;
+        const cells = parseCsvRow(line);
+        if (cells.length < 2) continue;
+        const size = Number(String(cells[0]).replace(/,/g, ''));
+        const filePath = cells[1].trim();
+        if (!Number.isFinite(size) || !filePath) continue;
+        hits.push({ size, path: filePath });
+    }
+    return hits;
+}
+
+export function resolveEsPath({ env = process.env, existsFn = fs.existsSync } = {}) {
+    if (env.MEDIATUNA_ES && existsFn(env.MEDIATUNA_ES)) return env.MEDIATUNA_ES;
+    for (const candidate of WELL_KNOWN_ES) {
+        if (existsFn(candidate)) return candidate;
+    }
+    return 'es.exe';
+}
+
+export function runEs(esPath, args, { instance = null } = {}) {
+    const full = instance ? ['-instance', instance, ...args] : args;
+    return execFileSync(esPath, full, {
+        encoding: 'utf8',
+        windowsHide: true,
+        maxBuffer: 16 * 1024 * 1024,
+    });
+}
+
+export function detectEverything({
+    esPath = resolveEsPath(),
+    runEsFn = runEs,
+} = {}) {
+    let lastError = null;
+    for (const instance of INSTANCES) {
+        try {
+            const raw = String(runEsFn(esPath, ['-get-everything-version'], { instance })).trim();
+            const version = parseEverythingVersion(raw);
+            if (!version) continue;
+            return { esPath, instance, version };
+        } catch (err) {
+            lastError = err;
+        }
+    }
+    const hint = lastError?.message ? ` (${lastError.message})` : '';
+    throw new Error(`Everything CLI did not respond${hint}. Is Everything running?`);
+}
+
+export function searchEverything(query, {
+    esPath,
+    instance = null,
+    runEsFn = runEs,
+    maxResults = 50,
+} = {}) {
+    const output = runEsFn(esPath, [
+        '-csv',
+        '-no-header',
+        '-no-digit-grouping',
+        '-n', String(maxResults),
+        '-size',
+        '-full-path-and-name',
+        ...searchTerms(query),
+    ], { instance });
+    return parseEsCsv(output);
+}

package/lib/extensions.js

@@ -0,0 +1,22 @@
+import path from 'path';
+import { VIDEO_EXTS, AUDIO_EXTS, LOSSLESS_AUDIO_EXTS, STAMP_EXTRA_EXTS } from './constants.js';
+
+export function hasVideoExt(filePath) {
+    return VIDEO_EXTS.has(path.extname(filePath).toLowerCase());
+}
+
+export function hasAudioExt(filePath) {
+    return AUDIO_EXTS.has(path.extname(filePath).toLowerCase());
+}
+
+export function hasMediaExt(filePath, mediaMode, { stampDates = false } = {}) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (mediaMode.video && VIDEO_EXTS.has(ext)) return true;
+    if (mediaMode.video && stampDates && STAMP_EXTRA_EXTS.has(ext)) return true;
+    if (mediaMode.audio && AUDIO_EXTS.has(ext)) return true;
+    return false;
+}
+
+export function isLossyAudioSource(input) {
+    return LOSSLESS_AUDIO_EXTS.has(path.extname(input).toLowerCase());
+}