@adforge-adgeniq/render 0.1.0

package/dist/index.js

@@ -0,0 +1,489 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  assignStartTimes: () => assignStartTimes,
+  buildAssSubtitles: () => buildAssSubtitles,
+  estimateRenderCredits: () => estimateRenderCredits,
+  flattenCaptions: () => flattenCaptions,
+  renderVideo: () => renderVideo,
+  storyboardDurationS: () => storyboardDurationS
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ffmpeg/renderer.ts
+var import_child_process = require("child_process");
+var import_util = require("util");
+var import_promises = __toESM(require("fs/promises"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+
+// src/ffmpeg/dimensions.ts
+var DIMS = {
+  "9:16": { "720p": { w: 720, h: 1280 }, "1080p": { w: 1080, h: 1920 } },
+  "16:9": { "720p": { w: 1280, h: 720 }, "1080p": { w: 1920, h: 1080 } },
+  "1:1": { "720p": { w: 720, h: 720 }, "1080p": { w: 1080, h: 1080 } }
+};
+var SAFE_AREA_PCT = { top: 0.08, bottom: 0.12, side: 0.05 };
+function getDimensions(aspect, resolution) {
+  const { w, h } = DIMS[aspect][resolution];
+  return {
+    width: w,
+    height: h,
+    safeAreaTop: Math.round(h * SAFE_AREA_PCT.top),
+    safeAreaBottom: Math.round(h * SAFE_AREA_PCT.bottom),
+    safeAreaSide: Math.round(w * SAFE_AREA_PCT.side)
+  };
+}
+function fontScale(dims) {
+  return dims.width / 1080;
+}
+
+// src/ffmpeg/captions.ts
+function toAssTime(s) {
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const sec = (s % 60).toFixed(2);
+  return `${h}:${String(m).padStart(2, "0")}:${String(sec).padStart(5, "0")}`;
+}
+function escapeAss(text) {
+  return text.replace(/\\/g, "\\\\").replace(/{/g, "\\{").replace(/}/g, "\\}");
+}
+function buildAssSubtitles(scenes, style, dims) {
+  if (style === "NONE") return "";
+  const scale = fontScale(dims);
+  const fontSize = Math.round(48 * scale);
+  const marginV = dims.safeAreaBottom + Math.round(40 * scale);
+  const marginH = dims.safeAreaSide + Math.round(20 * scale);
+  const header = `[Script Info]
+ScriptType: v4.00+
+PlayResX: ${dims.width}
+PlayResY: ${dims.height}
+ScaledBorderAndShadow: yes
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Arial,${fontSize},&H00FFFFFF,&H000000FF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,2,0,2,${marginH},${marginH},${marginV},1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text`;
+  const events = [];
+  for (const scene of scenes) {
+    if (!scene.captions?.length) continue;
+    const offset = scene.start_s;
+    if (style === "KARAOKE") {
+      for (const cap of scene.captions) {
+        const text = escapeAss(cap.text);
+        events.push(
+          `Dialogue: 0,${toAssTime(offset + cap.start_s)},${toAssTime(offset + cap.end_s)},Default,,0,0,0,,{\\an8\\fad(80,80)}${text}`
+        );
+      }
+    } else {
+      const merged = scene.captions.map((c) => c.text).join(" ");
+      const startS = offset + (scene.captions[0]?.start_s ?? 0);
+      const endS = offset + (scene.captions[scene.captions.length - 1]?.end_s ?? scene.duration_s);
+      events.push(
+        `Dialogue: 0,${toAssTime(startS)},${toAssTime(endS)},Default,,0,0,0,,{\\an2\\fad(100,100)}${escapeAss(merged)}`
+      );
+    }
+  }
+  return [header, ...events].join("\n");
+}
+function flattenCaptions(scenes) {
+  const out = [];
+  for (const s of scenes) {
+    for (const c of s.captions) {
+      out.push({ text: c.text, startS: c.start_s, endS: c.end_s });
+    }
+  }
+  return out;
+}
+
+// src/ffmpeg/renderer.ts
+var exec = (0, import_util.promisify)(import_child_process.execFile);
+var FFMPEG = process.env.FFMPEG_PATH ?? "ffmpeg";
+var FPS = 25;
+async function runFfmpeg(args) {
+  try {
+    await exec(FFMPEG, ["-y", "-loglevel", "error", ...args], {
+      maxBuffer: 100 * 1024 * 1024
+      // 100 MB
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`FFmpeg failed: ${message}`);
+  }
+}
+function ffDur(s) {
+  return String(s.toFixed(3));
+}
+async function renderAvatarClip(scene, videoPath, dims, outPath) {
+  const { width, height } = dims;
+  await runFfmpeg([
+    "-ss",
+    "0",
+    "-i",
+    videoPath,
+    "-t",
+    ffDur(scene.duration_s),
+    "-vf",
+    `scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:black,setsar=1`,
+    "-r",
+    String(FPS),
+    "-c:v",
+    "libx264",
+    "-preset",
+    "fast",
+    "-crf",
+    "22",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    "-pix_fmt",
+    "yuv420p",
+    outPath
+  ]);
+}
+async function renderBrollClip(scene, assetPath, dims, outPath, isImage) {
+  const { width, height } = dims;
+  const durationFrames = Math.ceil(scene.duration_s * FPS);
+  if (isImage) {
+    const motion = scene.motion ?? "kenburns_in";
+    const zoomStart = motion === "kenburns_out" ? 1.4 : 1;
+    const zoomEnd = motion === "kenburns_out" ? 1 : 1.4;
+    const zoomStep = (zoomEnd - zoomStart) / Math.max(durationFrames - 1, 1);
+    const zoompan = [
+      `zoompan=z='${zoomStart}+${zoomStep.toFixed(6)}*on'`,
+      `d=${durationFrames}`,
+      `x='iw/2-(iw/zoom/2)'`,
+      `y='ih/2-(ih/zoom/2)'`,
+      `s=${width}x${height}`,
+      `fps=${FPS}`
+    ].join(":");
+    await runFfmpeg([
+      "-loop",
+      "1",
+      "-i",
+      assetPath,
+      "-t",
+      ffDur(scene.duration_s),
+      "-vf",
+      `${zoompan},setsar=1`,
+      "-c:v",
+      "libx264",
+      "-preset",
+      "fast",
+      "-crf",
+      "22",
+      "-pix_fmt",
+      "yuv420p",
+      "-an",
+      outPath
+    ]);
+  } else {
+    await runFfmpeg([
+      "-ss",
+      "0",
+      "-i",
+      assetPath,
+      "-t",
+      ffDur(scene.duration_s),
+      "-vf",
+      `scale=${width}:${height}:force_original_aspect_ratio=increase,crop=${width}:${height},setsar=1`,
+      "-r",
+      String(FPS),
+      "-c:v",
+      "libx264",
+      "-preset",
+      "fast",
+      "-crf",
+      "22",
+      "-pix_fmt",
+      "yuv420p",
+      "-an",
+      outPath
+    ]);
+  }
+}
+async function renderTextCardClip(scene, dims, outPath, scale) {
+  const { width, height } = dims;
+  const text = scene.captions.map((c) => c.text).join(" ").replace(/'/g, "\\'").replace(/:/g, "\\:");
+  const fontSize = Math.round(52 * scale);
+  await runFfmpeg([
+    "-f",
+    "lavfi",
+    "-i",
+    `color=c=0x111118:s=${width}x${height}:r=${FPS}:d=${ffDur(scene.duration_s)}`,
+    "-vf",
+    [
+      `drawtext=text='${text}'`,
+      `fontsize=${fontSize}`,
+      `fontcolor=white`,
+      `x=(w-text_w)/2`,
+      `y=(h-text_h)/2`,
+      `box=1:boxcolor=black@0.4:boxborderw=${Math.round(16 * scale)}`
+    ].join(":"),
+    "-c:v",
+    "libx264",
+    "-preset",
+    "fast",
+    "-crf",
+    "22",
+    "-pix_fmt",
+    "yuv420p",
+    "-an",
+    outPath
+  ]);
+}
+async function concatClips(clipPaths, outPath) {
+  const listPath = outPath.replace(/\.\w+$/, "-list.txt");
+  const listContent = clipPaths.map((p) => `file '${p}'`).join("\n");
+  await import_promises.default.writeFile(listPath, listContent, "utf8");
+  await runFfmpeg([
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    listPath,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "fast",
+    "-crf",
+    "22",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    "-pix_fmt",
+    "yuv420p",
+    outPath
+  ]);
+  await import_promises.default.unlink(listPath).catch(() => {
+  });
+}
+async function burnSubtitles(inputPath, assPath, outputPath) {
+  await runFfmpeg([
+    "-i",
+    inputPath,
+    "-vf",
+    `ass='${assPath.replace(/'/g, "\\'")}'`,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "fast",
+    "-crf",
+    "22",
+    "-c:a",
+    "copy",
+    "-pix_fmt",
+    "yuv420p",
+    outputPath
+  ]);
+}
+async function mixMusic(videoPath, musicPath, volumeDb, outputPath) {
+  const vol = Math.pow(10, volumeDb / 20);
+  await runFfmpeg([
+    "-i",
+    videoPath,
+    "-stream_loop",
+    "-1",
+    "-i",
+    musicPath,
+    "-filter_complex",
+    `[1:a]aformat=sample_fmts=fltp:sample_rates=44100,volume=${vol.toFixed(4)},atrim=0[mus];[0:a][mus]amix=inputs=2:duration=shortest[aout]`,
+    "-map",
+    "0:v",
+    "-map",
+    "[aout]",
+    "-c:v",
+    "copy",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    "-shortest",
+    outputPath
+  ]);
+}
+async function applyWatermark(inputPath, outputPath, dims, scale) {
+  const fontSize = Math.round(28 * scale);
+  await runFfmpeg([
+    "-i",
+    inputPath,
+    "-vf",
+    [
+      `drawtext=text='Made with AdForge'`,
+      `fontsize=${fontSize}`,
+      `fontcolor=white@0.65`,
+      `x=(w-text_w)/2`,
+      `y=${Math.round(dims.height * 0.04)}`,
+      `box=1:boxcolor=black@0.3:boxborderw=${Math.round(8 * scale)}`
+    ].join(":"),
+    "-c:v",
+    "libx264",
+    "-preset",
+    "fast",
+    "-crf",
+    "22",
+    "-c:a",
+    "copy",
+    "-pix_fmt",
+    "yuv420p",
+    outputPath
+  ]);
+}
+var IMAGE_EXTS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".gif"]);
+function isImagePath(p) {
+  return IMAGE_EXTS.has(import_path.default.extname(p).toLowerCase());
+}
+async function resolveSceneAsset(scene, assetPaths, avatarRenderPaths) {
+  if (scene.type === "avatar" && scene.avatar_render_id) {
+    return avatarRenderPaths[scene.avatar_render_id] ?? null;
+  }
+  if (scene.asset_id) {
+    return assetPaths[scene.asset_id] ?? null;
+  }
+  return null;
+}
+async function renderVideo(job) {
+  const { storyboard, aspect, resolution, captionStyle, watermark, outputPath } = job;
+  const dims = getDimensions(aspect, resolution);
+  const scale = fontScale(dims);
+  const tmpDir = await import_promises.default.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "adforge-render-"));
+  const clipPaths = [];
+  try {
+    for (let i = 0; i < storyboard.scenes.length; i++) {
+      const scene = storyboard.scenes[i];
+      const clipOut = import_path.default.join(tmpDir, `scene-${i}.mp4`);
+      if (scene.type === "text_card") {
+        await renderTextCardClip(scene, dims, clipOut, scale);
+      } else {
+        const assetPath = await resolveSceneAsset(scene, job.assetPaths, job.avatarRenderPaths);
+        if (!assetPath) {
+          const fallback = {
+            ...scene,
+            type: "text_card",
+            captions: [{ text: scene.type.replace(/_/g, " ").toUpperCase(), start_s: scene.start_s, end_s: scene.start_s + scene.duration_s }]
+          };
+          await renderTextCardClip(fallback, dims, clipOut, scale);
+        } else if (scene.type === "avatar") {
+          await renderAvatarClip(scene, assetPath, dims, clipOut);
+        } else {
+          await renderBrollClip(scene, assetPath, dims, clipOut, isImagePath(assetPath));
+        }
+      }
+      clipPaths.push(clipOut);
+    }
+    const concatOut = import_path.default.join(tmpDir, "concat.mp4");
+    if (clipPaths.length === 1) {
+      await import_promises.default.copyFile(clipPaths[0], concatOut);
+    } else {
+      await concatClips(clipPaths, concatOut);
+    }
+    let currentPath = concatOut;
+    if (captionStyle !== "NONE") {
+      const assContent = buildAssSubtitles(storyboard.scenes, captionStyle, dims);
+      if (assContent) {
+        const assPath = import_path.default.join(tmpDir, "captions.ass");
+        await import_promises.default.writeFile(assPath, assContent, "utf8");
+        const subOut = import_path.default.join(tmpDir, "subtitled.mp4");
+        await burnSubtitles(currentPath, assPath, subOut);
+        currentPath = subOut;
+      }
+    }
+    const skippedAssets = [];
+    if (storyboard.music?.asset_id) {
+      const musicPath = job.assetPaths[storyboard.music.asset_id];
+      if (musicPath) {
+        const musicOut = import_path.default.join(tmpDir, "music.mp4");
+        await mixMusic(currentPath, musicPath, storyboard.music.volume_db, musicOut);
+        currentPath = musicOut;
+      } else {
+        console.warn(
+          `[renderer] Music asset "${storyboard.music.asset_id}" is set on the storyboard but its file path is missing from job.assetPaths \u2014 music step skipped.`
+        );
+        skippedAssets.push(storyboard.music.asset_id);
+      }
+    }
+    if (watermark) {
+      const wmOut = import_path.default.join(tmpDir, "watermarked.mp4");
+      await applyWatermark(currentPath, wmOut, dims, scale);
+      currentPath = wmOut;
+    }
+    await import_promises.default.mkdir(import_path.default.dirname(outputPath), { recursive: true });
+    await import_promises.default.copyFile(currentPath, outputPath);
+    const totalDurationMs = storyboard.scenes.reduce((sum, s) => sum + s.duration_s * 1e3, 0);
+    const totalS = totalDurationMs / 1e3;
+    const costUsd = Math.ceil(totalS / 30) * 5 * 2e-3;
+    return {
+      r2Key: outputPath,
+      url: outputPath,
+      durationMs: Math.round(totalDurationMs),
+      costUsd,
+      ...skippedAssets.length > 0 ? { skippedAssets } : {}
+    };
+  } finally {
+    for (const p of clipPaths) {
+      await import_promises.default.unlink(p).catch(() => {
+      });
+    }
+  }
+}
+
+// src/storyboard/utils.ts
+function storyboardDurationS(sb) {
+  return sb.scenes.reduce((sum, s) => sum + s.duration_s, 0);
+}
+function estimateRenderCredits(sb, aspects) {
+  const durationS = storyboardDurationS(sb);
+  return Math.ceil(durationS / 30) * 5 * aspects;
+}
+function assignStartTimes(sb) {
+  let cursor = 0;
+  const scenes = sb.scenes.map((s) => {
+    const scene = { ...s, start_s: cursor };
+    cursor += s.duration_s;
+    return scene;
+  });
+  return { ...sb, scenes };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assignStartTimes,
+  buildAssSubtitles,
+  estimateRenderCredits,
+  flattenCaptions,
+  renderVideo,
+  storyboardDurationS
+});