@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/chunk-YCMVI4MZ.js

@@ -0,0 +1,625 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  loadOptionalPackage,
+  loadSharp
+} from "./chunk-VMC4WSH5.js";
+import {
+  downloadFile
+} from "./chunk-WQ6ZXHFQ.js";
+import {
+  findFFmpeg,
+  findFFprobe,
+  getFFmpegInstallHint
+} from "./chunk-UMD3V7CU.js";
+import {
+  DEFAULT_VP9_CPU_USED,
+  SDR_RGB_TO_BT709_FILTER,
+  SDR_RGB_TO_TAGGED_BT709_FILTER,
+  renderProvenanceArgs
+} from "./chunk-TIQB63MX.js";
+import {
+  runCancellableProcess
+} from "./chunk-BL4U6U52.js";
+
+// src/background-removal/pipeline.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { renameSync, rmSync } from "fs";
+import { basename, dirname, extname, join as join2 } from "path";
+
+// src/background-removal/manager.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir, platform, arch } from "os";
+import { join } from "path";
+var MODELS_DIR = join(homedir(), ".cache", "hyperframes", "background-removal", "models");
+var DEFAULT_MODEL = "u2net_human_seg";
+var MODEL_URLS = {
+  u2net_human_seg: "https://github.com/danielgatis/rembg/releases/download/v0.0.0/u2net_human_seg.onnx"
+};
+var MODEL_MEMORY_MB = {
+  u2net_human_seg: 1500
+};
+var DEVICES = ["auto", "cpu", "coreml", "cuda"];
+function isDevice(value) {
+  return typeof value === "string" && DEVICES.includes(value);
+}
+function selectProviders(device = "auto") {
+  if (device === "cpu") return { providers: ["cpu"], label: "CPU" };
+  const available = listAvailableProviders();
+  const hasCoreML = available.includes("coreml");
+  const hasCUDA = available.includes("cuda");
+  if (device === "coreml") {
+    if (!hasCoreML) {
+      throw new Error(
+        "CoreML execution provider not available. Install onnxruntime-node on Apple Silicon, or use --device cpu."
+      );
+    }
+    return { providers: ["coreml", "cpu"], label: "CoreML" };
+  }
+  if (device === "cuda") {
+    if (!hasCUDA) {
+      throw new Error(
+        "CUDA execution provider not available. Use --device cpu or install an onnxruntime-node build with CUDA support."
+      );
+    }
+    return { providers: ["cuda", "cpu"], label: "CUDA" };
+  }
+  if (hasCoreML && platform() === "darwin" && arch() === "arm64") {
+    return { providers: ["coreml", "cpu"], label: "CoreML" };
+  }
+  if (hasCUDA) return { providers: ["cuda", "cpu"], label: "CUDA" };
+  return { providers: ["cpu"], label: "CPU" };
+}
+var _cachedProviders;
+function listAvailableProviders() {
+  if (_cachedProviders) return _cachedProviders;
+  const out = ["cpu"];
+  if (platform() === "darwin" && arch() === "arm64") out.push("coreml");
+  if (process.env["HYPERFRAMES_CUDA"] === "1") out.push("cuda");
+  _cachedProviders = out;
+  return out;
+}
+function modelPath(model = DEFAULT_MODEL) {
+  return join(MODELS_DIR, `${model}.onnx`);
+}
+async function ensureModel(model = DEFAULT_MODEL, options) {
+  const dest = modelPath(model);
+  if (existsSync(dest)) return dest;
+  mkdirSync(MODELS_DIR, { recursive: true });
+  options?.onProgress?.(`Downloading ${model} weights (~168 MB)...`);
+  await downloadFile(MODEL_URLS[model], dest);
+  if (!existsSync(dest)) {
+    throw new Error(`Model download failed: ${model}`);
+  }
+  return dest;
+}
+
+// src/background-removal/inference.ts
+var INPUT_SIZE = 320;
+var INPUT_PLANE = INPUT_SIZE * INPUT_SIZE;
+var MEAN = [0.485, 0.456, 0.406];
+var STD = [0.229, 0.224, 0.225];
+async function createSession(options = {}) {
+  const sharp = await loadSharp("remove-background");
+  const ort = await loadOptionalPackage(
+    "onnxruntime-node",
+    "background removal"
+  );
+  const choice = selectProviders(options.device ?? "auto");
+  const path = await ensureModel(options.model, { onProgress: options.onProgress });
+  options.onProgress?.(`Loading model on ${choice.label}...`);
+  const tryCreate = (providers) => ort.InferenceSession.create(path, {
+    executionProviders: providers,
+    graphOptimizationLevel: "all"
+  });
+  let session;
+  let providerUsed = choice.label;
+  try {
+    session = await tryCreate(choice.providers);
+  } catch (err) {
+    if (choice.providers[0] === "cpu") throw err;
+    options.onProgress?.(
+      `${choice.label} provider failed (${err.message}); falling back to CPU.`
+    );
+    session = await tryCreate(["cpu"]);
+    providerUsed = "CPU";
+  }
+  const inputName = session.inputNames[0];
+  const outputName = session.outputNames[0];
+  if (!inputName || !outputName) {
+    throw new Error("ONNX session is missing input or output bindings");
+  }
+  const inputData = new Float32Array(3 * INPUT_PLANE);
+  const maskBuf = Buffer.allocUnsafe(INPUT_PLANE);
+  let rgbaBuf = null;
+  let rgbaBgBuf = null;
+  let retried = false;
+  const run = async (tensor) => {
+    try {
+      return await session.run({ [inputName]: tensor });
+    } catch (err) {
+      if (providerUsed === "CPU" || retried) throw err;
+      retried = true;
+      options.onProgress?.(
+        `${providerUsed} failed while running a frame (${err.message}); continuing on CPU.`
+      );
+      await session.release().catch(() => void 0);
+      session = await tryCreate(["cpu"]);
+      providerUsed = "CPU";
+      return await session.run({ [inputName]: tensor });
+    }
+  };
+  return {
+    get provider() {
+      return providerUsed;
+    },
+    async process(rgb, width, height, withBackground = false) {
+      const tensor = await preprocess(sharp, ort, rgb, width, height, inputData);
+      const outputs = await run(tensor);
+      const output = outputs[outputName];
+      if (!output) throw new Error(`Model did not return output '${outputName}'`);
+      const expectedBytes = width * height * 4;
+      if (!rgbaBuf || rgbaBuf.length !== expectedBytes) {
+        rgbaBuf = Buffer.allocUnsafe(expectedBytes);
+      }
+      if (withBackground) {
+        if (!rgbaBgBuf || rgbaBgBuf.length !== expectedBytes) {
+          rgbaBgBuf = Buffer.allocUnsafe(expectedBytes);
+        }
+      }
+      return await postprocess(
+        sharp,
+        output,
+        rgb,
+        width,
+        height,
+        maskBuf,
+        rgbaBuf,
+        withBackground ? rgbaBgBuf : null
+      );
+    },
+    async close() {
+      await session.release();
+    }
+  };
+}
+async function preprocess(sharp, ort, rgb, width, height, inputData) {
+  const resized = await sharp(rgb, { raw: { width, height, channels: 3 } }).resize(INPUT_SIZE, INPUT_SIZE, { kernel: "lanczos3", fit: "fill" }).raw().toBuffer();
+  let maxPixel = 0;
+  for (let i = 0; i < resized.length; i++) {
+    if (resized[i] > maxPixel) maxPixel = resized[i];
+  }
+  if (maxPixel === 0) maxPixel = 1;
+  for (let y = 0; y < INPUT_SIZE; y++) {
+    for (let x = 0; x < INPUT_SIZE; x++) {
+      const src = (y * INPUT_SIZE + x) * 3;
+      const dst = y * INPUT_SIZE + x;
+      inputData[dst] = (resized[src] / maxPixel - MEAN[0]) / STD[0];
+      inputData[INPUT_PLANE + dst] = (resized[src + 1] / maxPixel - MEAN[1]) / STD[1];
+      inputData[2 * INPUT_PLANE + dst] = (resized[src + 2] / maxPixel - MEAN[2]) / STD[2];
+    }
+  }
+  return new ort.Tensor("float32", inputData, [1, 3, INPUT_SIZE, INPUT_SIZE]);
+}
+async function postprocess(sharp, output, rgb, width, height, maskBuf, rgbaBuf, rgbaBgBuf) {
+  const raw = output.data;
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (let i = 0; i < INPUT_PLANE; i++) {
+    const v = raw[i];
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  const range = hi - lo || 1;
+  for (let i = 0; i < INPUT_PLANE; i++) {
+    const norm = (raw[i] - lo) / range;
+    maskBuf[i] = Math.max(0, Math.min(255, Math.round(norm * 255)));
+  }
+  const fullMask = await sharp(maskBuf, {
+    raw: { width: INPUT_SIZE, height: INPUT_SIZE, channels: 1 }
+  }).resize(width, height, { kernel: "lanczos3", fit: "fill" }).toColourspace("b-w").raw().toBuffer();
+  return applyMask(rgb, fullMask, rgbaBuf, rgbaBgBuf, width * height);
+}
+function applyMask(rgb, mask, fg, bg, pixels) {
+  if (bg) {
+    for (let i = 0; i < pixels; i++) {
+      const r = rgb[i * 3];
+      const g = rgb[i * 3 + 1];
+      const b = rgb[i * 3 + 2];
+      const m = mask[i];
+      const o = i * 4;
+      fg[o] = r;
+      fg[o + 1] = g;
+      fg[o + 2] = b;
+      fg[o + 3] = m;
+      bg[o] = r;
+      bg[o + 1] = g;
+      bg[o + 2] = b;
+      bg[o + 3] = 255 - m;
+    }
+    return { fg, bg };
+  }
+  for (let i = 0; i < pixels; i++) {
+    fg[i * 4] = rgb[i * 3];
+    fg[i * 4 + 1] = rgb[i * 3 + 1];
+    fg[i * 4 + 2] = rgb[i * 3 + 2];
+    fg[i * 4 + 3] = mask[i];
+  }
+  return { fg, bg: null };
+}
+
+// src/background-removal/pipeline.ts
+var QUALITY_CRF = {
+  fast: 30,
+  balanced: 18,
+  best: 12
+};
+var QUALITIES = Object.keys(QUALITY_CRF);
+var DEFAULT_QUALITY = "balanced";
+var isQuality = (v) => typeof v === "string" && QUALITIES.includes(v);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".mkv", ".avi"]);
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp"]);
+function inferOutputFormat(outputPath) {
+  const ext = extname(outputPath).toLowerCase();
+  if (ext === ".webm") return "webm";
+  if (ext === ".mov") return "mov";
+  if (ext === ".png") return "png";
+  throw new Error(
+    `Unsupported output extension: ${ext}. Use .webm (VP9 alpha), .mov (ProRes 4444), or .png.`
+  );
+}
+function inferInputKind(inputPath) {
+  const ext = extname(inputPath).toLowerCase();
+  if (VIDEO_EXTENSIONS.has(ext)) return "video";
+  if (IMAGE_EXTENSIONS.has(ext)) return "image";
+  throw new Error(
+    `Unsupported input: ${ext}. Use a video (mp4/mov/webm/mkv/avi) or image (jpg/png/webp).`
+  );
+}
+async function decoderTransposesDimensions(inputPath) {
+  const ffprobePath = findFFprobe();
+  if (!ffprobePath) throw new Error(`ffprobe is required. Install: ${getFFmpegInstallHint()}`);
+  const { stdout } = await runCancellableProcess(
+    ffprobePath,
+    [
+      "-v",
+      "error",
+      "-select_streams",
+      "v:0",
+      "-show_streams",
+      "-print_format",
+      "json",
+      "--",
+      inputPath
+    ],
+    { timeoutMs: 3e4, maxBufferBytes: 256 * 1024 }
+  );
+  const probe = JSON.parse(stdout);
+  if (typeof probe !== "object" || probe === null || !("streams" in probe) || !Array.isArray(probe.streams))
+    return false;
+  const stream = probe.streams[0];
+  if (typeof stream !== "object" || stream === null) return false;
+  const sideData = "side_data_list" in stream && Array.isArray(stream.side_data_list) ? stream.side_data_list : [];
+  const matrix = sideData.find(
+    (entry) => typeof entry === "object" && entry !== null && "side_data_type" in entry && entry.side_data_type === "Display Matrix"
+  );
+  let rotation = typeof matrix === "object" && matrix !== null && "rotation" in matrix ? matrix.rotation : void 0;
+  if (rotation === void 0 && "tags" in stream && typeof stream.tags === "object" && stream.tags !== null && "rotate" in stream.tags)
+    rotation = Number(stream.tags.rotate);
+  if (typeof rotation !== "number" || !Number.isFinite(rotation)) return false;
+  const angle = (rotation % 360 + 360) % 360;
+  return Math.abs(angle - 90) < 1 || Math.abs(angle - 270) < 1;
+}
+async function probeMedia(inputPath) {
+  const isImage = inferInputKind(inputPath) === "image";
+  const engine = await import("./src-Z5PGEMXB.js");
+  const meta = await engine.extractMediaMetadata(inputPath);
+  if (isImage) {
+    return { width: meta.width, height: meta.height, fps: 0, frameCount: 1 };
+  }
+  const fps = meta.fps || 30;
+  const frameCount = meta.durationSeconds ? Math.round(meta.durationSeconds * fps) : 0;
+  const transposed = await decoderTransposesDimensions(inputPath);
+  return {
+    width: transposed ? meta.height : meta.width,
+    height: transposed ? meta.width : meta.height,
+    fps,
+    frameCount
+  };
+}
+function buildEncoderArgs(format, width, height, fps, outputPath, quality = DEFAULT_QUALITY) {
+  const base = [
+    "-y",
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "rgba",
+    "-s",
+    `${width}x${height}`,
+    "-r",
+    String(fps || 30),
+    "-i",
+    "-"
+  ];
+  if (format === "webm") {
+    return [
+      ...base,
+      "-vf",
+      SDR_RGB_TO_BT709_FILTER,
+      "-c:v",
+      "libvpx-vp9",
+      "-b:v",
+      "0",
+      "-crf",
+      String(QUALITY_CRF[quality]),
+      "-deadline",
+      "good",
+      "-row-mt",
+      "1",
+      "-cpu-used",
+      String(DEFAULT_VP9_CPU_USED),
+      "-auto-alt-ref",
+      "0",
+      "-pix_fmt",
+      "yuva420p",
+      "-colorspace",
+      "bt709",
+      "-color_primaries",
+      "bt709",
+      "-color_trc",
+      "bt709",
+      "-color_range",
+      "tv",
+      "-metadata:s:v:0",
+      "alpha_mode=1",
+      "-an",
+      ...renderProvenanceArgs(outputPath),
+      outputPath
+    ];
+  }
+  if (format === "mov") {
+    return [
+      ...base,
+      "-vf",
+      SDR_RGB_TO_TAGGED_BT709_FILTER,
+      "-c:v",
+      "prores_ks",
+      "-profile:v",
+      "4444",
+      "-vendor",
+      "apl0",
+      "-pix_fmt",
+      "yuva444p10le",
+      "-an",
+      ...renderProvenanceArgs(outputPath),
+      outputPath
+    ];
+  }
+  return [...base, "-frames:v", "1", "-pix_fmt", "rgba", "-update", "1", outputPath];
+}
+async function* readFrames(stream, frameBytes) {
+  let buffered = Buffer.alloc(0);
+  for await (const chunk of stream) {
+    buffered = buffered.length === 0 ? chunk : Buffer.concat([buffered, chunk]);
+    while (buffered.length >= frameBytes) {
+      yield Buffer.from(buffered.subarray(0, frameBytes));
+      buffered = buffered.subarray(frameBytes);
+    }
+  }
+}
+function resolveRenderTargets(inputPath, outputPath, backgroundOutputPath) {
+  const format = inferOutputFormat(outputPath);
+  const inputKind = inferInputKind(inputPath);
+  if (inputKind === "image" && format !== "png") {
+    throw new Error(
+      `Image input requires a .png output (got ${extname(outputPath)}). Use a video input for .webm/.mov.`
+    );
+  }
+  if (inputKind === "video" && format === "png") {
+    throw new Error(
+      `Video input requires a .webm or .mov output (got .png). Use an image input for .png.`
+    );
+  }
+  let bgFormat;
+  if (backgroundOutputPath) {
+    if (inputKind === "image") {
+      throw new Error(
+        "--background-output is not supported for image inputs. Use a video input (mp4/mov/webm) to produce both a cutout and a background plate."
+      );
+    }
+    bgFormat = inferOutputFormat(backgroundOutputPath);
+    if (bgFormat === "png") {
+      throw new Error(
+        "--background-output must be .webm or .mov; .png is only valid for single-image inputs."
+      );
+    }
+  }
+  return { format, inputKind, bgFormat };
+}
+async function render(options) {
+  const ffmpegPath = findFFmpeg();
+  if (!ffmpegPath || !findFFprobe()) {
+    throw new Error(`ffmpeg and ffprobe are required. Install: ${getFFmpegInstallHint()}`);
+  }
+  const { format, bgFormat } = resolveRenderTargets(
+    options.inputPath,
+    options.outputPath,
+    options.backgroundOutputPath
+  );
+  const media = await probeMedia(options.inputPath);
+  options.onProgress?.({
+    kind: "metadata",
+    width: media.width,
+    height: media.height,
+    fps: media.fps,
+    frameCount: media.frameCount
+  });
+  const session = await createSession({
+    model: options.model,
+    device: options.device,
+    onProgress: (msg) => options.onProgress?.({ kind: "info", message: msg })
+  });
+  const output = tempBeside(options.outputPath);
+  const background = options.backgroundOutputPath && tempBeside(options.backgroundOutputPath);
+  try {
+    const start = Date.now();
+    const framesProcessed = await runPipeline(
+      { ...options, outputPath: output, backgroundOutputPath: background },
+      session,
+      media,
+      format,
+      bgFormat,
+      ffmpegPath
+    );
+    renameSync(output, options.outputPath);
+    if (background) renameSync(background, options.backgroundOutputPath);
+    const durationSeconds = (Date.now() - start) / 1e3;
+    const avgMsPerFrame = framesProcessed ? durationSeconds * 1e3 / framesProcessed : 0;
+    return {
+      outputPath: options.outputPath,
+      backgroundOutputPath: options.backgroundOutputPath,
+      framesProcessed,
+      durationSeconds,
+      avgMsPerFrame,
+      provider: session.provider,
+      format
+    };
+  } finally {
+    await session.close();
+    rmSync(output, { force: true, maxRetries: 3 });
+    if (background) rmSync(background, { force: true, maxRetries: 3 });
+  }
+}
+function tempBeside(path) {
+  return join2(dirname(path), `.tmp-${randomUUID()}-${basename(path)}`);
+}
+var RECENT_WINDOW = 30;
+function spawnFfmpeg(ffmpegPath, args, label, stdio) {
+  const proc = spawn(ffmpegPath, args, { stdio, windowsHide: true });
+  let stderrBuf = "";
+  proc.stderr?.on("data", (d) => {
+    stderrBuf += d.toString();
+  });
+  proc.stdin?.on("error", () => {
+  });
+  const exit = waitForExit(proc, label, () => stderrBuf);
+  return { proc, exit, getStderr: () => stderrBuf };
+}
+async function runPipeline(options, session, media, format, bgFormat, ffmpegPath) {
+  const { inputPath, outputPath, backgroundOutputPath } = options;
+  const { width, height, fps, frameCount } = media;
+  const frameBytes = width * height * 3;
+  const quality = options.quality ?? DEFAULT_QUALITY;
+  const decoder = spawnFfmpeg(
+    ffmpegPath,
+    ["-loglevel", "error", "-i", inputPath, "-f", "rawvideo", "-pix_fmt", "rgb24", "-an", "-"],
+    "ffmpeg decoder",
+    ["ignore", "pipe", "pipe"]
+  );
+  const fg = spawnFfmpeg(
+    ffmpegPath,
+    buildEncoderArgs(format, width, height, fps || 30, outputPath, quality),
+    "ffmpeg encoder",
+    ["pipe", "ignore", "pipe"]
+  );
+  const bg = backgroundOutputPath && bgFormat ? spawnFfmpeg(
+    ffmpegPath,
+    buildEncoderArgs(bgFormat, width, height, fps || 30, backgroundOutputPath, quality),
+    "ffmpeg background encoder",
+    ["pipe", "ignore", "pipe"]
+  ) : null;
+  let processed = 0;
+  const total = frameCount;
+  const recentMs = new Array(RECENT_WINDOW).fill(0);
+  let recentSum = 0;
+  let recentSlot = 0;
+  let recentCount = 0;
+  try {
+    for await (const rgb of readFrames(decoder.proc.stdout, frameBytes)) {
+      const t0 = Date.now();
+      const result = await session.process(rgb, width, height, bg !== null);
+      const elapsed = Date.now() - t0;
+      recentSum += elapsed - recentMs[recentSlot];
+      recentMs[recentSlot] = elapsed;
+      recentSlot = (recentSlot + 1) % RECENT_WINDOW;
+      if (recentCount < RECENT_WINDOW) recentCount++;
+      const fgWroteFully = fg.proc.stdin.write(result.fg);
+      const bgWroteFully = bg && result.bg ? bg.proc.stdin.write(result.bg) : true;
+      if (!fgWroteFully || !bgWroteFully) {
+        const drains = [];
+        if (!fgWroteFully) {
+          drains.push(
+            new Promise((resolve) => fg.proc.stdin.once("drain", () => resolve()))
+          );
+        }
+        if (!bgWroteFully && bg) {
+          drains.push(
+            new Promise((resolve) => bg.proc.stdin.once("drain", () => resolve()))
+          );
+        }
+        await Promise.all(drains);
+      }
+      processed++;
+      options.onProgress?.({
+        kind: "frame",
+        index: processed,
+        total,
+        avgMsPerFrame: recentSum / recentCount
+      });
+    }
+  } catch (err) {
+    decoder.proc.kill("SIGKILL");
+    fg.proc.kill("SIGKILL");
+    bg?.proc.kill("SIGKILL");
+    throw err;
+  }
+  fg.proc.stdin.end();
+  bg?.proc.stdin.end();
+  const exits = [decoder.exit, fg.exit];
+  if (bg) exits.push(bg.exit);
+  await Promise.all(exits);
+  if (processed === 0) {
+    throw new Error(
+      `No frames produced from ${inputPath}. Decoder stderr:
+${decoder.getStderr().slice(-400)}`
+    );
+  }
+  return processed;
+}
+function waitForExit(proc, label, getStderr) {
+  return new Promise((resolve, reject) => {
+    proc.on("error", reject);
+    proc.on("exit", (code, signal) => {
+      if (code === 0 && !signal) {
+        resolve();
+        return;
+      }
+      const cause = signal ? `killed by ${signal}` : `exited with code ${code}`;
+      reject(new Error(`${label} ${cause}: ${getStderr().slice(-400)}`));
+    });
+  });
+}
+
+export {
+  DEFAULT_MODEL,
+  MODEL_MEMORY_MB,
+  DEVICES,
+  isDevice,
+  selectProviders,
+  listAvailableProviders,
+  modelPath,
+  QUALITIES,
+  DEFAULT_QUALITY,
+  isQuality,
+  inferOutputFormat,
+  inferInputKind,
+  buildEncoderArgs,
+  resolveRenderTargets,
+  render,
+  waitForExit
+};