@adminide-stack/yantra-mobile 12.0.121 → 12.0.123-alpha.0

package/lib/features/canvas/videoEditor/compileTimeline.js

@@ -0,0 +1,668 @@
+import {DEFAULT_IMAGE_SEC}from'./editorModel.js';import {colorFromSolidSrc,solidColorPngDataUrl}from'./solidColorPng.js';var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const MIN_HOLD_SLOWDOWN = 0.8;
+const DEFAULT_CANVAS = {
+  width: 1280,
+  height: 720
+};
+const FILTER_GRADE = {
+  none: null,
+  cinematic: {
+    contrast: 1.12,
+    saturation: 0.92,
+    brightness: -0.04
+  },
+  film: {
+    saturation: 0.85,
+    gamma: 1.05,
+    brightness: 0.03
+  },
+  kodak: {
+    saturation: 1.15,
+    gamma: 0.95,
+    hue: 8
+  },
+  mono: {
+    saturation: 0,
+    contrast: 1.08
+  },
+  vivid: {
+    contrast: 1.15,
+    saturation: 1.35
+  },
+  warm: {
+    hue: -12,
+    saturation: 1.08,
+    brightness: 0.03
+  },
+  cool: {
+    hue: 12,
+    saturation: 0.95
+  },
+  dreamy: {
+    blur: 4,
+    brightness: 0.06,
+    saturation: 1.1
+  }
+};
+const ZOOM_SCALE = {
+  subtle: 1.5,
+  moderate: 2,
+  strong: 2.6
+};
+const urlRef = (url) => ({
+  kind: "url",
+  url
+});
+const stepRef = (index) => ({
+  kind: "step",
+  index
+});
+const pctToPx = (pct, dim) => Math.round(pct / 100 * dim);
+const evenPx = (px) => Math.max(2, Math.round(px / 2) * 2);
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+const r3 = (v) => Math.round(v * 1e3) / 1e3;
+function specClipSec(clip) {
+  var _a, _b, _c;
+  if (clip.type === "image") return ((_a = clip.durationSec) != null ? _a : DEFAULT_IMAGE_SEC) / clip.speed;
+  const end = (_c = (_b = clip.trimEndSec) != null ? _b : clip.sourceDurationSec) != null ? _c : null;
+  if (end === null) return 0;
+  return Math.max(0, end - clip.trimStartSec) / clip.speed;
+}
+function canvasForAspect(width, height) {
+  if (!(width > 0) || !(height > 0)) return __spreadValues({}, DEFAULT_CANVAS);
+  const ratio = width / height;
+  if (ratio < 0.9) return {
+    width: 720,
+    height: 1280
+  };
+  if (ratio <= 1.1) return {
+    width: 1080,
+    height: 1080
+  };
+  return __spreadValues({}, DEFAULT_CANVAS);
+}
+function canvasForRatio(ratio) {
+  const m = /^(\d+(?:\.\d+)?)\s*[:x/]\s*(\d+(?:\.\d+)?)$/.exec((ratio != null ? ratio : "").trim());
+  return m ? canvasForAspect(Number(m[1]), Number(m[2])) : void 0;
+}
+function zoomWindow(z) {
+  var _a;
+  const side = 100 / ((_a = ZOOM_SCALE[z.depth]) != null ? _a : ZOOM_SCALE.moderate);
+  return {
+    x: z.x / 100 * (100 - side),
+    y: z.y / 100 * (100 - side),
+    width: side,
+    height: side
+  };
+}
+const segEnd = (s) => s.startSec + s.durationSec;
+const covering = (segs, kind, t) => segs.find((s) => s.kind === kind && t >= s.startSec && t < segEnd(s));
+function windowAt(segs, t) {
+  var _a, _b;
+  const z = (_a = covering(segs, "zoom", t)) == null ? void 0 : _a.zoom;
+  if (z) return zoomWindow(z);
+  const c = (_b = covering(segs, "crop", t)) == null ? void 0 : _b.crop;
+  if (!c) return null;
+  const width = clamp(c.width, 5, 100);
+  const height = clamp(c.height, 5, 100);
+  return {
+    x: clamp(c.x, 0, 100 - width),
+    y: clamp(c.y, 0, 100 - height),
+    width,
+    height
+  };
+}
+function trimAt(segs, t) {
+  let end = null;
+  for (const s of [...segs].sort((a, b) => a.startSec - b.startSec)) {
+    const cursor = end != null ? end : t;
+    if (s.kind === "trim" && s.startSec <= cursor && cursor < segEnd(s)) end = segEnd(s);
+  }
+  return end;
+}
+function segmentPieces(segments, durationSec) {
+  var _a, _b;
+  const segs = segments.filter((s) => s.kind !== "blur" && s.durationSec > 0);
+  if (!segs.length || durationSec <= 0) return [];
+  const cuts = [.../* @__PURE__ */ new Set([0, durationSec, ...segs.flatMap((s) => [s.startSec, segEnd(s)])])].filter((t) => t >= 0 && t <= durationSec).sort((a, b) => a - b);
+  const out = [];
+  for (let i = 1; i < cuts.length; i++) {
+    const from = cuts[i - 1];
+    const to = cuts[i];
+    const mid = (from + to) / 2;
+    if (to <= from || trimAt(segs, mid) != null) continue;
+    const speed = (_b = (_a = covering(segs, "speed", mid)) == null ? void 0 : _a.speed) != null ? _b : 1;
+    const window = windowAt(segs, mid);
+    out.push(__spreadValues(__spreadValues({
+      from,
+      to
+    }, speed !== 1 ? {
+      speed
+    } : {}), window ? {
+      window
+    } : {}));
+  }
+  return out;
+}
+function compileTimeline(spec, options = {}) {
+  var _a, _b, _c;
+  const steps = [];
+  const warnings = [];
+  const push = (s) => steps.push(s) - 1;
+  const canvas = (_b = (_a = options.canvas) != null ? _a : spec.canvas) != null ? _b : DEFAULT_CANVAS;
+  const canvasW = evenPx(canvas.width);
+  const canvasH = evenPx(canvas.height);
+  const fps = spec.fps || 30;
+  const clips = spec.clips;
+  if (clips.length === 0) {
+    return {
+      steps: [],
+      finalRef: urlRef(""),
+      warnings: ["Nothing to render - add a scene first."]
+    };
+  }
+  const spans = [];
+  {
+    let cursor = 0;
+    for (const clip of clips) {
+      const len = specClipSec(clip);
+      spans.push({
+        start: cursor,
+        end: cursor + len
+      });
+      cursor += len;
+    }
+  }
+  const totalSec = spans.length ? spans[spans.length - 1].end : 0;
+  if (clips.some((c) => c.type === "video" && specClipSec(c) === 0)) {
+    warnings.push("A video without a known length sits in the cut, so titles and segments after it may land early.");
+  }
+  const stillSrc = (clip) => {
+    const fill = clip.fillColor || colorFromSolidSrc(clip.src);
+    if (!fill) return clip.src;
+    const scale = 640 / Math.max(canvasW, canvasH);
+    return solidColorPngDataUrl(fill, Math.round(canvasW * scale), Math.round(canvasH * scale));
+  };
+  const holdMs = (index) => {
+    var _a2, _b2, _c2;
+    return (_c2 = (_b2 = (_a2 = clips[index + 1]) == null ? void 0 : _a2.transitionIn) == null ? void 0 : _b2.durationMs) != null ? _c2 : 0;
+  };
+  let unheldMs = 0;
+  const levelOps = (ref, clip) => {
+    if (clip.type !== "video") return ref;
+    if (clip.muted || clip.volume <= 0) {
+      return stepRef(push({
+        op: "mute",
+        label: "Mute",
+        primaryInput: ref,
+        params: {}
+      }));
+    }
+    if (clip.volume < 0.99) {
+      return stepRef(push({
+        op: "volume",
+        label: `Volume ${Math.round(clip.volume * 100)}%`,
+        primaryInput: ref,
+        params: {
+          level: clip.volume
+        }
+      }));
+    }
+    return ref;
+  };
+  const segmentRefs = clips.map((clip, index) => {
+    var _a2, _b2, _c2;
+    const hold = holdMs(index);
+    let ref;
+    if (clip.type === "image") {
+      const seconds = specClipSec(clip) + hold / 1e3;
+      if (clip.kenBurns) {
+        ref = stepRef(push({
+          op: "ken_burns",
+          label: `Ken Burns (${clip.kenBurns.direction})`,
+          primaryInput: urlRef(stillSrc(clip)),
+          params: {
+            width: canvasW,
+            height: canvasH,
+            fps,
+            duration_ms: Math.round(seconds * 1e3),
+            zoom_start: clip.kenBurns.zoomStart,
+            zoom_end: clip.kenBurns.zoomEnd,
+            direction: clip.kenBurns.direction
+          }
+        }));
+      } else {
+        ref = stepRef(push({
+          op: "slideshow",
+          label: `Image \u2192 ${seconds.toFixed(1)}s clip`,
+          primaryInput: urlRef(stillSrc(clip)),
+          params: {
+            duration_per_image: r3(seconds),
+            fps
+          }
+        }));
+      }
+    } else {
+      let trimEnd = clip.trimEndSec;
+      let speed = clip.speed;
+      if (hold > 0) {
+        const source = clip.sourceDurationSec;
+        const outPoint = (_a2 = trimEnd != null ? trimEnd : source) != null ? _a2 : null;
+        const extended = outPoint === null ? null : outPoint + hold / 1e3 * speed;
+        if (source && extended !== null && extended <= source + 1e-6) {
+          trimEnd = r3(extended);
+        } else if (source && outPoint !== null) {
+          const len = (outPoint - clip.trimStartSec) / speed;
+          const slowed = Math.floor((source - clip.trimStartSec) / (len + hold / 1e3) * 1e3) / 1e3;
+          if (slowed >= speed * MIN_HOLD_SLOWDOWN) {
+            trimEnd = source;
+            speed = slowed;
+          } else unheldMs += hold;
+        } else unheldMs += hold;
+      }
+      ref = urlRef(clip.src);
+      const coversSource = clip.trimStartSec <= 0 && (trimEnd === null || clip.sourceDurationSec != null && trimEnd >= clip.sourceDurationSec);
+      if (!coversSource) {
+        const end = (_b2 = trimEnd != null ? trimEnd : clip.sourceDurationSec) != null ? _b2 : null;
+        ref = stepRef(push({
+          op: "trim",
+          label: `Trim ${clip.trimStartSec.toFixed(1)}\u2013${end === null ? "end" : `${end.toFixed(1)}s`}`,
+          primaryInput: ref,
+          params: __spreadValues({
+            start_secs: clip.trimStartSec
+          }, end === null ? {} : {
+            end_secs: end
+          })
+        }));
+      }
+      if (speed !== 1) {
+        ref = stepRef(push({
+          op: "speed",
+          label: `Speed \xD7${speed}`,
+          primaryInput: ref,
+          params: {
+            factor: speed
+          }
+        }));
+      }
+    }
+    const grade = (_c2 = FILTER_GRADE[clip.filter]) != null ? _c2 : null;
+    if (grade) {
+      ref = stepRef(push({
+        op: "color_adjust",
+        label: `Grade (${clip.filter})`,
+        primaryInput: ref,
+        params: __spreadValues({}, grade)
+      }));
+    }
+    return levelOps(ref, clip);
+  });
+  const segments = (_c = spec.segments) != null ? _c : [];
+  const pieces = segmentPieces(segments, totalSec);
+  const blurs = segments.filter((s) => s.kind === "blur" && s.blur && s.durationSec > 0);
+  const mixedSources = new Set(clips.map((c) => `${c.fillColor || colorFromSolidSrc(c.src) ? "solid" : c.src}|${c.kenBurns ? "kb" : "raw"}`)).size > 1;
+  const normalized = clips.length > 1 && mixedSources || pieces.some((p) => p.window) || blurs.length > 0;
+  if (normalized) {
+    for (let i = 0; i < segmentRefs.length; i++) {
+      segmentRefs[i] = stepRef(push({
+        op: "letterbox",
+        label: `Fit scene ${i + 1} \u2192 ${canvasW}\xD7${canvasH}`,
+        primaryInput: segmentRefs[i],
+        params: {
+          width: canvasW,
+          height: canvasH,
+          color: "black"
+        }
+      }));
+    }
+  }
+  const textStep = (base, t, from, to) => stepRef(push({
+    op: "overlay_text",
+    label: `Text "${t.text.slice(0, 24)}"`,
+    primaryInput: base,
+    params: {
+      text: t.text,
+      // Normalized editor position -> ffmpeg expressions on the real frame, text-centre anchored.
+      x: `(w-text_w)*${t.x.toFixed(3)}`,
+      y: `(h-text_h)*${t.y.toFixed(3)}`,
+      font_size: 36,
+      font_color: "white",
+      start_secs: r3(Math.max(0, from)),
+      end_secs: r3(to)
+    }
+  }));
+  const sceneIndex = new Map(clips.map((c, i) => [c.id, i]).filter(([id]) => !!id));
+  const crosses = (i) => Boolean(clips[i].transitionIn) || holdMs(i) > 0;
+  const frame = 1 / fps;
+  const ridesScene = /* @__PURE__ */ new Set();
+  let cutAtTransition = 0;
+  const texts = spec.texts.filter((t) => t.text.trim() && t.durationSec > 0);
+  texts.forEach((t, k) => {
+    const i = t.sceneId == null ? void 0 : sceneIndex.get(t.sceneId);
+    if (i === void 0 || !crosses(i)) return;
+    const span = spans[i];
+    const end = t.startSec + t.durationSec;
+    const inside = t.startSec >= span.start - frame && end <= span.end + frame;
+    const covered = texts.slice(0, k).some((below) => !ridesScene.has(below.id) && below.startSec < end && below.startSec + below.durationSec > t.startSec);
+    if (!inside || covered) {
+      cutAtTransition += 1;
+      return;
+    }
+    ridesScene.add(t.id);
+    const heldThroughCut = end >= span.end - frame;
+    segmentRefs[i] = textStep(segmentRefs[i], t, t.startSec - span.start, end - span.start + (heldThroughCut ? holdMs(i) / 1e3 : 0));
+  });
+  if (cutAtTransition > 0) {
+    warnings.push(`${cutAtTransition} title${cutAtTransition === 1 ? "" : "s"} of a scene with a transition run${cutAtTransition === 1 ? "s" : ""} past the scene, so ${cutAtTransition === 1 ? "it cuts" : "they cut"} at the transition instead of crossing it.`);
+  }
+  let baseRef = segmentRefs[0];
+  let pending = [];
+  const flush = () => {
+    if (!pending.length) return;
+    baseRef = stepRef(push({
+      op: "concat",
+      label: `Join ${pending.length + 1} clips`,
+      primaryInput: baseRef,
+      params: {
+        reencode: true
+      },
+      inputRefs: {
+        input_urls: pending
+      }
+    }));
+    pending = [];
+  };
+  for (let i = 1; i < segmentRefs.length; i++) {
+    const transition = clips[i].transitionIn;
+    if (!transition || !(transition.durationMs > 0)) {
+      pending.push(segmentRefs[i]);
+      continue;
+    }
+    flush();
+    baseRef = stepRef(push({
+      op: "transition",
+      label: `Transition (${transition.effect})`,
+      primaryInput: baseRef,
+      params: {
+        effect: transition.effect,
+        duration_ms: transition.durationMs
+      },
+      inputRefs: {
+        input2_url: segmentRefs[i]
+      }
+    }));
+  }
+  flush();
+  if (unheldMs > 0) {
+    warnings.push(`A transition after a video clip overlaps the two clips, so the export runs ${(unheldMs / 1e3).toFixed(1)}s shorter than the timeline and later titles land that much late; end that clip earlier in its source, put a still before it, or cut instead.`);
+  }
+  for (const t of texts) {
+    if (!ridesScene.has(t.id)) baseRef = textStep(baseRef, t, t.startSec, t.startSec + t.durationSec);
+  }
+  for (const seg of blurs) {
+    const b = seg.blur;
+    const x = Math.floor(pctToPx(b.x, canvasW) / 2) * 2;
+    const y = Math.floor(pctToPx(b.y, canvasH) / 2) * 2;
+    const span = stepRef(push({
+      op: "trim",
+      label: `Blur span ${seg.startSec.toFixed(1)}\u2013${segEnd(seg).toFixed(1)}s`,
+      primaryInput: baseRef,
+      params: {
+        start_secs: r3(seg.startSec),
+        end_secs: r3(segEnd(seg))
+      }
+    }));
+    const blurred = stepRef(push({
+      op: "blur",
+      label: `Blur ${b.radius}px`,
+      primaryInput: span,
+      params: {
+        radius: b.radius
+      }
+    }));
+    const box = stepRef(push({
+      op: "crop",
+      label: "Blur box",
+      primaryInput: blurred,
+      params: {
+        x: String(x),
+        y: String(y),
+        width: String(Math.min(evenPx(pctToPx(b.width, canvasW)), canvasW - x)),
+        height: String(Math.min(evenPx(pctToPx(b.height, canvasH)), canvasH - y))
+      }
+    }));
+    baseRef = stepRef(push({
+      op: "picture_in_picture",
+      label: `Paste ${seg.name || "blur"}`,
+      primaryInput: baseRef,
+      params: {
+        x,
+        y,
+        start_ms: Math.round(seg.startSec * 1e3),
+        end_ms: Math.round(segEnd(seg) * 1e3)
+      },
+      inputRefs: {
+        overlay_url: box
+      }
+    }));
+  }
+  baseRef = compileAudio(spec, baseRef, spans, push, warnings);
+  if (!pieces.length && segments.some((s) => s.kind === "trim" && s.durationSec > 0) && totalSec > 0) {
+    warnings.push("Trim segments cover the whole cut - nothing is left to export.");
+  }
+  const effective = pieces.length > 1 || pieces.some((p) => p.speed || p.window || p.from > 0 || p.to < totalSec);
+  if (effective) {
+    const refs = pieces.map((piece, i) => {
+      let ref = stepRef(push({
+        op: "trim",
+        label: `Segment ${i + 1}`,
+        primaryInput: baseRef,
+        params: {
+          start_secs: r3(piece.from),
+          end_secs: r3(piece.to)
+        }
+      }));
+      if (piece.window) {
+        const win = piece.window;
+        const w = evenPx(pctToPx(win.width, canvasW));
+        const h = evenPx(pctToPx(win.height, canvasH));
+        ref = stepRef(push({
+          op: "crop",
+          label: `Window ${w}\xD7${h}`,
+          primaryInput: ref,
+          params: {
+            x: String(pctToPx(win.x, canvasW)),
+            y: String(pctToPx(win.y, canvasH)),
+            width: String(w),
+            height: String(h)
+          }
+        }));
+        const fills = Math.abs(w / h - canvasW / canvasH) < 0.01;
+        ref = stepRef(push(fills ? {
+          op: "transcode",
+          label: `Window \u2192 ${canvasW}\xD7${canvasH}`,
+          primaryInput: ref,
+          params: {
+            resolution: `${canvasW}x${canvasH}`
+          }
+        } : {
+          op: "letterbox",
+          label: `Window \u2192 ${canvasW}\xD7${canvasH}`,
+          primaryInput: ref,
+          params: {
+            width: canvasW,
+            height: canvasH,
+            color: "black"
+          }
+        }));
+      }
+      if (piece.speed) {
+        ref = stepRef(push({
+          op: "speed",
+          label: `Speed \xD7${piece.speed}`,
+          primaryInput: ref,
+          params: {
+            factor: piece.speed
+          }
+        }));
+      }
+      return ref;
+    });
+    baseRef = refs.length > 1 ? stepRef(push({
+      op: "concat",
+      label: `Join ${refs.length} segments`,
+      primaryInput: refs[0],
+      params: {
+        reencode: true
+      },
+      inputRefs: {
+        input_urls: refs.slice(1)
+      }
+    })) : refs[0];
+  }
+  return {
+    steps,
+    finalRef: baseRef,
+    warnings
+  };
+}
+function compileAudio(spec, base, spans, push, warnings) {
+  var _a, _b, _c;
+  const sceneAudio = ((_a = spec.sceneAudio) != null ? _a : []).filter((a) => a.audioUrl);
+  let baseRef = base;
+  if (!sceneAudio.length) {
+    if (spec.soundtrack) {
+      baseRef = stepRef(push({
+        op: "add_audio",
+        label: "Soundtrack",
+        primaryInput: baseRef,
+        params: {
+          replace_existing: spec.soundtrack.mode === "replace"
+        },
+        inputRefs: {
+          audio_input_url: urlRef(spec.soundtrack.audioUrl)
+        }
+      }));
+    }
+    if (spec.voiceover) {
+      baseRef = stepRef(push({
+        op: "add_audio",
+        label: "Voiceover",
+        primaryInput: baseRef,
+        // A replace-mode voiceover must not erase the soundtrack muxed a step earlier.
+        params: {
+          replace_existing: spec.voiceover.mode === "replace" && !spec.soundtrack
+        },
+        inputRefs: {
+          audio_input_url: urlRef(spec.voiceover.audioUrl)
+        }
+      }));
+    }
+    return baseRef;
+  }
+  const refs = [];
+  const lane = (src, at, sliceFrom, sliceTo, level, label) => {
+    let ref = urlRef(src);
+    if (sliceFrom > 0 || sliceTo !== null) {
+      ref = stepRef(push({
+        op: "trim",
+        label: `Trim ${label}`,
+        primaryInput: ref,
+        params: __spreadValues({
+          start_secs: r3(sliceFrom)
+        }, sliceTo === null ? {} : {
+          end_secs: r3(sliceTo)
+        }),
+        audioOnly: true
+      }));
+    }
+    if (level < 0.99) {
+      ref = stepRef(push({
+        op: "volume",
+        label: `${label} ${Math.round(level * 100)}%`,
+        primaryInput: ref,
+        params: {
+          level
+        }
+      }));
+    }
+    if (at > 5e-4) {
+      ref = stepRef(push({
+        op: "audio_delay",
+        label: `${label} at ${at.toFixed(1)}s`,
+        primaryInput: ref,
+        params: {
+          delay_ms: Math.round(at * 1e3)
+        },
+        audioOnly: true
+      }));
+    }
+    refs.push(ref);
+  };
+  const replaced = ((_b = spec.soundtrack) == null ? void 0 : _b.mode) === "replace" || ((_c = spec.voiceover) == null ? void 0 : _c.mode) === "replace";
+  if (!replaced) {
+    let skipped = 0;
+    spec.clips.forEach((clip, i) => {
+      if (clip.type !== "video" || clip.muted || clip.volume <= 0 || clip.hasAudio === false) return;
+      const len = spans[i].end - spans[i].start;
+      if (clip.speed !== 1 || len <= 0) {
+        skipped += 1;
+        return;
+      }
+      lane(clip.src, spans[i].start, clip.trimStartSec, clip.trimStartSec + len, clip.volume, `Scene ${i + 1} sound`);
+    });
+    if (skipped) {
+      warnings.push(`${skipped} sped-up or open-ended video scene${skipped === 1 ? "" : "s"} lose${skipped === 1 ? "s" : ""} its own sound where scene audio is mixed in.`);
+    }
+  }
+  if (spec.soundtrack) lane(spec.soundtrack.audioUrl, 0, 0, null, 1, "Soundtrack");
+  if (spec.voiceover) lane(spec.voiceover.audioUrl, 0, 0, null, 1, "Voiceover");
+  sceneAudio.forEach((a, i) => {
+    var _a2, _b2;
+    return lane(a.audioUrl, a.startSec, 0, a.durationSec, (_a2 = a.volume) != null ? _a2 : 1, ((_b2 = a.label) == null ? void 0 : _b2.slice(0, 20)) || `Audio ${i + 1}`);
+  });
+  const [first, ...rest] = refs;
+  const mixRef = rest.length ? stepRef(push({
+    op: "audio_mix",
+    label: `Mix ${refs.length} audio clips`,
+    primaryInput: first,
+    params: {
+      duration: "longest",
+      normalize: false
+    },
+    inputRefs: {
+      input_urls: rest
+    },
+    audioOnly: true
+  })) : first;
+  return stepRef(push({
+    op: "add_audio",
+    label: "Set audio",
+    primaryInput: baseRef,
+    params: {
+      replace_existing: true
+    },
+    inputRefs: {
+      audio_input_url: mixRef
+    }
+  }));
+}
+function specMixesSceneAudio(spec) {
+  var _a;
+  return ((_a = spec.sceneAudio) != null ? _a : []).some((a) => a.audioUrl);
+}export{DEFAULT_CANVAS,FILTER_GRADE,MIN_HOLD_SLOWDOWN,ZOOM_SCALE,canvasForAspect,canvasForRatio,compileTimeline,segmentPieces,specClipSec,specMixesSceneAudio,zoomWindow};//# sourceMappingURL=compileTimeline.js.map