simple-ffmpegjs 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-ffmpegjs",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Declarative video composition for Node.js — define clips, transitions, text, and audio as simple objects, and let FFmpeg handle the rest.",
   "author": "Brayden Blackwell <braydenblackwell21@gmail.com> (https://github.com/Fats403)",
   "license": "MIT",

package/src/core/validation.js

@@ -1,4 +1,5 @@
 const fs = require("fs");
+const nodePath = require("path");
 const { detectVisualGaps } = require("./gaps");
 
 // ========================================================================
@@ -118,6 +119,62 @@ const EFFECT_TYPES = [
   "letterbox",
 ];
 
+const VIDEO_EXTENSIONS = new Set([
+  ".mp4",
+  ".mov",
+  ".m4v",
+  ".mkv",
+  ".webm",
+  ".avi",
+  ".flv",
+  ".wmv",
+  ".mpg",
+  ".mpeg",
+  ".m2ts",
+  ".mts",
+  ".ts",
+  ".3gp",
+  ".ogv",
+]);
+
+const IMAGE_EXTENSIONS = new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".webp",
+  ".bmp",
+  ".tif",
+  ".tiff",
+  ".gif",
+  ".avif",
+]);
+
+function validateMediaUrlExtension(clip, clipPath, errors) {
+  if (typeof clip.url !== "string" || clip.url.length === 0) {
+    return;
+  }
+
+  if (clip.type !== "video" && clip.type !== "image") {
+    return;
+  }
+
+  const ext = nodePath.extname(clip.url).toLowerCase();
+  const expectedExts = clip.type === "video" ? VIDEO_EXTENSIONS : IMAGE_EXTENSIONS;
+  const expectedLabel = clip.type === "video" ? "video" : "image";
+  const oppositeLabel = clip.type === "video" ? "image" : "video";
+
+  if (!ext || !expectedExts.has(ext)) {
+    errors.push(
+      createIssue(
+        ValidationCodes.INVALID_FORMAT,
+        `${clipPath}.url`,
+        `URL extension '${ext || "(none)"}' does not match clip type '${clip.type}'. Expected a ${expectedLabel} file extension, not ${oppositeLabel}.`,
+        clip.url
+      )
+    );
+  }
+}
+
 function validateFiniteNumber(value, path, errors, opts = {}) {
   const { min = null, max = null, minInclusive = true, maxInclusive = true } = opts;
   if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -546,6 +603,8 @@ function validateClip(clip, index, options = {}) {
       } catch (_) {}
     }
 
