Skip to content

armgit / hypit

Public Imported from GitHub
0

Clone any viral video with AI agents. Not just a script, the whole workflow: swap the face, the words, the B-roll, ship 100 variants in one command, and get your 100M views.

8.4 KB
Raw Blame
import { assertVisualTrackIdentity, sealVisualTrack } from "@hypit/composition";
import type { VisualTrack } from "@hypit/composition";
import { canonicalize } from "@hypit/hypit/protocol";
import { assertSpatialFrame, assertSpatialPath } from "@hypit/spatial";
import type { SpatialPath } from "@hypit/spatial";
import { assertTemporalWindowFor } from "@hypit/temporal";
import type { TemporalWindow } from "@hypit/temporal";
import { assertTimelineIdentity, timelineFrameCount } from "@hypit/timeline";
import type { Timeline } from "@hypit/timeline";

import {
  assertMediaIdentity,
  assertMediaLayerSet,
} from "./layers.js";
import { lowerVisualClipElements } from "./lower.js";
import { assertVisualClipMotion, poseAnimation } from "./motion.js";
import { assertVisualFrameTreatment } from "./frame-treatment.js";
import { assertMediaLayerPrograms, assertResolvedSampleLayer, resolveMediaLayerPrograms } from "./spatial.js";
import type {
  MediaLayerSet,
  MediaSampleLayerProgram,
  VisualClipProgram,
  VisualClipMotion,
  VisualClipSpec,
  VisualTrackHeader,
  VisualTrackProgram,
  VisualTrackSet,
} from "./types.js";

function assert(condition: unknown, message: string): asserts condition {
  if (!condition) throw new Error(message);
}

export function bindVisualClipPath(spec: VisualClipSpec, path: SpatialPath): VisualClipSpec {
  assertVisualClipSpec(spec);
  assertSpatialPath(path);
  return sealVisualClipSpec({
    ...spec,
    treatment: { ...spec.treatment, clip: { kind: "path", path: structuredClone(path) } },
  });
}

export function bindVisualClipMotion(spec: VisualClipSpec, motion: VisualClipMotion): VisualClipSpec {
  assertVisualClipSpec(spec);
  assertVisualClipMotion(motion, "VisualClipMotion");
  return sealVisualClipSpec({ ...spec, motion: structuredClone(motion) });
}

export function assertVisualClipSpec(value: VisualClipSpec): void {
  assertMediaIdentity(value.id, "VisualClipSpec.id");
  assertVisualFrameTreatment(value.treatment, "VisualClipSpec.treatment");
  if (value.motion !== undefined) assertVisualClipMotion(value.motion, "VisualClipSpec.motion");
  assert(Number.isSafeInteger(value.z), "VisualClipSpec.z must be an integer.");
}

export function sealVisualClipSpec(value: VisualClipSpec): VisualClipSpec {
  assertVisualClipSpec(value);
  return canonicalize(value) as unknown as VisualClipSpec;
}

export function sealVisualTrackHeader(value: VisualTrackHeader): VisualTrackHeader {
  assertVisualTrackHeader(value);
  return canonicalize(value) as unknown as VisualTrackHeader;
}

export function assertVisualTrackHeader(value: VisualTrackHeader): void {
  assertMediaIdentity(value.id, "VisualTrackHeader.id");
}

export function createVisualTrackSet(): VisualTrackSet {
  return { clips: [] };
}

export function assertVisualTrackSet(value: VisualTrackSet): void {
  assert(Array.isArray(value.clips), "VisualTrackSet is invalid.");
}

/** Component entry point: source facts, absolute placement and visual treatment are already explicit. */
export function appendVisualClip(
  set: VisualTrackSet,
  header: VisualTrackHeader,
  timeline: Timeline,
  layers: MediaLayerSet,
  frame: VisualClipProgram["frame"],
  spec: VisualClipSpec,
  window: TemporalWindow,
): VisualTrackSet {
  assertVisualTrackSet(set);
  assertVisualTrackHeader(header);
  assertTimelineIdentity(timeline);
  assertMediaLayerSet(layers);
  assert(layers.layers.length > 0, `Visual Clip ${spec.id} requires at least one layer.`);
  assertSpatialFrame(frame);
  assertVisualClipSpec(spec);
  assertTemporalWindowFor(window, { subjectId: spec.id, timeline });
  const resolvedLayers = resolveMediaLayerPrograms(layers, frame, spec.treatment);
  const duration = window.span.endFrameExclusive - window.span.startFrame;
  if (spec.motion !== undefined) {
    assertVisualClipMotion(spec.motion, `Visual Clip ${spec.id} motion`);
    poseAnimation(spec.motion, duration);
  }
  const addition: VisualClipProgram = {
    id: window.id,
    subjectId: spec.id,
    span: { ...window.span },
    frame: { ...frame },
    treatment: structuredClone(spec.treatment),
    layers: structuredClone(resolvedLayers),
    ...(spec.motion === undefined ? {} : { motion: structuredClone(spec.motion) }),
    order: set.clips.length,
    z: spec.z,
  };
  assert(!set.clips.some((clip) => clip.id === addition.id), `Visual Track ${header.id} already contains ${addition.id}.`);
  return { clips: [...set.clips, addition] };
}

