reelkit-cli 0.8.0 → 0.10.2

package/src/render/worker.ts

@@ -0,0 +1,71 @@
+// Internal subprocess: HyperFrames owns capture, encoding and audio mixing.
+import { execFile } from "node:child_process";
+import { cp, mkdir, mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, extname } from "node:path";
+import { promisify } from "node:util";
+import { createCaptureSession, initializeSession, captureFrame, closeCaptureSession, encodeFramesFromDir, processCompositionAudio, muxVideoWithAudio, applyFaststart, type AudioElement } from "@hyperframes/engine";
+import { serveComposition } from "./serve";
+import type { VideoProps } from "../hyperframes/types";
+import type { AudioRecord } from "../hyperframes/frame";
+import type { RenderOptions } from "./render";
+
+const run = promisify(execFile);
+const input = JSON.parse(await readFile(process.argv[2]!, "utf8")) as { dir: string; props: VideoProps; mode: "stills" | "video"; output: string; frames: number[]; options?: RenderOptions; chromePath?: string };
+const m = input.props.manifest, fps = { num: m.fps, den: 1 };
+const work = await mkdtemp(join(tmpdir(), "reelkit-capture-"));
+const server = await serveComposition(input.dir);
+let session: Awaited<ReturnType<typeof createCaptureSession>> | undefined;
+try {
+  session = await createCaptureSession(server.url.replace(/\/$/, ""), work, { width: m.width, height: m.height, fps, format: "png", compositionDurationSeconds: m.totalFrames / m.fps }, async (page) => {
+    await page.evaluate(async () => { await (window as unknown as { __reelkitReady: Promise<void> }).__reelkitReady; });
+  }, { chromePath: input.chromePath, forceScreenshot: true, useDrawElement: false, staticFrameDedup: false, enableBrowserPool: false, browserGpuMode: input.options?.uses3D ? "software" : "auto" });
+  await initializeSession(session);
+  await session.page.evaluate(async () => { await (window as unknown as { __reelkitReady: Promise<void> }).__reelkitReady; });
+  const frames = input.mode === "stills" ? input.frames : Array.from({ length: m.totalFrames }, (_, i) => i);
+  for (const frame of frames) {
+    if (!Number.isInteger(frame) || frame < 0 || frame >= m.totalFrames) throw new Error(`Frame ${frame} is outside the composition.`);
+    const captured = await captureFrame(session, frame, frame / m.fps);
+    if (input.mode === "stills") await cp(captured.path, join(input.output, `still-${frame}.png`));
+  }
+  if (input.mode === "video") {
+    const silent = join(work, "silent.mp4");
+    const encoded = await encodeFramesFromDir(work, "frame_%06d.png", silent, { fps, width: m.width, height: m.height, codec: "h264", pixelFormat: "yuv420p", quality: input.options?.crf ?? 18, preset: "fast" });
+    if (!encoded.success) throw new Error(encoded.error ?? "HyperFrames encoding failed.");
+    const records = input.options?.silent ? [] : await session.page.evaluate(() => [...(window as unknown as { __reelkitAudio: Map<string, AudioRecord> }).__reelkitAudio.values()]);
+    const audio: AudioElement[] = [];
+    const localSources = new Map<string, string>();
+    for (const record of records) {
+      let src = localSources.get(record.src);
+      if (!src) {
+        const response = await fetch(record.src); if (!response.ok) throw new Error(`Audio source returned ${response.status}.`);
+        src = join(work, `source-${localSources.size}${extname(new URL(record.src).pathname) || ".media"}`);
+        await writeFile(src, new Uint8Array(await response.arrayBuffer())); localSources.set(record.src, src);
+      }
+      const info = JSON.parse((await run("ffprobe", ["-v", "error", "-show_format", "-of", "json", src])).stdout) as { format: { duration: string } };
+      let end = Math.min(record.end, record.start + Number(info.format.duration) - record.mediaStart);
+      if (record.loop) {
+        const looped = join(work, `loop-${audio.length}.wav`);
+        await run("ffmpeg", ["-y", "-v", "error", "-stream_loop", "-1", "-i", src, "-t", String(record.end - record.start + record.mediaStart), "-vn", looped]);
+        src = looped; end = record.end;
+      }
+      if (end <= record.start) continue;
+      const keys = [...new Map(record.volumeKeyframes.map((k) => [k.time, k])).values()].sort((a, b) => a.time - b.time);
+      audio.push({ ...record, src, end, volumeKeyframes: keys.length ? keys : undefined });
+    }
+    if (audio.length) {
+      const mixed = join(work, "audio.m4a");
+      const result = await processCompositionAudio(audio, work, join(work, "audio-work"), mixed, m.totalFrames / m.fps);
+      if (!result.success) throw new Error(result.error ?? "HyperFrames audio mixing failed.");
+      const muxed = await muxVideoWithAudio(silent, mixed, input.output, undefined, { audioCodec: "aac" });
+      if (!muxed.success) throw new Error(muxed.error ?? "HyperFrames audio mux failed.");
+    } else {
+      await mkdir(join(work, "faststart"));
+      const result = await applyFaststart(silent, input.output);
+      if (!result.success) throw new Error(result.error ?? "Faststart failed.");
+    }
+  }
+} finally {
+  if (session) await closeCaptureSession(session);
+  await server.close(); await rm(work, { recursive: true, force: true });
+}

package/src/testing/fixtures.ts

@@ -12,7 +12,7 @@ export const PIXEL_PNG = new Uint8Array(Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAE
 
 // A known-good composition, used as the worked example for composition authors.
 export const FIXTURE_COMPOSITION = `import React from "react";
-import { AbsoluteFill, useVideoConfig } from "remotion";
+import { AbsoluteFill, useVideoConfig } from "reelkit/frame";
 import { BgMesh, Captions, FootageLayer, fonts, Grade, Grain, KenBurnsImage, palettes, SceneFrame, Vignette, Voiceover, WordReveal } from "reelkit/kit";
 import type { VideoProps } from "reelkit/kit";
 

package/src/remotion/Root.tsx

@@ -1,31 +0,0 @@
-import React from "react";
-import { Composition } from "remotion";
-import { ManifestContext, UrlsContext } from "./kit/media";
-import type { VideoProps } from "./types";
-
-const EMPTY: VideoProps = { manifest: { fps: 30, width: 1080, height: 1920, totalFrames: 1, scenes: [] }, urls: {} };
-
-export const makeRoot = (Video: React.FC<VideoProps>): React.FC => {
-  const WithMedia: React.FC<VideoProps> = (props) => (
-    <UrlsContext.Provider value={props.urls}>
-      <ManifestContext.Provider value={props.manifest}>
-        <Video {...props} />
-      </ManifestContext.Provider>
-    </UrlsContext.Provider>
-  );
-  return () => (
-  <Composition
-    id="Video"
-    component={WithMedia as unknown as React.FC<Record<string, unknown>>}
-    durationInFrames={1}
-    fps={30}
-    width={1080}
-    height={1920}
-    defaultProps={EMPTY as unknown as Record<string, unknown>}
-    calculateMetadata={({ props }) => {
-      const m = (props as unknown as VideoProps).manifest;
-      return { durationInFrames: m.totalFrames, fps: m.fps, width: m.width, height: m.height };
-    }}
-  />
-);
-};