halfsize 0.0.0-stage → 0.1.0

package/src/plan.mjs

@@ -0,0 +1,152 @@
+export const CODECS = {
+  h264: { label: "H.264", encoder: "libx264", bpp: 0.072, twoPass: true },
+  h265: { label: "H.265", encoder: "libx265", bpp: 0.045, twoPass: true },
+};
+
+const TIERS = [
+  [3840, 2160],
+  [2560, 1440],
+  [1920, 1080],
+  [1600, 900],
+  [1280, 720],
+  [960, 540],
+  [854, 480],
+  [640, 360],
+  [426, 240],
+];
+
+const even = (n) => Math.max(2, Math.round(n / 2) * 2);
+
+function fitTier(video, tier) {
+  const portrait = video.height > video.width;
+  const [tw, th] = portrait ? [tier[1], tier[0]] : tier;
+  const scale = Math.min(1, tw / video.width, th / video.height);
+  return { w: even(video.width * scale), h: even(video.height * scale) };
+}
+
+function candidateSizes(info) {
+  const out = [];
+  const seen = new Set();
+  const push = (w, h) => {
+    const key = `${w}x${h}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push({ w, h });
+    }
+  };
+  push(even(info.video.width), even(info.video.height));
+  for (const tier of TIERS) {
+    const { w, h } = fitTier(info.video, tier);
+    push(w, h);
+  }
+  return out;
+}
+
+function audioBitrate(info, totalKbps) {
+  if (!info.audio) return 0;
+  const preferred = totalKbps > 2500 ? 160 : totalKbps > 800 ? 128 : totalKbps > 300 ? 96 : 64;
+  const source = info.audio.bitrate ? info.audio.bitrate / 1000 : preferred;
+  const share = totalKbps * 0.18;
+  const value = Math.min(preferred, source, share);
+  return Math.max(32, Math.round(value / 8) * 8);
+}
+
+export function planEncode(info, options = {}) {
+  const codecName = options.codec || "h264";
+  const codec = CODECS[codecName];
+  if (!codec) throw new Error(`Unknown codec "${codecName}". Use h264 or h265.`);
+
+  const preset = options.preset || "medium";
+  const allowDownscale = options.downscale !== false;
+  const warnings = [];
+
+  if (!info.duration) throw new Error("Could not read the duration of this file.");
+
+  if (options.crf !== undefined) {
+    return {
+      mode: "quality",
+      codec: codecName,
+      label: codec.label,
+      encoder: codec.encoder,
+      preset,
+      crf: Number(options.crf),
+      width: info.video.width,
+      height: info.video.height,
+      fps: capFps(info.video.fps),
+      videoKbps: null,
+      audioKbps: audioBitrate(info, 2000),
+      targetBytes: null,
+      twoPass: false,
+      downscaled: false,
+      scaleFilter: null,
+      fpsFilter: null,
+      warnings,
+    };
+  }
+
+  if (!options.targetBytes) throw new Error("A target size is required.");
+
+  const totalKbps = ((options.targetBytes * 8) / info.duration / 1000) * 0.97;
+  const audioKbps = audioBitrate(info, totalKbps);
+  const videoKbps = Math.max(40, Math.round(totalKbps - audioKbps));
+  const fps = capFps(info.video.fps);
+
+  const sizes = candidateSizes(info);
+  const original = sizes[0];
+  let chosen = sizes[sizes.length - 1];
+  for (const size of sizes) {
+    const requiredKbps = (size.w * size.h * fps * codec.bpp) / 1000;
+    if (requiredKbps <= videoKbps) {
+      chosen = size;
+      break;
+    }
+  }
+
+  const requiredAtChosen = (chosen.w * chosen.h * fps * codec.bpp) / 1000;
+  if (chosen.w === original.w && chosen.h === original.h && requiredAtChosen > videoKbps) {
+    warnings.push("The target is aggressive for this resolution; keeping full size will look soft.");
+  }
+  if (!allowDownscale && (chosen.w !== original.w || chosen.h !== original.h)) {
+    chosen = { w: original.w, h: original.h };
+    warnings.push("Downscaling is disabled, so the target may be missed. Quality will suffer.");
+  }
+  if (videoKbps < 120) {
+    warnings.push("Very low bitrate. Consider a larger target or H.265.");
+  }
+  if (info.video.hdr) {
+    warnings.push("HDR source detected. HDR-to-SDR conversion is not implemented yet, so colors may look washed out.");
+  }
+
+  const downscaled = chosen.w !== original.w || chosen.h !== original.h;
+
+  return {
+    mode: "size",
+    codec: codecName,
+    label: codec.label,
+    encoder: codec.encoder,
+    preset,
+    crf: null,
+    width: chosen.w,
+    height: chosen.h,
+    fps,
+    videoKbps,
+    audioKbps,
+    targetBytes: options.targetBytes,
+    twoPass: Boolean(codec.twoPass),
+    downscaled,
+    scaleFilter: downscaled ? `scale=${chosen.w}:${chosen.h}:flags=lanczos` : null,
+    fpsFilter: fps < info.video.fps - 0.01 ? `fps=${fps}` : null,
+    warnings,
+  };
+}
+
+function capFps(fps) {
+  if (!fps || !Number.isFinite(fps)) return 30;
+  return Math.min(60, Math.max(10, Math.round(fps * 1000) / 1000));
+}
+
+export function estimateBytes(info, plan) {
+  if (plan.mode !== "size") return null;
+  const kbps = plan.videoKbps + plan.audioKbps;
+  return Math.round((kbps * 1000 * info.duration) / 8);
+}

package/src/probe.mjs

@@ -0,0 +1,72 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { resolveBinaries } from "./ffmpeg.mjs";
+
+const run = promisify(execFile);
+
+export async function probe(file) {
+  const { ffprobe } = await resolveBinaries();
+  const { stdout } = await run(
+    ffprobe,
+    ["-v", "error", "-print_format", "json", "-show_format", "-show_streams", file],
+    { maxBuffer: 32 * 1024 * 1024, windowsHide: true },
+  );
+  const json = JSON.parse(stdout);
+
+  const video = json.streams.find((s) => s.codec_type === "video" && s.disposition?.attached_pic !== 1);
+  if (!video) throw new Error("No video stream found in this file.");
+
+  const audio = json.streams.find((s) => s.codec_type === "audio");
+  const duration = Number(json.format.duration || video.duration || 0);
+  const sizeBytes = Number(json.format.size || 0);
+
+  const rotation = readRotation(video);
+  const width = rotation % 180 === 0 ? video.width : video.height;
+  const height = rotation % 180 === 0 ? video.height : video.width;
+
+  return {
+    file,
+    duration,
+    sizeBytes,
+    container: (json.format.format_name || "").split(",")[0],
+    bitrate: Number(json.format.bit_rate || 0),
+    video: {
+      codec: video.codec_name,
+      profile: video.profile,
+      width,
+      height,
+      fps: parseFps(video.avg_frame_rate) || parseFps(video.r_frame_rate) || 30,
+      pixFmt: video.pix_fmt,
+      bitrate: Number(video.bit_rate || 0),
+      hdr: isHdr(video),
+      rotation,
+    },
+    audio: audio
+      ? {
+          codec: audio.codec_name,
+          channels: audio.channels,
+          sampleRate: Number(audio.sample_rate),
+          bitrate: Number(audio.bit_rate || 0),
+        }
+      : null,
+  };
+}
+
+function parseFps(value) {
+  if (!value || value === "0/0") return 0;
+  const [a, b] = value.split("/").map(Number);
+  if (!b) return a || 0;
+  return a / b;
+}
+
+function readRotation(stream) {
+  const side = stream.side_data_list?.find((d) => d.rotation !== undefined);
+  if (side) return Math.abs(Number(side.rotation)) % 360;
+  const tag = stream.tags?.rotate;
+  return tag ? Math.abs(Number(tag)) % 360 : 0;
+}
+
+function isHdr(stream) {
+  const t = `${stream.color_transfer || ""} ${stream.color_primaries || ""}`;
+  return /smpte2084|arib-std-b67|bt2020/i.test(t);
+}

package/src/quality.mjs

@@ -0,0 +1,75 @@
+import { spawn } from "node:child_process";
+import { resolveBinaries } from "./ffmpeg.mjs";
+
+const NULL_DEVICE = process.platform === "win32" ? "NUL" : "/dev/null";
+
+export async function measureQuality(source, output, duration, options = {}) {
+  const { ffmpeg } = await resolveBinaries();
+  const samples = options.samples || 3;
+  const seconds = Math.min(options.seconds || 2, Math.max(1, duration / 4));
+  const points = [];
+  for (let i = 0; i < samples; i++) {
+    const at = (duration * (i + 1)) / (samples + 1) - seconds / 2;
+    points.push(Math.max(0, Math.min(duration - seconds, at)));
+  }
+
+  const ssims = [];
+  for (const at of points) {
+    const value = await runMetric(ffmpeg, [
+      "-ss", String(at), "-t", String(seconds), "-i", output,
+      "-ss", String(at), "-t", String(seconds), "-i", source,
+      "-lavfi", "[0:v][1:v]scale2ref[a][b];[a][b]ssim",
+      "-f", "null", NULL_DEVICE,
+    ], /All:\s*([0-9.]+)/);
+    if (value !== null) ssims.push(value);
+  }
+
+  let vmaf = null;
+  if (options.vmaf !== false && duration > 1) {
+    const at = Math.max(0, duration / 2 - 1.5);
+    vmaf = await runMetric(ffmpeg, [
+      "-ss", String(at), "-t", "3", "-i", output,
+      "-ss", String(at), "-t", "3", "-i", source,
+      "-lavfi", "[0:v][1:v]scale2ref[a][b];[a][b]libvmaf=n_threads=2",
+      "-f", "null", NULL_DEVICE,
+    ], /VMAF score:\s*([0-9.]+)/);
+  }
+
+  const ssim = ssims.length ? ssims.reduce((a, b) => a + b, 0) / ssims.length : null;
+  return { ssim, vmaf, sampled: ssims.length, samples };
+}
+
+function runMetric(bin, args, regex) {
+  return new Promise((resolve) => {
+    const child = spawn(bin, ["-hide_banner", "-nostats", ...args], {
+      windowsHide: true,
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", () => resolve(null));
+    child.on("close", () => {
+      const match = stderr.match(regex);
+      resolve(match ? Number(match[1]) : null);
+    });
+  });
+}
+
+export function verdict({ vmaf, ssim }) {
+  if (vmaf !== null) {
+    if (vmaf >= 95) return { key: "indistinguishable", label: "indistinguishable", tone: "good" };
+    if (vmaf >= 90) return { key: "same", label: "looks the same", tone: "good" };
+    if (vmaf >= 80) return { key: "slight", label: "slight softening", tone: "ok" };
+    if (vmaf >= 70) return { key: "visible", label: "visible loss", tone: "warn" };
+    return { key: "degraded", label: "clearly degraded", tone: "bad" };
+  }
+  if (ssim !== null) {
+    if (ssim >= 0.98) return { key: "indistinguishable", label: "indistinguishable", tone: "good" };
+    if (ssim >= 0.95) return { key: "same", label: "looks the same", tone: "good" };
+    if (ssim >= 0.9) return { key: "slight", label: "slight softening", tone: "ok" };
+    return { key: "visible", label: "visible loss", tone: "warn" };
+  }
+  return { key: "none", label: "not measured", tone: "unknown" };
+}

package/src/server.mjs

@@ -0,0 +1,288 @@
+import http from "node:http";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { probe } from "./probe.mjs";
+import { planEncode } from "./plan.mjs";
+import { encode } from "./encode.mjs";
+import { measureQuality, verdict } from "./quality.mjs";
+import { parseSize, bytes as fmt } from "./human.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WEB_DIR = path.resolve(__dirname, "..", "web");
+
+const jobs = new Map();
+const clients = new Map();
+
+let workDir = "";
+
+function jobDir() {
+  if (!workDir) {
+    workDir = path.join(os.tmpdir(), `halfsize-${process.pid}-${Date.now().toString(36)}`);
+    fs.mkdirSync(workDir, { recursive: true });
+    const cleanup = () => {
+      try {
+        fs.rmSync(workDir, { recursive: true, force: true });
+      } catch {
+        // best effort
+      }
+    };
+    process.once("exit", cleanup);
+    process.once("SIGINT", () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.once("SIGTERM", () => {
+      cleanup();
+      process.exit(0);
+    });
+  }
+  return workDir;
+}
+
+function send(res, status, body, headers = {}) {
+  const payload = typeof body === "string" || Buffer.isBuffer(body) ? body : JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+    ...headers,
+  });
+  res.end(payload);
+}
+
+function readBody(req, limit = 8 * 1024 ** 3) {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    const chunks = [];
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > limit) {
+        reject(new Error("File is too large for the local app. Use the CLI for files over 8 GB."));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+function emit(id, event, data) {
+  const set = clients.get(id);
+  if (!set) return;
+  const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (const res of [...set]) {
+    try {
+      res.write(payload);
+    } catch {
+      set.delete(res);
+    }
+  }
+}
+
+export async function startServer(options = {}) {
+  const port = options.port || Number(process.env.HALFSIZE_PORT) || 4174;
+  const server = http.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url, "http://local");
+      const pathname = url.pathname;
+
+      if (req.method === "GET" && (pathname === "/" || pathname === "/index.html")) {
+        const html = fs.readFileSync(path.join(WEB_DIR, "index.html"));
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        return res.end(html);
+      }
+
+      if (req.method === "GET" && pathname.startsWith("/assets/")) {
+        const file = path.join(WEB_DIR, pathname.replace("/assets/", ""));
+        if (!file.startsWith(WEB_DIR) || !fs.existsSync(file)) return send(res, 404, { error: "not found" });
+        res.writeHead(200, { "content-type": contentType(file) });
+        return fs.createReadStream(file).pipe(res);
+      }
+
+      if (req.method === "POST" && pathname === "/api/upload") {
+        const name = decodeURIComponent(req.headers["x-filename"] || "video.mp4");
+        const id = crypto.randomBytes(8).toString("hex");
+        const ext = path.extname(name) || ".mp4";
+        const dir = jobDir();
+        const file = path.join(dir, `${id}${ext}`);
+        await new Promise((resolve, reject) => {
+          const out = fs.createWriteStream(file);
+          let size = 0;
+          req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > 8 * 1024 ** 3) {
+              req.destroy();
+              out.destroy();
+              reject(new Error("File is too large for the local app. Use the CLI for files over 8 GB."));
+            }
+          });
+          req.pipe(out);
+          out.on("finish", resolve);
+          out.on("error", reject);
+          req.on("error", reject);
+        });
+        const info = await probe(file);
+        jobs.set(id, { id, input: file, originalName: name, info, status: "ready" });
+        return send(res, 200, {
+          id,
+          name,
+          size: info.sizeBytes,
+          duration: info.duration,
+          width: info.video.width,
+          height: info.video.height,
+          fps: info.video.fps,
+          codec: info.video.codec,
+          hasAudio: Boolean(info.audio),
+        });
+      }
+
+      if (req.method === "GET" && pathname.startsWith("/api/events/")) {
+        const id = pathname.split("/").pop();
+        res.writeHead(200, {
+          "content-type": "text/event-stream",
+          "cache-control": "no-store",
+          connection: "keep-alive",
+        });
+        res.write(": connected\n\n");
+        if (!clients.has(id)) clients.set(id, new Set());
+        clients.get(id).add(res);
+        const job = jobs.get(id);
+        if (job?.status === "done") emit(id, "done", job.result);
+        if (job?.status === "error") emit(id, "failed", { message: job.error });
+        req.on("close", () => {
+          clients.get(id)?.delete(res);
+        });
+        return;
+      }
+
+      if (req.method === "POST" && pathname === "/api/compress") {
+        const body = JSON.parse((await readBody(req, 1024 * 1024)).toString());
+        const job = jobs.get(body.id);
+        if (!job) return send(res, 404, { error: "Unknown upload" });
+        if (job.status === "running") return send(res, 409, { error: "Already running" });
+
+        const targetBytes = body.target ? parseSize(body.target) : null;
+        if (targetBytes && targetBytes >= job.info.sizeBytes) {
+          return send(res, 400, {
+            error: `This file is already ${fmt(job.info.sizeBytes)}, smaller than the ${fmt(targetBytes)} target. Pick a smaller target.`,
+            code: "already_small",
+          });
+        }
+        const plan = planEncode(job.info, {
+          targetBytes,
+          crf: body.crf,
+          codec: body.codec || "h264",
+          preset: body.preset || "medium",
+          downscale: true,
+        });
+        const out = job.input.replace(/(\.[^.]+)$/, `.halfsize.mp4`);
+        job.status = "running";
+        job.plan = plan;
+        job.output = out;
+
+        send(res, 202, { ok: true, plan });
+
+        (async () => {
+          const started = Date.now();
+          try {
+            const result = await encode(job.input, out, plan, job.info, (p) => {
+              emit(job.id, "progress", { ...p, eta: p.ratio > 0.01 ? ((Date.now() - started) / 1000 / p.ratio) * (1 - p.ratio) : 0 });
+            });
+            emit(job.id, "phase", { phase: "verify" });
+            const quality = await measureQuality(job.input, out, job.info.duration);
+            job.result = {
+              id: job.id,
+              inputBytes: job.info.sizeBytes,
+              outputBytes: result.outputBytes,
+              targetBytes,
+              accuracy: targetBytes ? result.outputBytes / targetBytes - 1 : null,
+              ratio: job.info.sizeBytes / result.outputBytes,
+              elapsedMs: result.elapsedMs,
+              quality,
+              verdict: verdict(quality),
+              plan,
+              name: job.originalName,
+              download: `/api/download/${job.id}`,
+            };
+            job.status = "done";
+            emit(job.id, "done", job.result);
+          } catch (err) {
+            job.status = "error";
+            job.error = err.message;
+            emit(job.id, "failed", { message: err.message });
+          }
+        })();
+        return;
+      }
+
+      if (req.method === "GET" && pathname.startsWith("/api/download/")) {
+        const id = pathname.split("/").pop();
+        const job = jobs.get(id);
+        if (!job?.output || !fs.existsSync(job.output)) return send(res, 404, { error: "not ready" });
+        const name = job.originalName.replace(/(\.[^.]+)$/, "") + ".halfsize.mp4";
+        res.writeHead(200, {
+          "content-type": "video/mp4",
+          "content-disposition": `attachment; filename="${name.replace(/[^\x20-\x7e]/g, "_").replace(/"/g, "")}"; filename*=UTF-8''${encodeURIComponent(name)}`,
+          "content-length": fs.statSync(job.output).size,
+        });
+        return fs.createReadStream(job.output).pipe(res);
+      }
+
+      if (req.method === "GET" && pathname.startsWith("/api/media/")) {
+        const [, , , id, which] = pathname.split("/");
+        const job = jobs.get(id);
+        const file = which === "out" ? job?.output : job?.input;
+        if (!file || !fs.existsSync(file)) return send(res, 404, { error: "not found" });
+        return streamVideo(req, res, file);
+      }
+
+      return send(res, 404, { error: "not found" });
+    } catch (err) {
+      return send(res, 500, { error: err.message });
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", resolve);
+  });
+
+  return `http://127.0.0.1:${port}`;
+}
+
+function streamVideo(req, res, file) {
+  const stat = fs.statSync(file);
+  const range = req.headers.range;
+  if (range) {
+    const [startRaw, endRaw] = range.replace("bytes=", "").split("-");
+    const start = Number(startRaw) || 0;
+    const end = endRaw ? Number(endRaw) : stat.size - 1;
+    res.writeHead(206, {
+      "content-range": `bytes ${start}-${end}/${stat.size}`,
+      "accept-ranges": "bytes",
+      "content-length": end - start + 1,
+      "content-type": "video/mp4",
+    });
+    return fs.createReadStream(file, { start, end }).pipe(res);
+  }
+  res.writeHead(200, { "content-length": stat.size, "content-type": "video/mp4", "accept-ranges": "bytes" });
+  return fs.createReadStream(file).pipe(res);
+}
+
+function contentType(file) {
+  const ext = path.extname(file).toLowerCase();
+  return (
+    {
+      ".html": "text/html; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".js": "text/javascript; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".woff2": "font/woff2",
+    }[ext] || "application/octet-stream"
+  );
+}