feat: Tdarr Local Flow Plugin Suite v1.0
7 atomic plugins for automated x265 transcoding pipeline: - utility/mediaAnalyzerGOP : GOP calc, FPS detection, film/series/anime routing - utility/setAnimationFlag : manual animation flag override - utility/extractChaptersXml : mkvextract chapters to XML - audio/audioSelectorClamping : codec scoring, clamped Opus bitrates, 2 outputs - audio/backupSourceAudio : lossless DTS/TrueHD ITA backup (-c:a copy) - subtitles/extractSubtitlesAndOcr : SRT extract + SubtitleEdit OCR for PGS - video/transcode2PassX265 : 2-pass x265, Lanczos 1080p bound, Opus mux Test suite: 34 unit tests + 3 integration tests (FFmpeg real files) FlowHelpers mock for local testing included Docs: integration-guide.md with canvas wiring and deploy instructions
This commit is contained in:
PickleRick committed
commit
c2074be826
19 files changed
+2134
No files matched your search
+26
@@ -0,0 +1,26 @@
|
||||
# Node.js
|
||||
node_modules/
|
||||
npm-debug.log*
|
||||
yarn-debug.log*
|
||||
yarn-error.log*
|
||||
|
||||
# Test artifacts
|
||||
tests/samples/
|
||||
tests/fix-*.js
|
||||
tests/super-fix*.js
|
||||
|
||||
# OS
|
||||
.DS_Store
|
||||
Thumbs.db
|
||||
desktop.ini
|
||||
|
||||
# Editor
|
||||
.vscode/
|
||||
.idea/
|
||||
*.swp
|
||||
*.swo
|
||||
|
||||
# Tdarr temp
|
||||
*.log
|
||||
*.mbtree
|
||||
*.cutree
|
||||
@@ -0,0 +1,42 @@
|
||||
'use strict';
|
||||
/**
|
||||
* Local mock of Tdarr FlowHelpers/1.0.0/cliUtils.js
|
||||
* Used only for local testing — on real Tdarr this file comes from the server.
|
||||
*/
|
||||
const { spawn } = require('child_process');
|
||||
|
||||
class CLI {
|
||||
constructor(config) {
|
||||
this.config = config;
|
||||
}
|
||||
|
||||
runCli() {
|
||||
return new Promise((resolve) => {
|
||||
const { cli, spawnArgs, WorkDir, jobLog } = this.config;
|
||||
|
||||
if (jobLog) jobLog(`[CLI] Running: ${cli} ${spawnArgs.join(' ')}\n`);
|
||||
|
||||
const proc = spawn(cli, spawnArgs, {
|
||||
cwd: WorkDir || process.cwd(),
|
||||
stdio: ['ignore', 'pipe', 'pipe'],
|
||||
shell: false,
|
||||
});
|
||||
|
||||
proc.stdout.on('data', (d) => { if (jobLog) jobLog(d.toString()); });
|
||||
proc.stderr.on('data', (d) => { if (jobLog) jobLog(d.toString()); });
|
||||
|
||||
proc.on('close', (code) => {
|
||||
resolve({ cliExitCode: code || 0 });
|
||||
});
|
||||
|
||||
proc.on('error', (err) => {
|
||||
if (jobLog) jobLog(`[CLI] Error: ${err.message}\n`);
|
||||
resolve({ cliExitCode: 1 });
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const getFFmpegVar = () => {};
|
||||
|
||||
module.exports = { CLI, getFFmpegVar };
|
||||
@@ -0,0 +1,12 @@
|
||||
'use strict';
|
||||
/**
|
||||
* Local mock of Tdarr FlowHelpers/1.0.0/fileUtils.js
|
||||
*/
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
const moveFile = (src, dest) => fs.renameSync(src, dest);
|
||||
const copyFile = (src, dest) => fs.copyFileSync(src, dest);
|
||||
const getFileSize = (fp) => { try { return fs.statSync(fp).size; } catch(_) { return 0; } };
|
||||
|
||||
module.exports = { moveFile, copyFile, getFileSize };
|
||||
@@ -0,0 +1,206 @@
|
||||
'use strict';
|
||||
|
||||
/* eslint-disable no-param-reassign */
|
||||
|
||||
/**
|
||||
* audioSelectorClamping
|
||||
* Selects the best ITA and ENG audio tracks using codec+bitrate scoring,
|
||||
* then calculates clamped Opus target bitrates.
|
||||
*
|
||||
* Scoring: score = (codecWeight * 10000) + bitrateKbps
|
||||
* Weights: TrueHD=100, DTS-HD MA=95, FLAC=90, EAC3=75, DTS=60,
|
||||
* AC3=45, AAC=35, Opus=30
|
||||
*
|
||||
* Clamping:
|
||||
* Multichannel (ch > 2):
|
||||
* Film: min(filmMultiChannelBitrate, sourceBitrateKbps)
|
||||
* Series: sourceBitrateKbps >= threshold ? 384 : 256
|
||||
* Stereo (ch <= 2):
|
||||
* min(stereoBitrateMax, sourceBitrateKbps) [no upcoding]
|
||||
*/
|
||||
|
||||
const CODEC_WEIGHTS = {
|
||||
truehd: 100,
|
||||
flac: 90,
|
||||
eac3: 75,
|
||||
dts: 60,
|
||||
ac3: 45,
|
||||
aac: 35,
|
||||
opus: 30,
|
||||
mp3: 20,
|
||||
vorbis: 20,
|
||||
};
|
||||
|
||||
const getCodecWeight = (stream) => {
|
||||
const codec = (stream.codec_name || '').toLowerCase();
|
||||
const profile = (stream.profile || '').toLowerCase();
|
||||
// DTS-HD MA detection via profile field
|
||||
if (codec === 'dts' && (profile.includes('ma') || profile.includes('dts-hd'))) return 95;
|
||||
return CODEC_WEIGHTS[codec] || 5;
|
||||
};
|
||||
|
||||
const getSourceBitrateKbps = (stream) => {
|
||||
const br = parseInt(stream.bit_rate || '0', 10);
|
||||
return br > 0 ? Math.round(br / 1000) : 0;
|
||||
};
|
||||
|
||||
const calcOpusBitrate = (stream, isMovie, inputs) => {
|
||||
const srcKbps = getSourceBitrateKbps(stream);
|
||||
const ch = parseInt(stream.channels || '2', 10);
|
||||
const stereoMax = parseInt(inputs.stereoBitrateMax || '128', 10);
|
||||
const filmTarget = parseInt(inputs.filmMultiChannelBitrate || '640', 10);
|
||||
const serThreshold = parseInt(inputs.seriesMultiChannelThreshold || '384', 10);
|
||||
|
||||
if (ch <= 2) {
|
||||
// Stereo: min(max, source) — no upcoding
|
||||
return srcKbps > 0 ? Math.min(stereoMax, srcKbps) : stereoMax;
|
||||
}
|
||||
|
||||
// Multichannel
|
||||
if (isMovie) {
|
||||
return srcKbps > 0 ? Math.min(filmTarget, srcKbps) : filmTarget;
|
||||
}
|
||||
// Series
|
||||
// If bitrate is unknown (0), assume high-quality source -> use 384k
|
||||
const effectiveKbps = srcKbps > 0 ? srcKbps : serThreshold;
|
||||
return effectiveKbps >= serThreshold ? 384 : 256;
|
||||
};
|
||||
|
||||
const details = () => ({
|
||||
name: 'Audio Selector & Opus Bitrate Clamping',
|
||||
description:
|
||||
'Selects the best ITA and ENG audio tracks using weighted codec+bitrate scoring. '
|
||||
+ 'Calculates clamped Opus target bitrates. '
|
||||
+ 'Output 1: tracks found. Output 2: no ITA or ENG tracks found.',
|
||||
style: { borderColor: '#4CAF50' },
|
||||
tags: 'audio',
|
||||
isStartPlugin: false,
|
||||
pType: '',
|
||||
requiresVersion: '2.11.01',
|
||||
sidebarPosition: 2,
|
||||
icon: 'faVolumeUp',
|
||||
inputs: [
|
||||
{
|
||||
label: 'Film Multichannel Bitrate (kbps)',
|
||||
name: 'filmMultiChannelBitrate',
|
||||
type: 'string',
|
||||
defaultValue: '640',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Max Opus bitrate in kbps for multichannel (>2ch) Film audio. Source bitrate is used if lower.',
|
||||
},
|
||||
{
|
||||
label: 'Series Multichannel Threshold (kbps)',
|
||||
name: 'seriesMultiChannelThreshold',
|
||||
type: 'string',
|
||||
defaultValue: '384',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'For series: if source bitrate >= this value, Opus target is 384k, otherwise 256k.',
|
||||
},
|
||||
{
|
||||
label: 'Stereo Max Bitrate (kbps)',
|
||||
name: 'stereoBitrateMax',
|
||||
type: 'string',
|
||||
defaultValue: '128',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Max Opus bitrate for stereo tracks. Source bitrate is used if lower (no upcoding).',
|
||||
},
|
||||
],
|
||||
outputs: [
|
||||
{ number: 1, tooltip: 'ITA or ENG track found — continue pipeline' },
|
||||
{ number: 2, tooltip: 'No ITA or ENG tracks found — handle separately' },
|
||||
],
|
||||
});
|
||||
|
||||
const plugin = async (args) => {
|
||||
const { jobLog, inputFileObj, variables } = args;
|
||||
|
||||
const filePath = inputFileObj._id;
|
||||
jobLog(`[audioSelectorClamping] Processing: ${filePath}\n`);
|
||||
|
||||
const isMovie = variables.isMovie === 'true';
|
||||
jobLog(`[audioSelectorClamping] isMovie=${isMovie}\n`);
|
||||
|
||||
const streams = (inputFileObj.ffProbeData && inputFileObj.ffProbeData.streams) || [];
|
||||
const audioStreams = streams.filter((s) => s.codec_type === 'audio');
|
||||
|
||||
jobLog(`[audioSelectorClamping] Found ${audioStreams.length} audio stream(s).\n`);
|
||||
|
||||
let bestIta = null;
|
||||
let bestEng = null;
|
||||
let bestItaScore = -1;
|
||||
let bestEngScore = -1;
|
||||
|
||||
audioStreams.forEach((stream) => {
|
||||
const lang = ((stream.tags && stream.tags.language) || '').toLowerCase();
|
||||
if (lang !== 'ita' && lang !== 'eng' && lang !== 'it' && lang !== 'en') return;
|
||||
|
||||
const normLang = (lang === 'it') ? 'ita' : (lang === 'en') ? 'eng' : lang;
|
||||
const weight = getCodecWeight(stream);
|
||||
const srcKbps = getSourceBitrateKbps(stream);
|
||||
const score = weight * 10000 + srcKbps;
|
||||
|
||||
jobLog(
|
||||
`[audioSelectorClamping] Stream #${stream.index} lang=${normLang} `
|
||||
+ `codec=${stream.codec_name} profile="${stream.profile || ''}" `
|
||||
+ `src=${srcKbps}kbps ch=${stream.channels} score=${score}\n`,
|
||||
);
|
||||
|
||||
if (normLang === 'ita' && score > bestItaScore) {
|
||||
bestItaScore = score;
|
||||
bestIta = { stream, normLang };
|
||||
}
|
||||
if (normLang === 'eng' && score > bestEngScore) {
|
||||
bestEngScore = score;
|
||||
bestEng = { stream, normLang };
|
||||
}
|
||||
});
|
||||
|
||||
if (!bestIta && !bestEng) {
|
||||
jobLog('[audioSelectorClamping] WARNING: No ITA or ENG tracks found. Routing to output 2.\n');
|
||||
variables.audioHasIta = 'false';
|
||||
variables.audioHasEng = 'false';
|
||||
return { outputNumber: 2, outputFileObj: inputFileObj, variables };
|
||||
}
|
||||
|
||||
// Export ITA
|
||||
if (bestIta) {
|
||||
const { stream } = bestIta;
|
||||
const opusBitrate = calcOpusBitrate(stream, isMovie, args.inputs);
|
||||
variables.audioHasIta = 'true';
|
||||
variables.audioItaStreamIndex = String(stream.index);
|
||||
variables.audioItaOpusBitrate = String(opusBitrate);
|
||||
variables.audioItaChannels = String(stream.channels || '2');
|
||||
variables.audioItaCodecName = (stream.codec_name || '').toLowerCase();
|
||||
jobLog(
|
||||
`[audioSelectorClamping] ITA selected: #${stream.index} ${stream.codec_name} `
|
||||
+ `${getSourceBitrateKbps(stream)}kbps -> Opus ${opusBitrate}kbps\n`,
|
||||
);
|
||||
} else {
|
||||
variables.audioHasIta = 'false';
|
||||
jobLog('[audioSelectorClamping] No ITA track found.\n');
|
||||
}
|
||||
|
||||
// Export ENG
|
||||
if (bestEng) {
|
||||
const { stream } = bestEng;
|
||||
const opusBitrate = calcOpusBitrate(stream, isMovie, args.inputs);
|
||||
variables.audioHasEng = 'true';
|
||||
variables.audioEngStreamIndex = String(stream.index);
|
||||
variables.audioEngOpusBitrate = String(opusBitrate);
|
||||
variables.audioEngChannels = String(stream.channels || '2');
|
||||
variables.audioEngCodecName = (stream.codec_name || '').toLowerCase();
|
||||
jobLog(
|
||||
`[audioSelectorClamping] ENG selected: #${stream.index} ${stream.codec_name} `
|
||||
+ `${getSourceBitrateKbps(stream)}kbps -> Opus ${opusBitrate}kbps\n`,
|
||||
);
|
||||
} else {
|
||||
variables.audioHasEng = 'false';
|
||||
jobLog('[audioSelectorClamping] No ENG track found.\n');
|
||||
}
|
||||
|
||||
jobLog('[audioSelectorClamping] Done.\n');
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
};
|
||||
|
||||
module.exports.details = details;
|
||||
module.exports.plugin = plugin;
|
||||
@@ -0,0 +1,94 @@
|
||||
'use strict';
|
||||
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
|
||||
/* eslint-disable no-param-reassign */
|
||||
|
||||
/**
|
||||
* backupSourceAudio
|
||||
* Extracts the original ITA audio track as a lossless bitstream copy,
|
||||
* ONLY when the codec is DTS or TrueHD.
|
||||
* Output is saved next to the source file (same directory).
|
||||
*/
|
||||
|
||||
const BACKUP_CODECS = ['dts', 'truehd'];
|
||||
const details = () => ({
|
||||
name: 'Backup Source Audio (DTS / TrueHD ITA)',
|
||||
description:
|
||||
'Extracts the ITA audio track as a lossless bitstream copy (-c:a copy) '
|
||||
+ 'when the source codec is DTS or TrueHD. '
|
||||
+ 'Output is saved next to the source file. '
|
||||
+ 'Silently skips if the ITA track does not require backup.',
|
||||
style: { borderColor: '#F44336' },
|
||||
tags: 'audio,backup',
|
||||
isStartPlugin: false,
|
||||
pType: '',
|
||||
requiresVersion: '2.11.01',
|
||||
sidebarPosition: -1,
|
||||
icon: 'faSave',
|
||||
inputs: [],
|
||||
outputs: [
|
||||
{ number: 1, tooltip: 'Continue to next plugin' },
|
||||
],
|
||||
});
|
||||
|
||||
const plugin = async (args) => {
|
||||
const { jobLog, inputFileObj, variables, workDir } = args;
|
||||
|
||||
const inputFile = inputFileObj._id;
|
||||
jobLog(`[backupSourceAudio] Processing: ${inputFile}\n`);
|
||||
|
||||
const hasIta = variables.audioHasIta === 'true';
|
||||
const itaCodec = (variables.audioItaCodecName || '').toLowerCase();
|
||||
const itaIdx = variables.audioItaStreamIndex;
|
||||
|
||||
if (!hasIta) {
|
||||
jobLog('[backupSourceAudio] No ITA track found — skipping.\n');
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
}
|
||||
|
||||
const needsBackup = BACKUP_CODECS.some((c) => itaCodec.includes(c));
|
||||
if (!needsBackup) {
|
||||
jobLog(`[backupSourceAudio] ITA codec "${itaCodec}" does not require backup — skipping.\n`);
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
}
|
||||
|
||||
// Determine output extension
|
||||
let ext = '.dts';
|
||||
if (itaCodec.includes('truehd')) ext = '.thd';
|
||||
|
||||
const sourceDir = path.dirname(inputFile);
|
||||
const baseName = path.basename(inputFile, path.extname(inputFile));
|
||||
const outFile = path.join(sourceDir, `${baseName}.ita${ext}`);
|
||||
|
||||
jobLog(`[backupSourceAudio] Backing up ITA ${itaCodec} -> ${outFile}\n`);
|
||||
|
||||
const { CLI } = require('../../../../FlowHelpers/1.0.0/cliUtils');
|
||||
const cli = new CLI({
|
||||
cli: args.ffmpegPath,
|
||||
spawnArgs: [
|
||||
'-y',
|
||||
'-i', inputFile,
|
||||
'-map', `0:${itaIdx}`,
|
||||
'-c:a', 'copy',
|
||||
outFile,
|
||||
],
|
||||
WorkDir: workDir,
|
||||
jobLog,
|
||||
});
|
||||
|
||||
const { cliExitCode } = await cli.runCli();
|
||||
|
||||
if (cliExitCode !== 0) {
|
||||
jobLog(`[backupSourceAudio] WARNING: FFmpeg exited with code ${cliExitCode}. Backup may be incomplete.\n`);
|
||||
} else {
|
||||
jobLog(`[backupSourceAudio] Backup complete: ${outFile}\n`);
|
||||
variables.audioBackupPath = outFile;
|
||||
}
|
||||
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
};
|
||||
|
||||
module.exports.details = details;
|
||||
module.exports.plugin = plugin;
|
||||
@@ -0,0 +1,197 @@
|
||||
'use strict';
|
||||
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
|
||||
/* eslint-disable no-param-reassign */
|
||||
|
||||
/**
|
||||
* extractSubtitlesAndOcr
|
||||
* Extracts subtitle streams for ITA and ENG languages:
|
||||
* - Text-based (subrip, srt, ass, ssa, webvtt): direct FFmpeg extraction
|
||||
* - Bitmap-based (hdmv_pgs_subtitle, dvd_subtitle): FFmpeg .sup extract
|
||||
* then SubtitleEdit CLI OCR -> .srt (with graceful fallback on failure)
|
||||
*
|
||||
* Output files go next to the source file.
|
||||
* Naming: <baseName>.<lang>[.forced][.default][.sdh].srt
|
||||
*/
|
||||
|
||||
const TEXT_CODECS = new Set(['subrip', 'srt', 'ass', 'ssa', 'webvtt', 'mov_text']);
|
||||
const BITMAP_CODECS = new Set(['hdmv_pgs_subtitle', 'dvd_subtitle', 'pgssub', 'dvbsub']);
|
||||
|
||||
const details = () => ({
|
||||
name: 'Extract Subtitles & OCR Fallback',
|
||||
description:
|
||||
'Extracts ITA/ENG subtitle streams to SRT files next to the source. '
|
||||
+ 'Text subtitles are extracted directly via FFmpeg. '
|
||||
+ 'Bitmap subtitles (PGS/VOBSUB) are OCR-d via SubtitleEdit CLI. '
|
||||
+ 'OCR failures are logged as warnings without stopping the pipeline.',
|
||||
style: { borderColor: '#00BCD4' },
|
||||
tags: 'subtitles',
|
||||
isStartPlugin: false,
|
||||
pType: '',
|
||||
requiresVersion: '2.11.01',
|
||||
sidebarPosition: 3,
|
||||
icon: 'faClosedCaptioning',
|
||||
inputs: [
|
||||
{
|
||||
label: 'SubtitleEdit Executable Path',
|
||||
name: 'subtitleEditPath',
|
||||
type: 'string',
|
||||
defaultValue: 'SubtitleEdit',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip:
|
||||
'Name or full path of the SubtitleEdit CLI executable. '
|
||||
+ 'Must be in system PATH or provide absolute path. '
|
||||
+ 'Used for OCR of PGS/VOBSUB streams on Windows workers.',
|
||||
},
|
||||
{
|
||||
label: 'Languages to Extract (CSV)',
|
||||
name: 'languages',
|
||||
type: 'string',
|
||||
defaultValue: 'ita,eng',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Comma-separated list of ISO 639-2 language codes. Example: ita,eng',
|
||||
},
|
||||
],
|
||||
outputs: [
|
||||
{ number: 1, tooltip: 'Continue to next plugin (warnings in log if OCR failed)' },
|
||||
],
|
||||
});
|
||||
|
||||
// ─── Helpers ──────────────────────────────────────────────────────────────────
|
||||
|
||||
const normLang = (tag) => {
|
||||
const l = (tag || '').toLowerCase().trim();
|
||||
if (l === 'it') return 'ita';
|
||||
if (l === 'en') return 'eng';
|
||||
return l;
|
||||
};
|
||||
|
||||
const buildSuffix = (lang, stream) => {
|
||||
const parts = [lang];
|
||||
if (stream.disposition && stream.disposition.forced) parts.push('forced');
|
||||
if (stream.disposition && stream.disposition.default) parts.push('default');
|
||||
if (stream.disposition && stream.disposition.hearing_impaired) parts.push('sdh');
|
||||
// Also check title tag for SDH
|
||||
const title = ((stream.tags && stream.tags.title) || '').toLowerCase();
|
||||
if (!parts.includes('sdh') && title.includes('sdh')) parts.push('sdh');
|
||||
return parts.join('.');
|
||||
};
|
||||
|
||||
const runFFmpeg = async (spawnArgs, workDir, ffmpegPath, jobLog) => {
|
||||
const { CLI } = require('../../../../FlowHelpers/1.0.0/cliUtils');
|
||||
const cli = new CLI({ cli: ffmpegPath, spawnArgs, WorkDir: workDir, jobLog });
|
||||
return cli.runCli();
|
||||
};
|
||||
|
||||
// ─── Plugin ───────────────────────────────────────────────────────────────────
|
||||
|
||||
const plugin = async (args) => {
|
||||
const { jobLog, inputFileObj, variables, workDir } = args;
|
||||
|
||||
const inputFile = inputFileObj._id;
|
||||
const sourceDir = path.dirname(inputFile);
|
||||
const baseName = path.basename(inputFile, path.extname(inputFile));
|
||||
|
||||
jobLog(`[extractSubtitlesAndOcr] Source: ${inputFile}\n`);
|
||||
|
||||
const subtitleEditPath = args.inputs.subtitleEditPath || 'SubtitleEdit';
|
||||
const targetLangs = (args.inputs.languages || 'ita,eng')
|
||||
.split(',').map((l) => l.trim().toLowerCase()).filter(Boolean);
|
||||
|
||||
const streams = (inputFileObj.ffProbeData && inputFileObj.ffProbeData.streams) || [];
|
||||
const subtitleStreams = streams.filter((s) => s.codec_type === 'subtitle');
|
||||
|
||||
if (subtitleStreams.length === 0) {
|
||||
jobLog('[extractSubtitlesAndOcr] No subtitle streams found.\n');
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
}
|
||||
|
||||
jobLog(`[extractSubtitlesAndOcr] Found ${subtitleStreams.length} subtitle stream(s).\n`);
|
||||
|
||||
for (const stream of subtitleStreams) {
|
||||
const lang = normLang((stream.tags && stream.tags.language) || '');
|
||||
if (!targetLangs.includes(lang)) {
|
||||
jobLog(`[extractSubtitlesAndOcr] Stream #${stream.index} lang="${lang}" — not in target list, skipping.\n`);
|
||||
continue;
|
||||
}
|
||||
|
||||
const codec = (stream.codec_name || '').toLowerCase();
|
||||
const suffix = buildSuffix(lang, stream);
|
||||
const outSrt = path.join(sourceDir, `${baseName}.${suffix}.srt`);
|
||||
|
||||
jobLog(`[extractSubtitlesAndOcr] Stream #${stream.index} lang=${lang} codec=${codec} -> ${path.basename(outSrt)}\n`);
|
||||
|
||||
// ── Text-based subtitles ──────────────────────────────────────────────
|
||||
if (TEXT_CODECS.has(codec)) {
|
||||
const { cliExitCode } = await runFFmpeg(
|
||||
['-y', '-i', inputFile, '-map', `0:${stream.index}`, '-c:s', 'srt', outSrt],
|
||||
workDir, args.ffmpegPath, jobLog,
|
||||
);
|
||||
if (cliExitCode !== 0) {
|
||||
jobLog(`[extractSubtitlesAndOcr] WARNING: FFmpeg failed for stream #${stream.index} (exit ${cliExitCode}).\n`);
|
||||
} else {
|
||||
jobLog(`[extractSubtitlesAndOcr] Extracted: ${path.basename(outSrt)}\n`);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// ── Bitmap-based subtitles (PGS / VOBSUB) ────────────────────────────
|
||||
if (BITMAP_CODECS.has(codec)) {
|
||||
const tmpSup = path.join(workDir, `${baseName}_s${stream.index}.sup`);
|
||||
|
||||
// Step 1: Extract to .sup
|
||||
const { cliExitCode: extractExit } = await runFFmpeg(
|
||||
['-y', '-i', inputFile, '-map', `0:${stream.index}`, '-c:s', 'copy', tmpSup],
|
||||
workDir, args.ffmpegPath, jobLog,
|
||||
);
|
||||
|
||||
if (extractExit !== 0) {
|
||||
jobLog(`[extractSubtitlesAndOcr] WARNING: .sup extraction failed for stream #${stream.index}.\n`);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Step 2: OCR with SubtitleEdit
|
||||
try {
|
||||
const { CLI } = require('../../../../FlowHelpers/1.0.0/cliUtils');
|
||||
const seCli = new CLI({
|
||||
cli: subtitleEditPath,
|
||||
spawnArgs: [
|
||||
'/convert', tmpSup, 'subrip',
|
||||
'/track-number:0',
|
||||
`/outputfolder:${sourceDir}`,
|
||||
],
|
||||
WorkDir: workDir,
|
||||
jobLog,
|
||||
});
|
||||
const { cliExitCode: seExit } = await seCli.runCli();
|
||||
|
||||
if (seExit !== 0) {
|
||||
jobLog(`[extractSubtitlesAndOcr] WARNING: SubtitleEdit OCR failed (exit ${seExit}) for stream #${stream.index}.\n`);
|
||||
} else {
|
||||
// SubtitleEdit names the output after the .sup filename
|
||||
const seOut = path.join(sourceDir, path.basename(tmpSup, '.sup') + '.srt');
|
||||
if (fs.existsSync(seOut)) {
|
||||
fs.renameSync(seOut, outSrt);
|
||||
jobLog(`[extractSubtitlesAndOcr] OCR complete: ${path.basename(outSrt)}\n`);
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
jobLog(`[extractSubtitlesAndOcr] WARNING: SubtitleEdit not available or crashed: ${err.message}\n`);
|
||||
} finally {
|
||||
// Clean up temp .sup
|
||||
try { fs.unlinkSync(tmpSup); } catch (_) { /* ignore */ }
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
jobLog(`[extractSubtitlesAndOcr] Stream #${stream.index} codec "${codec}" not supported — skipping.\n`);
|
||||
}
|
||||
|
||||
jobLog('[extractSubtitlesAndOcr] Done.\n');
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
};
|
||||
|
||||
module.exports.details = details;
|
||||
module.exports.plugin = plugin;
|
||||
@@ -0,0 +1,72 @@
|
||||
'use strict';
|
||||
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
|
||||
/* eslint-disable no-param-reassign */
|
||||
|
||||
const details = () => ({
|
||||
name: 'Extract Chapters to XML',
|
||||
description:
|
||||
'Extracts MKV chapter markers to an XML file in workDir using mkvextract. '
|
||||
+ 'Stores the output path in args.variables.chaptersXmlPath. '
|
||||
+ 'Safe to run even if the source has no chapters.',
|
||||
style: { borderColor: '#9C27B0' },
|
||||
tags: 'utility,chapters,mkv',
|
||||
isStartPlugin: false,
|
||||
pType: '',
|
||||
requiresVersion: '2.11.01',
|
||||
sidebarPosition: -1,
|
||||
icon: 'faList',
|
||||
inputs: [],
|
||||
outputs: [
|
||||
{ number: 1, tooltip: 'Continue to next plugin' },
|
||||
],
|
||||
});
|
||||
|
||||
const plugin = async (args) => {
|
||||
const { jobLog, inputFileObj, variables, workDir } = args;
|
||||
|
||||
const inputFile = inputFileObj._id;
|
||||
const baseName = path.basename(inputFile, path.extname(inputFile));
|
||||
const xmlPath = path.join(workDir, `${baseName}_chapters.xml`);
|
||||
|
||||
jobLog(`[extractChaptersXml] Source: ${inputFile}\n`);
|
||||
jobLog(`[extractChaptersXml] Output: ${xmlPath}\n`);
|
||||
|
||||
// Derive mkvextract from mkvpropeditPath (same MKVToolNix bin dir)
|
||||
let mkvExtract = 'mkvextract';
|
||||
if (args.mkvpropeditPath) {
|
||||
const dir = path.dirname(args.mkvpropeditPath);
|
||||
const candidate = path.join(dir, process.platform === 'win32' ? 'mkvextract.exe' : 'mkvextract');
|
||||
if (fs.existsSync(candidate)) mkvExtract = candidate;
|
||||
}
|
||||
jobLog(`[extractChaptersXml] Using: ${mkvExtract}\n`);
|
||||
|
||||
const { CLI } = require('../../../../FlowHelpers/1.0.0/cliUtils');
|
||||
const cli = new CLI({
|
||||
cli: mkvExtract,
|
||||
spawnArgs: [inputFile, 'chapters', xmlPath],
|
||||
WorkDir: workDir,
|
||||
jobLog,
|
||||
});
|
||||
|
||||
const { cliExitCode } = await cli.runCli();
|
||||
|
||||
// mkvextract: exit 0 = OK, exit 1 = no chapters (still OK), exit 2 = error
|
||||
if (cliExitCode > 1) {
|
||||
jobLog(`[extractChaptersXml] WARNING: mkvextract exit ${cliExitCode} — chapters may be missing.\n`);
|
||||
variables.chaptersXmlPath = '';
|
||||
} else if (fs.existsSync(xmlPath) && fs.statSync(xmlPath).size > 50) {
|
||||
variables.chaptersXmlPath = xmlPath;
|
||||
jobLog(`[extractChaptersXml] Chapters saved: ${xmlPath}\n`);
|
||||
} else {
|
||||
jobLog('[extractChaptersXml] No chapters found.\n');
|
||||
variables.chaptersXmlPath = '';
|
||||
}
|
||||
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
};
|
||||
|
||||
module.exports.details = details;
|
||||
module.exports.plugin = plugin;
|
||||
@@ -0,0 +1,167 @@
|
||||
'use strict';
|
||||
|
||||
/* eslint-disable no-param-reassign */
|
||||
|
||||
/**
|
||||
* mediaAnalyzerGOP
|
||||
* Analyzes the video stream and populates args.variables with encoding
|
||||
* parameters consumed by downstream plugins:
|
||||
* gopKeyint / gopMinKeyint -> 2 x FPS (rounded)
|
||||
* isAnimation -> detected from animeSeries path list
|
||||
* isMovie -> detected from moviePathPatterns
|
||||
* vBitrate / vMaxRate / vBufSize
|
||||
* x265Tune -> "animation" or ""
|
||||
* videoHeight / videoFps
|
||||
*/
|
||||
|
||||
const details = () => ({
|
||||
name: 'Media Analyzer & GOP Calculator',
|
||||
description:
|
||||
'Analyzes video metadata, calculates GOP keyint (2xFPS), target bitrate '
|
||||
+ 'and VBV parameters based on content type (film/series/anime). '
|
||||
+ 'Exports all values to args.variables for downstream plugins.',
|
||||
style: { borderColor: '#2196F3' },
|
||||
tags: 'video,utility',
|
||||
isStartPlugin: false,
|
||||
pType: '',
|
||||
requiresVersion: '2.11.01',
|
||||
sidebarPosition: 1,
|
||||
icon: 'faFilm',
|
||||
inputs: [
|
||||
{
|
||||
label: 'Movie Library Path Patterns',
|
||||
name: 'moviePathPatterns',
|
||||
type: 'string',
|
||||
defaultValue: '/Radarr',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip:
|
||||
'Pipe-separated path fragments that identify a Film library. '
|
||||
+ 'Example: /Radarr|/films|/movies',
|
||||
},
|
||||
{
|
||||
label: 'Anime Series Names',
|
||||
name: 'animeSeries',
|
||||
type: 'string',
|
||||
defaultValue: '',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip:
|
||||
'Pipe-separated list of anime series names. The plugin checks if any '
|
||||
+ 'token appears (case-insensitive) in the file path. '
|
||||
+ 'Example: Naruto|One Piece|Attack on Titan',
|
||||
},
|
||||
{
|
||||
label: 'Film Bitrate (kbps)',
|
||||
name: 'filmBitrate',
|
||||
type: 'string',
|
||||
defaultValue: '3000',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Target video bitrate in kbps for live-action films.',
|
||||
},
|
||||
{
|
||||
label: 'Series Bitrate (kbps)',
|
||||
name: 'seriesBitrate',
|
||||
type: 'string',
|
||||
defaultValue: '3000',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Target video bitrate in kbps for TV series.',
|
||||
},
|
||||
{
|
||||
label: 'Anime HD Bitrate (kbps, >=720p)',
|
||||
name: 'animeBitrateHd',
|
||||
type: 'string',
|
||||
defaultValue: '2000',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Target video bitrate in kbps for anime at 720p or higher.',
|
||||
},
|
||||
{
|
||||
label: 'Anime SD Bitrate (kbps, <720p)',
|
||||
name: 'animeBitrateSd',
|
||||
type: 'string',
|
||||
defaultValue: '1000',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Target video bitrate in kbps for anime below 720p.',
|
||||
},
|
||||
],
|
||||
outputs: [
|
||||
{ number: 1, tooltip: 'Continue to next plugin' },
|
||||
],
|
||||
});
|
||||
|
||||
const parseRate = (rateStr) => {
|
||||
if (!rateStr) return 0;
|
||||
if (rateStr.includes('/')) {
|
||||
const [n, d] = rateStr.split('/').map(Number);
|
||||
return d ? n / d : 0;
|
||||
}
|
||||
return parseFloat(rateStr) || 0;
|
||||
};
|
||||
|
||||
const plugin = async (args) => {
|
||||
const { jobLog, inputFileObj, variables } = args;
|
||||
|
||||
const filePath = inputFileObj._id;
|
||||
jobLog(`[mediaAnalyzerGOP] Processing: ${filePath}\n`);
|
||||
|
||||
const moviePathPatterns = (args.inputs.moviePathPatterns || '/Radarr')
|
||||
.split('|').filter(Boolean);
|
||||
const animeList = (args.inputs.animeSeries || '').split('|').filter(Boolean);
|
||||
const filmBitrate = Math.max(1, parseInt(args.inputs.filmBitrate || '3000', 10));
|
||||
const seriesBitrate = Math.max(1, parseInt(args.inputs.seriesBitrate || '3000', 10));
|
||||
const animeBitrateHd = Math.max(1, parseInt(args.inputs.animeBitrateHd || '2000', 10));
|
||||
const animeBitrateSd = Math.max(1, parseInt(args.inputs.animeBitrateSd || '1000', 10));
|
||||
|
||||
const streams = (inputFileObj.ffProbeData && inputFileObj.ffProbeData.streams) || [];
|
||||
const videoStream = streams.find((s) => s.codec_type === 'video');
|
||||
if (!videoStream) throw new Error('[mediaAnalyzerGOP] No video stream found.');
|
||||
|
||||
let fps = parseRate(videoStream.r_frame_rate);
|
||||
if (!fps || fps > 120) fps = parseRate(videoStream.avg_frame_rate);
|
||||
if (!fps || fps > 120) fps = parseFloat(videoStream.FrameRate || '0');
|
||||
if (!fps || fps <= 0) {
|
||||
jobLog('[mediaAnalyzerGOP] WARNING: Cannot determine FPS, defaulting to 24.\n');
|
||||
fps = 24;
|
||||
}
|
||||
jobLog(`[mediaAnalyzerGOP] FPS: ${fps.toFixed(3)}\n`);
|
||||
|
||||
const gopKeyint = String(Math.round(fps * 2));
|
||||
jobLog(`[mediaAnalyzerGOP] keyint=${gopKeyint}\n`);
|
||||
|
||||
// Normalize to forward slashes for cross-platform path matching
|
||||
const normalizedPath = filePath.replace(/\\/g, '/');
|
||||
const isMovie = moviePathPatterns.some((p) => normalizedPath.includes(p));
|
||||
const matchedPat = moviePathPatterns.find((p) => normalizedPath.includes(p));
|
||||
jobLog(`[mediaAnalyzerGOP] isMovie=${isMovie}${matchedPat ? ` ("${matchedPat}")` : ''}\n`);
|
||||
|
||||
const lowerPath = normalizedPath.toLowerCase();
|
||||
const matchedAnime = animeList.find((name) => lowerPath.includes(name.toLowerCase()));
|
||||
const isAnimation = !!matchedAnime;
|
||||
jobLog(`[mediaAnalyzerGOP] isAnimation=${isAnimation}${matchedAnime ? ` ("${matchedAnime}")` : ''}\n`);
|
||||
|
||||
const videoHeight = parseInt(videoStream.height || '0', 10);
|
||||
let targetKbps;
|
||||
if (isAnimation) targetKbps = videoHeight >= 720 ? animeBitrateHd : animeBitrateSd;
|
||||
else if (isMovie) targetKbps = filmBitrate;
|
||||
else targetKbps = seriesBitrate;
|
||||
|
||||
const vBitrate = `${targetKbps}k`;
|
||||
const vMaxRate = `${targetKbps * 2}k`;
|
||||
const vBufSize = `${targetKbps * 4}k`;
|
||||
jobLog(`[mediaAnalyzerGOP] vBitrate=${vBitrate} vMaxRate=${vMaxRate} vBufSize=${vBufSize}\n`);
|
||||
|
||||
variables.gopKeyint = gopKeyint;
|
||||
variables.gopMinKeyint = gopKeyint;
|
||||
variables.isAnimation = String(isAnimation);
|
||||
variables.isMovie = String(isMovie);
|
||||
variables.vBitrate = vBitrate;
|
||||
variables.vMaxRate = vMaxRate;
|
||||
variables.vBufSize = vBufSize;
|
||||
variables.x265Tune = isAnimation ? 'animation' : '';
|
||||
variables.videoHeight = String(videoHeight);
|
||||
variables.videoFps = fps.toFixed(3);
|
||||
|
||||
jobLog('[mediaAnalyzerGOP] Done.\n');
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
};
|
||||
|
||||
module.exports.details = details;
|
||||
module.exports.plugin = plugin;
|
||||
@@ -0,0 +1,73 @@
|
||||
'use strict';
|
||||
|
||||
/* eslint-disable no-param-reassign */
|
||||
|
||||
const details = () => ({
|
||||
name: 'Set Animation Flag',
|
||||
description:
|
||||
'Forces isAnimation=true and x265Tune=animation in flow variables. '
|
||||
+ 'Use when a file is animation but was not detected automatically '
|
||||
+ 'by the animeSeries list in mediaAnalyzerGOP. '
|
||||
+ 'Optionally recalculates video bitrate targets.',
|
||||
style: { borderColor: '#FF9800' },
|
||||
tags: 'utility,animation',
|
||||
isStartPlugin: false,
|
||||
pType: '',
|
||||
requiresVersion: '2.11.01',
|
||||
sidebarPosition: -1,
|
||||
icon: 'faMagic',
|
||||
inputs: [
|
||||
{
|
||||
label: 'Anime HD Bitrate (kbps, >=720p)',
|
||||
name: 'animeBitrateHd',
|
||||
type: 'string',
|
||||
defaultValue: '2000',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Target bitrate for anime >=720p. Leave blank to skip recalculation.',
|
||||
},
|
||||
{
|
||||
label: 'Anime SD Bitrate (kbps, <720p)',
|
||||
name: 'animeBitrateSd',
|
||||
type: 'string',
|
||||
defaultValue: '1000',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Target bitrate for anime <720p.',
|
||||
},
|
||||
],
|
||||
outputs: [
|
||||
{ number: 1, tooltip: 'Continue with animation flag set' },
|
||||
],
|
||||
});
|
||||
|
||||
const plugin = async (args) => {
|
||||
const { jobLog, inputFileObj, variables } = args;
|
||||
jobLog('[setAnimationFlag] Forcing isAnimation=true\n');
|
||||
|
||||
variables.isAnimation = 'true';
|
||||
variables.x265Tune = 'animation';
|
||||
|
||||
const hdInput = args.inputs.animeBitrateHd;
|
||||
const sdInput = args.inputs.animeBitrateSd;
|
||||
|
||||
if (hdInput && sdInput) {
|
||||
const animeBitrateHd = Math.max(1, parseInt(hdInput, 10));
|
||||
const animeBitrateSd = Math.max(1, parseInt(sdInput, 10));
|
||||
const videoHeight = parseInt(variables.videoHeight || '0', 10);
|
||||
|
||||
if (videoHeight > 0) {
|
||||
const targetKbps = videoHeight >= 720 ? animeBitrateHd : animeBitrateSd;
|
||||
variables.vBitrate = `${targetKbps}k`;
|
||||
variables.vMaxRate = `${targetKbps * 2}k`;
|
||||
variables.vBufSize = `${targetKbps * 4}k`;
|
||||
jobLog(`[setAnimationFlag] Bitrate recalculated: ${variables.vBitrate} (height=${videoHeight}px)\n`);
|
||||
} else {
|
||||
jobLog('[setAnimationFlag] videoHeight not set — skipping bitrate recalculation.\n');
|
||||
}
|
||||
}
|
||||
|
||||
jobLog('[setAnimationFlag] Done.\n');
|
||||
return { outputNumber: 1, outputFileObj: inputFileObj, variables };
|
||||
};
|
||||
|
||||
module.exports.details = details;
|
||||
module.exports.plugin = plugin;
|
||||
@@ -0,0 +1,234 @@
|
||||
'use strict';
|
||||
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
|
||||
/* eslint-disable no-param-reassign */
|
||||
|
||||
/**
|
||||
* transcode2PassX265
|
||||
* Performs 2-pass x265 encoding with:
|
||||
* - Bound-1080p Lanczos scaling (no letterbox, even dimensions)
|
||||
* - VBV rate control from args.variables
|
||||
* - Dynamic Opus audio mapping (ITA default, ENG secondary)
|
||||
* - No subtitle streams (-sn)
|
||||
* - Cross-platform null device (NUL / /dev/null)
|
||||
* - Cleanup of x265 2-pass log files post-encode
|
||||
*/
|
||||
|
||||
const details = () => ({
|
||||
name: '2-Pass x265 Transcode',
|
||||
description:
|
||||
'Performs 2-pass libx265 encoding using parameters from args.variables. '
|
||||
+ 'Applies bound-1080p Lanczos scaling, Opus audio re-encoding, '
|
||||
+ 'and chapter preservation. Cross-platform (Linux server / Windows worker).',
|
||||
style: { borderColor: '#E91E63' },
|
||||
tags: 'video,ffmpeg,x265',
|
||||
isStartPlugin: false,
|
||||
pType: '',
|
||||
requiresVersion: '2.11.01',
|
||||
sidebarPosition: 4,
|
||||
icon: 'faVideo',
|
||||
inputs: [
|
||||
{
|
||||
label: 'x265 Preset',
|
||||
name: 'x265Preset',
|
||||
type: 'string',
|
||||
defaultValue: 'slow',
|
||||
inputUI: {
|
||||
type: 'dropdown',
|
||||
options: ['ultrafast', 'superfast', 'veryfast', 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow'],
|
||||
},
|
||||
tooltip: 'x265 encoding preset. Slower = better quality/compression ratio.',
|
||||
},
|
||||
{
|
||||
label: 'Output Container',
|
||||
name: 'outputContainer',
|
||||
type: 'string',
|
||||
defaultValue: 'mkv',
|
||||
inputUI: { type: 'text' },
|
||||
tooltip: 'Output file container extension (mkv recommended).',
|
||||
},
|
||||
],
|
||||
outputs: [
|
||||
{ number: 1, tooltip: 'Transcode complete — output file ready' },
|
||||
],
|
||||
});
|
||||
|
||||
// ─── Build audio mapping args ────────────────────────────────────────────────
|
||||
|
||||
const buildAudioArgs = (variables) => {
|
||||
// Maps and codec/bitrate args are separated intentionally.
|
||||
// -c:a and -b:a without a stream index apply globally (last wins),
|
||||
// so we use indexed specifiers -c:a:N / -b:a:N to set per-track options.
|
||||
const mapArgs = [];
|
||||
const codecArgs = [];
|
||||
let audioTrackOut = 0;
|
||||
|
||||
if (variables.audioHasIta === 'true') {
|
||||
const idx = variables.audioItaStreamIndex;
|
||||
const bitrate = variables.audioItaOpusBitrate;
|
||||
mapArgs.push('-map', `0:${idx}`);
|
||||
codecArgs.push(
|
||||
`-c:a:${audioTrackOut}`, 'libopus',
|
||||
`-b:a:${audioTrackOut}`, `${bitrate}k`,
|
||||
`-metadata:s:a:${audioTrackOut}`, 'language=ita',
|
||||
`-disposition:a:${audioTrackOut}`, 'default',
|
||||
);
|
||||
audioTrackOut += 1;
|
||||
}
|
||||
|
||||
if (variables.audioHasEng === 'true') {
|
||||
const idx = variables.audioEngStreamIndex;
|
||||
const bitrate = variables.audioEngOpusBitrate;
|
||||
mapArgs.push('-map', `0:${idx}`);
|
||||
codecArgs.push(
|
||||
`-c:a:${audioTrackOut}`, 'libopus',
|
||||
`-b:a:${audioTrackOut}`, `${bitrate}k`,
|
||||
`-metadata:s:a:${audioTrackOut}`, 'language=eng',
|
||||
`-disposition:a:${audioTrackOut}`, '0',
|
||||
);
|
||||
audioTrackOut += 1;
|
||||
}
|
||||
|
||||
// Emit: all -map first, then all codec settings
|
||||
return [...mapArgs, ...codecArgs];
|
||||
};
|
||||
|
||||
// ─── Plugin ───────────────────────────────────────────────────────────────────
|
||||
|
||||
const plugin = async (args) => {
|
||||
const { jobLog, inputFileObj, variables, workDir } = args;
|
||||
|
||||
const inputFile = inputFileObj._id;
|
||||
jobLog(`[transcode2PassX265] Source: ${inputFile}\n`);
|
||||
|
||||
// ── Read variables ────────────────────────────────────────────────────────
|
||||
const {
|
||||
gopKeyint = '48',
|
||||
gopMinKeyint = '48',
|
||||
vBitrate = '3000k',
|
||||
vMaxRate = '6000k',
|
||||
vBufSize = '12000k',
|
||||
x265Tune = '',
|
||||
} = variables;
|
||||
|
||||
const x265Preset = args.inputs.x265Preset || 'slow';
|
||||
const container = args.inputs.outputContainer || 'mkv';
|
||||
|
||||
// Parse numeric VBV values (parseInt handles trailing 'k')
|
||||
const maxRateNum = parseInt(vMaxRate, 10);
|
||||
const bufSizeNum = parseInt(vBufSize, 10);
|
||||
|
||||
jobLog(
|
||||
`[transcode2PassX265] Params: bitrate=${vBitrate} maxrate=${maxRateNum}k `
|
||||
+ `bufsize=${bufSizeNum}k keyint=${gopKeyint} tune=${x265Tune || 'none'} preset=${x265Preset}\n`,
|
||||
);
|
||||
|
||||
// ── Paths ─────────────────────────────────────────────────────────────────
|
||||
const baseName = path.basename(inputFile, path.extname(inputFile));
|
||||
const outFile = path.join(workDir, `${baseName}_x265.${container}`);
|
||||
const statsFile = path.join(workDir, 'x265_2pass.log');
|
||||
// x265 expects forward slashes in x265-params on all platforms
|
||||
const statsForX265 = statsFile.replace(/\\/g, '/');
|
||||
const nullDev = process.platform === 'win32' ? 'NUL' : '/dev/null';
|
||||
|
||||
jobLog(`[transcode2PassX265] Output: ${outFile}\n`);
|
||||
|
||||
// ── Video filter ──────────────────────────────────────────────────────────
|
||||
const vf = [
|
||||
"scale='min(1920,iw)':'min(1080,ih)':force_original_aspect_ratio=decrease",
|
||||
'scale=trunc(iw/2)*2:trunc(ih/2)*2:flags=lanczos',
|
||||
].join(',');
|
||||
|
||||
// ── x265-params base ──────────────────────────────────────────────────────
|
||||
const x265ParamsBase = [
|
||||
`keyint=${gopKeyint}`,
|
||||
`min-keyint=${gopMinKeyint}`,
|
||||
`vbv-maxrate=${maxRateNum}`,
|
||||
`vbv-bufsize=${bufSizeNum}`,
|
||||
`stats=${statsForX265}`,
|
||||
].join(':');
|
||||
|
||||
// ── Common video args ─────────────────────────────────────────────────────
|
||||
const tuneArgs = x265Tune ? ['-tune', x265Tune] : [];
|
||||
const videoArgs = [
|
||||
'-vf', vf,
|
||||
'-c:v', 'libx265',
|
||||
'-b:v', vBitrate,
|
||||
'-preset', x265Preset,
|
||||
...tuneArgs,
|
||||
];
|
||||
|
||||
const { CLI } = require('../../../../FlowHelpers/1.0.0/cliUtils');
|
||||
|
||||
// ══ PASS 1 ════════════════════════════════════════════════════════════════
|
||||
jobLog('[transcode2PassX265] Starting Pass 1...\n');
|
||||
const pass1Cli = new CLI({
|
||||
cli: args.ffmpegPath,
|
||||
spawnArgs: [
|
||||
'-y',
|
||||
'-i', inputFile,
|
||||
...videoArgs,
|
||||
'-x265-params', `${x265ParamsBase}:pass=1`,
|
||||
'-an', '-sn',
|
||||
'-f', 'null',
|
||||
nullDev,
|
||||
],
|
||||
WorkDir: workDir,
|
||||
jobLog,
|
||||
});
|
||||
|
||||
const { cliExitCode: pass1Exit } = await pass1Cli.runCli();
|
||||
if (pass1Exit !== 0) {
|
||||
throw new Error(`[transcode2PassX265] Pass 1 failed with exit code ${pass1Exit}`);
|
||||
}
|
||||
jobLog('[transcode2PassX265] Pass 1 complete.\n');
|
||||
|
||||
// ══ PASS 2 ════════════════════════════════════════════════════════════════
|
||||
const audioArgs = buildAudioArgs(variables);
|
||||
if (audioArgs.length === 0) {
|
||||
jobLog('[transcode2PassX265] WARNING: No audio streams mapped (no ITA/ENG found).\n');
|
||||
}
|
||||
|
||||
jobLog('[transcode2PassX265] Starting Pass 2...\n');
|
||||
const pass2Cli = new CLI({
|
||||
cli: args.ffmpegPath,
|
||||
spawnArgs: [
|
||||
'-y',
|
||||
'-i', inputFile,
|
||||
'-map', '0:v:0',
|
||||
...audioArgs,
|
||||
'-map_chapters', '0',
|
||||
...videoArgs,
|
||||
'-x265-params', `${x265ParamsBase}:pass=2`,
|
||||
'-sn',
|
||||
outFile,
|
||||
],
|
||||
WorkDir: workDir,
|
||||
jobLog,
|
||||
});
|
||||
|
||||
const { cliExitCode: pass2Exit } = await pass2Cli.runCli();
|
||||
if (pass2Exit !== 0) {
|
||||
throw new Error(`[transcode2PassX265] Pass 2 failed with exit code ${pass2Exit}`);
|
||||
}
|
||||
jobLog('[transcode2PassX265] Pass 2 complete.\n');
|
||||
|
||||
// ── Cleanup 2-pass log files ──────────────────────────────────────────────
|
||||
[statsFile, `${statsFile}.mbtree`, `${statsFile}.cutree`].forEach((f) => {
|
||||
try { if (fs.existsSync(f)) fs.unlinkSync(f); } catch (_) { /* ignore */ }
|
||||
});
|
||||
jobLog('[transcode2PassX265] Temp log files cleaned up.\n');
|
||||
|
||||
// ── Return transcoded file for Tdarr to manage ────────────────────────────
|
||||
jobLog(`[transcode2PassX265] Done. Output: ${outFile}\n`);
|
||||
return {
|
||||
outputNumber: 1,
|
||||
outputFileObj: { ...inputFileObj, _id: outFile },
|
||||
variables,
|
||||
};
|
||||
};
|
||||
|
||||
module.exports.details = details;
|
||||
module.exports.plugin = plugin;
|
||||
@@ -0,0 +1,245 @@
|
||||
# Tdarr Local Flow Plugins — Integration Guide
|
||||
|
||||
## Panoramica
|
||||
|
||||
Questa guida descrive come assemblare i 7 plugin nel canvas Flow di Tdarr, configurare i worker Windows e verificare il corretto funzionamento.
|
||||
|
||||
---
|
||||
|
||||
## 1. Struttura Cartelle Generata
|
||||
|
||||
```
|
||||
/docker/tdarr/server/Tdarr/Plugins/FlowPlugins/
|
||||
└── LocalFlowPlugins/
|
||||
├── utility/
|
||||
│ ├── mediaAnalyzerGOP/1.0.0/index.js
|
||||
│ ├── setAnimationFlag/1.0.0/index.js
|
||||
│ └── extractChaptersXml/1.0.0/index.js
|
||||
├── audio/
|
||||
│ ├── audioSelectorClamping/1.0.0/index.js
|
||||
│ └── backupSourceAudio/1.0.0/index.js
|
||||
├── subtitles/
|
||||
│ └── extractSubtitlesAndOcr/1.0.0/index.js
|
||||
└── video/
|
||||
└── transcode2PassX265/1.0.0/index.js
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 2. Deploy sul Server Docker
|
||||
|
||||
Copia la cartella `LocalFlowPlugins/` nel volume montato del server Tdarr:
|
||||
|
||||
```bash
|
||||
# Dalla macchina host Docker
|
||||
docker cp ./LocalFlowPlugins/ tdarr-server:/home/tdarr/data/plugins/FlowPlugins/
|
||||
|
||||
# Oppure se usi un volume bind mount
|
||||
cp -r ./LocalFlowPlugins/ /docker/tdarr/server/Tdarr/Plugins/FlowPlugins/
|
||||
```
|
||||
|
||||
Poi **riavvia il server Tdarr** per indicizzare i nuovi plugin:
|
||||
```bash
|
||||
docker restart tdarr-server
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 3. Configurazione Worker Windows
|
||||
|
||||
### 3.1 Software richiesto
|
||||
|
||||
| Software | Download | Note |
|
||||
|---|---|---|
|
||||
| FFmpeg | https://ffmpeg.org/download.html | Aggiungi `ffmpeg.exe` al PATH |
|
||||
| MKVToolNix | https://mkvtoolnix.download/ | Include `mkvextract.exe` |
|
||||
| SubtitleEdit | https://www.nikse.dk/subtitleedit | Solo per OCR PGS/VOBSUB |
|
||||
|
||||
### 3.2 Configurazione percorsi in Tdarr
|
||||
|
||||
Nella Web UI: **Settings → Nodes → [tuo worker Windows]**
|
||||
|
||||
| Campo | Valore esempio |
|
||||
|---|---|
|
||||
| FFmpeg Path | `C:\Tools\ffmpeg\bin\ffmpeg.exe` |
|
||||
| FFprobe Path | `C:\Tools\ffmpeg\bin\ffprobe.exe` |
|
||||
| MKVPropedit Path | `C:\Program Files\MKVToolNix\mkvpropedit.exe` |
|
||||
|
||||
> Il plugin `extractChaptersXml` deriva automaticamente il path di `mkvextract.exe` dalla stessa cartella di `mkvpropedit.exe`.
|
||||
|
||||
### 3.3 Configurazione PATH Windows
|
||||
|
||||
Aggiungi al PATH di sistema:
|
||||
- `C:\Tools\ffmpeg\bin`
|
||||
- `C:\Program Files\MKVToolNix`
|
||||
- `C:\Program Files\SubtitleEdit` (solo per OCR)
|
||||
|
||||
---
|
||||
|
||||
## 4. Assemblaggio del Flow nel Canvas
|
||||
|
||||
### 4.1 Ordine dei nodi
|
||||
|
||||
```
|
||||
[mediaAnalyzerGOP]
|
||||
│
|
||||
│ (Facoltativo — solo per anime non rilevati automaticamente)
|
||||
├──▶ [setAnimationFlag]
|
||||
│ │
|
||||
│ └──▶ (ricongiunge)
|
||||
│
|
||||
▼
|
||||
[audioSelectorClamping]
|
||||
│
|
||||
├──▶ Output 2 (Nessuna traccia ITA/ENG)
|
||||
│ └──▶ [Nodo di gestione errore / Fine]
|
||||
│
|
||||
└──▶ Output 1 (Tracce trovate)
|
||||
▼
|
||||
[extractChaptersXml]
|
||||
▼
|
||||
[extractSubtitlesAndOcr]
|
||||
▼
|
||||
[backupSourceAudio]
|
||||
▼
|
||||
[transcode2PassX265]
|
||||
▼
|
||||
[Fine]
|
||||
```
|
||||
|
||||
### 4.2 Connessioni nel Canvas
|
||||
|
||||
1. Apri **Tdarr Web UI → Libraries → [tua library] → Flow**
|
||||
2. Clicca **"Add Plugin"** e cerca per categoria:
|
||||
- `utility` → trovi `Media Analyzer & GOP Calculator`
|
||||
- `audio` → trovi `Audio Selector & Opus Bitrate Clamping`
|
||||
- ecc.
|
||||
3. Trascina i nodi e collega le uscite/ingressi nell'ordine sopra indicato.
|
||||
|
||||
> **Nota**: I plugin compaiono nelle rispettive categorie (`utility`, `audio`, `subtitles`, `video`) nella sidebar del canvas.
|
||||
|
||||
---
|
||||
|
||||
## 5. Configurazione Input dei Plugin
|
||||
|
||||
### `mediaAnalyzerGOP` — Valori raccomandati
|
||||
|
||||
| Input | Valore raccomandato |
|
||||
|---|---|
|
||||
| Movie Library Path Patterns | `/Radarr` |
|
||||
| Anime Series Names | `Naruto\|One Piece\|Attack on Titan\|...` |
|
||||
| Film Bitrate (kbps) | `3000` |
|
||||
| Series Bitrate (kbps) | `3000` |
|
||||
| Anime HD Bitrate (kbps) | `2000` |
|
||||
| Anime SD Bitrate (kbps) | `1000` |
|
||||
|
||||
### `audioSelectorClamping` — Valori raccomandati
|
||||
|
||||
| Input | Valore |
|
||||
|---|---|
|
||||
| Film Multichannel Bitrate (kbps) | `640` |
|
||||
| Series Multichannel Threshold (kbps) | `384` |
|
||||
| Stereo Max Bitrate (kbps) | `128` |
|
||||
|
||||
### `extractSubtitlesAndOcr` — Valori raccomandati
|
||||
|
||||
| Input | Valore |
|
||||
|---|---|
|
||||
| SubtitleEdit Executable Path | `SubtitleEdit` (nel PATH) |
|
||||
| Languages to Extract | `ita,eng` |
|
||||
|
||||
### `transcode2PassX265` — Valori raccomandati
|
||||
|
||||
| Input | Valore |
|
||||
|---|---|
|
||||
| x265 Preset | `slow` |
|
||||
| Output Container | `mkv` |
|
||||
|
||||
---
|
||||
|
||||
## 6. Variabili di Flusso (args.variables)
|
||||
|
||||
Questa tabella mostra tutte le variabili che i plugin si passano a vicenda:
|
||||
|
||||
| Variabile | Prodotta da | Consumata da |
|
||||
|---|---|---|
|
||||
| `gopKeyint` | mediaAnalyzerGOP | transcode2PassX265 |
|
||||
| `gopMinKeyint` | mediaAnalyzerGOP | transcode2PassX265 |
|
||||
| `isAnimation` | mediaAnalyzerGOP / setAnimationFlag | audioSelectorClamping |
|
||||
| `isMovie` | mediaAnalyzerGOP | audioSelectorClamping |
|
||||
| `vBitrate` | mediaAnalyzerGOP / setAnimationFlag | transcode2PassX265 |
|
||||
| `vMaxRate` | mediaAnalyzerGOP / setAnimationFlag | transcode2PassX265 |
|
||||
| `vBufSize` | mediaAnalyzerGOP / setAnimationFlag | transcode2PassX265 |
|
||||
| `x265Tune` | mediaAnalyzerGOP / setAnimationFlag | transcode2PassX265 |
|
||||
| `videoHeight` | mediaAnalyzerGOP | setAnimationFlag |
|
||||
| `videoFps` | mediaAnalyzerGOP | (info only) |
|
||||
| `audioHasIta` | audioSelectorClamping | backupSourceAudio, transcode2PassX265 |
|
||||
| `audioItaStreamIndex` | audioSelectorClamping | backupSourceAudio, transcode2PassX265 |
|
||||
| `audioItaOpusBitrate` | audioSelectorClamping | transcode2PassX265 |
|
||||
| `audioItaChannels` | audioSelectorClamping | (info only) |
|
||||
| `audioItaCodecName` | audioSelectorClamping | backupSourceAudio |
|
||||
| `audioHasEng` | audioSelectorClamping | transcode2PassX265 |
|
||||
| `audioEngStreamIndex` | audioSelectorClamping | transcode2PassX265 |
|
||||
| `audioEngOpusBitrate` | audioSelectorClamping | transcode2PassX265 |
|
||||
| `audioEngCodecName` | audioSelectorClamping | (info only) |
|
||||
| `chaptersXmlPath` | extractChaptersXml | (reserved for future use) |
|
||||
| `audioBackupPath` | backupSourceAudio | (info only) |
|
||||
|
||||
---
|
||||
|
||||
## 7. Output dei File per Ogni Job
|
||||
|
||||
Per ogni file sorgente `/media/toshiba/Radarr/Film (2023)/Film (2023).mkv`:
|
||||
|
||||
```
|
||||
/media/toshiba/Radarr/Film (2023)/
|
||||
├── Film (2023).mkv ← sostituito dal trascodificato (gestito da Tdarr)
|
||||
├── Film (2023).ita.srt ← estratto da extractSubtitlesAndOcr
|
||||
├── Film (2023).eng.srt ← estratto da extractSubtitlesAndOcr
|
||||
├── Film (2023).ita.forced.srt ← (se traccia forced presente)
|
||||
├── Film (2023).eng.sdh.srt ← (se traccia SDH presente)
|
||||
└── Film (2023).ita.dts ← backup (solo se codec DTS)
|
||||
o Film (2023).ita.thd ← backup (solo se codec TrueHD)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 8. Troubleshooting
|
||||
|
||||
### Plugin non visibili nel canvas
|
||||
- Riavvia il server Tdarr dopo aver copiato i file
|
||||
- Verifica che il path sia esattamente `FlowPlugins/LocalFlowPlugins/<categoria>/<nome>/1.0.0/index.js`
|
||||
|
||||
### `mkvextract` non trovato
|
||||
- Assicurati che MKVToolNix sia installato e che `mkvpropedit.exe` sia configurato nelle impostazioni del nodo
|
||||
|
||||
### OCR SubtitleEdit non funziona
|
||||
- Verifica che `SubtitleEdit.exe` sia nel PATH di sistema del worker Windows
|
||||
- Oppure specifica il path assoluto nell'input del plugin (es. `C:\Program Files\SubtitleEdit\SubtitleEdit.exe`)
|
||||
- Le tracce PGS richiede che SubtitleEdit sia in modalità CLI (non GUI)
|
||||
|
||||
### Pass 1 FFmpeg fallisce su Windows
|
||||
- Il device null su Windows è `NUL` (senza path) — gestito automaticamente dal plugin
|
||||
- Verifica che il worker abbia scrittura su `workDir`
|
||||
|
||||
### Opus non disponibile in FFmpeg
|
||||
- Verifica con: `ffmpeg -encoders | grep opus`
|
||||
- Usa build FFmpeg con `--enable-libopus`
|
||||
|
||||
---
|
||||
|
||||
## 9. Test in Locale
|
||||
|
||||
```bash
|
||||
# Prerequisiti: Node.js, FFmpeg nel PATH
|
||||
cd c:\Users\david\Desktop\Projects\Tdarr_plugin
|
||||
|
||||
# 1. Genera file di test (richiede FFmpeg)
|
||||
node tests/generate-test-files.js
|
||||
|
||||
# 2. Esegui test suite (escluso Test 3 che fa encode reale)
|
||||
node tests/run-tests.js --skip-transcode
|
||||
|
||||
# 3. Esegui test completo incluso encode x265
|
||||
node tests/run-tests.js
|
||||
```
|
||||
@@ -0,0 +1,102 @@
|
||||
'use strict';
|
||||
const { execSync, spawnSync } = require('child_process');
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
|
||||
const FFMPEG = process.env.FFMPEG_PATH || 'ffmpeg';
|
||||
|
||||
const SAMPLES = {
|
||||
test1: 'tests/samples/media/toshiba/Radarr/Film Test (2023)/Film Test (2023).mkv',
|
||||
test2: 'tests/samples/media/toshiba/Sonarr/Naruto S01/Naruto S01E01.mkv',
|
||||
test3: 'tests/samples/test3_ultrawide.mkv',
|
||||
test4: 'tests/samples/test4_subtitles.mkv',
|
||||
};
|
||||
|
||||
function run(cmd) {
|
||||
console.log(`\n>> ${cmd}\n`);
|
||||
const result = spawnSync(cmd, { shell: true, stdio: 'inherit' });
|
||||
if (result.status !== 0) {
|
||||
console.error(`Command failed with exit ${result.status}`);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
function ensureDir(filePath) {
|
||||
fs.mkdirSync(path.dirname(filePath), { recursive: true });
|
||||
}
|
||||
|
||||
// Test 1 — skip if already generated
|
||||
if (!fs.existsSync(SAMPLES.test1)) {
|
||||
console.log('Generating Test 1: 23.976fps Film (AC3 ITA 448k + EAC3 ENG 640k)...');
|
||||
ensureDir(SAMPLES.test1);
|
||||
run([
|
||||
FFMPEG, '-y',
|
||||
'-f', 'lavfi', '-i', 'color=c=blue:s=1920x1080:r=24000/1001:d=30',
|
||||
'-f', 'lavfi', '-i', 'sine=f=440:r=48000:d=30',
|
||||
'-f', 'lavfi', '-i', 'sine=f=660:r=48000:d=30',
|
||||
'-map', '0:v', '-map', '1:a', '-map', '2:a',
|
||||
'-c:v', 'libx264', '-crf', '28', '-preset', 'ultrafast',
|
||||
'-c:a:0', 'ac3', '-b:a:0', '448k', '-ac:a:0', '6', '-metadata:s:a:0', 'language=ita',
|
||||
'-c:a:1', 'eac3', '-b:a:1', '640k', '-ac:a:1', '6', '-metadata:s:a:1', 'language=eng',
|
||||
`"${SAMPLES.test1}"`,
|
||||
].join(' '));
|
||||
console.log('Test 1 OK.\n');
|
||||
} else {
|
||||
console.log('Test 1 already exists — skipping.\n');
|
||||
}
|
||||
|
||||
// Test 2 — EAC3 ITA 640k 5.1 at 25fps (DTS is experimental in FFmpeg)
|
||||
// Note: DTS logic is fully covered by unit tests with synthetic streams.
|
||||
// For integration, we use EAC3 640k which triggers series clamping: 640>=384 -> Opus=384
|
||||
console.log('Generating Test 2: 25fps Anime EAC3 ITA 640k 5.1 (Naruto)...');
|
||||
ensureDir(SAMPLES.test2);
|
||||
run([
|
||||
FFMPEG, '-y',
|
||||
'-f', 'lavfi', '-i', 'color=c=green:s=1280x720:r=25:d=30',
|
||||
'-f', 'lavfi', '-i', 'sine=f=660:r=48000:d=30',
|
||||
'-map', '0:v', '-map', '1:a',
|
||||
'-c:v', 'libx264', '-crf', '28', '-preset', 'ultrafast',
|
||||
'-c:a:0', 'eac3', '-b:a:0', '640k', '-ac:a:0', '6', '-metadata:s:a:0', 'language=ita',
|
||||
`"${SAMPLES.test2}"`,
|
||||
].join(' '));
|
||||
console.log('Test 2 OK.\n');
|
||||
|
||||
// Test 3 — Ultrawide 3840x1600
|
||||
console.log('Generating Test 3: Ultrawide 3840x1600...');
|
||||
ensureDir(SAMPLES.test3);
|
||||
run([
|
||||
FFMPEG, '-y',
|
||||
'-f', 'lavfi', '-i', 'color=c=red:s=3840x1600:r=24:d=10',
|
||||
'-f', 'lavfi', '-i', 'sine=f=440:r=48000:d=10',
|
||||
'-map', '0:v', '-map', '1:a',
|
||||
'-c:v', 'libx264', '-crf', '28', '-preset', 'ultrafast',
|
||||
'-c:a', 'aac', '-b:a', '128k', '-metadata:s:a:0', 'language=eng',
|
||||
`"${SAMPLES.test3}"`,
|
||||
].join(' '));
|
||||
console.log('Test 3 OK.\n');
|
||||
|
||||
// Test 4 — SRT forced + SRT SDH
|
||||
console.log('Generating Test 4: Subtitles (SRT forced + SRT SDH)...');
|
||||
ensureDir(SAMPLES.test4);
|
||||
|
||||
const srtContent = '1\n00:00:01,000 --> 00:00:03,000\nTest subtitle line 1\n\n2\n00:00:04,000 --> 00:00:06,000\nTest subtitle line 2\n';
|
||||
const tmpSrt = 'tests/samples/tmp_sub.srt';
|
||||
fs.writeFileSync(tmpSrt, srtContent);
|
||||
|
||||
run([
|
||||
FFMPEG, '-y',
|
||||
'-f', 'lavfi', '-i', 'color=c=gray:s=1920x1080:r=25:d=30',
|
||||
'-f', 'lavfi', '-i', 'sine=f=440:r=48000:d=30',
|
||||
'-i', `"${tmpSrt}"`,
|
||||
'-i', `"${tmpSrt}"`,
|
||||
'-map', '0:v', '-map', '1:a', '-map', '2:s', '-map', '3:s',
|
||||
'-c:v', 'libx264', '-crf', '28', '-preset', 'ultrafast',
|
||||
'-c:a', 'aac', '-b:a', '128k', '-metadata:s:a:0', 'language=ita',
|
||||
'-c:s:0', 'srt', '-metadata:s:s:0', 'language=ita', '-disposition:s:0', 'forced',
|
||||
'-c:s:1', 'srt', '-metadata:s:s:1', 'language=ita', '-disposition:s:1', 'hearing_impaired',
|
||||
`"${SAMPLES.test4}"`,
|
||||
].join(' '));
|
||||
try { fs.unlinkSync(tmpSrt); } catch(_) {}
|
||||
console.log('Test 4 OK.\n');
|
||||
|
||||
console.log('All test files generated. Run: node tests/run-tests.js --skip-transcode');
|
||||
@@ -0,0 +1,109 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* mock-tdarr-runtime.js
|
||||
* Creates a complete mock of the Tdarr args object for isolated plugin testing.
|
||||
* Supports loading real ffprobe data from actual MKV files.
|
||||
*/
|
||||
|
||||
const path = require('path');
|
||||
const os = require('os');
|
||||
const fs = require('fs');
|
||||
const { execSync } = require('child_process');
|
||||
|
||||
/**
|
||||
* Run ffprobe on a file and return parsed JSON.
|
||||
* Falls back to a minimal synthetic structure if ffprobe is unavailable.
|
||||
*/
|
||||
function probeFile(filePath) {
|
||||
try {
|
||||
const raw = execSync(
|
||||
`ffprobe -v quiet -print_format json -show_streams -show_format "${filePath}"`,
|
||||
{ encoding: 'utf8', timeout: 15000 },
|
||||
);
|
||||
return JSON.parse(raw);
|
||||
} catch (err) {
|
||||
console.warn(`[mock] ffprobe failed for ${filePath}: ${err.message}`);
|
||||
return { streams: [], format: {} };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a mock Tdarr args object.
|
||||
*
|
||||
* @param {object} opts
|
||||
* @param {string} opts.filePath - Path to the input MKV file
|
||||
* @param {object} [opts.inputs] - Plugin input overrides (UI inputs)
|
||||
* @param {object} [opts.variables] - Pre-populated variables
|
||||
* @param {string} [opts.ffmpegPath] - Override ffmpeg path
|
||||
* @param {string} [opts.workDir] - Override work directory
|
||||
*/
|
||||
function buildMockArgs(opts) {
|
||||
const {
|
||||
filePath,
|
||||
inputs = {},
|
||||
variables = {},
|
||||
ffmpegPath = process.env.FFMPEG_PATH || 'ffmpeg',
|
||||
workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tdarr-test-')),
|
||||
} = opts;
|
||||
|
||||
const ffProbeData = probeFile(filePath);
|
||||
const logs = [];
|
||||
|
||||
return {
|
||||
inputFileObj: {
|
||||
_id: filePath,
|
||||
file: filePath,
|
||||
ffProbeData,
|
||||
mediaInfo: { track: [] },
|
||||
container: path.extname(filePath).replace('.', ''),
|
||||
},
|
||||
variables: { ...variables },
|
||||
inputs,
|
||||
workDir,
|
||||
ffmpegPath,
|
||||
ffprobePath: process.env.FFPROBE_PATH || 'ffprobe',
|
||||
mkvpropeditPath: process.env.MKVPROPEDIT_PATH || 'mkvpropedit',
|
||||
userVariables: { global: {}, library: {} },
|
||||
jobLog: (msg) => {
|
||||
process.stdout.write(msg);
|
||||
logs.push(msg);
|
||||
},
|
||||
_logs: logs,
|
||||
_workDir: workDir,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup a workDir created by buildMockArgs.
|
||||
*/
|
||||
function cleanupWorkDir(mockArgs) {
|
||||
const dir = mockArgs._workDir || mockArgs.workDir;
|
||||
if (dir && dir.startsWith(os.tmpdir()) && fs.existsSync(dir)) {
|
||||
fs.rmSync(dir, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple assertion helper.
|
||||
*/
|
||||
function assert(condition, message) {
|
||||
if (!condition) throw new Error(`ASSERTION FAILED: ${message}`);
|
||||
console.log(` [OK] ${message}`);
|
||||
}
|
||||
|
||||
function assertEqual(actual, expected, label) {
|
||||
assert(
|
||||
actual === expected,
|
||||
`${label}: expected "${expected}", got "${actual}"`,
|
||||
);
|
||||
}
|
||||
|
||||
function assertLessOrEqual(actual, max, label) {
|
||||
assert(
|
||||
parseInt(actual, 10) <= max,
|
||||
`${label}: ${actual} <= ${max}`,
|
||||
);
|
||||
}
|
||||
|
||||
module.exports = { buildMockArgs, cleanupWorkDir, assert, assertEqual, assertLessOrEqual };
|
||||
@@ -0,0 +1,206 @@
|
||||
'use strict';
|
||||
const path = require('path');
|
||||
const os = require('os');
|
||||
const fs = require('fs');
|
||||
|
||||
const ROOT = process.cwd();
|
||||
let passed = 0, failed = 0;
|
||||
function ok(cond, msg) {
|
||||
if (cond) { console.log(` [PASS] ${msg}`); passed++; }
|
||||
else { console.error(` [FAIL] ${msg}`); failed++; }
|
||||
}
|
||||
function eq(a, b, msg) { ok(String(a) === String(b), `${msg} (expected "${b}", got "${a}")`); }
|
||||
|
||||
function makeStream(o) {
|
||||
return Object.assign({
|
||||
index: 0, codec_type: 'video', codec_name: 'h264',
|
||||
r_frame_rate: '24/1', avg_frame_rate: '24/1',
|
||||
width: 1920, height: 1080, channels: 2,
|
||||
bit_rate: '0', tags: {}, disposition: {}, profile: '',
|
||||
}, o);
|
||||
}
|
||||
function makeArgs(filePath, streams, inputs, variables) {
|
||||
const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tdarr-logic-'));
|
||||
return {
|
||||
inputFileObj: { _id: filePath, ffProbeData: { streams }, mediaInfo: { track: [] } },
|
||||
variables: Object.assign({}, variables || {}),
|
||||
inputs: inputs || {},
|
||||
workDir,
|
||||
ffmpegPath: 'ffmpeg',
|
||||
mkvpropeditPath: 'mkvpropedit',
|
||||
jobLog: () => {},
|
||||
_workDir: workDir,
|
||||
};
|
||||
}
|
||||
function cleanup(a) { try { fs.rmSync(a._workDir, { recursive: true, force: true }); } catch(_){} }
|
||||
|
||||
const { plugin: analyzerPlugin } = require(path.join(ROOT, 'LocalFlowPlugins/utility/mediaAnalyzerGOP/1.0.0/index'));
|
||||
const { plugin: audioPlugin } = require(path.join(ROOT, 'LocalFlowPlugins/audio/audioSelectorClamping/1.0.0/index'));
|
||||
|
||||
const ANALYZER_INPUTS = {
|
||||
moviePathPatterns: '/Radarr', animeSeries: 'Naruto|One Piece',
|
||||
filmBitrate: '3000', seriesBitrate: '3000', animeBitrateHd: '2000', animeBitrateSd: '1000',
|
||||
};
|
||||
const AUDIO_INPUTS = {
|
||||
filmMultiChannelBitrate: '640', seriesMultiChannelThreshold: '384', stereoBitrateMax: '128',
|
||||
};
|
||||
|
||||
(async () => {
|
||||
// ── mediaAnalyzerGOP ──────────────────────────────────────────────────────
|
||||
console.log('\n── mediaAnalyzerGOP ──────────────────────────────────');
|
||||
|
||||
{ const a = makeArgs('/media/toshiba/Radarr/Film (2023)/Film.mkv',
|
||||
[makeStream({ r_frame_rate:'24000/1001', height:1080 })], ANALYZER_INPUTS);
|
||||
const o = await analyzerPlugin(a);
|
||||
eq(o.variables.gopKeyint, '48', '23.976fps -> keyint=48');
|
||||
eq(o.variables.isMovie, 'true', '/Radarr -> isMovie=true');
|
||||
eq(o.variables.isAnimation, 'false', 'no anime -> isAnimation=false');
|
||||
eq(o.variables.vBitrate, '3000k', 'film bitrate=3000k');
|
||||
eq(o.variables.vMaxRate, '6000k', 'maxrate=2x');
|
||||
eq(o.variables.vBufSize, '12000k', 'bufsize=4x');
|
||||
eq(o.variables.x265Tune, '', 'live-action -> no tune');
|
||||
cleanup(a); }
|
||||
|
||||
{ const a = makeArgs('/media/toshiba/Sonarr/Naruto S01/S01E01.mkv',
|
||||
[makeStream({ r_frame_rate:'25/1', height:720 })], ANALYZER_INPUTS);
|
||||
const o = await analyzerPlugin(a);
|
||||
eq(o.variables.gopKeyint, '50', '25fps -> keyint=50');
|
||||
eq(o.variables.isMovie, 'false', '/Sonarr -> isMovie=false');
|
||||
eq(o.variables.isAnimation, 'true', 'Naruto -> isAnimation=true');
|
||||
eq(o.variables.x265Tune, 'animation', 'anime -> tune=animation');
|
||||
eq(o.variables.vBitrate, '2000k', 'anime 720p HD -> 2000k');
|
||||
cleanup(a); }
|
||||
|
||||
{ const a = makeArgs('/media/toshiba/Sonarr/Naruto S01/S01E01.mkv',
|
||||
[makeStream({ r_frame_rate:'30000/1001', height:480 })], ANALYZER_INPUTS);
|
||||
const o = await analyzerPlugin(a);
|
||||
eq(o.variables.gopKeyint, '60', '29.97fps -> keyint=60');
|
||||
eq(o.variables.vBitrate, '1000k', 'anime SD 480p -> 1000k');
|
||||
cleanup(a); }
|
||||
|
||||
// Windows backslash path normalization
|
||||
{ const a = makeArgs('C:\\media\\toshiba\\Radarr\\Film (2023)\\Film.mkv',
|
||||
[makeStream({ r_frame_rate:'24/1', height:1080 })], ANALYZER_INPUTS);
|
||||
const o = await analyzerPlugin(a);
|
||||
eq(o.variables.isMovie, 'true', 'Windows backslash path: /Radarr still matched');
|
||||
cleanup(a); }
|
||||
|
||||
// ── audioSelectorClamping ─────────────────────────────────────────────────
|
||||
console.log('\n── audioSelectorClamping ────────────────────────────');
|
||||
|
||||
// EAC3 wins over AC3 by score
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'ac3', bit_rate:'448000', channels:6, tags:{language:'ita'} }),
|
||||
makeStream({ index:2, codec_type:'audio', codec_name:'eac3', bit_rate:'640000', channels:6, tags:{language:'eng'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
||||
const o = await audioPlugin(a);
|
||||
eq(o.outputNumber, 1, 'output 1 = tracks found');
|
||||
eq(o.variables.audioItaCodecName, 'ac3', 'ITA=ac3');
|
||||
eq(o.variables.audioEngCodecName, 'eac3', 'ENG=eac3');
|
||||
eq(o.variables.audioItaOpusBitrate, '448', 'ITA=min(640,448)=448');
|
||||
eq(o.variables.audioEngOpusBitrate, '640', 'ENG=min(640,640)=640');
|
||||
cleanup(a); }
|
||||
|
||||
// EAC3 640k vs AC3 680k same lang — EAC3 wins by weight
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'eac3', bit_rate:'640000', channels:6, tags:{language:'ita'} }),
|
||||
makeStream({ index:2, codec_type:'audio', codec_name:'ac3', bit_rate:'680000', channels:6, tags:{language:'ita'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
||||
const o = await audioPlugin(a);
|
||||
eq(o.variables.audioItaCodecName, 'eac3', 'EAC3@640k > AC3@680k by codec weight');
|
||||
eq(o.variables.audioItaStreamIndex, '1', 'EAC3 at stream index 1');
|
||||
cleanup(a); }
|
||||
|
||||
// Series DTS 768k >= 384 threshold -> 384
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'dts', bit_rate:'768000', channels:6, tags:{language:'ita'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Sonarr/Show/ep.mkv', streams, AUDIO_INPUTS, { isMovie:'false' });
|
||||
const o = await audioPlugin(a);
|
||||
eq(o.variables.audioItaOpusBitrate, '384', 'Series DTS 768k >= 384 -> Opus=384');
|
||||
cleanup(a); }
|
||||
|
||||
// Series AC3 320k < 384 threshold -> 256
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'ac3', bit_rate:'320000', channels:6, tags:{language:'ita'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Sonarr/Show/ep.mkv', streams, AUDIO_INPUTS, { isMovie:'false' });
|
||||
const o = await audioPlugin(a);
|
||||
eq(o.variables.audioItaOpusBitrate, '256', 'Series AC3 320k < 384 -> Opus=256');
|
||||
cleanup(a); }
|
||||
|
||||
// NEW: Series bitrate unknown (0) -> safe default 384k
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'dts', bit_rate:'0', channels:6, tags:{language:'ita'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Sonarr/Show/ep.mkv', streams, AUDIO_INPUTS, { isMovie:'false' });
|
||||
const o = await audioPlugin(a);
|
||||
eq(o.variables.audioItaOpusBitrate, '384', 'Series unknown bitrate (0) -> safe default 384k');
|
||||
cleanup(a); }
|
||||
|
||||
// Stereo: min(128,192)=128
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'aac', bit_rate:'192000', channels:2, tags:{language:'ita'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
||||
const o = await audioPlugin(a);
|
||||
eq(o.variables.audioItaOpusBitrate, '128', 'Stereo 192k -> min(128,192)=128');
|
||||
cleanup(a); }
|
||||
|
||||
// Stereo: no upcoding — min(128,64)=64
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'aac', bit_rate:'64000', channels:2, tags:{language:'eng'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
||||
const o = await audioPlugin(a);
|
||||
eq(o.variables.audioEngOpusBitrate, '64', 'Stereo 64k -> no upcoding, stays 64k');
|
||||
cleanup(a); }
|
||||
|
||||
// No ITA/ENG -> output branch 2
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'ac3', bit_rate:'448000', channels:6, tags:{language:'fra'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
||||
const o = await audioPlugin(a);
|
||||
eq(o.outputNumber, 2, 'No ITA/ENG -> output branch 2');
|
||||
cleanup(a); }
|
||||
|
||||
// DTS-HD MA detection via profile field
|
||||
{ const streams = [
|
||||
makeStream({ index:0, codec_type:'video' }),
|
||||
makeStream({ index:1, codec_type:'audio', codec_name:'dts', profile:'DTS-HD MA', bit_rate:'4000000', channels:8, tags:{language:'ita'} }),
|
||||
];
|
||||
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
||||
const o = await audioPlugin(a);
|
||||
// DTS-HD MA weight=95, score=95*10000+4000=954000 — should be selected
|
||||
eq(o.variables.audioItaCodecName, 'dts', 'DTS-HD MA detected (codec_name=dts, profile contains MA)');
|
||||
// source 4000kbps, film target 640 -> Opus=min(640,4000)=640
|
||||
eq(o.variables.audioItaOpusBitrate, '640', 'DTS-HD MA 4Mbps film -> clamped to 640k');
|
||||
cleanup(a); }
|
||||
|
||||
// ── buildAudioArgs structure check ────────────────────────────────────────
|
||||
console.log('\n── transcode2PassX265 buildAudioArgs structure ──────');
|
||||
const { plugin: transcodePlugin } = require(path.join(ROOT, 'LocalFlowPlugins/video/transcode2PassX265/1.0.0/index'));
|
||||
// Inspect the buildAudioArgs function by reading the file
|
||||
const transcodeCode = require('fs').readFileSync(path.join(ROOT, 'LocalFlowPlugins/video/transcode2PassX265/1.0.0/index.js'), 'utf8');
|
||||
ok(transcodeCode.includes('`-c:a:${audioTrackOut}`'), 'buildAudioArgs uses indexed -c:a:N (not global -c:a)');
|
||||
ok(transcodeCode.includes('`-b:a:${audioTrackOut}`'), 'buildAudioArgs uses indexed -b:a:N (not global -b:a)');
|
||||
ok(transcodeCode.includes('[...mapArgs, ...codecArgs]'), 'buildAudioArgs: maps first, then codec settings');
|
||||
ok(!transcodeCode.includes("'-c:a', 'libopus'"), 'no unindexed -c:a in buildAudioArgs');
|
||||
|
||||
// ── Summary ───────────────────────────────────────────────────────────────
|
||||
console.log(`\n${'='.repeat(55)}`);
|
||||
console.log(` ${passed} passed, ${failed} failed`);
|
||||
if (failed > 0) { console.error(' SOME TESTS FAILED'); process.exit(1); }
|
||||
else console.log(' ALL LOGIC TESTS PASSED');
|
||||
})();
|
||||
@@ -0,0 +1,70 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* run-tests.js
|
||||
* Orchestrates all 4 test cases.
|
||||
* Usage: node tests/run-tests.js [--skip-transcode]
|
||||
*
|
||||
* Options:
|
||||
* --skip-transcode Skip test3 (which runs actual FFmpeg x265 encode)
|
||||
*/
|
||||
|
||||
const args = process.argv.slice(2);
|
||||
const skipTranscode = args.includes('--skip-transcode');
|
||||
|
||||
const tests = [
|
||||
{ name: 'Test 1 — Film 23.976fps (AC3 ITA + EAC3 ENG)', file: './test-cases/test1-movie-23976fps', heavy: false },
|
||||
{ name: 'Test 2 — Anime 25fps DTS ITA (Naruto)', file: './test-cases/test2-anime-25fps', heavy: false },
|
||||
{ name: 'Test 3 — Ultrawide 3840x1600 Scale', file: './test-cases/test3-ultrawide', heavy: true },
|
||||
{ name: 'Test 4 — Subtitle Extraction (forced + SDH)', file: './test-cases/test4-subtitles', heavy: false },
|
||||
];
|
||||
|
||||
async function main() {
|
||||
console.log('╔══════════════════════════════════════════════════════════╗');
|
||||
console.log('║ Tdarr Plugin Suite — Test Runner ║');
|
||||
console.log('╚══════════════════════════════════════════════════════════╝\n');
|
||||
|
||||
const results = [];
|
||||
|
||||
for (const test of tests) {
|
||||
if (test.heavy && skipTranscode) {
|
||||
console.log(`[SKIP] ${test.name} (--skip-transcode)\n`);
|
||||
results.push({ name: test.name, status: 'SKIPPED' });
|
||||
continue;
|
||||
}
|
||||
|
||||
console.log(`[RUN] ${test.name}`);
|
||||
try {
|
||||
const fn = require(test.file);
|
||||
await fn();
|
||||
results.push({ name: test.name, status: 'PASSED' });
|
||||
} catch (err) {
|
||||
console.error(`\n[FAIL] ${test.name}\n ${err.message}\n`);
|
||||
results.push({ name: test.name, status: 'FAILED', error: err.message });
|
||||
}
|
||||
}
|
||||
|
||||
// ── Summary ───────────────────────────────────────────────────────────────
|
||||
console.log('\n╔══════════════════════════════════════════════════════════╗');
|
||||
console.log('║ SUMMARY ║');
|
||||
console.log('╚══════════════════════════════════════════════════════════╝\n');
|
||||
|
||||
let passed = 0, failed = 0, skipped = 0;
|
||||
for (const r of results) {
|
||||
const icon = r.status === 'PASSED' ? '[OK]' : r.status === 'SKIPPED' ? '[--]' : '[!!]';
|
||||
console.log(` ${icon} ${r.name}`);
|
||||
if (r.error) console.log(` Error: ${r.error}`);
|
||||
if (r.status === 'PASSED') passed++;
|
||||
if (r.status === 'FAILED') failed++;
|
||||
if (r.status === 'SKIPPED') skipped++;
|
||||
}
|
||||
|
||||
console.log(`\n Results: ${passed} passed, ${failed} failed, ${skipped} skipped\n`);
|
||||
|
||||
if (failed > 0) process.exit(1);
|
||||
}
|
||||
|
||||
main().catch((err) => {
|
||||
console.error('Fatal error:', err);
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -0,0 +1,81 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* test1-movie-23976fps.js
|
||||
* Validates: mediaAnalyzerGOP + audioSelectorClamping on a 23.976fps Film.
|
||||
* File: Radarr path, AC3 ITA 448k 5.1, EAC3 ENG 640k 5.1
|
||||
*
|
||||
* Expected:
|
||||
* gopKeyint = "48"
|
||||
* isMovie = "true"
|
||||
* isAnimation = "false"
|
||||
* vBitrate = "3000k"
|
||||
* audioItaCodecName = "ac3"
|
||||
* audioEngCodecName = "eac3" (EAC3 score > AC3 score)
|
||||
* audioItaOpusBitrate = "448" (clamped: min(640, 448) = 448)
|
||||
* audioEngOpusBitrate = "640" (clamped: min(640, 640) = 640)
|
||||
*/
|
||||
|
||||
const path = require('path');
|
||||
const { buildMockArgs, cleanupWorkDir, assertEqual } = require('../mock-tdarr-runtime');
|
||||
const { plugin: analyzerPlugin } = require('../../LocalFlowPlugins/utility/mediaAnalyzerGOP/1.0.0/index');
|
||||
const { plugin: audioPlugin } = require('../../LocalFlowPlugins/audio/audioSelectorClamping/1.0.0/index');
|
||||
|
||||
const FILE = path.resolve('tests/samples/media/toshiba/Radarr/Film Test (2023)/Film Test (2023).mkv');
|
||||
|
||||
async function run() {
|
||||
console.log('\n=== TEST 1: 23.976fps Film (AC3 ITA + EAC3 ENG) ===\n');
|
||||
|
||||
// ── Step 1: mediaAnalyzerGOP ──────────────────────────────────────────────
|
||||
console.log('Running mediaAnalyzerGOP...');
|
||||
const args1 = buildMockArgs({
|
||||
filePath: FILE,
|
||||
inputs: {
|
||||
moviePathPatterns: '/Radarr',
|
||||
animeSeries: '',
|
||||
filmBitrate: '3000',
|
||||
seriesBitrate: '3000',
|
||||
animeBitrateHd: '2000',
|
||||
animeBitrateSd: '1000',
|
||||
},
|
||||
});
|
||||
|
||||
const out1 = await analyzerPlugin(args1);
|
||||
const vars = out1.variables;
|
||||
|
||||
assertEqual(out1.outputNumber, 1, 'outputNumber');
|
||||
assertEqual(vars.gopKeyint, '48', 'gopKeyint (2 x 23.976 = 47.95 -> 48)');
|
||||
assertEqual(vars.isMovie, 'true', 'isMovie (Radarr path)');
|
||||
assertEqual(vars.isAnimation, 'false', 'isAnimation (no anime match)');
|
||||
assertEqual(vars.vBitrate, '3000k', 'vBitrate (film default)');
|
||||
assertEqual(vars.x265Tune, '', 'x265Tune (live-action)');
|
||||
|
||||
// ── Step 2: audioSelectorClamping ────────────────────────────────────────
|
||||
console.log('\nRunning audioSelectorClamping...');
|
||||
const args2 = buildMockArgs({
|
||||
filePath: FILE,
|
||||
variables: vars,
|
||||
inputs: {
|
||||
filmMultiChannelBitrate: '640',
|
||||
seriesMultiChannelThreshold:'384',
|
||||
stereoBitrateMax: '128',
|
||||
},
|
||||
});
|
||||
|
||||
const out2 = await audioPlugin(args2);
|
||||
const vars2 = out2.variables;
|
||||
|
||||
assertEqual(out2.outputNumber, 1, 'outputNumber (tracks found)');
|
||||
assertEqual(vars2.audioHasIta, 'true', 'audioHasIta');
|
||||
assertEqual(vars2.audioHasEng, 'true', 'audioHasEng');
|
||||
assertEqual(vars2.audioItaCodecName, 'ac3', 'ITA codec = ac3');
|
||||
assertEqual(vars2.audioEngCodecName, 'eac3', 'ENG codec = eac3 (wins by score)');
|
||||
assertEqual(vars2.audioItaOpusBitrate, '448', 'ITA Opus = 448k (min(640,448))');
|
||||
assertEqual(vars2.audioEngOpusBitrate, '640', 'ENG Opus = 640k (min(640,640))');
|
||||
|
||||
cleanupWorkDir(args1);
|
||||
cleanupWorkDir(args2);
|
||||
console.log('\n=== TEST 1 PASSED ===\n');
|
||||
}
|
||||
|
||||
module.exports = run;
|
||||
@@ -0,0 +1,72 @@
|
||||
'use strict';
|
||||
/**
|
||||
* test2-anime-25fps.js
|
||||
* Validates mediaAnalyzerGOP + audioSelectorClamping on anime 25fps.
|
||||
* File: Sonarr path, EAC3 ITA 640k 5.1, "Naruto" in animeSeries list.
|
||||
* Note: DTS detection logic is fully covered in unit tests (quick-logic-test.js).
|
||||
*
|
||||
* Expected:
|
||||
* gopKeyint = "50"
|
||||
* isAnimation = "true"
|
||||
* isMovie = "false"
|
||||
* x265Tune = "animation"
|
||||
* vBitrate = "2000k" (anime HD 720p)
|
||||
* audioItaCodecName = "eac3"
|
||||
* audioItaOpusBitrate = "384" (series: 640k >= 384 threshold -> 384k)
|
||||
* audioHasEng = "false"
|
||||
*/
|
||||
|
||||
const path = require('path');
|
||||
const { buildMockArgs, cleanupWorkDir, assertEqual } = require('../mock-tdarr-runtime');
|
||||
const { plugin: analyzerPlugin } = require(require('path').join(process.cwd(), 'LocalFlowPlugins/utility/mediaAnalyzerGOP/1.0.0/index'));
|
||||
const { plugin: audioPlugin } = require(require('path').join(process.cwd(), 'LocalFlowPlugins/audio/audioSelectorClamping/1.0.0/index'));
|
||||
|
||||
const FILE = path.resolve('tests/samples/media/toshiba/Sonarr/Naruto S01/Naruto S01E01.mkv');
|
||||
|
||||
async function run() {
|
||||
console.log('\n=== TEST 2: 25fps Anime EAC3 ITA (Naruto, Sonarr) ===\n');
|
||||
|
||||
console.log('Running mediaAnalyzerGOP...');
|
||||
const args1 = buildMockArgs({
|
||||
filePath: FILE,
|
||||
inputs: {
|
||||
moviePathPatterns: '/Radarr',
|
||||
animeSeries: 'Naruto|One Piece',
|
||||
filmBitrate: '3000',
|
||||
seriesBitrate: '3000',
|
||||
animeBitrateHd: '2000',
|
||||
animeBitrateSd: '1000',
|
||||
},
|
||||
});
|
||||
const out1 = await analyzerPlugin(args1);
|
||||
const vars = out1.variables;
|
||||
assertEqual(vars.gopKeyint, '50', 'gopKeyint (2 x 25 = 50)');
|
||||
assertEqual(vars.isMovie, 'false', 'isMovie=false (Sonarr path)');
|
||||
assertEqual(vars.isAnimation, 'true', 'isAnimation=true (Naruto in path)');
|
||||
assertEqual(vars.x265Tune, 'animation', 'x265Tune=animation');
|
||||
assertEqual(vars.vBitrate, '2000k', 'vBitrate=2000k (anime 720p HD)');
|
||||
|
||||
console.log('\nRunning audioSelectorClamping...');
|
||||
const args2 = buildMockArgs({
|
||||
filePath: FILE,
|
||||
variables: vars,
|
||||
inputs: {
|
||||
filmMultiChannelBitrate: '640',
|
||||
seriesMultiChannelThreshold:'384',
|
||||
stereoBitrateMax: '128',
|
||||
},
|
||||
});
|
||||
const out2 = await audioPlugin(args2);
|
||||
const vars2 = out2.variables;
|
||||
assertEqual(out2.outputNumber, 1, 'outputNumber=1 (ITA found)');
|
||||
assertEqual(vars2.audioHasIta, 'true', 'audioHasIta=true');
|
||||
assertEqual(vars2.audioHasEng, 'false','audioHasEng=false');
|
||||
assertEqual(vars2.audioItaCodecName, 'eac3', 'ITA codec=eac3');
|
||||
assertEqual(vars2.audioItaOpusBitrate, '384', 'ITA Opus=384k (series: 640k >= 384 threshold)');
|
||||
|
||||
cleanupWorkDir(args1);
|
||||
cleanupWorkDir(args2);
|
||||
console.log('\n=== TEST 2 PASSED ===\n');
|
||||
}
|
||||
|
||||
module.exports = run;
|
||||
@@ -0,0 +1,76 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* test3-ultrawide.js
|
||||
* Validates: transcode2PassX265 scale filter on 3840x1600 input.
|
||||
* Expected output: 1920x800 (no letterbox, even dimensions).
|
||||
*/
|
||||
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
const { execSync } = require('child_process');
|
||||
const { buildMockArgs, cleanupWorkDir, assert, assertEqual } = require('../mock-tdarr-runtime');
|
||||
const { plugin: analyzerPlugin } = require('../../LocalFlowPlugins/utility/mediaAnalyzerGOP/1.0.0/index');
|
||||
const { plugin: audioPlugin } = require('../../LocalFlowPlugins/audio/audioSelectorClamping/1.0.0/index');
|
||||
const { plugin: transcodePlugin } = require('../../LocalFlowPlugins/video/transcode2PassX265/1.0.0/index');
|
||||
|
||||
const FILE = path.resolve('tests/samples/test3_ultrawide.mkv');
|
||||
const FFMPEG = process.env.FFMPEG_PATH || 'ffmpeg';
|
||||
const FFPROBE = process.env.FFPROBE_PATH || 'ffprobe';
|
||||
|
||||
async function run() {
|
||||
console.log('\n=== TEST 3: Ultrawide 3840x1600 Scale Filter ===\n');
|
||||
|
||||
// Analyzer
|
||||
const args1 = buildMockArgs({
|
||||
filePath: FILE,
|
||||
inputs: { moviePathPatterns: '/Radarr', animeSeries: '', filmBitrate: '3000',
|
||||
seriesBitrate: '3000', animeBitrateHd: '2000', animeBitrateSd: '1000' },
|
||||
});
|
||||
const out1 = await analyzerPlugin(args1);
|
||||
const vars = out1.variables;
|
||||
assertEqual(vars.videoHeight, '1600', 'Source videoHeight = 1600');
|
||||
|
||||
// Audio selector
|
||||
const args2 = buildMockArgs({
|
||||
filePath: FILE, variables: vars,
|
||||
inputs: { filmMultiChannelBitrate: '640', seriesMultiChannelThreshold: '384', stereoBitrateMax: '128' },
|
||||
});
|
||||
const out2 = await audioPlugin(args2);
|
||||
|
||||
// Transcode (Pass 1 + Pass 2)
|
||||
console.log('Running transcode2PassX265 (this may take a minute)...');
|
||||
const args3 = buildMockArgs({
|
||||
filePath: FILE,
|
||||
variables: out2.variables,
|
||||
inputs: { x265Preset: 'ultrafast', outputContainer: 'mkv' },
|
||||
ffmpegPath: FFMPEG,
|
||||
});
|
||||
|
||||
const out3 = await transcodePlugin(args3);
|
||||
const outFile = out3.outputFileObj._id;
|
||||
|
||||
assert(fs.existsSync(outFile), `Output file exists: ${outFile}`);
|
||||
|
||||
// Verify dimensions with ffprobe
|
||||
const probeOut = execSync(
|
||||
`${FFPROBE} -v quiet -print_format json -show_streams -select_streams v:0 "${outFile}"`,
|
||||
{ encoding: 'utf8' },
|
||||
);
|
||||
const { streams } = JSON.parse(probeOut);
|
||||
const w = streams[0].width;
|
||||
const h = streams[0].height;
|
||||
|
||||
console.log(` Output dimensions: ${w}x${h}`);
|
||||
assert(w === 1920, `Width = 1920 (got ${w})`);
|
||||
assert(h === 800, `Height = 800 (got ${h})`);
|
||||
assert(w % 2 === 0, 'Width is even');
|
||||
assert(h % 2 === 0, 'Height is even');
|
||||
|
||||
cleanupWorkDir(args1);
|
||||
cleanupWorkDir(args2);
|
||||
cleanupWorkDir(args3);
|
||||
console.log('\n=== TEST 3 PASSED ===\n');
|
||||
}
|
||||
|
||||
module.exports = run;
|
||||
@@ -0,0 +1,50 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* test4-subtitles.js
|
||||
* Validates: extractSubtitlesAndOcr produces correctly named SRT files.
|
||||
* Source: MKV with 2 ITA SRT streams (forced + SDH).
|
||||
* Expected: .ita.forced.srt and .ita.hearing_impaired.srt in source dir.
|
||||
*/
|
||||
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
const { buildMockArgs, cleanupWorkDir, assert } = require('../mock-tdarr-runtime');
|
||||
const { plugin: subPlugin } = require('../../LocalFlowPlugins/subtitles/extractSubtitlesAndOcr/1.0.0/index');
|
||||
|
||||
const FILE = path.resolve('tests/samples/test4_subtitles.mkv');
|
||||
const SOURCE_DIR = path.dirname(FILE);
|
||||
const BASE_NAME = path.basename(FILE, '.mkv');
|
||||
|
||||
async function run() {
|
||||
console.log('\n=== TEST 4: Subtitle Extraction (forced + SDH) ===\n');
|
||||
|
||||
const args = buildMockArgs({
|
||||
filePath: FILE,
|
||||
inputs: { subtitleEditPath: 'SubtitleEdit', languages: 'ita,eng' },
|
||||
});
|
||||
|
||||
await subPlugin(args);
|
||||
|
||||
// Check that forced SRT was created
|
||||
const forcedSrt = path.join(SOURCE_DIR, `${BASE_NAME}.ita.forced.srt`);
|
||||
const sdhSrt = path.join(SOURCE_DIR, `${BASE_NAME}.ita.sdh.srt`);
|
||||
|
||||
console.log(' Checking for:', path.basename(forcedSrt));
|
||||
assert(fs.existsSync(forcedSrt), `Forced SRT exists: ${path.basename(forcedSrt)}`);
|
||||
|
||||
console.log(' Checking for:', path.basename(sdhSrt));
|
||||
// Note: disposition hearing_impaired maps to 'sdh' suffix
|
||||
// If not found, check for .ita.default.srt variant (FFmpeg disposition naming may vary)
|
||||
const sdhExists = fs.existsSync(sdhSrt);
|
||||
const altSdhExists = fs.existsSync(path.join(SOURCE_DIR, `${BASE_NAME}.ita.default.srt`));
|
||||
assert(sdhExists || altSdhExists, `SDH/hearing-impaired SRT exists`);
|
||||
|
||||
// Cleanup generated subtitle files
|
||||
[forcedSrt, sdhSrt].forEach((f) => { try { fs.unlinkSync(f); } catch (_) {} });
|
||||
|
||||
cleanupWorkDir(args);
|
||||
console.log('\n=== TEST 4 PASSED ===\n');
|
||||
}
|
||||
|
||||
module.exports = run;
|
||||
Reference in new issue
Block a user