function assertSampleLayerForTimeline(layer: MediaSampleLayerProgram, timeline: Timeline, label: string): void {
  assertResolvedSampleLayer(layer, label);
  const timing = layer.source.kind === "timed"
    ? { frameRate: layer.source.frameRate, frameCount: layer.source.frameCount }
    : layer.source.kind === "surface" && layer.source.surface.timing.kind === "frames"
      ? layer.source.surface.timing
      : undefined;
  if (timing === undefined) {
    assert(layer.sourceTime === undefined, `${label} is still material and cannot have source time.`);
    return;
  }
  assert(
    timing.frameRate.numerator === timeline.frameRate.numerator
      && timing.frameRate.denominator === timeline.frameRate.denominator,
    `${label} is not normalized to Timeline frame rate.`,
  );
  assert(layer.sourceTime !== undefined, `${label} requires source time.`);
}

function assertClip(clip: VisualClipProgram, timeline: Timeline, label: string): void {
  assertMediaIdentity(clip.id, `${label}.id`);
  assertMediaIdentity(clip.subjectId, `${label}.subjectId`);
  assert(
    Number.isSafeInteger(clip.span.startFrame)
      && Number.isSafeInteger(clip.span.endFrameExclusive)
      && clip.span.startFrame >= 0
      && clip.span.endFrameExclusive > clip.span.startFrame
      && clip.span.endFrameExclusive <= timelineFrameCount(timeline),
    `${label}.span is invalid.`,
  );
  assertSpatialFrame(clip.frame);
  assertVisualFrameTreatment(clip.treatment, `${label}.treatment`);
  if (clip.motion !== undefined) {
    assertVisualClipMotion(clip.motion, `${label}.motion`);
    poseAnimation(clip.motion, clip.span.endFrameExclusive - clip.span.startFrame);
  }
  assert(Number.isSafeInteger(clip.order) && clip.order >= 0, `${label}.order is invalid.`);
  assert(Number.isSafeInteger(clip.z), `${label}.z is invalid.`);
  assert(clip.layers.length > 0, `${label} requires layers.`);
  assertMediaLayerPrograms(clip.layers);
  for (const layer of clip.layers) {
    if (layer.kind === "sample") assertSampleLayerForTimeline(layer, timeline, `${label}.${layer.id}`);
  }
}

function normalizeProgram(value: VisualTrackProgram): VisualTrackProgram {
  return {
    id: value.id,
    clips: [...value.clips].map((clip) => structuredClone(clip)).sort((left, right) => left.id.localeCompare(right.id)),
  };
}

export function sealVisualTrackProgram(value: VisualTrackProgram, timeline: Timeline): VisualTrackProgram {
  const normalized = normalizeProgram(value);
  assertVisualTrackProgramIdentity(normalized, timeline);
  return canonicalize(normalized) as unknown as VisualTrackProgram;
}

export function finalizeVisualTrack(set: VisualTrackSet, header: VisualTrackHeader, timeline: Timeline): VisualTrackProgram {
  assertVisualTrackSet(set);
  assertVisualTrackHeader(header);
  assert(set.clips.length > 0, "Visual Track requires at least one Clip.");
  return sealVisualTrackProgram({ id: header.id, clips: set.clips }, timeline);
}

export function assertVisualTrackProgram(value: VisualTrackProgram): void {
  assertMediaIdentity(value.id, "VisualTrackProgram.id");
  assert(Array.isArray(value.clips) && value.clips.length > 0, "VisualTrackProgram is empty.");
}

export function assertVisualTrackProgramIdentity(value: VisualTrackProgram, timeline: Timeline): void {
  assertVisualTrackProgram(value);
  assertTimelineIdentity(timeline);
  const ids = new Set<string>();
  for (const clip of value.clips) {
    assert(!ids.has(clip.id), `VisualTrackProgram repeats ${clip.id}.`);
    ids.add(clip.id);
    assertClip(clip, timeline, `Visual Clip ${clip.id}`);
  }
}

export function projectVisualTrack(timeline: Timeline, program: VisualTrackProgram): VisualTrack {
  assertVisualTrackProgramIdentity(program, timeline);
  const track = sealVisualTrack({
    timelineId: timeline.id,
    visualIr: "hypit.visual-ir@1",
    id: program.id,
    presents: program.clips.map((clip) => ({
      id: clip.id,
      order: clip.order,
      z: clip.z,
      subjectId: clip.subjectId,
      span: { ...clip.span },
      elements: lowerVisualClipElements(clip, timeline),
    })),
  });
  assertVisualTrackIdentity(track, timeline);
  return track;
}