@poe-platform/safe-bash 0.1.803 → 0.1.804

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

@@ -1,4 +1,4 @@
-import "../safe-bash/command-chunks/chunk-AJR3AQYA.js";
+import "../safe-bash/command-chunks/chunk-UKX3LZHR.js";
 import {
   decodeImage,
   encodeImage,
@@ -10,7 +10,7 @@ import {
   negateImage,
   resizeImage,
   rotateImage
-} from "../safe-bash/command-chunks/chunk-YG4EPFWC.js";
+} from "../safe-bash/command-chunks/chunk-M3NINRDU.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
@@ -1385,7 +1385,7 @@ function buildH264SpsPps(width, height, fps = 30) {
   pps.set(ppsRbsp, 1);
   return { sps, pps };
 }
-function encodeH264IdrFrame(rgba, width, height, frameIndex = 0) {
+function encodeH264IdrFrame(rgba, width, height, frameIndex = 0, refBuffer) {
   const mbWidth = Math.max(1, Math.ceil(width / 16));
   const mbHeight = Math.max(1, Math.ceil(height / 16));
   const paddedWidth = mbWidth * 16;
@@ -1408,6 +1408,96 @@ function encodeH264IdrFrame(rgba, width, height, frameIndex = 0) {
   }
   const { y: yPlane, u: uPlane, v: vPlane } = rgbaToYuv420p(paddedRgba, paddedWidth, paddedHeight);
   const uvWidth = paddedWidth >>> 1;
+  const gopPos = frameIndex % 24;
+  if (refBuffer && gopPos !== 0 && refBuffer.y?.byteLength === yPlane.byteLength && refBuffer.u?.byteLength === uPlane.byteLength && refBuffer.v?.byteLength === vPlane.byteLength) {
+    const refY = refBuffer.y;
+    const refU = refBuffer.u;
+    const refV = refBuffer.v;
+    const pBits = new BitWriter();
+    pBits.writeUE(0);
+    pBits.writeUE(5);
+    pBits.writeUE(0);
+    pBits.writeBits(gopPos & 15, 4);
+    pBits.writeBits(gopPos * 2 & 15, 4);
+    pBits.writeBit(0);
+    pBits.writeBit(0);
+    pBits.writeBit(0);
+    pBits.writeSE(0);
+    pBits.writeUE(1);
+    let skipRun = 0;
+    for (let mbY = 0; mbY < mbHeight; mbY++) {
+      for (let mbX = 0; mbX < mbWidth; mbX++) {
+        const lumaBaseY = mbY * 16;
+        const lumaBaseX = mbX * 16;
+        const chromaBaseY = mbY * 8;
+        const chromaBaseX = mbX * 8;
+        let unchanged = true;
+        for (let dy = 0; dy < 16 && unchanged; dy++) {
+          const ro = (lumaBaseY + dy) * paddedWidth + lumaBaseX;
+          for (let dx = 0; dx < 16; dx++) {
+            if (yPlane[ro + dx] !== refY[ro + dx]) {
+              unchanged = false;
+              break;
+            }
+          }
+        }
+        for (let dy = 0; dy < 8 && unchanged; dy++) {
+          const ro = (chromaBaseY + dy) * uvWidth + chromaBaseX;
+          for (let dx = 0; dx < 8; dx++) {
+            if (uPlane[ro + dx] !== refU[ro + dx] || vPlane[ro + dx] !== refV[ro + dx]) {
+              unchanged = false;
+              break;
+            }
+          }
+        }
+        if (unchanged) {
+          skipRun++;
+        } else {
+          pBits.writeUE(skipRun);
+          skipRun = 0;
+          pBits.writeUE(30);
+          pBits.alignWithZeroBits();
+          for (let dy = 0; dy < 16; dy++) {
+            const ro = (lumaBaseY + dy) * paddedWidth + lumaBaseX;
+            for (let dx = 0; dx < 16; dx++) {
+              pBits.writeBits(yPlane[ro + dx], 8);
+            }
+          }
+          for (let dy = 0; dy < 8; dy++) {
+            const ro = (chromaBaseY + dy) * uvWidth + chromaBaseX;
+            for (let dx = 0; dx < 8; dx++) {
+              pBits.writeBits(uPlane[ro + dx], 8);
+            }
+          }
+          for (let dy = 0; dy < 8; dy++) {
+            const ro = (chromaBaseY + dy) * uvWidth + chromaBaseX;
+            for (let dx = 0; dx < 8; dx++) {
+              pBits.writeBits(vPlane[ro + dx], 8);
+            }
+          }
+        }
+      }
+    }
+    if (skipRun > 0) {
+      pBits.writeUE(skipRun);
+    }
+    pBits.writeRbspTrailingBits();
+    const pEscaped = escapeRbsp(pBits.toUint8Array());
+    const pLen = 1 + pEscaped.byteLength;
+    const pAvcc = new Uint8Array(4 + pLen);
+    new DataView(pAvcc.buffer).setUint32(0, pLen, false);
+    pAvcc[4] = 97;
+    pAvcc.set(pEscaped, 5);
+    refBuffer.y = yPlane;
+    refBuffer.u = uPlane;
+    refBuffer.v = vPlane;
+    return pAvcc;
+  }
+  if (refBuffer) {
+    refBuffer.y = yPlane;
+    refBuffer.u = uPlane;
+    refBuffer.v = vPlane;
+  }
   const bits = new BitWriter();
   bits.writeUE(0);
   bits.writeUE(7);
@@ -1457,7 +1547,7 @@ function encodeH264IdrFrame(rgba, width, height, frameIndex = 0) {
   avcc.set(escapedRbsp, 5);
   return avcc;
 }
-function decodeH264FrameToRgba(sampleData, width, height, lengthSize = 4) {
+function decodeH264FrameToRgba(sampleData, width, height, lengthSize = 4, refBuffer) {
   const mbWidth = Math.max(1, Math.ceil(width / 16));
   const mbHeight = Math.max(1, Math.ceil(height / 16));
   const paddedWidth = mbWidth * 16;
@@ -1487,9 +1577,18 @@ function decodeH264FrameToRgba(sampleData, width, height, lengthSize = 4) {
       return decodeH264FrameToRgba(converted.avccData, width, height, 4);
     }
   }
-  const yPlane = new Uint8Array(paddedWidth * paddedHeight).fill(16);
-  const uPlane = new Uint8Array(uvWidth * uvHeight).fill(128);
-  const vPlane = new Uint8Array(uvWidth * uvHeight).fill(128);
+  const yPlane = new Uint8Array(paddedWidth * paddedHeight);
+  const uPlane = new Uint8Array(uvWidth * uvHeight);
+  const vPlane = new Uint8Array(uvWidth * uvHeight);
+  if (refBuffer && refBuffer.y?.byteLength === yPlane.byteLength && refBuffer.u?.byteLength === uPlane.byteLength && refBuffer.v?.byteLength === vPlane.byteLength) {
+    yPlane.set(refBuffer.y);
+    uPlane.set(refBuffer.u);
+    vPlane.set(refBuffer.v);
+  } else {
+    yPlane.fill(16);
+    uPlane.fill(128);
+    vPlane.fill(128);
+  }
   if (sliceNalu && sliceNalu.byteLength > 1) {
     const nalType = sliceNalu[0] & 31;
     const nalRefIdc = sliceNalu[0] >>> 5 & 3;
@@ -1503,6 +1602,16 @@ function decodeH264FrameToRgba(sampleData, width, height, lengthSize = 4) {
       bits.readUE();
     }
     bits.readBits(4);
+    if (sliceType === 0 || sliceType === 5) {
+      const numRefOverride = bits.readBit();
+      if (numRefOverride) bits.readUE();
+      const refPicListMod = bits.readBit();
+      if (refPicListMod) {
+        while (bits.bitsRemaining > 0 && bits.readUE() !== 3) {
+          bits.readUE();
+        }
+      }
+    }
     if (nalType === 5) {
       bits.readBit();
       bits.readBit();
@@ -1551,6 +1660,52 @@ function decodeH264FrameToRgba(sampleData, width, height, lengthSize = 4) {
           }
         }
       }
+    } else if (firstMb === 0 && (sliceType === 0 || sliceType === 5)) {
+      const totalMbs = mbWidth * mbHeight;
+      let mbAddr = 0;
+      while (mbAddr < totalMbs && bits.bitsRemaining > 0) {
+        const skipRun = bits.readUE();
+        mbAddr += skipRun;
+        decodedMbs += skipRun;
+        if (mbAddr >= totalMbs || bits.bitsRemaining < 8) break;
+        const mbType = bits.readUE();
+        if (mbType === 30) {
+          bits.alignToByte();
+          const mbY = Math.floor(mbAddr / mbWidth);
+          const mbX = mbAddr % mbWidth;
+          const lumaBaseY = mbY * 16;
+          const lumaBaseX = mbX * 16;
+          for (let dy = 0; dy < 16; dy++) {
+            const rowOffset = (lumaBaseY + dy) * paddedWidth + lumaBaseX;
+            for (let dx = 0; dx < 16; dx++) {
+              yPlane[rowOffset + dx] = bits.readBits(8);
+            }
+          }
+          const chromaBaseY = mbY * 8;
+          const chromaBaseX = mbX * 8;
+          for (let dy = 0; dy < 8; dy++) {
+            const rowOffset = (chromaBaseY + dy) * uvWidth + chromaBaseX;
+            for (let dx = 0; dx < 8; dx++) {
+              uPlane[rowOffset + dx] = bits.readBits(8);
+            }
+          }
+          for (let dy = 0; dy < 8; dy++) {
+            const rowOffset = (chromaBaseY + dy) * uvWidth + chromaBaseX;
+            for (let dx = 0; dx < 8; dx++) {
+              vPlane[rowOffset + dx] = bits.readBits(8);
+            }
+          }
+          mbAddr++;
+          decodedMbs++;
+        } else {
+          break;
+        }
+      }
+    }
+    if (refBuffer && decodedMbs > 0) {
+      refBuffer.y = yPlane;
+      refBuffer.u = uPlane;
+      refBuffer.v = vPlane;
     }
     if (decodedMbs === 0) {
       for (let mbY = 0; mbY < mbHeight; mbY++) {
@@ -2401,9 +2556,10 @@ function parseMp4(bytes, options = {}) {
     if (options.decodeFrames && type === "video" && width && height) {
       const lengthSize = (firstCodec?.avcC?.lengthSizeMinusOne ?? 3) + 1;
       decodedVideoFrames = [];
+      const refBuffer = {};
       for (const sample of samples) {
         budget.recordFrame(width, height);
-        const rgba = decodeH264FrameToRgba(sample.data, width, height, lengthSize);
+        const rgba = decodeH264FrameToRgba(sample.data, width, height, lengthSize, refBuffer);
         decodedVideoFrames.push({
           width,
           height,
@@ -2676,10 +2832,11 @@ function materializeTrackSamples(track) {
     const avcC = parseAvcC(avcCBytes);
     const samples = [];
     let dts = 0;
+    const refBuffer = {};
     for (let i = 0; i < track.decodedVideoFrames.length; i++) {
       const frame = track.decodedVideoFrames[i];
       const duration = Math.max(1, Math.round(frame.durationSeconds * timescale));
-      const encoded = encodeH264IdrFrame(frame.data, width, height, i);
+      const encoded = encodeH264IdrFrame(frame.data, width, height, i, refBuffer);
       samples.push({
         data: encoded,
         dts,
@@ -2692,36 +2849,42 @@ function materializeTrackSamples(track) {
       });
       dts += duration;
     }
+    const codecDescriptions = [
+      {
+        formatFourCC: "avc1",
+        codecName: "h264",
+        profile: "Constrained Baseline",
+        level: 31,
+        width,
+        height,
+        pixFmt: "yuv420p",
+        avcC
+      }
+    ];
+    const mutableTrack = track;
+    mutableTrack.samples = samples;
+    mutableTrack.codecDescriptions = codecDescriptions;
+    mutableTrack.dirtyVideoEncode = false;
+    mutableTrack.decodedVideoFrames = void 0;
     return {
       samples,
-      codecDescriptions: [
-        {
-          formatFourCC: "avc1",
-          codecName: "h264",
-          profile: "Constrained Baseline",
-          level: 31,
-          width,
-          height,
-          pixFmt: "yuv420p",
-          avcC
-        }
-      ]
+      codecDescriptions
     };
   }
   if (track.type === "audio" && track.decodedAudio) {
     const sampleRate = track.decodedAudio.sampleRate || 44100;
     const channels = track.decodedAudio.channels || 2;
-    const totalSamples = track.decodedAudio.channelData[0]?.length ?? 1024;
-    const numFrames = Math.max(1, Math.ceil(totalSamples / 1024));
+    const totalSamples = track.decodedAudio.channelData[0]?.length ?? 0;
+    const numFrames = Math.ceil(totalSamples / 1024);
     const silentAac = createSilentAacFrame(channels);
     const samples = [];
     for (let i = 0; i < numFrames; i++) {
       samples.push({
         data: silentAac,
-        dts: i * 1024,
-        pts: i * 1024,
+        dts: Math.round(i * 1024 * track.timescale / sampleRate),
+        pts: Math.round(i * 1024 * track.timescale / sampleRate),
         cts: 0,
-        duration: 1024,
+        duration: Math.round(Math.min(totalSamples, (i + 1) * 1024) * track.timescale / sampleRate) - Math.round(i * 1024 * track.timescale / sampleRate),
         size: silentAac.byteLength,
         isKeyframe: true,
         sampleDescriptionIndex: 1
@@ -3139,6 +3302,8 @@ function concatMp4(docs, options = {}) {
   const mergedSamples = trackSlots.map(() => []);
   const mergedDecodedFrames = trackSlots.map(() => []);
   const runningTicksPerSlot = trackSlots.map(() => 0);
+  const audioSegments = trackSlots.map(() => []);
+  const encodedAudioSlots = /* @__PURE__ */ new Set();
   for (let docIdx = 0; docIdx < docs.length; docIdx++) {
     budget.checkCpu();
     const doc = docs[docIdx];
@@ -3180,6 +3345,13 @@ function concatMp4(docs, options = {}) {
         }
       }
       let currentTick = runningTicksPerSlot[slotIdx];
+      if (trk.type === "audio") {
+        if (trk.decodedAudio) {
+          audioSegments[slotIdx].push({ audio: trk.decodedAudio, offsetSeconds: currentTick / targetTimescale });
+        } else if (materialized.samples.length > 0) {
+          encodedAudioSlots.add(slotIdx);
+        }
+      }
       for (const s of materialized.samples) {
         const scaledDur = Math.max(1, Math.round(s.duration * scaleRatio));
         const scaledCts = Math.round(s.cts * scaleRatio);
@@ -3230,9 +3402,49 @@ function concatMp4(docs, options = {}) {
     const timescale = slotTimescales[idx];
     const samples = mergedSamples[idx];
     const duration = samples.reduce((acc, s) => acc + s.duration, 0);
+    const segments = audioSegments[idx];
+    let decodedAudio;
+    if (segments.length > 0) {
+      if (encodedAudioSlots.has(idx)) {
+        throw new Error("concatMp4 requires all segments in a decoded audio track to be decoded");
+      }
+      const { sampleRate, channels } = segments[0].audio;
+      const length = Math.round(duration / timescale * sampleRate);
+      budget.allocateMemory(length * channels * Float32Array.BYTES_PER_ELEMENT);
+      const channelData = Array.from({ length: channels }, () => new Float32Array(length));
+      for (const { audio, offsetSeconds } of segments) {
+        const offset = Math.round(offsetSeconds * sampleRate);
+        const sourceLength = audio.channelData[0]?.length ?? 0;
+        const count = Math.min(length - offset, Math.round(sourceLength * sampleRate / audio.sampleRate));
+        for (let channel = 0; channel < channels; channel++) {
+          const sources = channels === 1 ? audio.channelData : [audio.channelData[channel % audio.channels]];
+          const output = channelData[channel];
+          if (audio.sampleRate === sampleRate && sources.length === 1) {
+            budget.checkCpu();
+            output.set(sources[0].subarray(0, count), offset);
+            continue;
+          }
+          for (let i = 0; i < count; i++) {
+            if (i % 4096 === 0) budget.checkCpu();
+            const position = i * audio.sampleRate / sampleRate;
+            const left = Math.floor(position);
+            const fraction = position - left;
+            let value = 0;
+            for (const source of sources) {
+              const a = source[left] ?? 0;
+              const b = source[Math.min(left + 1, source.length - 1)] ?? 0;
+              value += a + (b - a) * fraction;
+            }
+            output[offset + i] = value / sources.length;
+          }
+        }
+      }
+      decodedAudio = { sampleRate, channels, channelData };
+    }
     return {
       ...slot.template,
       id: idx + 1,
+      decodedAudio,
       timescale,
       duration,
       codecDescriptions: mergedCodecDescriptions[idx],
@@ -3264,11 +3476,11 @@ function* sliceMp4Steps(doc, options = {}) {
   let work = 0;
   const startSec = Math.max(0, options.startSeconds ?? 0);
   const endSec = options.endSeconds !== void 0 ? options.endSeconds : options.durationSeconds !== void 0 ? startSec + options.durationSeconds : doc.durationSeconds;
-  const useEditList = options.useEditList ?? true;
   const movieTimescale = doc.timescale || 1e3;
   const slicedTracks = [];
   for (const track of doc.tracks) {
     if (++work % 256 === 0) yield;
+    const useEditList = (options.useEditList ?? true) && !track.decodedAudio;
     const materialized = materializeTrackSamples(track);
     const ts = track.timescale || 1e3;
     const sourceOrigin = Math.max(0, track.editList?.[0]?.mediaTime ?? 0);
@@ -3295,14 +3507,37 @@ function* sliceMp4Steps(doc, options = {}) {
     }
     const slicedSamples = [];
     let runningDts = 0;
+    let promotedFirstSampleData;
+    if (track.type === "video" && actualStartIdx < materialized.samples.length && materialized.samples[actualStartIdx].data.byteLength > 5 && (materialized.samples[actualStartIdx].data[4] & 31) === 1) {
+      let keyIdx = actualStartIdx;
+      while (keyIdx > 0 && (materialized.samples[keyIdx].data[4] & 31) !== 5) {
+        keyIdx--;
+      }
+      const w = track.width ?? materialized.codecDescriptions[0]?.width ?? 64;
+      const h = track.height ?? materialized.codecDescriptions[0]?.height ?? 64;
+      const lengthSize = (materialized.codecDescriptions[0]?.avcC?.lengthSizeMinusOne ?? 3) + 1;
+      const refBuf = {};
+      let rgba;
+      for (let k = keyIdx; k <= actualStartIdx; k++) {
+        rgba = decodeH264FrameToRgba(materialized.samples[k].data, w, h, lengthSize, refBuf);
+      }
+      if (rgba) {
+        promotedFirstSampleData = encodeH264IdrFrame(rgba, w, h, 0);
+      }
+    }
     for (let i = actualStartIdx; i < materialized.samples.length; i++) {
       if (++work % 256 === 0) yield;
       const s = materialized.samples[i];
       if (s.dts >= endTick) break;
       const sampleStart = useEditList ? s.dts : Math.max(startTick, s.dts);
       const clippedDuration = Math.max(0, Math.min(s.dts + s.duration, endTick) - sampleStart);
+      const isPromotedFirst = i === actualStartIdx && promotedFirstSampleData !== void 0;
+      const sampleData = isPromotedFirst ? promotedFirstSampleData : s.data;
       slicedSamples.push({
         ...s,
+        data: sampleData,
+        size: sampleData.byteLength,
+        isKeyframe: isPromotedFirst ? true : s.isKeyframe,
         dts: runningDts,
         pts: runningDts + s.cts,
         duration: clippedDuration
@@ -3329,8 +3564,18 @@ function* sliceMp4Steps(doc, options = {}) {
         ptsSeconds: Math.max(0, f.ptsSeconds - startSec)
       }));
     }
+    const decodedAudio = track.decodedAudio && {
+      ...track.decodedAudio,
+      channelData: track.decodedAudio.channelData.map(
+        (channel) => channel.slice(Math.round(startSec * track.decodedAudio.sampleRate), Math.max(0, Math.round(endSec * track.decodedAudio.sampleRate)))
+      )
+    };
+    if (decodedAudio) {
+      runningDts = Math.round((decodedAudio.channelData[0]?.length ?? 0) * ts / decodedAudio.sampleRate);
+    }
     slicedTracks.push({
       ...track,
+      decodedAudio,
       duration: editList ? Math.round(editList[0].segmentDuration * ts / movieTimescale) : runningDts,
       codecDescriptions: materialized.codecDescriptions,
       editList,
@@ -5922,7 +6167,7 @@ function flvAst() {
 
 // packages/mp4-ast/src/containers/adapters.ts
 init_buffer();
-function extractVideoFramesFromDoc(doc) {
+function extractVideoFramesFromDoc(doc, maxFrames) {
   const vTrack = doc.tracks.find((t) => t.type === "video");
   if (!vTrack) {
     return { frames: [], width: 64, height: 64, fps: 10 };
@@ -5940,10 +6185,12 @@ function extractVideoFramesFromDoc(doc) {
   }
   const ts = vTrack.timescale || 9e4;
   const lengthSize = (vTrack.codecDescriptions[0]?.avcC?.lengthSizeMinusOne ?? 3) + 1;
-  const frames = vTrack.samples.map((s) => ({
+  const refBuffer = {};
+  const targetSamples = maxFrames !== void 0 ? vTrack.samples.slice(0, maxFrames) : vTrack.samples;
+  const frames = targetSamples.map((s) => ({
     width,
     height,
-    data: decodeH264FrameToRgba(s.data, width, height, lengthSize),
+    data: decodeH264FrameToRgba(s.data, width, height, lengthSize, refBuffer),
     ptsSeconds: s.pts / ts,
     durationSeconds: s.duration / ts,
     keyframe: s.isKeyframe
@@ -6938,7 +7185,7 @@ function image2Ast() {
       };
     },
     serialize(doc, options) {
-      const { frames, width, height } = extractVideoFramesFromDoc(doc);
+      const { frames, width, height } = extractVideoFramesFromDoc(doc, 1);
       const first = frames[0]?.data ?? new Uint8Array(width * height * 4);
       const fmt = options?.format?.toLowerCase() ?? "png";
       const imgFmt = fmt === "jpg" || fmt === "jpeg" || fmt === "mjpeg" ? "jpeg" : fmt === "webp" ? "webp" : fmt === "gif" ? "gif" : fmt === "bmp" ? "bmp" : fmt === "tiff" || fmt === "tif" ? "tiff" : fmt === "ppm" ? "ppm" : "png";
@@ -7498,10 +7745,37 @@ function createMediaAstRegistry(plugins) {
 }
 
 // packages/safe-bash-command-ffmpeg/src/index.ts
-async function readStdinAll(context) {
+function isStdin(path) {
+  return ["-", "pipe:", "pipe:0", "/dev/stdin", "/dev/fd/0"].includes(path);
+}
+function isStdout(path) {
+  return ["-", "pipe:", "pipe:1", "/dev/stdout", "/dev/fd/1"].includes(path);
+}
+function rethrowRuntimeError(context, error) {
+  context.signal.throwIfAborted();
+  if (error instanceof Error && (error.name === "BudgetExceededError" || error.name === "AbortError")) throw error;
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "EPIPE") throw error;
+}
+function createInputReader(context, budget) {
+  let total = 0;
+  const account = (bytes) => {
+    context.signal.throwIfAborted();
+    total += bytes.byteLength;
+    context.inputBudget?.check(total);
+    budget.checkInputBytes(total);
+  };
+  return async (path) => {
+    if (isStdin(path)) return readStdinAll(context, account);
+    const bytes = await context.fs.readFile(resolvePath(context.cwd, path), { signal: context.signal });
+    account(bytes);
+    return bytes;
+  };
+}
+async function readStdinAll(context, account) {
   const chunks = [];
   let total = 0;
   for await (const chunk of readBytes(context.stdin, context.signal)) {
+    account(chunk);
     chunks.push(chunk);
     total += chunk.byteLength;
   }
@@ -7689,9 +7963,11 @@ function* lavfiSteps(spec, budget, durationOverride) {
             [0, 0, 255]
           ];
           const [r, g, b] = palette[bar % 7];
-          rgba[idx] = r + i * 12 & 255;
-          rgba[idx + 1] = g;
-          rgba[idx + 2] = b;
+          const scanY = i * 16 % Math.max(16, height);
+          const inScanBar = y >= scanY && y < scanY + 16;
+          rgba[idx] = inScanBar ? r ^ 128 : r;
+          rgba[idx + 1] = inScanBar ? g ^ 128 : g;
+          rgba[idx + 2] = inScanBar ? b ^ 128 : b;
           rgba[idx + 3] = 255;
         } else {
           rgba[idx] = color[0];
@@ -7715,15 +7991,17 @@ function* lavfiSteps(spec, budget, durationOverride) {
     width,
     height,
     fps,
-    frameCount,
+    frameCount: 1,
     color: [color[0], color[1], color[2]],
     includeAudio: false
   });
   const parsed = parseMp4(mp4Bytes);
   return {
     ...parsed,
+    duration: Math.round(frameCount / fps * parsed.timescale),
+    durationSeconds: frameCount / fps,
     tracks: parsed.tracks.map(
-      (t) => t.type === "video" ? { ...t, decodedVideoFrames: frames } : t
+      (t) => t.type === "video" ? { ...t, duration: Math.round(frameCount / fps * t.timescale), samples: [], decodedVideoFrames: frames } : t
     )
   };
 }
@@ -7735,12 +8013,13 @@ async function ensureDecodedFrames(track, budget, signal) {
   const height = track.height ?? track.codecDescriptions[0]?.height ?? 64;
   const ts = track.timescale || 9e4;
   const lengthSize = (track.codecDescriptions[0]?.avcC?.lengthSizeMinusOne ?? 3) + 1;
+  const refBuffer = {};
   return await mapWork(track.samples, async (s) => {
     budget.recordFrame(width, height);
     return {
       width,
       height,
-      data: decodeH264FrameToRgba(s.data, width, height, lengthSize),
+      data: decodeH264FrameToRgba(s.data, width, height, lengthSize, refBuffer),
       ptsSeconds: s.pts / ts,
       durationSeconds: s.duration / ts,
       keyframe: s.isKeyframe
@@ -8682,7 +8961,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
       if (inp.format === "lavfi") {
         return void 0;
       } else {
-        const rawBytes = inp.path === "-" || inp.path === "pipe:" || inp.path === "pipe:0" ? inBytes : readFileSync?.(inp.path);
+        const rawBytes = isStdin(inp.path) ? inBytes : readFileSync?.(inp.path);
         if (!rawBytes || rawBytes.byteLength > 262144) return void 0;
         budget.checkInputBytes(rawBytes.byteLength);
         const plugin = registry.detect(rawBytes, inp.path, inp.format);
@@ -8756,7 +9035,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
     if (!outPlugin || !outPlugin.canMux) return void 0;
     const outExt = outputTarget.split(".").pop()?.toLowerCase();
     const serializedBytes = outPlugin.serialize(workingDoc, { format: outputFormat ?? outExt, faststart, fragmented, metadata: metaTags, budget });
-    if (outputTarget === "-" || outputTarget === "pipe:" || outputTarget === "pipe:1") return void 0;
+    if (isStdout(outputTarget)) return void 0;
     if (!writeFileSync(outputTarget, serializedBytes)) return void 0;
     return "";
   } catch {
@@ -8829,7 +9108,7 @@ function evalSyncFfprobe(inBytes, args, readFileSync) {
   if (!inputTarget) return void 0;
   try {
     let bytes;
-    if (inputTarget === "-" || inputTarget === "pipe:" || inputTarget === "pipe:0") {
+    if (isStdin(inputTarget)) {
       bytes = inBytes;
     } else {
       bytes = readFileSync?.(inputTarget);
@@ -8871,6 +9150,7 @@ function createFfprobeCommand(options = {}) {
     description: "Multimedia stream analyzer powered by pluggable ASTs",
     async execute(context) {
       const budget = new MediaBudgetTracker(options.limits);
+      const readInput = createInputReader(context, budget);
       const argsObj = getCommandArguments(context);
       const args = argsObj.args;
       if (args.length === 0) {
@@ -8952,14 +9232,7 @@ function createFfprobeCommand(options = {}) {
         return { exitCode: 1 };
       }
       try {
-        let bytes;
-        if (inputTarget === "-" || inputTarget === "pipe:" || inputTarget === "pipe:0") {
-          bytes = await readStdinAll(context);
-        } else {
-          const fullPath = resolvePath(context.cwd, inputTarget);
-          bytes = await context.fs.readFile(fullPath, { signal: context.signal });
-        }
-        budget.checkInputBytes(bytes.byteLength);
+        const bytes = await readInput(inputTarget);
         const plugin = registry.detect(bytes, inputTarget, explicitFormat);
         if (!plugin || !plugin.canDemux) {
           const msg = explicitFormat ? `ffprobe: Unknown input format: '${explicitFormat}' (AST not registered)
@@ -8992,6 +9265,7 @@ function createFfprobeCommand(options = {}) {
         options.onMetrics?.(budget.getStats());
         return { exitCode: 0 };
       } catch (err) {
+        rethrowRuntimeError(context, err);
         const msg = err instanceof Error ? err.message : String(err);
         await writeBytes(context.stderr, encodeUtf8(`ffprobe: ${msg}
 `), context.signal);
@@ -9010,6 +9284,7 @@ function createFfmpegCommand(options = {}) {
     description: "Multimedia converter, merger, and stream processor powered by pluggable ASTs",
     async execute(context) {
       const budget = new MediaBudgetTracker(options.limits);
+      const readInput = createInputReader(context, budget);
       const argsObj = getCommandArguments(context);
       const args = argsObj.args;
       if (args.length === 0) {
@@ -9229,7 +9504,7 @@ function createFfmpegCommand(options = {}) {
         return { exitCode: 1 };
       }
       try {
-        if (noOverwrite && outputTarget !== "-" && outputTarget !== "pipe:" && outputTarget !== "pipe:1" && outputFormat !== "null") {
+        if (noOverwrite && !isStdout(outputTarget) && outputFormat !== "null") {
           const outFull = resolvePath(context.cwd, outputTarget);
           try {
             await context.fs.stat(outFull, { signal: context.signal });
@@ -9240,7 +9515,9 @@ function createFfmpegCommand(options = {}) {
               context.signal
             );
             return { exitCode: 1 };
-          } catch {
+          } catch (error) {
+            rethrowRuntimeError(context, error);
+            if (error.code !== "ENOENT") throw error;
           }
         }
         const loadSingleDocument = async (filePath, explicitFormat, fpsHint, input) => {
@@ -9259,7 +9536,7 @@ function createFfmpegCommand(options = {}) {
           }
           if (/\.m3u8?$/i.test(filePath) || explicitFormat === "hls") {
             const m3uResolved = resolvePath(context.cwd, filePath);
-            const m3uBytes = await context.fs.readFile(m3uResolved, { signal: context.signal });
+            const m3uBytes = await readInput(filePath);
             const m3uText = decodeUtf8(m3uBytes).replace(/\r\n/g, "\n");
             const baseDir = m3uResolved.includes("/") ? m3uResolved.slice(0, m3uResolved.lastIndexOf("/")) || "/" : "/";
             const segDocs = [];
@@ -9270,7 +9547,9 @@ function createFfmpegCommand(options = {}) {
               try {
                 const segDoc = await loadSingleDocument(segPath);
                 segDocs.push(segDoc);
-              } catch {
+              } catch (error) {
+                rethrowRuntimeError(context, error);
+                if (error.code !== "ENOENT") throw error;
               }
             }
             if (segDocs.length > 0) {
@@ -9299,8 +9578,9 @@ function createFfmpegCommand(options = {}) {
               const resolved = resolvePath(context.cwd, formatted);
               let imgBytes;
               try {
-                imgBytes = await context.fs.readFile(resolved, { signal: context.signal });
+                imgBytes = await readInput(resolved);
               } catch (error) {
+                rethrowRuntimeError(context, error);
                 if (error.code !== "ENOENT") throw error;
                 if (idx === 0 && input?.startNumber === void 0) continue;
                 break;
@@ -9326,25 +9606,18 @@ function createFfmpegCommand(options = {}) {
               width: first.width,
               height: first.height,
               fps,
-              frameCount: frames.length,
+              frameCount: 1,
               includeAudio: false
             }));
             const base = parseMp4(synthBytes);
             return {
               ...base,
               tracks: base.tracks.map(
-                (t) => t.type === "video" ? { ...t, decodedVideoFrames: frames } : t
+                (t) => t.type === "video" ? { ...t, samples: [], decodedVideoFrames: frames } : t
               )
             };
           }
-          let rawBytes;
-          if (filePath === "-" || filePath === "pipe:" || filePath === "pipe:0") {
-            rawBytes = await readStdinAll(context);
-          } else {
-            const fullPath = resolvePath(context.cwd, filePath);
-            rawBytes = await context.fs.readFile(fullPath, { signal: context.signal });
-          }
-          budget.checkInputBytes(rawBytes.byteLength);
+          const rawBytes = await readInput(filePath);
           if (explicitFormat === "concat") {
             const listText = new TextDecoder().decode(rawBytes);
             const listDir = filePath === "-" ? context.cwd : dirnameOf(resolvePath(context.cwd, filePath));
@@ -9686,6 +9959,22 @@ function createFfmpegCommand(options = {}) {
         if (outputFps && videoCodec !== "copy") {
           vfFilters.push(`fps=${outputFps}`);
         }
+        if (maxVideoFrames !== void 0 && !vfFilters.some((f) => /\b(fps|select|reverse|trim|tile|setpts)\b/i.test(f))) {
+          workingDoc = {
+            ...workingDoc,
+            tracks: workingDoc.tracks.map((t) => {
+              if (t.type !== "video") return t;
+              if (t.decodedVideoFrames && t.decodedVideoFrames.length > maxVideoFrames) {
+                return { ...t, samples: [], decodedVideoFrames: t.decodedVideoFrames.slice(0, maxVideoFrames) };
+              }
+              if (t.samples.length > maxVideoFrames) {
+                const slicedSamples = t.samples.slice(0, maxVideoFrames);
+                return { ...t, duration: slicedSamples.reduce((acc, s) => acc + s.duration, 0), samples: slicedSamples };
+              }
+              return t;
+            })
+          };
+        }
         if (vfFilters.length > 0) {
           if (features.videoTranscode === false || features.filterGraph === false) {
             throw new Error("Video transcoding / filtergraph is disabled by consumer feature configuration");
@@ -9695,7 +9984,7 @@ function createFfmpegCommand(options = {}) {
           const subMatch = /subtitles=(?:filename=)?['"]?([^:'",]+)['"]?/.exec(combinedChain);
           if (subMatch?.[1]) {
             const subPath = resolvePath(context.cwd, subMatch[1]);
-            const subBytes = await context.fs.readFile(subPath, { signal: context.signal });
+            const subBytes = await readInput(subPath);
             const subFmt = subPath.toLowerCase().endsWith(".vtt") ? "webvtt" : "srt";
             const subDoc = parseSubtitleDocument(subBytes, subFmt);
             const st = subDoc.tracks.find((t) => t.type === "subtitle");
@@ -9962,7 +10251,7 @@ function createFfmpegCommand(options = {}) {
           budget
         });
         budget.checkOutputBytes(serializedBytes.byteLength);
-        if (outputTarget === "-" || outputTarget === "pipe:" || outputTarget === "pipe:1") {
+        if (isStdout(outputTarget)) {
           await writeBytes(context.stdout, serializedBytes, context.signal);
         } else {
           const fullOutPath = resolvePath(context.cwd, outputTarget);
@@ -9971,6 +10260,7 @@ function createFfmpegCommand(options = {}) {
         options.onMetrics?.(budget.getStats());
         return { exitCode: 0 };
       } catch (err) {
+        rethrowRuntimeError(context, err);
         const msg = err instanceof Error ? err.message : String(err);
         await writeBytes(context.stderr, encodeUtf8(`ffmpeg: ${msg}
 `), context.signal);