+    validateMediaUrlExtension(clip, path, errors);
+
     if (typeof clip.cutFrom === "number") {
       if (!Number.isFinite(clip.cutFrom)) {
         errors.push(

package/src/ffmpeg/command_builder.js

@@ -1,5 +1,6 @@
 const os = require("os");
 const { escapeFilePath } = require("./strings");
+const { SimpleffmpegError } = require("../core/errors");
 
 /**
  * Get the null device path for the current platform
@@ -258,10 +259,62 @@ function escapeMetadata(value) {
     .replace(/\n/g, "\\n");
 }
 
+/**
+ * Sanitize a filter_complex string before passing it to FFmpeg.
+ *
+ * Guards against:
+ *  - Trailing semicolons that create empty filter chains (some FFmpeg builds
+ *    reject these with "No such filter: ''").
+ *  - Double (or more) semicolons that produce empty chains between real ones.
+ *  - Completely empty filter names between pad labels, e.g. "[a][b]" with no
+ *    filter name — detected and surfaced as a descriptive error.
+ */
+function sanitizeFilterComplex(fc) {
+  if (!fc || typeof fc !== "string") return fc;
+
+  // Collapse runs of semicolons (;;; → ;) that would produce empty chains
+  let sanitized = fc.replace(/;{2,}/g, ";");
+
+  // Strip leading/trailing semicolons
+  sanitized = sanitized.replace(/^;+/, "").replace(/;+$/, "");
+
+  // Detect empty filter names: a closing ']' immediately followed by an
+  // opening '[' with no filter name in between (at a chain boundary).
+  // Valid patterns like "[a][b]xfade=..." have a filter name after the
+  // second label. An empty name looks like "[a][b];" or "[a][b]," or
+  // "[a];[b]" at the very start of a chain.
+  //
+  // We check for the pattern: ';' followed by optional whitespace then '['
+  // where the preceding chain segment has no filter name.
+  // Also check for label sequences with no filter: "][" not followed by an
+  // alphanumeric filter name within the same chain segment.
+  const chains = sanitized.split(";");
+  for (let i = 0; i < chains.length; i++) {
+    const chain = chains[i].trim();
+    if (!chain) continue;
+
+    // Remove all pad labels to see if there's an actual filter name left
+    const withoutLabels = chain.replace(/\[[^\]]*\]/g, "").trim();
+    // After removing labels, what's left should start with a filter name
+    // (alphabetic). If it's empty or starts with ',' or '=' that means
+    // a filter name is missing.
+    if (withoutLabels.length === 0) {
+      throw new SimpleffmpegError(
+        `Empty filter name detected in filter_complex chain segment ${i}: "${chain}". ` +
+        `This usually means an effect or transition is not producing a valid FFmpeg filter. ` +
+        `Full filter_complex (truncated): "${sanitized.slice(0, 500)}..."`
+      );
+    }
+  }
+
+  return sanitized;
+}
+
 module.exports = {
   buildMainCommand,
   buildTextBatchCommand,
   buildThumbnailCommand,
   buildSnapshotCommand,
   escapeMetadata,
+  sanitizeFilterComplex,
 };

package/src/ffmpeg/effect_builder.js

@@ -155,6 +155,19 @@ function buildProcessedEffectFilter(effectClip, inputLabel, outputLabel) {
   );
 }
 
+/**
+ * Extract the FFmpeg filter name from a filter segment string.
+ * Expected format: "[inputLabel]filterName=params[outputLabel];"
+ * Returns the filter name or an empty string if it can't be found.
+ */
+function extractFilterName(filterSegment) {
+  // Strip leading pad labels like [fxsrc0]
+  const withoutLabels = filterSegment.replace(/\[[^\]]*\]/g, "");
+  // The filter name is the first word before '=' or ',' or ';' or end-of-string
+  const match = withoutLabels.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+  return match ? match[1] : "";
+}
+
 function buildEffectFilters(effectClips, inputLabel) {
   if (!Array.isArray(effectClips) || effectClips.length === 0) {
     return { filter: "", finalVideoLabel: inputLabel };
@@ -190,6 +203,20 @@ function buildEffectFilters(effectClips, inputLabel) {
       procSrcLabel,
       fxLabel
     );
+
+    // Safeguard: verify the filter builder produced a non-empty filter name.
+    // If any effect resolves to an empty filter (e.g. unsupported on the
+    // running FFmpeg version), FFmpeg would receive '' as a filter name and
+    // fail with "No such filter: ''".
+    const filterName = extractFilterName(fxFilter);
+    if (!filterName) {
+      throw new Error(
+        `Effect '${clip.effect}' produced an empty filter name. ` +
+        `This usually means the effect is not supported by the current FFmpeg version. ` +
+        `Generated filter segment: ${JSON.stringify(fxFilter)}`
+      );
+    }
+
     filter += fxFilter;
 
     const start = formatNumber(clip.position || 0, 4);
@@ -217,4 +244,4 @@ function buildEffectFilters(effectClips, inputLabel) {
   return { filter, finalVideoLabel: currentLabel };
 }
 
-module.exports = { buildEffectFilters };
+module.exports = { buildEffectFilters, extractFilterName };

package/src/simpleffmpeg.js

@@ -30,6 +30,7 @@ const {
   buildMainCommand,
   buildThumbnailCommand,
   buildSnapshotCommand,
+  sanitizeFilterComplex,
 } = require("./ffmpeg/command_builder");
 const { runTextPasses } = require("./ffmpeg/text_passes");
 const { formatBytes, runFFmpeg } = require("./lib/utils");
@@ -799,9 +800,12 @@ class SIMPLEFFMPEG {
 
       const wmConfig = exportOptions.watermark;
 
-      // For image watermarks, we need to add an input
+      // For image watermarks, we need to add an input.
+      // Use the actual file input count (from _inputIndexMap) rather than
+      // videoOrAudioClips.length, because flat color clips use the color=
+      // filter source and don't produce file inputs.
       if (wmConfig.type === "image" && wmConfig.url) {
-        watermarkInputIndex = this.videoOrAudioClips.length;
+        watermarkInputIndex = this._inputIndexMap.size;
         watermarkInputString = ` -i "${escapeFilePath(wmConfig.url)}"`;
       }
 
@@ -830,6 +834,12 @@ class SIMPLEFFMPEG {
       }
     }
 
+    // Sanitize the filter complex string before passing to FFmpeg.
+    // Remove trailing semicolons (which create empty filter chains on some
+    // FFmpeg builds) and collapse double semicolons that could result from
+    // concatenating builder outputs where one returned an empty string.
+    filterComplex = sanitizeFilterComplex(filterComplex);
+
     // Build command
     const command = buildMainCommand({
       inputs: this._getInputStreams() + watermarkInputString,