@gannochenko/staticstripes 0.0.22 → 0.0.24

package/src/ffmpeg.ts

@@ -427,6 +427,26 @@ export function makeFps(inputs: Label[], fps: number): Filter {
   return new Filter(inputs, [output], `fps=${fps}`);
 }
 
+export function makeFormat(inputs: Label[], format: string): Filter {
+  if (inputs.length !== 1) {
+    throw new Error(`makeFormat: expects one input`);
+  }
+
+  const input1 = inputs[0];
+  if (input1.isAudio) {
+    throw new Error(
+      `makeFormat: input1 must be video, got audio (tag: ${input1.tag})`,
+    );
+  }
+
+  const output = {
+    tag: getLabel(),
+    isAudio: false,
+  };
+
+  return new Filter(inputs, [output], `format=${format}`);
+}
+
 export function makeScale(
   inputs: Label[],
   options: { width: number | string; height: number | string; flags?: string },
@@ -1183,6 +1203,147 @@ export function makeChromakey(
   );
 }
 
+/**
+ * Creates a Ken Burns effect (zoom/pan) filter for images
+ * @param inputs - Input stream labels (must be video)
+ * @param options - Ken Burns parameters
+ *   - effect: Type of effect (zoom-in, zoom-out, pan-left, pan-right, pan-top, pan-bottom)
+ *   - zoom: Zoom percentage (30 = 30%, applies to all effects)
+ *   - effectDuration: Duration of the ken burns animation in milliseconds (0 = use fragment duration)
+ *   - fragmentDuration: Total duration of the fragment in milliseconds
+ *   - easing: Easing function (linear, ease-in, ease-out, ease-in-out)
+ *   - width: Output width
+ *   - height: Output height
+ *   - fps: Output frame rate
+ *   - focalX: Focal point X in percent (0-100, for zoom effects)
+ *   - focalY: Focal point Y in percent (0-100, for zoom effects)
+ */
+export function makeKenBurns(
+  inputs: Label[],
+  options: {
+    effect: 'zoom-in' | 'zoom-out' | 'pan-left' | 'pan-right' | 'pan-top' | 'pan-bottom';
+    zoom: number;
+    effectDuration: number;
+    fragmentDuration: number;
+    easing: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
+    width: number;
+    height: number;
+    fps: number;
+    focalX?: number;
+    focalY?: number;
+    panStartX?: number;
+    panStartY?: number;
+    panEndX?: number;
+    panEndY?: number;
+  },
+): Filter {
+  const input = inputs[0];
+
+  if (input.isAudio) {
+    throw new Error(
+      `makeKenBurns: input must be video, got audio (tag: ${input.tag})`,
+    );
+  }
+
+  const output = {
+    tag: getLabel(),
+    isAudio: false,
+  };
+
+  const focalX = options.focalX ?? 50;
+  const focalY = options.focalY ?? 50;
+
+  // Determine animation duration (0 = use fragment duration)
+  const animationDuration = options.effectDuration > 0 ? options.effectDuration : options.fragmentDuration;
+  const animationDurationInSeconds = animationDuration / 1000;
+
+  // Total fragment duration
+  const fragmentDurationInSeconds = options.fragmentDuration / 1000;
+  const totalFrames = Math.floor(fragmentDurationInSeconds * options.fps);
+
+  // Animation frames (how many frames the effect takes)
+  const animationFrames = Math.floor(animationDurationInSeconds * options.fps);
+
+  // Convert zoom percentage to factor (e.g., 30% = 1.3x)
+  const zoomFactor = 1 + options.zoom / 100;
+
+  // Create easing function expression
+  // t = progress from 0 to 1 (on/animationFrames)
+  // Returns eased value from 0 to 1
+  const getEasingExpr = (easing: string): string => {
+    const t = `min(1,on/${animationFrames})`;
+    switch (easing) {
+      case 'ease-in':
+        // Quadratic ease-in: t^2
+        return `pow(${t},2)`;
+      case 'ease-out':
+        // Quadratic ease-out: 1-(1-t)^2
+        return `1-pow(1-(${t}),2)`;
+      case 'ease-in-out':
+        // Quadratic ease-in-out: t<0.5 ? 2*t^2 : 1-2*(1-t)^2
+        return `if(lt(${t},0.5),2*pow(${t},2),1-pow(-2*(${t})+2,2)/2)`;
+      case 'linear':
+      default:
+        return t;
+    }
+  };
+
+  const progress = getEasingExpr(options.easing);
+
+  let zoomExpr: string;
+  let xExpr: string;
+  let yExpr: string;
+
+  switch (options.effect) {
+    case 'zoom-in':
+      // Start at 1.0, zoom to zoomFactor over animation duration, then hold
+      zoomExpr = `'1+(${zoomFactor}-1)*(${progress})'`;
+      xExpr = `'iw*${focalX/100}-iw/zoom/2'`;
+      yExpr = `'ih*${focalY/100}-ih/zoom/2'`;
+      break;
+
+    case 'zoom-out':
+      // Start at zoomFactor, zoom out to 1.0 over animation duration, then hold
+      zoomExpr = `'${zoomFactor}-(${zoomFactor}-1)*(${progress})'`;
+      xExpr = `'iw*${focalX/100}-iw/zoom/2'`;
+      yExpr = `'ih*${focalY/100}-ih/zoom/2'`;
+      break;
+
+    case 'pan-left':
+    case 'pan-right': {
+      // Horizontal panning with custom start/end positions
+      const panStart = (options.panStartX ?? 0) / 100; // 0 = left edge, 1 = right edge
+      const panEnd = (options.panEndX ?? 100) / 100;
+
+      zoomExpr = `'${zoomFactor}'`;
+      // Interpolate between start and end positions: start + (end - start) * progress
+      xExpr = `'(iw-iw/zoom)*(${panStart}+(${panEnd}-${panStart})*(${progress}))'`;
+      yExpr = `'(ih-ih/zoom)/2'`; // center vertically
+      break;
+    }
+
+    case 'pan-top':
+    case 'pan-bottom': {
+      // Vertical panning with custom start/end positions
+      const panStart = (options.panStartY ?? 0) / 100; // 0 = top edge, 1 = bottom edge
+      const panEnd = (options.panEndY ?? 100) / 100;
+
+      zoomExpr = `'${zoomFactor}'`;
+      xExpr = `'(iw-iw/zoom)/2'`; // center horizontally
+      // Interpolate between start and end positions: start + (end - start) * progress
+      yExpr = `'(ih-ih/zoom)*(${panStart}+(${panEnd}-${panStart})*(${progress}))'`;
+      break;
+    }
+  }
+
+  // zoompan filter syntax:
+  // zoompan=z='zoom':x='x':y='y':d=frames:s=WxH:fps=FPS
+  // d=totalFrames ensures we generate frames for the entire fragment duration
+  const filterStr = `zoompan=z=${zoomExpr}:x=${xExpr}:y=${yExpr}:d=${totalFrames}:s=${options.width}x${options.height}:fps=${options.fps}`;
+
+  return new Filter(inputs, [output], filterStr);
+}
+
 /**
  * Creates a despill filter to remove color spill from chromakey
  * @param inputs - Input stream labels (must be video)