401 lines
11 KiB
JavaScript
401 lines
11 KiB
JavaScript
/**
|
||
* Сканирует папку с .mp4, создаёт рядом .webm и .webp (превью).
|
||
* Пропускает ролик, если уже есть оба выхода с тем же базовым именем.
|
||
* Недостающие из пары — догенерирует.
|
||
*
|
||
* Требуется: ffmpeg и ffprobe в PATH.
|
||
*
|
||
* Использование: node scripts/convert-videos.mjs <папка_с_роликами>
|
||
*/
|
||
|
||
import { execFile, execFileSync, spawn } from "node:child_process";
|
||
import fs from "node:fs";
|
||
import path from "node:path";
|
||
import { fileURLToPath } from "node:url";
|
||
|
||
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
||
const projectRoot = path.resolve(__dirname, "..");
|
||
|
||
const isTty = process.stdout.isTTY;
|
||
|
||
function hasBin(name) {
|
||
try {
|
||
execFileSync(name, ["-version"], { stdio: "ignore" });
|
||
return true;
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function getDurationSec(inputPath) {
|
||
const out = execFileSync("ffprobe", [
|
||
"-v",
|
||
"error",
|
||
"-show_entries",
|
||
"format=duration",
|
||
"-of",
|
||
"default=nw=1:nk=1",
|
||
inputPath,
|
||
], { encoding: "utf8" });
|
||
const n = parseFloat(String(out).trim());
|
||
return Number.isFinite(n) && n > 0 ? n : 0.1;
|
||
}
|
||
|
||
function hasAudioStream(inputPath) {
|
||
try {
|
||
const o = execFileSync(
|
||
"ffprobe",
|
||
[
|
||
"-v",
|
||
"error",
|
||
"-select_streams",
|
||
"a:0",
|
||
"-show_entries",
|
||
"stream=index",
|
||
"-of",
|
||
"csv=p=0",
|
||
inputPath,
|
||
],
|
||
{ encoding: "utf8" },
|
||
);
|
||
return o.trim().length > 0;
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {string[]} ffmpegArgs аргументы без префикса `ffmpeg` (с `-i` и в конце выход)
|
||
* @param {{ durationSec: number, onProgress: (p: number) => void }} o
|
||
*/
|
||
function runFfmpegProgress(ffmpegArgs, { durationSec, onProgress }) {
|
||
const totalMs = Math.max(1, Math.round(durationSec * 1000));
|
||
const allArgs = [
|
||
"-hide_banner",
|
||
"-y",
|
||
"-loglevel",
|
||
"error",
|
||
"-progress",
|
||
"pipe:1",
|
||
...ffmpegArgs,
|
||
];
|
||
return new Promise((resolve, reject) => {
|
||
const child = spawn("ffmpeg", allArgs, {
|
||
stdio: ["ignore", "pipe", "pipe"],
|
||
windowsHide: true,
|
||
});
|
||
onProgress(0);
|
||
let outBuf = "";
|
||
let errBuf = "";
|
||
let lastPct = -1;
|
||
let lastLogTs = 0;
|
||
if (child.stdout) {
|
||
child.stdout.setEncoding("utf8");
|
||
child.stdout.on("data", (chunk) => {
|
||
outBuf += chunk;
|
||
for (;;) {
|
||
const nl = outBuf.indexOf("\n");
|
||
if (nl < 0) break;
|
||
const line = outBuf.slice(0, nl);
|
||
outBuf = outBuf.slice(nl + 1);
|
||
if (line.startsWith("out_time_ms=")) {
|
||
const ms = parseInt(line.slice("out_time_ms=".length), 10);
|
||
if (!Number.isFinite(ms)) continue;
|
||
const pct = Math.min(100, (ms / totalMs) * 100);
|
||
const now = Date.now();
|
||
const tick =
|
||
isTty
|
||
? pct - lastPct >= 0.3 || now - lastLogTs > 200
|
||
: Math.floor(pct) > Math.floor(lastPct) && Math.floor(pct) % 5 === 0;
|
||
if (tick && pct > lastPct) {
|
||
lastPct = pct;
|
||
lastLogTs = now;
|
||
onProgress(pct);
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
if (child.stderr) {
|
||
child.stderr.setEncoding("utf8");
|
||
child.stderr.on("data", (d) => {
|
||
errBuf += d;
|
||
});
|
||
}
|
||
child.on("error", reject);
|
||
child.on("close", (code) => {
|
||
if (code === 0) {
|
||
onProgress(100);
|
||
resolve();
|
||
} else {
|
||
reject(
|
||
new Error(
|
||
(errBuf && errBuf.trim()) || `ffmpeg завершился с кодом ${code}`,
|
||
),
|
||
);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
function runFfmpegQuiet(ffmpegArgs) {
|
||
return new Promise((resolve, reject) => {
|
||
execFile("ffmpeg", ["-hide_banner", "-y", ...ffmpegArgs], (err) => {
|
||
if (err) reject(err);
|
||
else resolve();
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* @param {object} p
|
||
* @param {number} p.fileIndex 1..fileTotal
|
||
* @param {number} p.fileTotal
|
||
* @param {number} p.stepIndex текущий шаг 0..totalSteps-1
|
||
* @param {number} p.totalSteps
|
||
* @param {string} p.name basename mp4
|
||
* @param {string} p.label webm|webp
|
||
* @param {number} p.stepPct 0..100 внутри шага
|
||
*/
|
||
function renderStatus(p) {
|
||
const overall =
|
||
p.totalSteps > 0
|
||
? ((p.stepIndex + p.stepPct / 100) / p.totalSteps) * 100
|
||
: 100;
|
||
const s = `Общий: ${overall.toFixed(0)}% | ролик ${p.fileIndex}/${p.fileTotal}: ${p.name} | ${p.label} ${p.stepPct.toFixed(0)}%`;
|
||
if (isTty) {
|
||
process.stdout.write(`\r\x1B[K${s}`);
|
||
} else {
|
||
const now = Date.now();
|
||
if (!p._last || now - p._last > 500 || p.stepPct >= 100) {
|
||
p._last = now;
|
||
console.log(s);
|
||
}
|
||
}
|
||
}
|
||
|
||
async function toWebm(inputPath, outPath, statusCtx) {
|
||
const a = [
|
||
"-i",
|
||
inputPath,
|
||
"-c:v",
|
||
"libvpx-vp9",
|
||
"-crf",
|
||
"32",
|
||
"-b:v",
|
||
"0",
|
||
];
|
||
if (hasAudioStream(inputPath)) {
|
||
a.push("-c:a", "libopus", "-b:a", "128k");
|
||
} else {
|
||
a.push("-an");
|
||
}
|
||
a.push(outPath);
|
||
const d = getDurationSec(inputPath);
|
||
await runFfmpegProgress(a, {
|
||
durationSec: d,
|
||
onProgress: (pct) => {
|
||
if (statusCtx) {
|
||
statusCtx.stepPct = pct;
|
||
renderStatus(statusCtx);
|
||
}
|
||
},
|
||
});
|
||
}
|
||
|
||
/** Превью: один кадр, timestamp ~ min(1 c, 10% длительности), max ширина 1280. */
|
||
async function toWebpPreview(inputPath, outPath) {
|
||
const d = getDurationSec(inputPath);
|
||
const ss = Math.min(1, Math.max(0, d * 0.1));
|
||
await runFfmpegQuiet([
|
||
"-ss",
|
||
String(ss),
|
||
"-i",
|
||
inputPath,
|
||
"-vframes",
|
||
"1",
|
||
"-vf",
|
||
"scale=1280:-1:flags=lanczos",
|
||
"-c:v",
|
||
"libwebp",
|
||
"-quality",
|
||
"85",
|
||
outPath,
|
||
]);
|
||
}
|
||
|
||
function listMp4(dir) {
|
||
const names = fs.readdirSync(dir, { withFileTypes: true });
|
||
return names
|
||
.filter((d) => d.isFile() && d.name.toLowerCase().endsWith(".mp4"))
|
||
.map((d) => path.join(dir, d.name));
|
||
}
|
||
|
||
async function main() {
|
||
const raw = process.argv[2];
|
||
if (!raw) {
|
||
console.error("Укажи папку: node scripts/convert-videos.mjs <папка>");
|
||
process.exit(1);
|
||
}
|
||
const targetDir = path.resolve(projectRoot, raw);
|
||
if (!fs.existsSync(targetDir) || !fs.statSync(targetDir).isDirectory()) {
|
||
console.error("Папка не найдена или не каталог:", targetDir);
|
||
process.exit(1);
|
||
}
|
||
if (!hasBin("ffmpeg") || !hasBin("ffprobe")) {
|
||
console.error("Нужны ffmpeg и ffprobe в PATH.");
|
||
process.exit(1);
|
||
}
|
||
|
||
const mp4s = listMp4(targetDir);
|
||
if (mp4s.length === 0) {
|
||
console.log("В папке нет .mp4:", targetDir);
|
||
return;
|
||
}
|
||
|
||
let skipped = 0;
|
||
/** @type {{ mp4: string, base: string, webm: string, webp: string, needW: boolean, needP: boolean }[]} */
|
||
const jobs = [];
|
||
for (const mp4 of mp4s) {
|
||
const base = path.join(
|
||
path.dirname(mp4),
|
||
path.basename(mp4, path.extname(mp4)),
|
||
);
|
||
const webm = base + ".webm";
|
||
const webp = base + ".webp";
|
||
const haveWebm = fs.existsSync(webm);
|
||
const haveWebp = fs.existsSync(webp);
|
||
if (haveWebm && haveWebp) {
|
||
skipped += 1;
|
||
continue;
|
||
}
|
||
jobs.push({
|
||
mp4,
|
||
base,
|
||
webm,
|
||
webp,
|
||
needW: !haveWebm,
|
||
needP: !haveWebp,
|
||
});
|
||
}
|
||
|
||
if (skipped > 0) {
|
||
console.log(
|
||
`Пропущено (уже webm+webp): ${skipped} из ${mp4s.length} роликов.`,
|
||
);
|
||
}
|
||
const totalSteps = jobs.reduce(
|
||
(n, j) => n + (j.needW ? 1 : 0) + (j.needP ? 1 : 0),
|
||
0,
|
||
);
|
||
if (jobs.length === 0) {
|
||
console.log("Конвертировать нечего.");
|
||
return;
|
||
}
|
||
console.log(
|
||
`К конвертации: ${jobs.length} роликов, шагов кодирования: ${totalSteps}.`,
|
||
);
|
||
|
||
let stepIndex = 0;
|
||
const fileTotal = jobs.length;
|
||
for (let fi = 0; fi < jobs.length; fi += 1) {
|
||
const j = jobs[fi];
|
||
const name = path.basename(j.mp4);
|
||
const fileIndex = fi + 1;
|
||
const rel = path.relative(projectRoot, j.mp4) || j.mp4;
|
||
try {
|
||
if (j.needW) {
|
||
if (!isTty) {
|
||
console.log(
|
||
`Ролик ${fileIndex}/${fileTotal}: ${name} — webm (шаг ${stepIndex + 1}/${totalSteps})`,
|
||
);
|
||
} else {
|
||
process.stdout.write(
|
||
`\nРолик ${fileIndex}/${fileTotal}: ${name} — webm\n`,
|
||
);
|
||
}
|
||
const ctx = isTty
|
||
? {
|
||
fileIndex,
|
||
fileTotal,
|
||
stepIndex,
|
||
totalSteps,
|
||
name,
|
||
label: "webm",
|
||
stepPct: 0,
|
||
}
|
||
: {
|
||
fileIndex,
|
||
fileTotal,
|
||
stepIndex,
|
||
totalSteps,
|
||
name,
|
||
label: "webm",
|
||
stepPct: 0,
|
||
_last: 0,
|
||
};
|
||
await toWebm(j.mp4, j.webm, ctx);
|
||
if (isTty) {
|
||
process.stdout.write("\n");
|
||
}
|
||
stepIndex += 1;
|
||
} else {
|
||
if (!isTty) {
|
||
console.log(
|
||
`Ролик ${fileIndex}/${fileTotal}: ${name} — webm уже есть.`,
|
||
);
|
||
}
|
||
}
|
||
|
||
if (j.needP) {
|
||
if (!isTty) {
|
||
console.log(
|
||
`Ролик ${fileIndex}/${fileTotal}: ${name} — webp (шаг ${stepIndex + 1}/${totalSteps})`,
|
||
);
|
||
} else {
|
||
if (!j.needW) {
|
||
process.stdout.write(
|
||
`\nРолик ${fileIndex}/${fileTotal}: ${name} — webp\n`,
|
||
);
|
||
}
|
||
const overall = (stepIndex / totalSteps) * 100;
|
||
process.stdout.write(
|
||
`\r\x1B[KОбщий: ${overall.toFixed(0)}% | ролик ${fileIndex}/${fileTotal}: ${name} | webp …`,
|
||
);
|
||
}
|
||
await toWebpPreview(j.mp4, j.webp);
|
||
if (isTty) {
|
||
const o = ((stepIndex + 1) / totalSteps) * 100;
|
||
process.stdout.write(
|
||
`\r\x1B[KОбщий: ${o.toFixed(0)}% | ролик ${fileIndex}/${fileTotal}: ${name} | webp 100%`,
|
||
);
|
||
process.stdout.write("\n");
|
||
} else {
|
||
const o = ((stepIndex + 1) / totalSteps) * 100;
|
||
console.log(`Общий: ${o.toFixed(0)}% | webp готово — ${rel}`);
|
||
}
|
||
stepIndex += 1;
|
||
} else if (j.needW && !j.needP && !isTty) {
|
||
console.log(
|
||
`Ролик ${fileIndex}/${fileTotal}: ${name} — webp уже есть.`,
|
||
);
|
||
}
|
||
} catch (e) {
|
||
if (isTty) {
|
||
process.stdout.write("\n");
|
||
}
|
||
console.error("Ошибка для", rel, e.message || e);
|
||
process.exitCode = 1;
|
||
}
|
||
}
|
||
if (isTty) {
|
||
process.stdout.write(
|
||
`\r\x1B[KГотово: ${jobs.length} роликов, ${totalSteps} шагов.\n`,
|
||
);
|
||
} else {
|
||
console.log(`Готово: ${jobs.length} роликов, ${totalSteps} шагов.`);
|
||
}
|
||
}
|
||
|
||
main();
|