@poe-platform/safe-bash 0.1.845 → 0.1.846

package/dist/safe-bash-command-ffmpeg/index.js

@@ -23,7 +23,7 @@ import {
   sliceMp4,
   srtAst,
   webvttAst
-} from "../safe-bash/command-chunks/chunk-CMGVQM4Y.js";
+} from "../safe-bash/command-chunks/chunk-CSJHADNR.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-ffmpeg/src/index.ts
@@ -342,6 +342,26 @@ import {
   resizeImage,
   rotateImage
 } from "../image-ast/portable.js";
+function parseFrameRate(value) {
+  switch (value) {
+    case "ntsc":
+    case "qntsc":
+    case "sntsc":
+      return 3e4 / 1001;
+    case "pal":
+    case "qpal":
+    case "spal":
+      return 25;
+    case "film":
+      return 24;
+    case "ntsc-film":
+      return 24e3 / 1001;
+  }
+  const [numerator, denominator = "1", extra] = value.split("/");
+  if (extra !== void 0 || !numerator?.trim() || !denominator.trim()) return void 0;
+  const rate = Number(numerator) / Number(denominator);
+  return Number.isFinite(rate) && rate > 0 ? rate : void 0;
+}
 function loopToOutputEnd(doc, endSeconds, budget) {
   if (endSeconds === void 0 || !Number.isFinite(endSeconds)) {
     throw new Error("-stream_loop -1 requires a finite output -t or -to");
@@ -599,6 +619,7 @@ function* lavfiSteps(spec, budget, durationOverride) {
   };
 }
 async function ensureDecodedFrames(track, movieTimescale, budget, signal, maxFrames) {
+  if (maxFrames === 0) return [];
   const width = track.width ?? track.codecDescriptions[0]?.width ?? 64;
   const height = track.height ?? track.codecDescriptions[0]?.height ?? 64;
   const ts = track.timescale || 9e4;
@@ -668,6 +689,9 @@ function parseFilterExpression(expression, filter, variables) {
         }
         if (name === "not" && args.length === 1) value = Number(args[0] === 0);
         else if (name === "eq" && args.length === 2) value = Number(args[0] === args[1]);
+        else if (name === "gte" && args.length === 2) value = Number(args[0] >= args[1]);
+        else if (name === "lt" && args.length === 2) value = Number(args[0] < args[1]);
+        else if (name === "if" && args.length === 3) value = args[0] !== 0 ? args[1] : args[2];
         else if (name === "gt" && args.length === 2) value = Number(args[0] > args[1]);
         else if (name === "mod" && args.length === 2) value = args[0] - Math.floor(args[0] / args[1]) * args[1];
         else if (name === "between" && args.length === 3) value = Number(args[0] >= args[1] && args[0] <= args[2]);
@@ -854,10 +878,7 @@ async function renderBitmapTextToRgba(rgba, width, height, text, opts = {}, sign
   }
   return out;
 }
-async function applyVideoFilterChain(frames, filterChainStr, budget, subtitleCues, signal) {
-  let work = 0;
-  let current = frames;
-  if (current.length === 0) return current;
+function parseFilterChain(filterChainStr) {
   const filters = [];
   let filter = "";
   let quoted = false;
@@ -875,7 +896,13 @@ async function applyVideoFilterChain(frames, filterChainStr, budget, subtitleCue
     }
   }
   if (filter.trim()) filters.push(filter.trim());
-  for (const filterSpec of filters) {
+  return filters;
+}
+async function applyVideoFilterChain(frames, filterChainStr, budget, subtitleCues, signal) {
+  let work = 0;
+  let current = frames;
+  if (current.length === 0) return current;
+  for (const filterSpec of parseFilterChain(filterChainStr)) {
     if (++work % 1024 === 0) {
       await yieldTurn5(signal);
       signal?.throwIfAborted();
@@ -1464,7 +1491,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
       if (arg === "-y" || arg === "-n") {
         if (noOverwrite !== void 0 && noOverwrite !== (arg === "-n")) return void 0;
         noOverwrite = arg === "-n";
-      } else if (arg === "-v" || arg === "-loglevel" || arg === "-safe" || arg === "-threads" || arg === "-pix_fmt" || arg === "-preset" || arg === "-crf" || arg === "-b:v" || arg === "-b:a" || arg === "-bsf:v" || arg === "-bsf:a" || arg === "-tag:v" || arg === "-tag:a" || arg === "-vsync" || arg === "-fps_mode") i++;
+      } else if (arg === "-v" || arg === "-loglevel" || arg === "-safe" || arg === "-threads" || arg === "-pix_fmt" || arg === "-preset" || arg === "-crf" || arg === "-bf" || arg === "-b:v" || arg === "-b:a" || arg === "-bsf:v" || arg === "-bsf:a" || arg === "-tag:v" || arg === "-tag:a" || arg === "-vsync" || arg === "-fps_mode") i++;
       else if (arg === "-map_chapters") {
         const value = args[++i];
         chapterSource = value?.trim() ? Number(value) : NaN;
@@ -1502,7 +1529,8 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
         else outputDuration = val;
       } else if (arg === "-stream_loop") pendingLoop = parseInt(args[++i] ?? "0", 10) || 0;
       else if (arg === "-r" || arg === "-framerate") {
-        const val = parseFloat(args[++i] ?? "25") || 25;
+        const val = parseFrameRate(args[++i] ?? "");
+        if (val === void 0) return void 0;
         if (args.slice(i + 1).includes("-i")) pendingFps = val;
         else outputFps = val;
       } else if (arg === "-s") outputSize = args[++i];
@@ -1540,7 +1568,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
       else if (arg === "-vn") stripVideo = true;
       else if (arg === "-sn") stripSubtitles = true;
       else if (arg === "-shortest") shortest = true;
-      else if (arg === "-frames:v" || arg === "-vframes") maxVideoFrames = parseInt(args[++i] ?? "1", 10) || 1;
+      else if (arg === "-frames:v" || arg === "-vframes") maxVideoFrames = parseInt(args[++i] ?? "1", 10);
       else if (arg === "-frames:a" || arg === "-aframes") {
         const value = args[++i];
         maxAudioFrames = value?.trim() ? Number(value) : NaN;
@@ -1657,16 +1685,16 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
     if (isNullMux) return "";
     if (inputs.some((inp) => isStdin(inp.path)) && !inBytes) return void 0;
     if (!writeFileSync || !outputTarget || outputTarget.endsWith("/") || outputTarget.endsWith("/.") || outputTarget.includes("/./") || /(?:^|\/)\.\.(?:\/|$)/u.test(outputTarget)) return void 0;
-    if (/%0?\d*d/.test(outputTarget)) {
+    if (formatImageSequence(outputTarget, outputStartNumber ?? 1) !== void 0) {
       const outExt2 = outputTarget.split(".").pop()?.toLowerCase() ?? "png";
       const vTrack = workingDoc.tracks.find((t) => t.type === "video");
       if (vTrack && !vTrack.decodedVideoFrames) return void 0;
       const frames = vTrack?.decodedVideoFrames ?? [];
-      const limit = maxVideoFrames ? Math.min(frames.length, maxVideoFrames) : frames.length;
+      const limit = Math.min(frames.length, maxVideoFrames ?? Infinity);
       const imgFmt = outExt2 === "jpg" || outExt2 === "jpeg" ? "jpeg" : outExt2 === "webp" ? "webp" : outExt2 === "gif" ? "gif" : outExt2 === "bmp" ? "bmp" : outExt2 === "ppm" ? "ppm" : "png";
       for (let idx = 0; idx < limit; idx++) {
         const f = frames[idx];
-        const fileName = outputTarget.replace(/%0?(\d*)d/, (_, widthDigits) => String(idx + (outputStartNumber ?? 1)).padStart(parseInt(widthDigits || "0", 10) || 0, "0"));
+        const fileName = formatImageSequence(outputTarget, idx + (outputStartNumber ?? 1));
         const encoded = encodeImage(makeRgbaImg(f.width, f.height, f.data), { format: imgFmt }).data;
         if (!writeFileSync(fileName, encoded)) return void 0;
       }
@@ -1674,6 +1702,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
     }
     const outPlugin = outputFormat ? registry.findByFormatName(outputFormat) : registry.findByFilename(outputTarget);
     if (!outPlugin || !outPlugin.canMux || outPlugin.id === "dash" || outPlugin.id === "hls") return void 0;
+    if (outPlugin.id === "image2" && maxVideoFrames === 0) return "";
     const outExt = outputTarget.split(".").pop()?.toLowerCase();
     const serializedBytes = outPlugin.serialize(workingDoc, { audioCodec, format: outputFormat ?? outExt, faststart, fragmented, metadata: metaTags, budget });
     if (isStdout(outputTarget)) return void 0;
@@ -1683,6 +1712,81 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
     return void 0;
   }
 }
+function formatImageSequence(pattern, number) {
+  let filename = "";
+  let numbered = false;
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== "%") {
+      filename += pattern[i];
+      continue;
+    }
+    i++;
+    if (pattern[i] === "%") {
+      filename += "%";
+      continue;
+    }
+    let width = 0;
+    while (i < pattern.length && pattern[i] >= "0" && pattern[i] <= "9") {
+      width = width * 10 + Number(pattern[i]);
+      i++;
+    }
+    if (pattern[i] !== "d") return void 0;
+    filename += String(number).padStart(width, "0");
+    numbered = true;
+  }
+  return numbered ? filename : void 0;
+}
+function matchesImageGlob(pattern, name, budget) {
+  const characters = Array.from(name);
+  let positions = /* @__PURE__ */ new Set([0]);
+  for (let i = 0; i < pattern.length; i++) {
+    budget.checkCpu();
+    const token = pattern[i];
+    const next = /* @__PURE__ */ new Set();
+    if (token === "*") {
+      let start = characters.length;
+      for (const p of positions) start = Math.min(start, p);
+      for (let p = start; p <= characters.length; p++) next.add(p);
+    } else {
+      let literal = token;
+      let contents;
+      if (token === "\\") literal = pattern[++i] ?? "\\";
+      if (token === "[") {
+        let end = i + 1;
+        if (pattern[end] === "!" || pattern[end] === "^") end++;
+        if (pattern[end] === "]") end++;
+        while (end < pattern.length && pattern[end] !== "]") end++;
+        if (end < pattern.length) {
+          contents = pattern.slice(i + 1, end);
+          i = end;
+        }
+      }
+      for (const p of positions) {
+        budget.checkCpu();
+        const character = characters[p];
+        if (character === void 0) continue;
+        let matches = token === "?" || character === literal;
+        if (contents !== void 0) {
+          const negated = contents[0] === "!" || contents[0] === "^";
+          let included = false;
+          for (let c = negated ? 1 : 0; c < contents.length; c++) {
+            let start = contents[c];
+            if (start === "\\" && c + 1 < contents.length) start = contents[++c];
+            if (contents[c + 1] === "-" && c + 2 < contents.length) {
+              included ||= character >= start && character <= contents[c + 2];
+              c += 2;
+            } else included ||= character === start;
+          }
+          matches = negated ? !included : included;
+        }
+        if (matches) next.add(p + 1);
+      }
+    }
+    positions = next;
+    if (positions.size === 0) return false;
+  }
+  return positions.has(characters.length);
+}
 function createFfmpegCommand(options = {}) {
   const astPlugins = options.asts ?? allMediaAsts();
   const registry = createMediaAstRegistry(astPlugins);
@@ -1716,14 +1820,20 @@ function createFfmpegCommand(options = {}) {
       }
       const inputs = [];
       let pendingFormat;
+      let pendingSafe;
       let pendingAudioDecoder;
       let pendingSs;
       let pendingTo;
       let pendingDuration;
       let pendingLoop;
+      let pendingImageLoop;
       let pendingFps;
       let pendingStartNumber;
+      let pendingStartNumberRange;
+      let pendingPatternType;
       let overwrite;
+      let exitOnError = false;
+      let inputReadFailed = false;
       let filterComplex;
       const outputs = [];
       const inputBytes = /* @__PURE__ */ new Map();
@@ -1739,6 +1849,8 @@ function createFfmpegCommand(options = {}) {
       let i = 0;
       while (i < args.length) {
         let outputStartNumber;
+        let updateImage = false;
+        let framePts = false;
         let outputFormat;
         let outputSs;
         let outputTo;
@@ -1784,8 +1896,19 @@ function createFfmpegCommand(options = {}) {
               return { exitCode: 234 };
             }
             overwrite = arg === "-y";
-          } else if (arg === "-v" || arg === "-loglevel" || arg === "-safe" || arg === "-threads" || arg === "-pix_fmt" || arg === "-preset" || arg === "-crf" || arg === "-b:v" || arg === "-b:a" || arg === "-bsf:v" || arg === "-bsf:a" || arg === "-tag:v" || arg === "-tag:a" || arg === "-update" || arg === "-loop") {
+          } else if (arg === "-xerror") {
+            exitOnError = true;
+          } else if (arg === "-safe") {
+            const value = args[++i];
+            if (value !== "0" && value !== "1") {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: -safe must be 0 or 1\n"), context.signal);
+              return { exitCode: 1 };
+            }
+            pendingSafe = value === "1";
+          } else if (arg === "-v" || arg === "-loglevel" || arg === "-threads" || arg === "-pix_fmt" || arg === "-preset" || arg === "-crf" || arg === "-bf" || arg === "-b:v" || arg === "-b:a" || arg === "-bsf:v" || arg === "-bsf:a" || arg === "-tag:v" || arg === "-tag:a") {
             i++;
+          } else if (arg === "-update") {
+            updateImage = args[++i] === "1";
           } else if (arg === "-vsync" || arg === "-fps_mode") {
             videoSync = args[++i] ?? "";
           } else if (arg === "-hls_time" || arg === "-seg_duration") {
@@ -1837,6 +1960,20 @@ function createFfmpegCommand(options = {}) {
               await writeBytes(context.stderr, encodeUtf8("ffmpeg: invalid metadata input index\n"), context.signal);
               return { exitCode: 1 };
             }
+          } else if (arg === "-frame_pts") {
+            const value = args[++i];
+            if (value !== "0" && value !== "1") {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: invalid frame_pts\n"), context.signal);
+              return { exitCode: 1 };
+            }
+            framePts = value === "1";
+          } else if (arg === "-start_number_range") {
+            const value = Number(args[++i]);
+            if (!Number.isInteger(value) || value < 1 || value > 2147483647) {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: invalid start_number_range\n"), context.signal);
+              return { exitCode: 1 };
+            }
+            pendingStartNumberRange = value;
           } else if (arg === "-start_number") {
             const val = Number(args[++i]);
             if (!Number.isSafeInteger(val) || val < 0) {
@@ -1886,10 +2023,29 @@ function createFfmpegCommand(options = {}) {
             } else {
               outputDuration = val;
             }
+          } else if (arg === "-pattern_type") {
+            const value = args[++i];
+            if (value !== "glob" && value !== "none" && value !== "sequence") {
+              await writeBytes(context.stderr, encodeUtf8(`ffmpeg: Invalid image2 pattern type: ${value ?? ""}
+`), context.signal);
+              return { exitCode: 1 };
+            }
+            pendingPatternType = value;
+          } else if (arg === "-loop") {
+            const value = args[++i];
+            if (value !== "0" && value !== "1") {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: -loop must be 0 or 1\n"), context.signal);
+              return { exitCode: 1 };
+            }
+            pendingImageLoop = value === "1";
           } else if (arg === "-stream_loop") {
             pendingLoop = parseInt(args[++i] ?? "0", 10) || 0;
           } else if (arg === "-r" || arg === "-framerate") {
-            const val = parseFloat(args[++i] ?? "25") || 25;
+            const val = parseFrameRate(args[++i] ?? "");
+            if (val === void 0) {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: Invalid framerate\n"), context.signal);
+              return { exitCode: 1 };
+            }
             if (args.slice(i + 1).includes("-i")) {
               pendingFps = val;
             } else {
@@ -1908,20 +2064,28 @@ function createFfmpegCommand(options = {}) {
             inputs.push({
               path,
               format: pendingFormat,
+              safe: pendingSafe,
               startSeconds: pendingSs,
               endSeconds: pendingTo,
               durationSeconds: pendingDuration,
               streamLoop: pendingLoop,
+              imageLoop: pendingImageLoop,
               fps: pendingFps,
-              startNumber: pendingStartNumber
+              startNumber: pendingStartNumber,
+              patternType: pendingPatternType,
+              startNumberRange: pendingStartNumberRange
             });
             pendingFormat = void 0;
+            pendingSafe = void 0;
             pendingSs = void 0;
             pendingTo = void 0;
             pendingDuration = void 0;
             pendingLoop = void 0;
+            pendingImageLoop = void 0;
             pendingFps = void 0;
             pendingStartNumber = void 0;
+            pendingStartNumberRange = void 0;
+            pendingPatternType = void 0;
           } else if (arg === "-c" || arg === "-codec") {
             const val = args[++i];
             videoCodec = val;
@@ -1943,7 +2107,7 @@ function createFfmpegCommand(options = {}) {
           } else if (arg === "-shortest") {
             shortest = true;
           } else if (arg === "-frames:v" || arg === "-vframes") {
-            maxVideoFrames = parseInt(args[++i] ?? "1", 10) || 1;
+            maxVideoFrames = parseInt(args[++i] ?? "1", 10);
           } else if (arg === "-frames:a" || arg === "-aframes") {
             const value = args[++i];
             maxAudioFrames = value?.trim() ? Number(value) : NaN;
@@ -2063,16 +2227,41 @@ function createFfmpegCommand(options = {}) {
                 }
                 return concatMp4(docs, { limits: options.limits, budget });
               }
-              if (/%0?\d*d/.test(filePath)) {
+              let globPaths;
+              if (input?.patternType === "glob") {
+                globPaths = ["/"];
+                for (const component of resolvePath(context.cwd, filePath).split("/").filter(Boolean)) {
+                  const matches = [];
+                  for (const directory of globPaths) {
+                    budget.checkCpu();
+                    context.signal.throwIfAborted();
+                    let entries;
+                    try {
+                      entries = await context.fs.readdir(directory, { signal: context.signal });
+                    } catch (error) {
+                      rethrowRuntimeError(context, error);
+                      if (["ENOENT", "ENOTDIR"].includes(error.code ?? "")) continue;
+                      throw error;
+                    }
+                    for (const entry of entries) {
+                      budget.checkCpu();
+                      if (entry.name.startsWith(".") && !component.startsWith(".") && !component.startsWith("\\.")) continue;
+                      if (matchesImageGlob(component, entry.name, budget)) matches.push(resolvePath(directory, entry.name));
+                    }
+                  }
+                  globPaths = matches;
+                }
+                globPaths.sort();
+              }
+              if (globPaths || input?.patternType !== "none" && formatImageSequence(filePath, input?.startNumber ?? 0) !== void 0) {
                 const frames = [];
                 const fps = fpsHint ?? 25;
-                for (let idx = input?.startNumber ?? 0; ; idx++) {
+                const startNumber = input?.startNumber ?? 0;
+                const startNumberRange = input?.startNumberRange ?? 5;
+                for (let idx = globPaths ? 0 : startNumber; !globPaths || idx < globPaths.length; idx++) {
                   budget.checkCpu();
                   context.signal.throwIfAborted();
-                  const formatted = filePath.replace(/%0?(\d*)d/, (_, widthDigits) => {
-                    const padLen = parseInt(widthDigits || "0", 10) || 0;
-                    return String(idx).padStart(padLen, "0");
-                  });
+                  const formatted = globPaths ? globPaths[idx] : formatImageSequence(filePath, idx);
                   const resolved = resolvePath(context.cwd, formatted);
                   let imgBytes;
                   try {
@@ -2080,7 +2269,8 @@ function createFfmpegCommand(options = {}) {
                   } catch (error) {
                     rethrowRuntimeError(context, error);
                     if (error.code !== "ENOENT") throw error;
-                    if (idx === 0 && input?.startNumber === void 0) continue;
+                    if (globPaths) throw error;
+                    if (frames.length === 0 && idx - startNumber < startNumberRange - 1) continue;
                     break;
                   }
                   {
@@ -2119,27 +2309,76 @@ function createFfmpegCommand(options = {}) {
                 detachBytesBuffer(synthBytes);
                 return {
                   ...base,
+                  duration: Math.round(frames.length / fps * base.timescale),
+                  durationSeconds: frames.length / fps,
                   tracks: base.tracks.map(
-                    (t) => t.type === "video" ? { ...t, width: first.width, height: first.height, samples: [], decodedVideoFrames: frames } : t
+                    (t) => t.type === "video" ? { ...t, width: first.width, height: first.height, duration: Math.round(frames.length / fps * t.timescale), samples: [], decodedVideoFrames: frames } : t
                   )
                 };
               }
               const rawBytes = await readInput(filePath);
-              if (explicitFormat === "concat") {
+              const concatSignature = "ffconcat version 1.0";
+              if (explicitFormat === "concat" || explicitFormat === void 0 && new TextDecoder("utf-8", { ignoreBOM: true }).decode(rawBytes.subarray(0, concatSignature.length)) === concatSignature) {
                 const listText = new TextDecoder().decode(rawBytes);
                 const listDir = filePath === "-" ? context.cwd : dirnameOf(resolvePath(context.cwd, filePath));
                 const concatDocs = [];
+                const startTimesSeconds = [];
+                let nextStartSeconds = 0;
+                const segments = [];
                 let currentInpoint;
                 let currentOutpoint;
                 let currentDuration;
                 const lines = listText.split(/\r?\n/);
                 for (let l = 0; l < lines.length; l++) {
-                  const line = lines[l].trim();
-                  if (!line || line.startsWith("#") || line.startsWith("ffconcat")) continue;
-                  if (line.startsWith("file ")) {
-                    let target2 = line.slice(5).trim();
-                    if (target2.startsWith("'") && target2.endsWith("'") || target2.startsWith('"') && target2.endsWith('"')) {
-                      target2 = target2.slice(1, -1);
+                  const line = lines[l].trimStart();
+                  if (!line || line.startsWith("#")) continue;
+                  const keyword = line.split(/[ \t]/, 1)[0];
+                  if (keyword === "option" && input?.safe !== false) {
+                    throw new Error(`Line ${l + 1}: option not allowed if safe`);
+                  }
+                  if (keyword === "ffconcat") {
+                    const [, declaration, version] = line.split("	").join(" ").split(" ").filter(Boolean);
+                    if (declaration !== "version" || version !== "1.0") {
+                      throw new Error(`Line ${l + 1}: invalid version`);
+                    }
+                    continue;
+                  }
+                  if (segments.length === 0) {
+                    const directive = ["duration", "inpoint", "outpoint"].find(
+                      (name) => line === name || line.startsWith(`${name} `) || line.startsWith(`${name}	`)
+                    );
+                    if (directive) throw new Error(`Line ${l + 1}: ${directive} without file`);
+                  }
+                  if (keyword === "file") {
+                    let target2 = "";
+                    let protectedEnd = 0;
+                    let cursor = keyword.length;
+                    const whitespace = " 	\r\n";
+                    while (cursor < line.length && whitespace.includes(line[cursor])) cursor++;
+                    while (cursor < line.length && !whitespace.includes(line[cursor])) {
+                      const char = line[cursor++];
+                      if (char === "\\" && cursor < line.length) {
+                        target2 += line[cursor++];
+                        protectedEnd = target2.length;
+                      } else if (char === "'") {
+                        while (cursor < line.length && line[cursor] !== "'") target2 += line[cursor++];
+                        if (cursor < line.length) {
+                          cursor++;
+                          protectedEnd = target2.length;
+                        }
+                      } else {
+                        target2 += char;
+                      }
+                    }
+                    while (target2.length > protectedEnd && whitespace.includes(target2[target2.length - 1])) {
+                      target2 = target2.slice(0, -1);
+                    }
+                    if (input?.safe !== false && target2.split("/").some(
+                      (component) => !component || component.startsWith(".") || Array.from(component).some(
+                        (char) => !(char >= "a" && char <= "z") && !(char >= "A" && char <= "Z") && !(char >= "0" && char <= "9") && char !== "_" && char !== "-" && char !== "."
+                      )
+                    )) {
+                      throw new Error(`Unsafe file name '${target2}'`);
                     }
                     const resolvedItem = resolvePath(listDir, target2);
                     currentInpoint = void 0;
@@ -2147,32 +2386,66 @@ function createFfmpegCommand(options = {}) {
                     currentDuration = void 0;
                     while (l + 1 < lines.length) {
                       const nextLine = lines[l + 1].trim();
-                      if (nextLine.startsWith("inpoint ")) {
-                        currentInpoint = parseFfmpegTimestamp(nextLine.slice(8));
+                      if (!nextLine || nextLine.startsWith("#")) {
                         l++;
-                      } else if (nextLine.startsWith("outpoint ")) {
-                        currentOutpoint = parseFfmpegTimestamp(nextLine.slice(9));
-                        l++;
-                      } else if (nextLine.startsWith("duration ")) {
-                        currentDuration = parseFfmpegTimestamp(nextLine.slice(9));
+                      } else if (["inpoint", "outpoint", "duration"].includes(nextLine.split(/[ \t]/, 1)[0])) {
+                        const directive = nextLine.split(/[ \t]/, 1)[0];
+                        const value = nextLine.slice(directive.length).trim();
+                        if (!/^-?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:s|ms|us)?|(?:\d+:)?[0-5]?\d:[0-5]?\d(?:\.\d*)?)$/.test(value)) {
+                          throw new Error(`Line ${l + 2}: invalid ${directive} '${value}'`);
+                        }
+                        const seconds = value.startsWith("-") ? -parseFfmpegTimestamp(value.slice(1)) : parseFfmpegTimestamp(value);
+                        if (!Number.isFinite(seconds) || Math.abs(seconds) >= 2 ** 63 / 1e6) {
+                          throw new Error(`Line ${l + 2}: invalid ${directive} '${value}'`);
+                        }
+                        if (directive === "inpoint") currentInpoint = seconds;
+                        else if (directive === "outpoint") currentOutpoint = seconds;
+                        else currentDuration = seconds;
                         l++;
                       } else {
                         break;
                       }
                     }
-                    let itemDoc = await loadSingleDocument(resolvedItem);
-                    if (currentInpoint !== void 0 || currentOutpoint !== void 0 || currentDuration !== void 0) {
-                      itemDoc = sliceMp4(itemDoc, {
-                        startSeconds: currentInpoint,
-                        endSeconds: currentOutpoint,
-                        durationSeconds: currentDuration
-                      });
+                    if (currentInpoint !== void 0 && currentOutpoint !== void 0 && currentOutpoint < currentInpoint) {
+                      throw new Error(`${resolvedItem}: outpoint must not precede inpoint`);
                     }
-                    concatDocs.push(itemDoc);
+                    segments.push({ path: resolvedItem, inpoint: currentInpoint, outpoint: currentOutpoint, duration: currentDuration });
+                  } else {
+                    throw new Error(`Line ${l + 1}: unknown keyword '${keyword}'`);
+                  }
+                }
+                budget.checkConcatInputs(segments.length);
+                for (const segment of segments) {
+                  let itemDoc;
+                  try {
+                    itemDoc = await loadSingleDocument(segment.path);
+                  } catch (error) {
+                    rethrowRuntimeError(context, error);
+                    if (error.code !== "ENOENT" || !concatDocs.some((doc) => doc.tracks.some((track) => track.samples.length > 0))) throw error;
+                    await writeBytes(context.stderr, encodeUtf8(`ffmpeg: Impossible to open '${segment.path}': No such file or directory
+`), context.signal);
+                    inputReadFailed = true;
+                    break;
+                  }
+                  let sliceEnd = segment.outpoint;
+                  const wavTrack = itemDoc.containerFormat === "wav" ? itemDoc.tracks[0] : void 0;
+                  const packetFrames = wavTrack?.samples[0]?.duration;
+                  if (sliceEnd !== void 0 && wavTrack && packetFrames) {
+                    const start = Math.max(0, segment.inpoint ?? 0);
+                    const packets = Math.ceil(Math.max(0, sliceEnd - start) * wavTrack.timescale / packetFrames);
+                    sliceEnd = start + packets * packetFrames / wavTrack.timescale;
                   }
+                  if (segment.inpoint !== void 0 || segment.outpoint !== void 0) {
+                    itemDoc = sliceMp4(itemDoc, {
+                      startSeconds: segment.inpoint,
+                      endSeconds: sliceEnd
+                    });
+                  }
+                  startTimesSeconds.push(nextStartSeconds);
+                  nextStartSeconds += segment.duration ?? itemDoc.durationSeconds;
+                  concatDocs.push(itemDoc);
                 }
-                budget.checkConcatInputs(concatDocs.length);
-                return concatMp4(concatDocs, { limits: options.limits, budget });
+                return concatMp4(concatDocs, { startTimesSeconds, limits: options.limits, budget });
               }
               const plugin = explicitFormat !== void 0 ? registry.findByFormatName(explicitFormat) : registry.detect(rawBytes, filePath);
               if (!plugin || !plugin.canDemux) {
@@ -2193,6 +2466,38 @@ function createFfmpegCommand(options = {}) {
               await yieldTurn5(context.signal);
               context.signal.throwIfAborted();
               let doc = await loadSingleDocument(inp.path, inp.format, inp.fps, inp);
+              if (inp.imageLoop) {
+                const fps = inp.fps ?? 25;
+                const endSeconds = Math.min(
+                  inp.durationSeconds !== void 0 ? (inp.startSeconds ?? 0) + inp.durationSeconds : inp.endSeconds ?? Infinity,
+                  (inp.startSeconds ?? 0) + (outputDuration !== void 0 ? (outputSs ?? 0) + outputDuration : outputTo ?? Infinity),
+                  maxVideoFrames !== void 0 ? (inp.startSeconds ?? 0) + (outputSs ?? 0) + maxVideoFrames / (outputFps ?? fps) : Infinity
+                );
+                if (!Number.isFinite(endSeconds)) {
+                  throw new Error("-loop 1 requires a finite frame count or duration");
+                }
+                budget.checkDuration(endSeconds);
+                const frameCount = Math.max(0, Math.ceil(endSeconds * fps));
+                doc = {
+                  ...doc,
+                  duration: Math.round(frameCount / fps * doc.timescale),
+                  durationSeconds: frameCount / fps,
+                  tracks: await mapWork(doc.tracks, async (track) => {
+                    if (track.type !== "video") return track;
+                    const source = track.decodedVideoFrames;
+                    if (!source?.length) throw new Error("-loop requires decoded image input");
+                    const frames = [];
+                    for (let index = 0; index < frameCount; index++) {
+                      if (index % 64 === 0) await yieldTurn5(context.signal);
+                      context.signal.throwIfAborted();
+                      const frame = source[index % source.length];
+                      budget.recordFrame(frame.width, frame.height);
+                      frames.push({ ...frame, ptsSeconds: index / fps, durationSeconds: 1 / fps });
+                    }
+                    return { ...track, duration: Math.round(frameCount / fps * track.timescale), samples: [], decodedVideoFrames: frames };
+                  }, context.signal)
+                };
+              }
               if (inp.startSeconds !== void 0 || inp.endSeconds !== void 0 || inp.durationSeconds !== void 0) {
                 doc = sliceMp4(doc, {
                   startSeconds: inp.startSeconds,
@@ -2631,7 +2936,7 @@ To ignore this, add a trailing '?' to the map.
                   const origRate = audio.sampleRate;
                   const origCh = audio.channels;
                   const targetRate = audioRate ?? origRate;
-                  const targetCh = audioChannels ?? origCh;
+                  const targetCh = audioChannels === -1 ? origCh : audioChannels ?? origCh;
                   const channelMask = audio.channelMask;
                   const surroundMono = origCh === 6 && targetCh === 1;
                   const monoStereo = origCh === 1 && (targetCh === 2 || targetCh === 3);
@@ -2643,32 +2948,80 @@ To ignore this, add a trailing '?' to the map.
                   const volFactor = t.volume ?? 1;
                   let stretched = audio.channelData;
                   if (filter) {
-                    for (const item of filter.expression.split(",")) {
+                    for (const item of parseFilterChain(filter.expression)) {
                       if (++work % 1024 === 0) {
                         await yieldTurn5(context.signal);
                         context.signal?.throwIfAborted();
                       }
-                      const trimmed = item.trim();
-                      if (trimmed.startsWith("volume=")) {
-                        const volSpec = trimmed.slice("volume=".length).trim();
+                      let trimmed = item.trim();
+                      const equals = trimmed.indexOf("=");
+                      const instance = trimmed.indexOf("@");
+                      if (instance >= 0 && (equals < 0 || instance < equals)) {
+                        trimmed = trimmed.slice(0, instance) + (equals < 0 ? "" : trimmed.slice(equals));
+                      }
+                      if (trimmed === "anull") continue;
+                      if (trimmed === "volume" || trimmed.startsWith("volume=")) {
+                        const argument = trimmed === "volume" ? "1" : trimmed.slice("volume=".length).trim();
+                        let volSpec = "1";
+                        let precision = "float";
+                        let evaluation = "once";
+                        let enable;
+                        for (const [index, option] of argument.split(":").entries()) {
+                          const separator = option.indexOf("=");
+                          const key = separator < 0 ? ["volume", "precision", "eval"][index] ?? "" : option.slice(0, separator).trim();
+                          const value = separator < 0 ? option.trim() : option.slice(separator + 1).trim();
+                          if (key === "volume") volSpec = value;
+                          else if (key === "precision") precision = value;
+                          else if (key === "eval") evaluation = value;
+                          else if (key === "enable") enable = value;
+                          else throw new Error(`volume: unsupported option ${key}`);
+                        }
+                        if (!["fixed", "float", "double"].includes(precision)) throw new Error("volume: invalid precision");
+                        if (evaluation !== "once" && evaluation !== "frame") throw new Error("volume: invalid eval");
                         const decibels = volSpec.endsWith("dB");
-                        const gain = parseFilterExpression(decibels ? volSpec.slice(0, -2) : volSpec, "volume", {});
-                        const factor = decibels ? Math.pow(10, gain / 20) : gain;
-                        if (!Number.isFinite(factor)) throw new Error("volume: invalid gain");
-                        stretched = await mapWork(stretched, async (channel) => {
-                          const output = new Float32Array(channel.length);
-                          for (let i2 = 0; i2 < channel.length; i2++) {
-                            if (++work % 1024 === 0) {
-                              await yieldTurn5(context.signal);
-                              context.signal?.throwIfAborted();
+                        const output = stretched.map((channel) => new Float32Array(channel.length));
+                        const length = stretched[0]?.length ?? 0;
+                        const sampleScale = t.codecDescriptions[0]?.codecName === "pcm_s16le" ? 32768 : 2147483648;
+                        for (let start = 0, n = 0; start < length; n++) {
+                          const packet = t.samples[n];
+                          const count = packet ? Math.max(1, Math.round(packet.duration * origRate / t.timescale)) : 1024;
+                          const end = evaluation === "once" && enable === void 0 ? length : Math.min(length, start + count);
+                          const variables = { sample_rate: origRate, nb_channels: origCh, tb: 1 / origRate };
+                          if (evaluation === "frame") Object.assign(variables, {
+                            n,
+                            t: packet ? packet.pts / t.timescale : start / origRate,
+                            pts: packet ? packet.pts * origRate / t.timescale : start,
+                            nb_samples: end - start,
+                            nb_consumed_samples: start
+                          });
+                          const gain = parseFilterExpression(decibels ? volSpec.slice(0, -2) : volSpec, "volume", variables);
+                          const factor = decibels ? Math.pow(10, gain / 20) : gain;
+                          if (!Number.isFinite(factor)) throw new Error("volume: invalid gain");
+                          const fixedGain = Math.floor(factor * 256 + 0.5);
+                          const enabled = enable === void 0 || parseFilterExpression(enable, "volume enable", {
+                            n,
+                            t: packet ? packet.pts / t.timescale : start / origRate
+                          }) !== 0;
+                          for (let c = 0; c < stretched.length; c++) {
+                            const channel = stretched[c];
+                            for (let i2 = start; i2 < end; i2++) {
+                              if (++work % 1024 === 0) {
+                                await yieldTurn5(context.signal);
+                                context.signal?.throwIfAborted();
+                              }
+                              output[c][i2] = !enabled ? channel[i2] : precision === "fixed" ? Math.max(-sampleScale, Math.min(
+                                sampleScale - 1,
+                                Math.floor((channel[i2] * sampleScale * fixedGain + 128) / 256)
+                              )) / sampleScale : channel[i2] * (precision === "float" ? Math.fround(factor) : factor);
                             }
-                            output[i2] = channel[i2] * factor;
                           }
-                          return output;
-                        }, context.signal);
-                      } else if (trimmed.startsWith("atempo=")) {
-                        const tempo = Number(trimmed.slice(7));
-                        if (!Number.isFinite(tempo) || tempo < 0.5 || tempo > 100) {
+                          start = end;
+                        }
+                        stretched = output;
+                      } else if (trimmed === "atempo" || trimmed.startsWith("atempo=")) {
+                        const argument = trimmed === "atempo" ? "1" : trimmed.slice("atempo=".length).trim();
+                        const tempo = parseFilterExpression(argument.startsWith("tempo=") ? argument.slice("tempo=".length) : argument, "atempo", {});
+                        if (tempo < 0.5 || tempo > 100) {
                           throw new Error("atempo must be in the range [0.5, 100]");
                         }
                         stretched = tempo === 1 ? await filterUnityTempo(stretched, origRate, t.codecDescriptions[0]?.codecName === "pcm_s16le", budget, context.signal) : await stretchAudio(stretched, origRate, tempo, budget, context.signal);
@@ -2876,10 +3229,15 @@ To ignore this, add a trailing '?' to the map.
               options.onMetrics?.(budget.getStats());
               return { exitCode: 0 };
             }
+            if (imageOutput && maxVideoFrames === 0) {
+              options.onMetrics?.(budget.getStats());
+              return { exitCode: 0 };
+            }
             if (imageOutput && !workingDoc.tracks.some((track) => track.type === "video" && track.decodedVideoFrames?.length)) {
               throw new Error("No video frame in the requested presentation interval");
             }
-            if (/%0?\d*d/.test(outputTarget2)) {
+            const numberedImageOutput = formatImageSequence(outputTarget2, outputStartNumber ?? 1) !== void 0;
+            if (imageOutput && !isStdout(outputTarget2) || numberedImageOutput) {
               const outExt2 = outputTarget2.split(".").pop()?.toLowerCase() ?? "png";
               const imgPlugin = registry.findByFilename(`x.${outExt2}`);
               if (!imgPlugin || !imgPlugin.canMux) {
@@ -2901,15 +3259,16 @@ To ignore this, add a trailing '?' to the map.
                 const previousCopies = constantRate && delta0 > 1.1 ? Math.max(0, Math.round(delta0 - 0.6)) : 0;
                 if (!Number.isSafeInteger(copies)) throw new Error("Invalid output frame timestamp");
                 for (let copy = 0; copy < copies && idx < limit; copy++, idx++, nextPts++) {
+                  if (idx > 0 && !numberedImageOutput && !updateImage) {
+                    throw new Error("Cannot write more than one file with the same name. Use a numbered pattern or -update 1.");
+                  }
                   budget.checkCpu();
                   budget.checkSamples(idx + 1);
                   budget.checkDuration((idx + 1) * duration);
                   const f = copy < previousCopies && sourceIndex > 0 ? frames[sourceIndex - 1] : source;
                   if (copy > 0) budget.recordFrame(f.width, f.height);
-                  const fileName = outputTarget2.replace(/%0?(\d*)d/, (_, widthDigits) => {
-                    const padLen = parseInt(widthDigits || "0", 10) || 0;
-                    return String(idx + (outputStartNumber ?? 1)).padStart(padLen, "0");
-                  });
+                  const number = framePts ? Math.round(constantRate ? nextPts : source.ptsSeconds / duration) : idx + (outputStartNumber ?? 1);
+                  const fileName = updateImage ? outputTarget2 : formatImageSequence(outputTarget2, number) ?? outputTarget2;
                   const fullOutPath = resolvePath(context.cwd, fileName);
                   const encoded = (await yieldTurn5(context.signal), context.signal?.throwIfAborted(), encodeImage(makeRgbaImg(f.width, f.height, f.data), {
                     format: imgFmt
@@ -2985,7 +3344,7 @@ To ignore this, add a trailing '?' to the map.
         const result = await output();
         if (result.exitCode !== 0) return result;
       }
-      return { exitCode: 0 };
+      return { exitCode: exitOnError && inputReadFailed ? 1 : 0 };
     }
   };
 }