bytecut 0.0.0-stage → 0.0.1

package/dist/chunk-WE7AEDVI.js

@@ -0,0 +1,536 @@
+#!/usr/bin/env node
+import {
+  ffmpegDirOf,
+  probeFfmpeg,
+  resolveBinary
+} from "./chunk-YBEC5QGV.js";
+import {
+  BytecutError
+} from "./chunk-TWI2OZJZ.js";
+
+// src/core/posix.ts
+import { sep } from "path";
+function toPosix(path) {
+  return sep === "/" ? path : path.split(sep).join("/");
+}
+
+// src/core/video/probe.ts
+import { open } from "fs/promises";
+function rate(text) {
+  const m = /^(\d+)\/(\d+)$/.exec(text ?? "");
+  if (!m || Number(m[2]) === 0) return 0;
+  return Number(m[1]) / Number(m[2]);
+}
+function parseProbe(json) {
+  const data = json;
+  const streams = data.streams ?? [];
+  const video = streams.find((s) => s.codec_type === "video" && !s.disposition?.attached_pic);
+  if (!video) return null;
+  const audio = streams.find((s) => s.codec_type === "audio");
+  const duration = Number(data.format?.duration ?? video.duration ?? 0);
+  const bitrate = Number(data.format?.bit_rate);
+  return {
+    durationSec: Number.isFinite(duration) ? duration : 0,
+    width: video.width ?? 0,
+    height: video.height ?? 0,
+    // avg is the real rate for variable-rate sources; r_frame_rate is the container's base.
+    fps: rate(video.avg_frame_rate) || rate(video.r_frame_rate),
+    videoCodec: video.codec_name ?? "unknown",
+    pixelFormat: video.pix_fmt ?? null,
+    bitrate: Number.isFinite(bitrate) && bitrate > 0 ? bitrate : null,
+    hasAudio: audio !== void 0,
+    audioCodec: audio?.codec_name ?? null,
+    container: data.format?.format_name ?? "unknown"
+  };
+}
+async function isFastStart(path) {
+  const file = await open(path, "r");
+  try {
+    const { size } = await file.stat();
+    const header = Buffer.alloc(16);
+    let offset = 0;
+    let first = true;
+    for (let guard = 0; guard < 64 && offset + 8 <= size; guard++) {
+      const { bytesRead } = await file.read(header, 0, 16, offset);
+      if (bytesRead < 8) return null;
+      let boxSize = header.readUInt32BE(0);
+      const type = header.toString("latin1", 4, 8);
+      if (first) {
+        if (type !== "ftyp") return null;
+        first = false;
+      }
+      if (type === "moov") return true;
+      if (type === "mdat") return false;
+      if (boxSize === 1) {
+        if (bytesRead < 16) return null;
+        boxSize = Number(header.readBigUInt64BE(8));
+      } else if (boxSize === 0) {
+        return null;
+      }
+      if (boxSize < 8) return null;
+      offset += boxSize;
+    }
+    return null;
+  } finally {
+    await file.close();
+  }
+}
+
+// src/core/video/ffmpeg-engine.ts
+import { spawn } from "child_process";
+
+// src/core/video/args.ts
+var evenDown = (n) => Math.max(2, Math.floor(n / 2) * 2);
+function outputWidth(sourceWidth, maxWidth) {
+  const capped = maxWidth !== null ? Math.min(sourceWidth, maxWidth) : sourceWidth;
+  return evenDown(capped);
+}
+function needsFpsCap(probe, maxFps) {
+  return maxFps !== null && probe.fps > maxFps + 0.01;
+}
+function videoFilter(probe, maxWidth, maxFps) {
+  const filters = [];
+  if (needsFpsCap(probe, maxFps)) filters.push(`fps=${maxFps}`);
+  filters.push(`scale=${outputWidth(probe.width, maxWidth)}:-2:flags=lanczos`);
+  filters.push("format=yuv420p");
+  return filters.join(",");
+}
+function encoderArgs(encoder, crf, speed) {
+  switch (encoder) {
+    case "libsvtav1":
+      return ["-c:v", "libsvtav1", "-crf", String(crf), "-preset", speed];
+    case "libaom-av1":
+      return [
+        "-c:v",
+        "libaom-av1",
+        "-crf",
+        String(crf),
+        "-b:v",
+        "0",
+        "-cpu-used",
+        speed,
+        "-row-mt",
+        "1"
+      ];
+    case "libx264":
+      return ["-c:v", "libx264", "-crf", String(crf), "-preset", speed];
+  }
+}
+function buildEncodeArgs(request) {
+  const args = [
+    "-hide_banner",
+    "-nostdin",
+    "-loglevel",
+    "error",
+    "-y",
+    "-i",
+    request.source,
+    "-map",
+    "0:v:0"
+  ];
+  if (request.audio === "keep" && request.probe.hasAudio) {
+    args.push("-map", "0:a:0", "-c:a", "aac", "-b:a", request.audioBitrate);
+  } else {
+    args.push("-an");
+  }
+  args.push(
+    "-vf",
+    videoFilter(request.probe, request.maxWidth, request.maxFps),
+    ...encoderArgs(request.encoder, request.crf, request.speed),
+    "-movflags",
+    "+faststart",
+    "-map_metadata",
+    "-1",
+    "-fflags",
+    "+bitexact",
+    "-flags:v",
+    "+bitexact",
+    "-flags:a",
+    "+bitexact",
+    // The reserved temp path ends in .tmp, so the muxer cannot be inferred from it.
+    "-f",
+    "mp4",
+    "-progress",
+    "pipe:1",
+    "-nostats",
+    request.output
+  );
+  return args;
+}
+function buildSampleArgs(request) {
+  const raw = request.encoder === "libx264" ? "h264" : "ivf";
+  return [
+    "-hide_banner",
+    "-nostdin",
+    "-loglevel",
+    "error",
+    "-ss",
+    String(request.startSec),
+    "-t",
+    String(request.durationSec),
+    "-i",
+    request.source,
+    "-map",
+    "0:v:0",
+    "-an",
+    "-vf",
+    videoFilter(request.probe, request.maxWidth, request.maxFps),
+    ...encoderArgs(request.encoder, request.crf, request.speed),
+    "-f",
+    raw,
+    "pipe:1"
+  ];
+}
+function buildClipEncodeArgs(request) {
+  const args = buildSampleArgs(request);
+  const at = args.lastIndexOf("-f");
+  return [...args.slice(0, at), "-f", "matroska", "pipe:1"];
+}
+var COMMON = ["-hide_banner", "-nostdin", "-loglevel", "error"];
+function frameSelection(request) {
+  const rate2 = Math.max(0.1, request.count / Math.max(0.1, request.durationSec));
+  return [`fps=${Math.round(rate2 * 1e3) / 1e3}`];
+}
+function rawOut(count) {
+  return ["-frames:v", String(count), "-an", "-f", "rawvideo", "-pix_fmt", "rgb24", "pipe:1"];
+}
+function buildFramesArgs(request) {
+  const filters = [];
+  if (request.pipeline) {
+    const { probe, maxWidth, maxFps } = request.pipeline;
+    filters.push(videoFilter(probe, maxWidth, maxFps));
+  }
+  filters.push(...frameSelection(request), `scale=${request.width}:${request.height}:flags=area`);
+  return [
+    ...COMMON,
+    "-ss",
+    String(request.startSec),
+    "-t",
+    String(request.durationSec),
+    "-i",
+    request.source,
+    "-map",
+    "0:v:0",
+    "-vf",
+    filters.join(","),
+    ...rawOut(request.count)
+  ];
+}
+function buildPipedFramesArgs(request) {
+  return [
+    ...COMMON,
+    "-f",
+    "matroska",
+    "-i",
+    "pipe:0",
+    "-map",
+    "0:v:0",
+    "-vf",
+    [...frameSelection(request), `scale=${request.width}:${request.height}:flags=area`].join(","),
+    ...rawOut(request.count)
+  ];
+}
+function buildVmafArgs(request, width, height) {
+  const size = `scale=${width}:${height}:flags=bicubic,setpts=PTS-STARTPTS`;
+  return [
+    "-hide_banner",
+    "-nostdin",
+    "-loglevel",
+    "info",
+    "-ss",
+    String(request.startSec),
+    "-t",
+    String(request.durationSec),
+    "-i",
+    request.source,
+    ...request.candidate ? [
+      "-ss",
+      String(request.startSec),
+      "-t",
+      String(request.durationSec),
+      "-i",
+      request.candidate
+    ] : ["-f", "matroska", "-i", "pipe:0"],
+    "-lavfi",
+    `[0:v]${videoFilter(request.probe, request.maxWidth, request.maxFps)},${size}[ref];[1:v]${size}[dist];[dist][ref]libvmaf=n_subsample=3`,
+    "-f",
+    "null",
+    "-"
+  ];
+}
+function parseVmafScore(stderr) {
+  const matches = [...stderr.matchAll(/VMAF score:\s*(-?\d+(?:\.\d+)?)/g)];
+  const last = matches[matches.length - 1];
+  return last ? Number(last[1]) : null;
+}
+function buildFrameArgs(source, atSec, maxWidth, sourceWidth) {
+  return [
+    "-hide_banner",
+    "-nostdin",
+    "-loglevel",
+    "error",
+    "-ss",
+    String(atSec),
+    "-i",
+    source,
+    "-frames:v",
+    "1",
+    "-vf",
+    `scale=${outputWidth(sourceWidth, maxWidth)}:-2:flags=lanczos`,
+    "-f",
+    "image2pipe",
+    "-vcodec",
+    "png",
+    "pipe:1"
+  ];
+}
+function progressFraction(chunk, durationSec) {
+  if (durationSec <= 0) return null;
+  let latest = null;
+  for (const line of chunk.split("\n")) {
+    const m = /^out_time_us=(\d+)/.exec(line.trim());
+    if (m) latest = Number(m[1]);
+  }
+  if (latest === null) return null;
+  return Math.max(0, Math.min(1, latest / (durationSec * 1e6)));
+}
+
+// src/core/video/ffmpeg-engine.ts
+function splitFrames(data, width, height) {
+  const size = width * height * 3;
+  if (size === 0 || data.byteLength === 0 || data.byteLength % size !== 0) {
+    throw new Error("ffmpeg returned no frames, or frames of an unexpected size");
+  }
+  const frames = [];
+  for (let at = 0; at < data.byteLength; at += size) {
+    frames.push({ data: new Uint8Array(data.subarray(at, at + size)), width, height });
+  }
+  return frames;
+}
+function stderrTail(text) {
+  return text.split("\n").filter((l) => l.trim() && !l.startsWith("Svt[info]")).slice(-6).join("\n");
+}
+function runProcess(file, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, { stdio: ["pipe", "pipe", "pipe"] });
+    child.stdin.on("error", () => void 0);
+    child.stdin.end(options.input);
+    const out = [];
+    let counted = 0;
+    let stderr = "";
+    let aborted = false;
+    let killTimer;
+    const abort = () => {
+      aborted = true;
+      child.kill("SIGTERM");
+      killTimer = setTimeout(() => child.kill("SIGKILL"), 3e3);
+    };
+    if (options.signal?.aborted) abort();
+    else options.signal?.addEventListener("abort", abort, { once: true });
+    child.stdout.on("data", (chunk) => {
+      if (options.collectStdout) out.push(chunk);
+      if (options.countOnly) counted += chunk.length;
+      options.onStdout?.(chunk.toString("utf8"));
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = (stderr + chunk.toString("utf8")).slice(-16384);
+    });
+    child.on("error", (error) => {
+      if (killTimer) clearTimeout(killTimer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (killTimer) clearTimeout(killTimer);
+      options.signal?.removeEventListener("abort", abort);
+      resolve({
+        stdout: options.countOnly ? Buffer.alloc(counted) : Buffer.concat(out),
+        code,
+        stderr,
+        aborted
+      });
+    });
+  });
+}
+var AbortedError = class extends Error {
+  constructor() {
+    super("Cancelled");
+    this.name = "AbortedError";
+  }
+};
+function createFfmpegVideoEngine(options) {
+  let resolved;
+  function resolve() {
+    resolved ??= (async () => {
+      const base = { env: options.env, platform: options.platform };
+      const ffmpeg = resolveBinary(
+        "ffmpeg",
+        { ...base, flag: options.ffmpegFlag, config: options.ffmpegConfig },
+        options.deps
+      );
+      if (!ffmpeg.found) return null;
+      let info;
+      try {
+        info = await probeFfmpeg(ffmpeg.path, options.run);
+      } catch {
+        return null;
+      }
+      const probe = resolveBinary(
+        "ffprobe",
+        {
+          ...base,
+          flag: options.ffprobeFlag,
+          config: options.ffprobeConfig,
+          ffmpegDir: ffmpegDirOf(ffmpeg)
+        },
+        options.deps
+      );
+      return {
+        ffmpeg: ffmpeg.path,
+        ffprobe: probe.found ? probe.path : null,
+        caps: info.capabilities,
+        version: info.version
+      };
+    })();
+    return resolved;
+  }
+  async function need() {
+    const r = await resolve();
+    if (!r) throw new BytecutError("FFMPEG_NOT_FOUND", "ffmpeg was not found.");
+    return r;
+  }
+  return {
+    async capabilities() {
+      return (await resolve())?.caps ?? null;
+    },
+    async versions() {
+      const r = await resolve();
+      const versions = {};
+      if (r) versions.ffmpeg = r.version;
+      return versions;
+    },
+    async probe(source) {
+      const r = await need();
+      if (!r.ffprobe) {
+        throw new BytecutError("FFMPEG_NOT_FOUND", "ffprobe was not found.");
+      }
+      const { stdout } = await options.run(r.ffprobe, [
+        "-v",
+        "error",
+        "-show_format",
+        "-show_streams",
+        "-of",
+        "json",
+        source
+      ]);
+      return parseProbe(JSON.parse(stdout));
+    },
+    async encode(request, onProgress, signal) {
+      const r = await need();
+      const result = await runProcess(r.ffmpeg, buildEncodeArgs(request), {
+        signal,
+        onStdout: (chunk) => {
+          const f = progressFraction(chunk, request.probe.durationSec);
+          if (f !== null) onProgress(f);
+        }
+      });
+      if (result.aborted) throw new AbortedError();
+      if (result.code !== 0) {
+        throw new Error(`ffmpeg exited with code ${result.code}: ${stderrTail(result.stderr)}`);
+      }
+      onProgress(1);
+    },
+    async sampleBytes(request, signal) {
+      const r = await need();
+      const result = await runProcess(r.ffmpeg, buildSampleArgs(request), {
+        signal,
+        countOnly: true
+      });
+      if (result.aborted) throw new AbortedError();
+      if (result.code !== 0) {
+        throw new Error(`ffmpeg exited with code ${result.code}: ${stderrTail(result.stderr)}`);
+      }
+      return result.stdout.byteLength;
+    },
+    async frames(request, signal) {
+      const r = await need();
+      const result = await runProcess(r.ffmpeg, buildFramesArgs(request), {
+        signal,
+        collectStdout: true
+      });
+      if (result.aborted) throw new AbortedError();
+      if (result.code !== 0) {
+        throw new Error(`ffmpeg exited with code ${result.code}: ${stderrTail(result.stderr)}`);
+      }
+      return splitFrames(result.stdout, request.width, request.height);
+    },
+    async encodedFrames(request, signal) {
+      const r = await need();
+      const encoded = await runProcess(r.ffmpeg, buildClipEncodeArgs(request), {
+        signal,
+        collectStdout: true
+      });
+      if (encoded.aborted) throw new AbortedError();
+      if (encoded.code !== 0) {
+        throw new Error(`ffmpeg exited with code ${encoded.code}: ${stderrTail(encoded.stderr)}`);
+      }
+      const decoded = await runProcess(r.ffmpeg, buildPipedFramesArgs(request), {
+        signal,
+        collectStdout: true,
+        input: encoded.stdout
+      });
+      if (decoded.aborted) throw new AbortedError();
+      if (decoded.code !== 0) {
+        throw new Error(`ffmpeg exited with code ${decoded.code}: ${stderrTail(decoded.stderr)}`);
+      }
+      return splitFrames(decoded.stdout, request.width, request.height);
+    },
+    async vmaf(request, signal) {
+      const r = await need();
+      let candidate;
+      if (!request.candidate) {
+        const encoded = await runProcess(r.ffmpeg, buildClipEncodeArgs(request), {
+          signal,
+          collectStdout: true
+        });
+        if (encoded.aborted) throw new AbortedError();
+        if (encoded.code !== 0) {
+          throw new Error(`ffmpeg exited with code ${encoded.code}: ${stderrTail(encoded.stderr)}`);
+        }
+        candidate = encoded.stdout;
+      }
+      const width = outputWidth(request.probe.width, request.maxWidth);
+      const height = Math.max(
+        2,
+        Math.round(request.probe.height * width / Math.max(1, request.probe.width) / 2) * 2
+      );
+      const scored = await runProcess(r.ffmpeg, buildVmafArgs(request, width, height), {
+        signal,
+        ...candidate ? { input: candidate } : {}
+      });
+      if (scored.aborted) throw new AbortedError();
+      const score = parseVmafScore(scored.stderr);
+      if (scored.code !== 0 || score === null) {
+        throw new Error(`libvmaf did not report a score: ${stderrTail(scored.stderr)}`);
+      }
+      return score;
+    },
+    async frame(source, atSec, maxWidth) {
+      const r = await need();
+      const probe = await this.probe(source);
+      const args = buildFrameArgs(source, atSec, maxWidth, probe?.width ?? 0);
+      const result = await runProcess(r.ffmpeg, args, { collectStdout: true });
+      if (result.code !== 0 || result.stdout.byteLength === 0) {
+        throw new Error(`could not extract a frame: ${stderrTail(result.stderr)}`);
+      }
+      return result.stdout;
+    }
+  };
+}
+
+export {
+  toPosix,
+  outputWidth,
+  isFastStart,
+  AbortedError,
+  createFfmpegVideoEngine
+};