simple-ffmpegjs 0.1.0

package/src/ffmpeg/text_renderer.js

@@ -0,0 +1,363 @@
+const Strings = require("./strings");
+const C = require("../core/constants");
+
+function buildXParam(baseClip, canvasWidth) {
+  if (typeof baseClip.centerX === "number") {
+    return `:x=(${canvasWidth} - text_w)/2 + ${baseClip.centerX}`;
+  } else if (typeof baseClip.x === "number") {
+    return `:x=${baseClip.x}`;
+  }
+  return `:x=(${canvasWidth} - text_w)/2`;
+}
+
+function baseYExpression(baseClip, canvasHeight) {
+  if (typeof baseClip.centerY === "number") {
+    return `(${canvasHeight} - text_h)/2 + ${baseClip.centerY}`;
+  } else if (typeof baseClip.y === "number") {
+    return `${baseClip.y}`;
+  }
+  return `(${canvasHeight} - text_h)/2`;
+}
+
+function buildYParamAnimated(baseClip, canvasHeight, start, end) {
+  const baseY = baseYExpression(baseClip, canvasHeight);
+  return `:y=${baseY}`;
+}
+
+function buildAlphaParam(baseClip, start, end) {
+  const anim = baseClip.animation || {};
+  const type = anim.type || "none";
+  if (type === "fade-in") {
+    const entry =
+      typeof anim.in === "number" ? anim.in : C.DEFAULT_TEXT_ANIM_IN;
+    return `:alpha=if(lt(t\\,${start})\\,0\\,if(lt(t\\,${
+      start + entry
+    })\\,(t-${start})/${entry}\\,1))`;
+  }
+  if (type === "fade-in-out" || type === "fade") {
+    const entry =
+      typeof anim.in === "number" ? anim.in : C.DEFAULT_TEXT_ANIM_IN;
+    const exit = typeof anim.out === "number" ? anim.out : entry;
+    const fadeOutStart = Math.max(start, end - exit);
+    return `:alpha=if(lt(t\\,${start})\\,0\\,if(lt(t\\,${
+      start + entry
+    })\\,(t-${start})/${entry}\\,if(lt(t\\,${fadeOutStart})\\,1\\,if(lt(t\\,${end})\\,((${end}-t)/${exit})\\,0))))`;
+  }
+  return "";
+}
+
+function buildFontsizeParam(baseClip, start) {
+  const anim = baseClip.animation || {};
+  const type = anim.type || "none";
+  const baseSize = baseClip.fontSize;
+  if (type === "pop") {
+    const entry =
+      typeof anim.in === "number" ? anim.in : C.DEFAULT_TEXT_ANIM_IN;
+    return `:fontsize=if(lt(t\\,${start + entry})\\,${(baseSize * 0.7).toFixed(
+      3
+    )}+${(baseSize * 0.3).toFixed(
+      3
+    )}*sin(PI/2*(t-${start})/${entry})\\,${baseSize})`;
+  }
+  if (type === "pop-bounce") {
+    const entry =
+      typeof anim.in === "number" ? anim.in : C.DEFAULT_TEXT_ANIM_IN;
+    return `:fontsize=if(lt(t\\,${start + entry})\\,${(baseSize * 0.7).toFixed(
+      3
+    )}+${(baseSize * 0.4).toFixed(
+      3
+    )}*sin(PI/2*(t-${start})/${entry})\\,${baseSize})`;
+  }
+  return `:fontsize=${baseSize}`;
+}
+
+function buildDrawtextParams(
+  baseClip,
+  text,
+  canvasWidth,
+  canvasHeight,
+  start,
+  end
+) {
+  const fontSpec = baseClip.fontFile
+    ? `fontfile=${baseClip.fontFile}`
+    : baseClip.fontFamily
+    ? `font=${baseClip.fontFamily}`
+    : `font=Sans`;
+
+  const escaped = Strings.escapeDrawtextText(text);
+  let params = `drawtext=text='${escaped}':${fontSpec}`;
+  params += buildFontsizeParam(baseClip, start);
+  params += `:fontcolor=${baseClip.fontColor}`;
+  params += buildXParam(baseClip, canvasWidth);
+  params += buildYParamAnimated(baseClip, canvasHeight, start, end);
+  params += buildAlphaParam(baseClip, start, end);
+
+  if (baseClip.borderColor) params += `:bordercolor=${baseClip.borderColor}`;
+  if (baseClip.borderWidth) params += `:borderw=${baseClip.borderWidth}`;
+  if (baseClip.shadowColor) params += `:shadowcolor=${baseClip.shadowColor}`;
+  if (baseClip.shadowX) params += `:shadowx=${baseClip.shadowX}`;
+  if (baseClip.shadowY) params += `:shadowy=${baseClip.shadowY}`;
+  if (baseClip.backgroundColor) {
+    params += `:box=1:boxcolor=${baseClip.backgroundColor}`;
+    if (baseClip.backgroundOpacity) params += `@${baseClip.backgroundOpacity}`;
+  }
+  if (baseClip.padding) params += `:boxborderw=${baseClip.padding}`;
+
+  return params;
+}
+
+function computeWordWindows(clip, words) {
+  const windows = [];
+  const startBase = clip.position;
+  const endBase = clip.end;
+
+  if (Array.isArray(clip.words) && clip.words.length > 0) {
+    clip.words.forEach((w) => {
+      if (
+        typeof w.start === "number" &&
+        typeof w.end === "number" &&
+        typeof w.text === "string"
+      ) {
+        const start = Math.max(startBase, w.start);
+        const end = Math.min(endBase, w.end);
+        if (end > start) windows.push({ start, end, text: w.text });
+      }
+    });
+    return windows;
+  }
+
+  const timestamps = Array.isArray(clip.wordTimestamps)
+    ? clip.wordTimestamps.slice()
+    : [];
+  if (timestamps.length > 0) {
+    const ts = timestamps
+      .map((t) => Math.min(endBase, Math.max(startBase, t)))
+      .filter((t) => typeof t === "number")
+      .sort((a, b) => a - b);
+
+    if (ts.length === words.length + 1) {
+      for (let i = 0; i < words.length; i++) {
+        const start = ts[i];
+        const end = ts[i + 1];
+        if (end > start) windows.push({ start, end, text: words[i] });
+      }
+      return windows;
+    }
+
+    if (ts.length === words.length) {
+      for (let i = 0; i < words.length; i++) {
+        const start = ts[i];
+        const end = i + 1 < ts.length ? ts[i + 1] : endBase;
+        if (end > start) windows.push({ start, end, text: words[i] });
+      }
+      return windows;
+    }
+  }
+
+  const total = Math.max(0, endBase - startBase);
+  if (words.length === 0 || total <= 0) return windows;
+  if (words.length === 1) {
+    windows.push({ start: startBase, end: endBase, text: words[0] });
+    return windows;
+  }
+
+  const step = total / words.length;
+  for (let i = 0; i < words.length; i++) {
+    const start = startBase + i * step;
+    const end = i === words.length - 1 ? endBase : startBase + (i + 1) * step;
+    windows.push({ start, end, text: words[i] });
+  }
+  return windows;
+}
+
+function buildTextFilters(
+  textClips,
+  canvasWidth,
+  canvasHeight,
+  initialVideoLabel
+) {
+  let filterString = "";
+  let currentLabel = initialVideoLabel;
+  let labelIndex = 0;
+  const nextLabel = () => {
+    const label = `[vtext${labelIndex}]`;
+    labelIndex += 1;
+    return label;
+  };
+
+  for (const clip of textClips) {
+    const mode = clip.mode || "static";
+    if (mode === "static") {
+      const params = buildDrawtextParams(
+        clip,
+        clip.text,
+        canvasWidth,
+        canvasHeight,
+        clip.position,
+        clip.end
+      );
+      const enable = `:enable='between(t,${clip.position},${clip.end})'`;
+      const outLabel = nextLabel();
+      filterString += `${currentLabel}${params}${enable}${outLabel};`;
+      currentLabel = outLabel;
+      continue;
+    }
+    const splitWords = (clip.text || "").split(/\s+/).filter(Boolean);
+    const sourceWords =
+      Array.isArray(clip.words) && clip.words.length > 0
+        ? clip.words.map((w) => w.text)
+        : splitWords;
+    const windows = computeWordWindows(clip, sourceWords);
+
+    if (mode === "word-replace") {
+      for (const w of windows) {
+        const params = buildDrawtextParams(
+          clip,
+          w.text,
+          canvasWidth,
+          canvasHeight,
+          w.start,
+          w.end
+        );
+        const enable = `:enable='between(t,${w.start},${w.end})'`;
+        const outLabel = nextLabel();
+        filterString += `${currentLabel}${params}${enable}${outLabel};`;
+        currentLabel = outLabel;
+      }
+      continue;
+    }
+
+    if (mode === "word-sequential") {
+      for (let i = 0; i < windows.length; i++) {
+        const visible = sourceWords.slice(0, i + 1).join(" ");
+        const w = windows[i];
+        const params = buildDrawtextParams(
+          clip,
+          visible,
+          canvasWidth,
+          canvasHeight,
+          w.start,
+          w.end
+        );
+        const enable = `:enable='between(t,${w.start},${w.end})'`;
+        const outLabel = nextLabel();
+        filterString += `${currentLabel}${params}${enable}${outLabel};`;
+        currentLabel = outLabel;
+      }
+      continue;
+    }
+
+    // Unknown mode -> static fallback
+    const params = buildDrawtextParams(
+      clip,
+      clip.text,
+      canvasWidth,
+      canvasHeight,
+      clip.position,
+      clip.end
+    );
+    const enable = `:enable='between(t,${clip.position},${clip.end})'`;
+    const outLabel = nextLabel();
+    filterString += `${currentLabel}${params}${enable}${outLabel};`;
+    currentLabel = outLabel;
+  }
+
+  if (currentLabel !== initialVideoLabel) {
+    filterString += `${currentLabel}null[outVideoAndText];`;
+    currentLabel = "[outVideoAndText]";
+  }
+  return { filterString, finalVideoLabel: currentLabel };
+}
+
+function expandTextWindows(textClips) {
+  const ops = [];
+  for (const clip of textClips) {
+    const effectiveClip = { ...clip };
+    const mode = effectiveClip.mode || "static";
+    if (mode === "static") {
+      ops.push({
+        text: effectiveClip.text || "",
+        start: effectiveClip.position,
+        end: effectiveClip.end,
+        clip: effectiveClip,
+      });
+      continue;
+    }
+    const splitWords = (effectiveClip.text || "").split(/\s+/).filter(Boolean);
+    const sourceWords =
+      Array.isArray(effectiveClip.words) && effectiveClip.words.length > 0
+        ? effectiveClip.words.map((w) => w.text)
+        : splitWords;
+    const windows = computeWordWindows(effectiveClip, sourceWords);
+
+    if (mode === "word-replace") {
+      for (const w of windows)
+        ops.push({
+          text: w.text,
+          start: w.start,
+          end: w.end,
+          clip: effectiveClip,
+        });
+      continue;
+    }
+    if (mode === "word-sequential") {
+      for (let i = 0; i < windows.length; i++) {
+        const visible = sourceWords.slice(0, i + 1).join(" ");
+        const w = windows[i];
+        ops.push({
+          text: visible,
+          start: w.start,
+          end: w.end,
+          clip: effectiveClip,
+        });
+      }
+      continue;
+    }
+  }
+  return ops;
+}
+
+function buildFiltersForWindows(
+  windows,
+  canvasWidth,
+  canvasHeight,
+  initialVideoLabel
+) {
+  let filterString = "";
+  let currentLabel = initialVideoLabel;
+  let labelIndex = 0;
+  const nextLabel = () => {
+    const label = `[vtextb${labelIndex}]`;
+    labelIndex += 1;
+    return label;
+  };
+
+  for (const win of windows) {
+    const params = buildDrawtextParams(
+      win.clip,
+      win.text,
+      canvasWidth,
+      canvasHeight,
+      win.start,
+      win.end
+    );
+    const enable = `:enable='between(t,${win.start},${win.end})'`;
+    const outLabel = nextLabel();
+    filterString += `${currentLabel}${params}${enable}${outLabel};`;
+    currentLabel = outLabel;
+  }
+
+  if (currentLabel !== initialVideoLabel) {
+    filterString += `${currentLabel}null[outVideoAndText];`;
+    currentLabel = "[outVideoAndText]";
+  }
+
+  return { filterString, finalVideoLabel: currentLabel };
+}
+
+module.exports = {
+  buildTextFilters,
+  expandTextWindows,
+  buildFiltersForWindows,
+};

