simple-ffmpegjs 0.1.1 → 0.3.0

package/src/ffmpeg/watermark_builder.js

@@ -0,0 +1,411 @@
+const Strings = require("./strings");
+
+/**
+ * Position presets for watermarks
+ */
+const POSITION_PRESETS = {
+  "top-left": (margin) => ({ x: margin, y: margin }),
+  "top-right": (margin) => ({ x: `W-w-${margin}`, y: margin }),
+  "bottom-left": (margin) => ({ x: margin, y: `H-h-${margin}` }),
+  "bottom-right": (margin) => ({ x: `W-w-${margin}`, y: `H-h-${margin}` }),
+  center: () => ({ x: "(W-w)/2", y: "(H-h)/2" }),
+};
+
+/**
+ * Calculate position expressions for overlay/drawtext
+ * @param {Object} config - Watermark config with position, margin
+ * @param {number} canvasWidth - Video width
+ * @param {number} canvasHeight - Video height
+ * @param {boolean} isText - Whether this is for drawtext (uses different variables)
+ * @returns {{ x: string, y: string }}
+ */
+function calculatePosition(config, canvasWidth, canvasHeight, isText = false) {
+  const margin = typeof config.margin === "number" ? config.margin : 20;
+
+  // Text uses 'tw'/'th' for text width/height, overlay uses 'w'/'h'
+  const wVar = isText ? "tw" : "w";
+  const hVar = isText ? "th" : "h";
+  const W = isText ? canvasWidth : "W";
+  const H = isText ? canvasHeight : "H";
+
+  // Preset positions
+  if (typeof config.position === "string") {
+    const preset = config.position;
+    if (preset === "top-left") {
+      return { x: `${margin}`, y: `${margin}` };
+    }
+    if (preset === "top-right") {
+      return { x: `${W}-${wVar}-${margin}`, y: `${margin}` };
+    }
+    if (preset === "bottom-left") {
+      return { x: `${margin}`, y: `${H}-${hVar}-${margin}` };
+    }
+    if (preset === "bottom-right") {
+      return { x: `${W}-${wVar}-${margin}`, y: `${H}-${hVar}-${margin}` };
+    }
+    if (preset === "center") {
+      return { x: `(${W}-${wVar})/2`, y: `(${H}-${hVar})/2` };
+    }
+    // Default to bottom-right if unknown preset
+    return { x: `${W}-${wVar}-${margin}`, y: `${H}-${hVar}-${margin}` };
+  }
+
+  // Custom positioning object
+  if (typeof config.position === "object" && config.position !== null) {
+    const pos = config.position;
+
+    // Percentage-based positioning
+    if (typeof pos.xPercent === "number" && typeof pos.yPercent === "number") {
+      const xPos = pos.xPercent * canvasWidth;
+      const yPos = pos.yPercent * canvasHeight;
+      // Center the watermark on the position point
+      return {
+        x: `${xPos}-${wVar}/2`,
+        y: `${yPos}-${hVar}/2`,
+      };
+    }
+
+    // Pixel-based positioning
+    if (typeof pos.x === "number" && typeof pos.y === "number") {
+      return { x: `${pos.x}`, y: `${pos.y}` };
+    }
+  }
+
+  // Default to bottom-right
+  return { x: `${W}-${wVar}-${margin}`, y: `${H}-${hVar}-${margin}` };
+}
+
+/**
+ * Build filter for image watermark
+ * @param {Object} config - Watermark configuration
+ * @param {string} videoLabel - Current video stream label (e.g., "[outVideoAndText]")
+ * @param {number} watermarkInputIndex - FFmpeg input index for watermark image
+ * @param {number} canvasWidth - Video width
+ * @param {number} canvasHeight - Video height
+ * @param {number} totalDuration - Total video duration for enable expression
+ * @returns {{ filter: string, finalLabel: string }}
+ */
+function buildImageWatermark(
+  config,
+  videoLabel,
+  watermarkInputIndex,
+  canvasWidth,
+  canvasHeight,
+  totalDuration
+) {
+  const scale = typeof config.scale === "number" ? config.scale : 0.15;
+  const opacity = typeof config.opacity === "number" ? config.opacity : 1;
+  const startTime = typeof config.startTime === "number" ? config.startTime : 0;
+  const endTime =
+    typeof config.endTime === "number" ? config.endTime : totalDuration;
+
+  // Calculate scaled width based on percentage of video width
+  const scaledWidth = Math.round(canvasWidth * scale);
+
+  // Build scale and opacity filter for watermark input
+  let wmFilter = `[${watermarkInputIndex}:v]`;
+  wmFilter += `scale=${scaledWidth}:-1`; // Scale to width, maintain aspect ratio
+
+  // Apply opacity if not fully opaque
+  if (opacity < 1) {
+    wmFilter += `,format=rgba,colorchannelmixer=aa=${opacity}`;
+  }
+
+  wmFilter += `[wm_scaled];`;
+
+  // Calculate position
+  const pos = calculatePosition(config, canvasWidth, canvasHeight, false);
+
+  // Build overlay filter
+  const enableExpr =
+    startTime === 0 && endTime >= totalDuration
+      ? "" // Always enabled
+      : `:enable='between(t,${startTime},${endTime})'`;
+
+  const overlayFilter = `${videoLabel}[wm_scaled]overlay=${pos.x}:${pos.y}${enableExpr}[outwm]`;
+
+  return {
+    filter: wmFilter + overlayFilter,
+    finalLabel: "[outwm]",
+  };
+}
+
+/**
+ * Build filter for text watermark
+ * @param {Object} config - Watermark configuration
+ * @param {string} videoLabel - Current video stream label
+ * @param {number} canvasWidth - Video width
+ * @param {number} canvasHeight - Video height
+ * @param {number} totalDuration - Total video duration for enable expression
+ * @returns {{ filter: string, finalLabel: string }}
+ */
+function buildTextWatermark(
+  config,
+  videoLabel,
+  canvasWidth,
+  canvasHeight,
+  totalDuration
+) {
+  const text = config.text || "";
+  const fontSize = typeof config.fontSize === "number" ? config.fontSize : 24;
+  const fontColor = config.fontColor || "#FFFFFF";
+  const fontFamily = config.fontFamily || "Sans";
+  const opacity = typeof config.opacity === "number" ? config.opacity : 1;
+  const startTime = typeof config.startTime === "number" ? config.startTime : 0;
+  const endTime =
+    typeof config.endTime === "number" ? config.endTime : totalDuration;
+
+  // Escape text for drawtext
+  const escapedText = Strings.escapeDrawtextText(text);
+
+  // Font specification
+  const fontSpec = config.fontFile
+    ? `fontfile=${config.fontFile}`
+    : `font=${fontFamily}`;
+
+  // Calculate position (for text)
+  const pos = calculatePosition(config, canvasWidth, canvasHeight, true);
+
+  // Build drawtext filter
+  let params = `drawtext=text='${escapedText}':${fontSpec}`;
+  params += `:fontsize=${fontSize}`;
+
+  // Apply opacity to font color if needed
+  if (opacity < 1) {
+    // Check if color is hex format (#RGB, #RRGGBB, or 0xRRGGBB)
+    const isHexColor = fontColor.startsWith("#") || fontColor.startsWith("0x");
+    if (isHexColor) {
+      // Convert opacity to hex alpha (0-255)
+      const alphaHex = Math.round(opacity * 255)
+        .toString(16)
+        .padStart(2, "0");
+      // Append alpha to hex color
+      params += `:fontcolor=${fontColor}${alphaHex}`;
+    } else {
+      // Named color - use FFmpeg's @opacity syntax
+      params += `:fontcolor=${fontColor}@${opacity}`;
+    }
+  } else {
+    params += `:fontcolor=${fontColor}`;
+  }
+
+  params += `:x=${pos.x}:y=${pos.y}`;
+
+  // Border/outline
+  if (config.borderColor) {
+    const borderColor = config.borderColor;
+    // Apply same opacity to border if needed
+    if (opacity < 1) {
+      const isHexColor =
+        borderColor.startsWith("#") || borderColor.startsWith("0x");
+      if (isHexColor) {
+        const alphaHex = Math.round(opacity * 255)
+          .toString(16)
+          .padStart(2, "0");
+        params += `:bordercolor=${borderColor}${alphaHex}`;
+      } else {
+        // Named color - use FFmpeg's @opacity syntax
+        params += `:bordercolor=${borderColor}@${opacity}`;
+      }
+    } else {
+      params += `:bordercolor=${borderColor}`;
+    }
+  }
+  if (typeof config.borderWidth === "number") {
+    params += `:borderw=${config.borderWidth}`;
+  }
+
+  // Shadow
+  if (config.shadowColor) {
+    params += `:shadowcolor=${config.shadowColor}`;
+    if (typeof config.shadowX === "number")
+      params += `:shadowx=${config.shadowX}`;
+    if (typeof config.shadowY === "number")
+      params += `:shadowy=${config.shadowY}`;
+  }
+
+  // Enable expression for timing
+  if (startTime !== 0 || endTime < totalDuration) {
+    params += `:enable='between(t,${startTime},${endTime})'`;
+  }
+
+  // Remove the leading label bracket if present for proper filter syntax
+  const inputLabel = videoLabel.startsWith("[")
+    ? videoLabel
+    : `[${videoLabel}]`;
+  const filter = `${inputLabel}${params}[outwm]`;
+
+  return {
+    filter: filter,
+    finalLabel: "[outwm]",
+  };
+}
+
+/**
+ * Build watermark filter based on config type
+ * @param {Object} config - Watermark configuration
+ * @param {string} videoLabel - Current video stream label
+ * @param {number|null} watermarkInputIndex - FFmpeg input index for image watermark (null for text)
+ * @param {number} canvasWidth - Video width
+ * @param {number} canvasHeight - Video height
+ * @param {number} totalDuration - Total video duration
+ * @returns {{ filter: string, finalLabel: string, needsInput: boolean }}
+ */
+function buildWatermarkFilter(
+  config,
+  videoLabel,
+  watermarkInputIndex,
+  canvasWidth,
+  canvasHeight,
+  totalDuration
+) {
+  if (!config || typeof config !== "object") {
+    return { filter: "", finalLabel: videoLabel, needsInput: false };
+  }
+
+  const type = config.type || "image";
+
+  if (type === "text") {
+    const result = buildTextWatermark(
+      config,
+      videoLabel,
+      canvasWidth,
+      canvasHeight,
+      totalDuration
+    );
+    return { ...result, needsInput: false };
+  }
+
+  // Default to image watermark
+  if (type === "image") {
+    if (typeof watermarkInputIndex !== "number") {
+      // No input index provided, can't build image watermark
+      return { filter: "", finalLabel: videoLabel, needsInput: true };
+    }
+    const result = buildImageWatermark(
+      config,
+      videoLabel,
+      watermarkInputIndex,
+      canvasWidth,
+      canvasHeight,
+      totalDuration
+    );
+    return { ...result, needsInput: true };
+  }
+
+  // Unknown type, return unchanged
+  return { filter: "", finalLabel: videoLabel, needsInput: false };
+}
+
+/**
+ * Validate watermark configuration
+ * @param {Object} config - Watermark configuration
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+function validateWatermarkConfig(config) {
+  const errors = [];
+
+  if (!config || typeof config !== "object") {
+    return { valid: true, errors: [] }; // No watermark is valid
+  }
+
+  const type = config.type || "image";
+
+  if (type !== "image" && type !== "text") {
+    errors.push(`watermark.type must be 'image' or 'text', got '${type}'`);
+  }
+
+  if (type === "image") {
+    if (typeof config.url !== "string" || config.url.length === 0) {
+      errors.push("watermark.url is required for image watermarks");
+    }
+    if (
+      typeof config.scale === "number" &&
+      (config.scale <= 0 || config.scale > 1)
+    ) {
+      errors.push("watermark.scale must be between 0 and 1");
+    }
+  }
+
+  if (type === "text") {
+    if (typeof config.text !== "string" || config.text.length === 0) {
+      errors.push("watermark.text is required for text watermarks");
+    }
+  }
+
+  // Common validations
+  if (
+    typeof config.opacity === "number" &&
+    (config.opacity < 0 || config.opacity > 1)
+  ) {
+    errors.push("watermark.opacity must be between 0 and 1");
+  }
+
+  if (typeof config.margin === "number" && config.margin < 0) {
+    errors.push("watermark.margin must be >= 0");
+  }
+
+  if (typeof config.startTime === "number" && config.startTime < 0) {
+    errors.push("watermark.startTime must be >= 0");
+  }
+
+  if (
+    typeof config.startTime === "number" &&
+    typeof config.endTime === "number" &&
+    config.endTime <= config.startTime
+  ) {
+    errors.push("watermark.endTime must be > startTime");
+  }
+
+  // Position validation
+  if (typeof config.position === "string") {
+    const validPositions = [
+      "top-left",
+      "top-right",
+      "bottom-left",
+      "bottom-right",
+      "center",
+    ];
+    if (!validPositions.includes(config.position)) {
+      errors.push(
+        `watermark.position must be one of: ${validPositions.join(
+          ", "
+        )}; got '${config.position}'`
+      );
+    }
+  } else if (typeof config.position === "object" && config.position !== null) {
+    const pos = config.position;
+    const hasPercent =
+      typeof pos.xPercent === "number" || typeof pos.yPercent === "number";
+    const hasPixel = typeof pos.x === "number" || typeof pos.y === "number";
+
+    if (hasPercent && hasPixel) {
+      errors.push("watermark.position cannot mix percentage and pixel values");
+    }
+
+    if (hasPercent) {
+      if (
+        typeof pos.xPercent !== "number" ||
+        typeof pos.yPercent !== "number"
+      ) {
+        errors.push("watermark.position requires both xPercent and yPercent");
+      }
+    }
+
+    if (hasPixel) {
+      if (typeof pos.x !== "number" || typeof pos.y !== "number") {
+        errors.push("watermark.position requires both x and y");
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+module.exports = {
+  buildWatermarkFilter,
+  buildImageWatermark,
+  buildTextWatermark,
+  validateWatermarkConfig,
+  calculatePosition,
+};

package/src/lib/utils.js

@@ -1,3 +1,6 @@
+const { spawn } = require("child_process");
+const { FFmpegError, ExportCancelledError } = require("../core/errors");
+
 const formatBytes = (bytes) => {
   if (!Number.isFinite(bytes)) return `${bytes}`;
   const units = ["B", "KB", "MB", "GB", "TB"];
@@ -10,4 +13,200 @@ const formatBytes = (bytes) => {
   return `${n.toFixed(n < 10 && i > 0 ? 2 : 1)} ${units[i]}`;
 };
 
-module.exports = { formatBytes };
+/**
+ * Parse FFmpeg time string (HH:MM:SS.ms) to seconds
+ */
+function parseFFmpegTime(timeStr) {
+  if (!timeStr) return 0;
+  const parts = timeStr.split(":");
+  if (parts.length === 3) {
+    const [hours, minutes, seconds] = parts;
+    return (
+      parseFloat(hours) * 3600 + parseFloat(minutes) * 60 + parseFloat(seconds)
+    );
+  }
+  return parseFloat(timeStr) || 0;
+}
+
+/**
+ * Parse FFmpeg progress line and extract metrics
+ */
+function parseFFmpegProgress(line, totalDuration) {
+  const progress = {};
+
+  // Parse frame=  120
+  const frameMatch = line.match(/frame=\s*(\d+)/);
+  if (frameMatch) progress.frame = parseInt(frameMatch[1], 10);
+
+  // Parse fps=45.2
+  const fpsMatch = line.match(/fps=\s*([\d.]+)/);
+  if (fpsMatch) progress.fps = parseFloat(fpsMatch[1]);
+
+  // Parse time=00:00:04.00
+  const timeMatch = line.match(/time=\s*([\d:.]+)/);
+  if (timeMatch) {
+    progress.timeProcessed = parseFFmpegTime(timeMatch[1]);
+    if (totalDuration > 0) {
+      progress.percent = Math.min(
+        100,
+        Math.round((progress.timeProcessed / totalDuration) * 100)
+      );
+    }
+  }
+
+  // Parse speed=1.5x
+  const speedMatch = line.match(/speed=\s*([\d.]+)x/);
+  if (speedMatch) progress.speed = parseFloat(speedMatch[1]);
+
+  // Parse bitrate=1234kbits/s
+  const bitrateMatch = line.match(/bitrate=\s*([\d.]+)kbits\/s/);
+  if (bitrateMatch) progress.bitrate = parseFloat(bitrateMatch[1]);
+
+  // Parse size=  1234kB
+  const sizeMatch = line.match(/size=\s*(\d+)kB/);
+  if (sizeMatch) progress.size = parseInt(sizeMatch[1], 10) * 1024;
+
+  return progress;
+}
+
+/**
+ * Run FFmpeg command with spawn, supporting progress callbacks and cancellation
+ * @param {Object} options
+ * @param {string} options.command - The full FFmpeg command string
+ * @param {number} options.totalDuration - Expected output duration in seconds (for progress %)
+ * @param {Function} options.onProgress - Progress callback
+ * @param {AbortSignal} options.signal - AbortSignal for cancellation
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+function runFFmpeg({ command, totalDuration = 0, onProgress, signal }) {
+  return new Promise((resolve, reject) => {
+    // Parse command into args (simple split, assumes no quoted args with spaces in values)
+    // FFmpeg commands from this library don't have spaces in quoted paths handled this way
+    // We need to handle the command string properly
+    const args = parseFFmpegCommand(command);
+    const ffmpegPath = args.shift(); // Remove 'ffmpeg' from args
+
+    const proc = spawn(ffmpegPath, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let cancelled = false;
+
+    // Handle cancellation
+    if (signal) {
+      const abortHandler = () => {
+        cancelled = true;
+        proc.kill("SIGTERM");
+      };
+
+      if (signal.aborted) {
+        proc.kill("SIGTERM");
+        reject(new ExportCancelledError());
+        return;
+      }
+
+      signal.addEventListener("abort", abortHandler, { once: true });
+
+      proc.on("close", () => {
+        signal.removeEventListener("abort", abortHandler);
+      });
+    }
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data) => {
+      const chunk = data.toString();
+      stderr += chunk;
+
+      // Parse progress from stderr (FFmpeg outputs progress to stderr)
+      if (onProgress && typeof onProgress === "function") {
+        const progress = parseFFmpegProgress(chunk, totalDuration);
+        if (Object.keys(progress).length > 0) {
+          onProgress(progress);
+        }
+      }
+    });
+
+    proc.on("error", (error) => {
+      reject(
+        new FFmpegError(`FFmpeg process error: ${error.message}`, {
+          stderr,
+          command,
+        })
+      );
+    });
+
+    proc.on("close", (code) => {
+      if (cancelled) {
+        reject(new ExportCancelledError());
+        return;
+      }
+
+      if (code !== 0) {
+        reject(
+          new FFmpegError(`FFmpeg exited with code ${code}`, {
+            stderr,
+            command,
+            exitCode: code,
+          })
+        );
+        return;
+      }
+
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+/**
+ * Parse a command string into an array of arguments
+ * Handles quoted strings and escaped characters
+ */
+function parseFFmpegCommand(command) {
+  const args = [];
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+
+    if (inQuote) {
+      if (char === quoteChar) {
+        inQuote = false;
+        // Don't add the closing quote to the argument
+      } else {
+        current += char;
+      }
+    } else if (char === '"' || char === "'") {
+      inQuote = true;
+      quoteChar = char;
+      // Don't add the opening quote to the argument
+    } else if (char === " " || char === "\t") {
+      if (current.length > 0) {
+        args.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+
+  if (current.length > 0) {
+    args.push(current);
+  }
+
+  return args;
+}
+
+module.exports = {
+  formatBytes,
+  parseFFmpegTime,
+  parseFFmpegProgress,
+  runFFmpeg,
+  parseFFmpegCommand,
+};