@hraness/slopcamera 3.2.4

package/apps/desktop/core/time-map.ts

@@ -0,0 +1,91 @@
+import type { EditPlanV1, SourceInterval } from "../contracts/edit";
+import { TimeMapSegmentSchema, type TimeMapSegment } from "../contracts/render";
+import { intersectIntervals } from "./intervals";
+
+export interface SourceTimeMap {
+  readonly durationUs: number;
+  readonly segments: readonly TimeMapSegment[];
+}
+
+function rateAt(plan: EditPlanV1, sourceTimeUs: number): number {
+  return plan.speed.find(({ range }) => range.startUs <= sourceTimeUs && sourceTimeUs < range.endUs)?.rate
+    ?? plan.baseSpeed;
+}
+
+export function buildSourceTimeMap(plan: EditPlanV1): SourceTimeMap {
+  const segments: TimeMapSegment[] = [];
+  let outputCursorUs = 0;
+  for (const keep of plan.keep) {
+    const boundaries = new Set<number>([keep.startUs, keep.endUs]);
+    for (const speed of plan.speed) {
+      if (speed.range.startUs > keep.startUs && speed.range.startUs < keep.endUs) boundaries.add(speed.range.startUs);
+      if (speed.range.endUs > keep.startUs && speed.range.endUs < keep.endUs) boundaries.add(speed.range.endUs);
+    }
+    const points = [...boundaries].sort((left, right) => left - right);
+    for (let index = 1; index < points.length; index += 1) {
+      const startUs = points[index - 1];
+      const endUs = points[index];
+      if (startUs === undefined || endUs === undefined || endUs <= startUs) continue;
+      const speed = rateAt(plan, startUs);
+      const outputDurationUs = Math.max(1, Math.round((endUs - startUs) / speed));
+      const segment = TimeMapSegmentSchema.parse({
+        output: { startUs: outputCursorUs, endUs: outputCursorUs + outputDurationUs },
+        source: { startUs, endUs },
+        speed,
+      });
+      segments.push(segment);
+      outputCursorUs += outputDurationUs;
+    }
+  }
+  return { durationUs: outputCursorUs, segments };
+}
+
+function interpolate(
+  value: number,
+  inputStart: number,
+  inputEnd: number,
+  outputStart: number,
+  outputEnd: number,
+): number {
+  const ratio = (value - inputStart) / (inputEnd - inputStart);
+  return Math.round(outputStart + ratio * (outputEnd - outputStart));
+}
+
+export function sourceToOutputUs(map: SourceTimeMap, sourceTimeUs: number): number | null {
+  const segment = map.segments.find(({ source }) => source.startUs <= sourceTimeUs && sourceTimeUs < source.endUs)
+    ?? [...map.segments].reverse().find(({ source }) => source.endUs === sourceTimeUs);
+  if (segment === undefined) return null;
+  return interpolate(
+    sourceTimeUs,
+    segment.source.startUs,
+    segment.source.endUs,
+    segment.output.startUs,
+    segment.output.endUs,
+  );
+}
+
+export function outputToSourceUs(map: SourceTimeMap, outputTimeUs: number): number | null {
+  const segment = map.segments.find(({ output }) => output.startUs <= outputTimeUs && outputTimeUs < output.endUs)
+    ?? map.segments.at(-1);
+  if (segment === undefined || outputTimeUs < 0 || outputTimeUs > map.durationUs) return null;
+  if (outputTimeUs < segment.output.startUs || outputTimeUs > segment.output.endUs) return null;
+  return interpolate(
+    outputTimeUs,
+    segment.output.startUs,
+    segment.output.endUs,
+    segment.source.startUs,
+    segment.source.endUs,
+  );
+}
+
+export function mapSourceInterval(
+  map: SourceTimeMap,
+  interval: SourceInterval,
+): readonly { readonly source: SourceInterval; readonly output: SourceInterval }[] {
+  return map.segments.flatMap((segment) => intersectIntervals([interval], [segment.source]).flatMap((source) => {
+    const outputStart = sourceToOutputUs(map, source.startUs);
+    const outputEnd = sourceToOutputUs(map, source.endUs);
+    if (outputStart === null || outputEnd === null || outputEnd <= outputStart) return [];
+    return [{ source, output: { startUs: outputStart, endUs: outputEnd } }];
+  }));
+}

package/apps/desktop/core/time.ts

@@ -0,0 +1,61 @@
+const TIME_TOKEN = /(?:([0-9]+(?:\.[0-9]+)?)(ms|us|h|m|s))/gyu;
+
+function exactIntegerMicroseconds(value: number): number {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("Time literal must resolve to a non-negative, safe integer number of microseconds.");
+  }
+  return value;
+}
+
+export function parseTimeLiteral(input: string): number {
+  const value = input.trim();
+  if (value.length === 0) throw new Error("Time literal cannot be empty.");
+
+  const clock = /^(?:(\d+):)?([0-5]?\d):([0-5]?\d)(?:\.(\d{1,6}))?$/u.exec(value);
+  if (clock !== null) {
+    const hours = Number(clock[1] ?? "0");
+    const minutes = Number(clock[2]);
+    const seconds = Number(clock[3]);
+    const fractionUs = Number((clock[4] ?? "").padEnd(6, "0"));
+    return exactIntegerMicroseconds((((hours * 60 + minutes) * 60 + seconds) * 1_000_000) + fractionUs);
+  }
+
+  let cursor = 0;
+  let totalUs = 0;
+  let matched = false;
+  TIME_TOKEN.lastIndex = 0;
+  while (cursor < value.length) {
+    TIME_TOKEN.lastIndex = cursor;
+    const match = TIME_TOKEN.exec(value);
+    if (match === null || match.index !== cursor) {
+      throw new Error(`Invalid time literal at offset ${cursor}: ${input}`);
+    }
+    matched = true;
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const multiplier = unit === "h"
+      ? 3_600_000_000
+      : unit === "m"
+        ? 60_000_000
+        : unit === "s"
+          ? 1_000_000
+          : unit === "ms"
+            ? 1_000
+            : 1;
+    totalUs += amount * multiplier;
+    cursor = TIME_TOKEN.lastIndex;
+  }
+  if (!matched) throw new Error(`Invalid time literal: ${input}`);
+  return exactIntegerMicroseconds(totalUs);
+}
+
+export function formatTimeLiteral(timeUs: number): string {
+  exactIntegerMicroseconds(timeUs);
+  const hours = Math.floor(timeUs / 3_600_000_000);
+  const minutes = Math.floor((timeUs % 3_600_000_000) / 60_000_000);
+  const seconds = Math.floor((timeUs % 60_000_000) / 1_000_000);
+  const fraction = timeUs % 1_000_000;
+  const prefix = hours > 0 ? `${hours}:${String(minutes).padStart(2, "0")}` : String(minutes);
+  const suffix = fraction === 0 ? "" : `.${String(fraction).padStart(6, "0").replace(/0+$/u, "")}`;
+  return `${prefix}:${String(seconds).padStart(2, "0")}${suffix}`;
+}