package/src/ffmpeg/video_builder.js

@@ -0,0 +1,130 @@
+function buildVideoFilter(project, videoClips) {
+  let filterComplex = "";
+  let videoIndex = 0;
+  const fps = project.options.fps;
+  const width = project.options.width;
+  const height = project.options.height;
+
+  // Build scaled streams
+  const scaledStreams = [];
+  videoClips.forEach((clip) => {
+    const inputIndex = project.videoOrAudioClips.indexOf(clip);
+    const scaledLabel = `[scaled${videoIndex}]`;
+
+    const requestedDuration = Math.max(
+      0,
+      (clip.end || 0) - (clip.position || 0)
+    );
+    const maxAvailable =
+      typeof clip.mediaDuration === "number" && typeof clip.cutFrom === "number"
+        ? Math.max(0, clip.mediaDuration - clip.cutFrom)
+        : requestedDuration;
+    const clipDuration = Math.max(0, Math.min(requestedDuration, maxAvailable));
+
+    if (clip.type === "image" && clip.kenBurns) {
+      const frames = Math.max(1, Math.round(clipDuration * fps));
+      const framesMinusOne = Math.max(1, frames - 1);
+      const s = `${width}x${height}`;
+
+      // Use overscan pre-scale + center crop, then zoompan with center-based x/y
+      const overscanW = Math.max(width * 3, 4000);
+      const kb = clip.kenBurns;
+      const type = typeof kb === "string" ? kb : kb.type;
+      // Simplified fixed-intensity zoom. API no longer exposes strength.
+      const zoomAmount = 0.15;
+
+      let zoomExpr = `1`;
+      let xExpr = `round(iw/2 - (iw/zoom)/2)`;
+      let yExpr = `round(ih/2 - (ih/zoom)/2)`;
+
+      if (type === "zoom-in") {
+        const inc = (zoomAmount / framesMinusOne).toFixed(6);
+        // Ensure first frame starts exactly at base zoom=1 (on==0)
+        zoomExpr = `if(eq(on\\,0)\\,1\\,zoom+${inc})`;
+      } else if (type === "zoom-out") {
+        const start = (1 + zoomAmount).toFixed(4);
+        const dec = (zoomAmount / framesMinusOne).toFixed(6);
+        // Start pre-zoomed on first frame to avoid jump
+        zoomExpr = `if(eq(on\\,0)\\,${start}\\,zoom-${dec})`;
+      } else {
+        const panZoom = 1.12;
+        zoomExpr = `${panZoom}`;
+        const dx = `(iw - iw/${panZoom})`;
+        const dy = `(ih - ih/${panZoom})`;
+        if (type === "pan-left") {
+          xExpr = `${dx} - ${dx}*on/${framesMinusOne}`;
+          yExpr = `(ih - ih/zoom)/2`;
+        } else if (type === "pan-right") {
+          xExpr = `${dx}*on/${framesMinusOne}`;
+          yExpr = `(ih - ih/zoom)/2`;
+        } else if (type === "pan-up") {
+          xExpr = `(iw - iw/zoom)/2`;
+          yExpr = `${dy} - ${dy}*on/${framesMinusOne}`;
+        } else if (type === "pan-down") {
+          xExpr = `(iw - iw/zoom)/2`;
+          yExpr = `${dy}*on/${framesMinusOne}`;
+        }
+      }
+
+      filterComplex += `[${inputIndex}:v]select=eq(n\\,0),setpts=PTS-STARTPTS,scale=${width}:-2,setsar=1:1,crop=${width}:${height}:(iw-${width})/2:(ih-${height})/2,scale=${overscanW}:-1,zoompan=z='${zoomExpr}':x='${xExpr}':y='${yExpr}':d=${frames}:s=${s},fps=${fps},settb=1/${fps}${scaledLabel};`;
+    } else {
+      filterComplex += `[${inputIndex}:v]trim=start=${
+        clip.cutFrom || 0
+      }:duration=${clipDuration},setpts=PTS-STARTPTS,fps=${fps},scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,settb=1/${fps}${scaledLabel};`;
+    }
+
+    scaledStreams.push({
+      label: scaledLabel,
+      clip,
+      index: videoIndex,
+      duration: clipDuration,
+    });
+    videoIndex++;
+  });
+
+  if (scaledStreams.length === 0) {
+    return { filter: "", finalVideoLabel: null, hasVideo: false };
+  }
+
+  const hasTransitions = scaledStreams.some(
+    (s, i) => i > 0 && s.clip.transition
+  );
+
+  if (!hasTransitions) {
+    const labels = scaledStreams.map((s) => s.label);
+    filterComplex += `${labels.join("")}concat=n=${
+      labels.length
+    }:v=1:a=0,fps=${fps},settb=1/${fps}[outv];`;
+    return { filter: filterComplex, finalVideoLabel: "[outv]", hasVideo: true };
+  }
+
+  let currentVideo = scaledStreams[0].label;
+  let currentVideoDuration = scaledStreams[0].duration;
+  for (let i = 1; i < scaledStreams.length; i++) {
+    const nextVideoLabel = scaledStreams[i].label;
+    const transClip = scaledStreams[i].clip;
+    const transitionedVideoLabel = `[vtrans${i}]`;
+    if (transClip.transition) {
+      const type = transClip.transition.type;
+      const duration = transClip.transition.duration;
+      const offset = Math.max(0, currentVideoDuration - duration);
+      filterComplex += `${currentVideo}${nextVideoLabel}xfade=transition=${type}:duration=${duration}:offset=${offset},fps=${fps},settb=1/${fps}${transitionedVideoLabel};`;
+      currentVideoDuration =
+        currentVideoDuration + scaledStreams[i].duration - duration;
+      currentVideo = transitionedVideoLabel;
+    } else {
+      const concatenatedVideoLabel = `[vcat${i}]`;
+      filterComplex += `${currentVideo}${nextVideoLabel}concat=n=2:v=1:a=0,fps=${fps},settb=1/${fps}${concatenatedVideoLabel};`;
+      currentVideo = concatenatedVideoLabel;
+      currentVideoDuration = currentVideoDuration + scaledStreams[i].duration;
+    }
+  }
+
+  return {
+    filter: filterComplex,
+    finalVideoLabel: currentVideo,
+    hasVideo: true,
+  };
+}
+
+module.exports = { buildVideoFilter };

package/src/lib/utils.js

@@ -0,0 +1,13 @@
+const formatBytes = (bytes) => {
+  if (!Number.isFinite(bytes)) return `${bytes}`;
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let i = 0;
+  let n = bytes;
+  while (n >= 1024 && i < units.length - 1) {
+    n /= 1024;
+    i++;
+  }
+  return `${n.toFixed(n < 10 && i > 0 ? 2 : 1)} ${units[i]}`;
+};
+
+module.exports = { formatBytes };

package/src/loaders.js

@@ -0,0 +1,136 @@
+const { getVideoMetadata, getMediaDuration } = require("./core/media_info");
+const C = require("./core/constants");
+
+async function loadVideo(project, clipObj) {
+  const metadata = await getVideoMetadata(clipObj.url);
+  if (typeof clipObj.cutFrom === "number" && metadata.durationSec != null) {
+    if (clipObj.cutFrom >= metadata.durationSec) {
+      throw new Error(
+        `Video clip cutFrom (${clipObj.cutFrom}s) must be < source duration (${metadata.durationSec}s)`
+      );
+    }
+  }
+  if (
+    typeof clipObj.position === "number" &&
+    typeof clipObj.end === "number" &&
+    typeof clipObj.cutFrom === "number" &&
+    metadata.durationSec != null
+  ) {
+    const requestedDuration = Math.max(0, clipObj.end - clipObj.position);
+    const maxAvailable = Math.max(0, metadata.durationSec - clipObj.cutFrom);
+    if (requestedDuration > maxAvailable) {
+      const clampedEnd = clipObj.position + maxAvailable;
+      console.warn(
+        `Video clip overruns source by ${(
+          requestedDuration - maxAvailable
+        ).toFixed(3)}s. Clamping end from ${clipObj.end}s to ${clampedEnd}s.`
+      );
+      clipObj.end = clampedEnd;
+    }
+  }
+  project.videoOrAudioClips.push({
+    ...clipObj,
+    iphoneRotation: metadata.iphoneRotation,
+    hasAudio: metadata.hasAudio,
+    mediaDuration: metadata.durationSec,
+  });
+}
+
+async function loadAudio(project, clipObj) {
+  const durationSec = await getMediaDuration(clipObj.url);
+  if (typeof clipObj.cutFrom === "number" && durationSec != null) {
+    if (clipObj.cutFrom >= durationSec) {
+      throw new Error(
+        `Audio clip cutFrom (${clipObj.cutFrom}s) must be < source duration (${durationSec}s)`
+      );
+    }
+  }
+  if (
+    typeof clipObj.position === "number" &&
+    typeof clipObj.end === "number" &&
+    typeof clipObj.cutFrom === "number" &&
+    durationSec != null
+  ) {
+    const requestedDuration = Math.max(0, clipObj.end - clipObj.position);
+    const maxAvailable = Math.max(0, durationSec - clipObj.cutFrom);
+    if (requestedDuration > maxAvailable) {
+      const clampedEnd = clipObj.position + maxAvailable;
+      console.warn(
+        `Audio clip overruns source by ${(
+          requestedDuration - maxAvailable
+        ).toFixed(3)}s. Clamping end from ${clipObj.end}s to ${clampedEnd}s.`
+      );
+      clipObj.end = clampedEnd;
+    }
+  }
+  project.videoOrAudioClips.push({ ...clipObj, mediaDuration: durationSec });
+}
+
+function loadImage(project, clipObj) {
+  const clip = { ...clipObj, hasAudio: false, cutFrom: 0 };
+  project.videoOrAudioClips.push(clip);
+}
+
+async function loadBackgroundAudio(project, clipObj) {
+  const durationSec = await getMediaDuration(clipObj.url);
+  const clip = {
+    ...clipObj,
+    volume:
+      typeof clipObj.volume === "number"
+        ? clipObj.volume
+        : C.DEFAULT_BGM_VOLUME,
+    cutFrom: typeof clipObj.cutFrom === "number" ? clipObj.cutFrom : 0,
+    position: typeof clipObj.position === "number" ? clipObj.position : 0,
+  };
+  if (typeof clip.cutFrom === "number" && durationSec != null) {
+    if (clip.cutFrom >= durationSec) {
+      throw new Error(
+        `Background audio cutFrom (${clip.cutFrom}s) must be < source duration (${durationSec}s)`
+      );
+    }
+  }
+  if (
+    typeof clip.position === "number" &&
+    typeof clip.end === "number" &&
+    typeof clip.cutFrom === "number" &&
+    durationSec != null
+  ) {
+    const requestedDuration = Math.max(0, clip.end - clip.position);
+    const maxAvailable = Math.max(0, durationSec - clip.cutFrom);
+    if (requestedDuration > maxAvailable) {
+      const clampedEnd = clip.position + maxAvailable;
+      console.warn(
+        `Background audio overruns source by ${(
+          requestedDuration - maxAvailable
+        ).toFixed(3)}s. Clamping end from ${clip.end}s to ${clampedEnd}s.`
+      );
+      clip.end = clampedEnd;
+    }
+  }
+  project.videoOrAudioClips.push({ ...clip, mediaDuration: durationSec });
+}
+
+function loadText(project, clipObj) {
+  const clip = {
+    ...clipObj,
+    fontFile: clipObj.fontFile || null,
+    fontFamily: clipObj.fontFamily || C.DEFAULT_FONT_FAMILY,
+    fontSize: clipObj.fontSize || C.DEFAULT_FONT_SIZE,
+    fontColor: clipObj.fontColor || C.DEFAULT_FONT_COLOR,
+  };
+  if (typeof clipObj.centerX === "number") clip.centerX = clipObj.centerX;
+  else if (typeof clipObj.x === "number") clip.x = clipObj.x;
+  else clip.centerX = 0;
+  if (typeof clipObj.centerY === "number") clip.centerY = clipObj.centerY;
+  else if (typeof clipObj.y === "number") clip.y = clipObj.y;
+  else clip.centerY = 0;
+  project.textClips.push(clip);
+}
+
+module.exports = {
+  loadVideo,
+  loadAudio,
+  loadImage,
+  loadBackgroundAudio,
+  loadText,
+};