Skip to content

Create polished demo videos without editing skills. Mac/Windows/Linux

Add webcam export coverage

webadderalla808eae6c714
diff --git a/src/lib/exporter/frameRenderer.test.ts b/src/lib/exporter/frameRenderer.test.ts
new file mode 100644
index 00000000..0bd7c07e
--- /dev/null
+++ b/src/lib/exporter/frameRenderer.test.ts
@@ -0,0 +1,290 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DEFAULT_WEBCAM_OVERLAY } from '@/components/video-editor/types';
+
+vi.mock('pixi.js', () => ({
+ Application: class {},
+ Container: class {},
+ Sprite: class {},
+ Graphics: class {},
+ BlurFilter: class {},
+ Texture: {
+ from: vi.fn(() => ({ destroy: vi.fn() })),
+ },
+}));
+
+vi.mock('pixi-filters/motion-blur', () => ({
+ MotionBlurFilter: class {},
+}));
+
+vi.mock('@/lib/assetPath', () => ({
+ getAssetPath: vi.fn(async (value: string) => value),
+ getRenderableAssetUrl: vi.fn((value: string) => value),
+}));
+
+vi.mock('@/components/video-editor/videoPlayback/zoomRegionUtils', () => ({
+ findDominantRegion: vi.fn(() => ({
+ region: null,
+ strength: 0,
+ blendedScale: 1,
+ transition: null,
+ })),
+}));
+
+vi.mock('@/components/video-editor/videoPlayback/zoomTransform', () => ({
+ applyZoomTransform: vi.fn(),
+ computeFocusFromTransform: vi.fn(() => ({ cx: 0.5, cy: 0.5 })),
+ computeZoomTransform: vi.fn(() => ({ scale: 1, x: 0, y: 0 })),
+ createMotionBlurState: vi.fn(() => ({})),
+}));
+
+vi.mock('./annotationRenderer', () => ({
+ renderAnnotations: vi.fn(),
+}));
+
+vi.mock('@/components/video-editor/videoPlayback/cursorRenderer', () => ({
+ PixiCursorOverlay: class {
+ container = {};
+ update = vi.fn();
+ destroy = vi.fn();
+ },
+ DEFAULT_CURSOR_CONFIG: {
+ dotRadius: 28,
+ smoothingFactor: 0.18,
+ motionBlur: 0,
+ clickBounce: 1,
+ sway: 0,
+ },
+ preloadCursorAssets: vi.fn(async () => undefined),
+}));
+
+import { FrameRenderer } from './frameRenderer';
+
+type Listener = {
+ callback: () => void;
+ once: boolean;
+};
+
+class FakeVideoElement {
+ duration: number;
+ readyState: number;
+ seeking = false;
+ videoWidth: number;
+ videoHeight: number;
+ muted = true;
+ preload = 'auto';
+ playsInline = true;
+ src = '';
+
+ private currentTimeValue: number;
+ private listeners = new Map<string, Listener[]>();
+
+ constructor({
+ duration = 5,
+ currentTime = 0,
+ readyState = 2,
+ videoWidth = 1280,
+ videoHeight = 720,
+ }: {
+ duration?: number;
+ currentTime?: number;
+ readyState?: number;
+ videoWidth?: number;
+ videoHeight?: number;
+ } = {}) {
+ this.duration = duration;
+ this.currentTimeValue = currentTime;
+ this.readyState = readyState;
+ this.videoWidth = videoWidth;
+ this.videoHeight = videoHeight;
+ }
+
+ get currentTime() {
+ return this.currentTimeValue;
+ }
+
+ set currentTime(next: number) {
+ this.currentTimeValue = next;
+ this.seeking = true;
+ queueMicrotask(() => {
+ this.seeking = false;
+ this.dispatch('seeked');
+ });
+ }
+
+ addEventListener(name: string, callback: () => void, options?: boolean | AddEventListenerOptions) {
+ const listeners = this.listeners.get(name) ?? [];
+ listeners.push({
+ callback,
+ once: !!(typeof options === 'object' && options?.once),
+ });
+ this.listeners.set(name, listeners);
+ }
+
+ removeEventListener(name: string, callback: () => void) {
+ const listeners = this.listeners.get(name) ?? [];
+ this.listeners.set(
+ name,
+ listeners.filter((listener) => listener.callback !== callback),
+ );
+ }
+
+ load() {}
+
+ pause() {}
+
+ private dispatch(name: string) {
+ const listeners = [...(this.listeners.get(name) ?? [])];
+ if (listeners.length === 0) {
+ return;
+ }
+
+ for (const listener of listeners) {
+ listener.callback();
+ if (listener.once) {
+ this.removeEventListener(name, listener.callback);
+ }
+ }
+ }
+}
+
+function createMockContext() {
+ return {
+ beginPath: vi.fn(),
+ roundRect: vi.fn(),
+ clip: vi.fn(),
+ drawImage: vi.fn(),
+ save: vi.fn(),
+ restore: vi.fn(),
+ translate: vi.fn(),
+ scale: vi.fn(),
+ clearRect: vi.fn(),
+ filter: '',
+ } as unknown as CanvasRenderingContext2D;
+}
+
+function createMockCanvas() {
+ const context = createMockContext();
+ return {
+ width: 0,
+ height: 0,
+ context,
+ getContext: vi.fn(() => context),
+ };
+}
+
+function createRenderer() {
+ return new FrameRenderer({
+ width: 1920,
+ height: 1080,
+ wallpaper: '#000000',
+ zoomRegions: [],
+ showShadow: false,
+ shadowIntensity: 0,
+ backgroundBlur: 0,
+ cropRegion: { x: 0, y: 0, width: 1, height: 1 },
+ webcam: {
+ ...DEFAULT_WEBCAM_OVERLAY,
+ enabled: true,
+ mirror: false,
+ shadow: 0,
+ },
+ webcamUrl: 'file:///tmp/webcam.webm',
+ videoWidth: 1920,
+ videoHeight: 1080,
+ });
+}
+
+describe('FrameRenderer webcam export path', () => {
+ const createdCanvases: ReturnType<typeof createMockCanvas>[] = [];
+
+ beforeEach(() => {
+ createdCanvases.length = 0;
+
+ Object.assign(globalThis, {
+ window: globalThis,
+ requestAnimationFrame: (callback: FrameRequestCallback) => {
+ callback(0);
+ return 1;
+ },
+ HTMLMediaElement: {
+ HAVE_CURRENT_DATA: 2,
+ },
+ document: {
+ createElement: vi.fn((tag: string) => {
+ if (tag !== 'canvas') {
+ throw new Error(`Unexpected element requested in test: ${tag}`);
+ }
+
+ const canvas = createMockCanvas();
+ createdCanvases.push(canvas);
+ return canvas;
+ }),
+ },
+ });
+ });
+
+ it('clamps webcam sync seeks to the media duration', async () => {
+ const renderer = createRenderer() as any;
+ const webcamVideo = new FakeVideoElement({ duration: 4.5, currentTime: 0.25 });
+ renderer.webcamVideoElement = webcamVideo;
+
+ await renderer.syncWebcamFrame(12);
+
+ expect(webcamVideo.currentTime).toBe(4.5);
+ expect(renderer.lastSyncedWebcamTime).toBe(4.5);
+ expect(renderer.webcamSeekPromise).toBeNull();
+ });
+
+ it('uses the cached webcam frame when the live video is out of sync', () => {
+ const renderer = createRenderer() as any;
+ const outputContext = createMockContext();
+ const webcamVideo = new FakeVideoElement({
+ currentTime: 2,
+ readyState: 2,
+ videoWidth: 640,
+ videoHeight: 360,
+ });
+ const cachedFrameCanvas = createMockCanvas();
+ cachedFrameCanvas.width = 640;
+ cachedFrameCanvas.height = 360;
+
+ renderer.webcamVideoElement = webcamVideo;
+ renderer.webcamFrameCacheCanvas = cachedFrameCanvas;
+ renderer.webcamFrameCacheCtx = cachedFrameCanvas.getContext('2d');
+ renderer.lastSyncedWebcamTime = 1.5;
+ renderer.currentVideoTime = 2;
+ renderer.animationState.appliedScale = 1;
+
+ renderer.drawWebcamOverlay(outputContext, 1280, 720);
+
+ const bubbleCanvas = createdCanvases[0];
+ expect(bubbleCanvas).toBeDefined();
+ expect((bubbleCanvas.context.drawImage as any).mock.calls[0][0]).toBe(cachedFrameCanvas);
+ expect((outputContext.drawImage as any).mock.calls[0][0]).toBe(bubbleCanvas);
+ });
+
+ it('uses the live webcam frame and refreshes the cache when the video is synchronized', () => {
+ const renderer = createRenderer() as any;
+ const outputContext = createMockContext();
+ const webcamVideo = new FakeVideoElement({
+ currentTime: 2,
+ readyState: 2,
+ videoWidth: 800,
+ videoHeight: 600,
+ });
+
+ renderer.webcamVideoElement = webcamVideo;
+ renderer.lastSyncedWebcamTime = 2;
+ renderer.currentVideoTime = 2;
+ renderer.animationState.appliedScale = 1;
+
+ renderer.drawWebcamOverlay(outputContext, 1280, 720);
+
+ const bubbleCanvas = createdCanvases[0];
+ const cacheCanvas = createdCanvases[1];
+ expect(cacheCanvas).toBeDefined();
+ expect((cacheCanvas.context.drawImage as any).mock.calls[0][0]).toBe(webcamVideo);
+ expect((bubbleCanvas.context.drawImage as any).mock.calls[0][0]).toBe(webcamVideo);
+ expect((outputContext.drawImage as any).mock.calls[0][0]).toBe(bubbleCanvas);
+ });
+});
\ No newline at end of file
diff --git a/src/lib/exporter/frameRenderer.ts b/src/lib/exporter/frameRenderer.ts
index b024b6e1..a8cff4d1 100644
--- a/src/lib/exporter/frameRenderer.ts
+++ b/src/lib/exporter/frameRenderer.ts
@@ -37,7 +37,6 @@ import {
preloadCursorAssets,
} from "@/components/video-editor/videoPlayback/cursorRenderer";
import { getWebcamOverlaySizePx } from "@/components/video-editor/webcamOverlay";
-import { ForwardFrameSource } from "./forwardFrameSource";
interface FrameRenderConfig {
width: number;
@@ -114,12 +113,11 @@ export class FrameRenderer {
private currentVideoTime = 0;
private lastMotionVector = { x: 0, y: 0 };
private cursorOverlay: PixiCursorOverlay | null = null;
- private webcamFrameSource: ForwardFrameSource | null = null;
- private webcamCurrentFrame: VideoFrame | null = null;
+ private webcamVideoElement: HTMLVideoElement | null = null;
+ private webcamSeekPromise: Promise<void> | null = null;
private webcamFrameCacheCanvas: HTMLCanvasElement | null = null;
private webcamFrameCacheCtx: CanvasRenderingContext2D | null = null;
- private webcamFrameWidth = 0;
- private webcamFrameHeight = 0;
+ private lastSyncedWebcamTime: number | null = null;
constructor(config: FrameRenderConfig) {
this.config = config;
@@ -424,71 +422,157 @@ export class FrameRenderer {
private async setupWebcamSource(): Promise<void> {
const webcamUrl = this.config.webcamUrl;
if (!this.config.webcam?.enabled || !webcamUrl) {
- this.webcamFrameSource = null;
- this.webcamCurrentFrame?.close();
- this.webcamCurrentFrame = null;
+ this.webcamVideoElement = null;
this.webcamFrameCacheCanvas = null;
this.webcamFrameCacheCtx = null;
- this.webcamFrameWidth = 0;
- this.webcamFrameHeight = 0;
+ this.lastSyncedWebcamTime = null;
return;
}
- const frameSource = new ForwardFrameSource();
-
- try {
- await frameSource.initialize(webcamUrl);
- this.webcamFrameSource = frameSource;
- } catch (error) {
+ const video = document.createElement("video");
+ video.src = webcamUrl;
+ video.muted = true;
+ video.preload = "auto";
+ video.playsInline = true;
+ video.load();
+
+ await new Promise<void>((resolve, reject) => {
+ const onReady = () => {
+ if (video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) {
+ return;
+ }
+ cleanup();
+ resolve();
+ };
+ const onError = () => {
+ cleanup();
+ reject(new Error("Failed to load webcam source for export"));
+ };
+ const cleanup = () => {
+ video.removeEventListener("loadeddata", onReady);
+ video.removeEventListener("canplay", onReady);
+ video.removeEventListener("canplaythrough", onReady);
+ video.removeEventListener("error", onError);
+ };
+ if (video.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
+ resolve();
+ return;
+ }
+ video.addEventListener("loadeddata", onReady, { once: true });
+ video.addEventListener("canplay", onReady, { once: true });
+ video.addEventListener("canplaythrough", onReady, { once: true });
+ video.addEventListener("error", onError, { once: true });
+ }).catch((error) => {
console.warn("[FrameRenderer] Webcam overlay unavailable during export:", error);
- await frameSource.destroy();
- this.webcamFrameSource = null;
- this.webcamCurrentFrame?.close();
- this.webcamCurrentFrame = null;
- this.webcamFrameCacheCanvas = null;
- this.webcamFrameCacheCtx = null;
- this.webcamFrameWidth = 0;
- this.webcamFrameHeight = 0;
- }
- }
+ this.webcamVideoElement = null;
+ });
- private async syncWebcamFrame(targetTime: number): Promise<void> {
- const webcamFrameSource = this.webcamFrameSource;
- if (!webcamFrameSource) {
+ if (video.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
+ this.webcamVideoElement = video;
return;
}
- const nextFrame = await webcamFrameSource.getFrameAtTime(targetTime);
- if (!nextFrame) {
+ this.webcamVideoElement = null;
+ this.webcamFrameCacheCanvas = null;
+ this.webcamFrameCacheCtx = null;
+ this.lastSyncedWebcamTime = null;
+ }
+
+ private async syncWebcamFrame(targetTime: number): Promise<void> {
+ const webcamVideo = this.webcamVideoElement;
+ if (!webcamVideo) {
return;
}
- this.webcamCurrentFrame?.close();
- this.webcamCurrentFrame = nextFrame;
+ const duration = Number.isFinite(webcamVideo.duration)
+ ? webcamVideo.duration
+ : targetTime;
+ const clampedTime = Math.max(0, Math.min(targetTime, duration || targetTime));
- const frameWidth =
- nextFrame.displayWidth || nextFrame.codedWidth || this.webcamFrameWidth;
- const frameHeight =
- nextFrame.displayHeight || nextFrame.codedHeight || this.webcamFrameHeight;
- if (frameWidth <= 0 || frameHeight <= 0) {
+ if (Math.abs(webcamVideo.currentTime - clampedTime) <= 0.008) {
+ this.lastSyncedWebcamTime = clampedTime;
return;
}
- if (
- !this.webcamFrameCacheCanvas ||
- this.webcamFrameWidth !== frameWidth ||
- this.webcamFrameHeight !== frameHeight
- ) {
- this.webcamFrameCacheCanvas = document.createElement("canvas");
- this.webcamFrameCacheCanvas.width = frameWidth;
- this.webcamFrameCacheCanvas.height = frameHeight;
- this.webcamFrameCacheCtx = this.webcamFrameCacheCanvas.getContext("2d");
- this.webcamFrameWidth = frameWidth;
- this.webcamFrameHeight = frameHeight;
+ if (this.webcamSeekPromise) {
+ await this.webcamSeekPromise;
}
- this.webcamFrameCacheCtx?.clearRect(0, 0, frameWidth, frameHeight);
- this.webcamFrameCacheCtx?.drawImage(nextFrame, 0, 0, frameWidth, frameHeight);
+ this.webcamSeekPromise = new Promise<void>((resolve) => {
+ let settled = false;
+ let fallbackTimeout: number | null = null;
+ const waitForPresentedFrame = () => {
+ requestAnimationFrame(() => {
+ finish();
+ });
+ };
+ const finish = () => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ if (Math.abs(webcamVideo.currentTime - clampedTime) <= 0.02) {
+ this.lastSyncedWebcamTime = clampedTime;
+ }
+ cleanup();
+ resolve();
+ };
+ const handleMediaReady = () => {
+ if (
+ !webcamVideo.seeking &&
+ Math.abs(webcamVideo.currentTime - clampedTime) <= 0.01 &&
+ webcamVideo.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA
+ ) {
+ waitForPresentedFrame();
+ }
+ };
+ const cleanup = () => {
+ webcamVideo.removeEventListener("seeked", waitForPresentedFrame);
+ webcamVideo.removeEventListener("loadeddata", handleMediaReady);
+ webcamVideo.removeEventListener("canplay", handleMediaReady);
+ webcamVideo.removeEventListener("error", finish);
+ if (fallbackTimeout !== null) {
+ window.clearTimeout(fallbackTimeout);
+ }
+ };
+
+ webcamVideo.addEventListener("seeked", waitForPresentedFrame, {
+ once: true,
+ });
+ webcamVideo.addEventListener("loadeddata", handleMediaReady, {
+ once: true,
+ });
+ webcamVideo.addEventListener("canplay", handleMediaReady, {
+ once: true,
+ });
+ webcamVideo.addEventListener("error", finish, {
+ once: true,
+ });
+ fallbackTimeout = window.setTimeout(() => {
+ finish();
+ }, 250);
+
+ try {
+ webcamVideo.currentTime = clampedTime;
+ } catch {
+ finish();
+ return;
+ }
+
+ if (
+ !webcamVideo.seeking &&
+ Math.abs(webcamVideo.currentTime - clampedTime) <= 0.001 &&
+ webcamVideo.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA
+ ) {
+ waitForPresentedFrame();
+ }
+ });
+
+ try {
+ await this.webcamSeekPromise;
+ } finally {
+ this.webcamSeekPromise = null;
+ }
}
async renderFrame(videoFrame: VideoFrame, timestamp: number): Promise<void> {
@@ -498,7 +582,7 @@ export class FrameRenderer {
this.currentVideoTime = timestamp / 1000000;
- if (this.webcamFrameSource) {
+ if (this.webcamVideoElement) {
const targetTime = Math.max(0, this.currentVideoTime);
await this.syncWebcamFrame(targetTime);
}
@@ -860,7 +944,8 @@ export class FrameRenderer {
height: number,
): void {
const webcam = this.config.webcam;
- if (!webcam?.enabled || !this.webcamFrameCacheCanvas) {
+ const webcamVideo = this.webcamVideoElement;
+ if (!webcam?.enabled || !webcamVideo || webcamVideo.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) {
return;
}
@@ -885,7 +970,45 @@ export class FrameRenderer {
return;
}
- const webcamFrameSource = this.webcamFrameCacheCanvas;
+ const canRefreshCache =
+ webcamVideo.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA &&
+ !webcamVideo.seeking &&
+ this.lastSyncedWebcamTime !== null &&
+ Math.abs(this.lastSyncedWebcamTime - this.currentVideoTime) <= 0.02 &&
+ Math.abs(webcamVideo.currentTime - this.currentVideoTime) <= 0.02 &&
+ webcamVideo.videoWidth > 0 &&
+ webcamVideo.videoHeight > 0;
+
+ if (canRefreshCache) {
+ if (
+ !this.webcamFrameCacheCanvas ||
+ this.webcamFrameCacheCanvas.width !== webcamVideo.videoWidth ||
+ this.webcamFrameCacheCanvas.height !== webcamVideo.videoHeight
+ ) {
+ this.webcamFrameCacheCanvas = document.createElement("canvas");
+ this.webcamFrameCacheCanvas.width = webcamVideo.videoWidth;
+ this.webcamFrameCacheCanvas.height = webcamVideo.videoHeight;
+ this.webcamFrameCacheCtx = this.webcamFrameCacheCanvas.getContext("2d");
+ }
+
+ this.webcamFrameCacheCtx?.clearRect(
+ 0,
+ 0,
+ this.webcamFrameCacheCanvas!.width,
+ this.webcamFrameCacheCanvas!.height,
+ );
+ this.webcamFrameCacheCtx?.drawImage(
+ webcamVideo,
+ 0,
+ 0,
+ this.webcamFrameCacheCanvas!.width,
+ this.webcamFrameCacheCanvas!.height,
+ );
+ }
+
+ const webcamFrameSource = canRefreshCache
+ ? webcamVideo
+ : this.webcamFrameCacheCanvas;
if (!webcamFrameSource) {
return;
}
@@ -961,19 +1084,18 @@ export class FrameRenderer {
this.cursorOverlay.destroy();
this.cursorOverlay = null;
}
- this.webcamCurrentFrame?.close();
- this.webcamCurrentFrame = null;
- if (this.webcamFrameSource) {
- void this.webcamFrameSource.destroy();
- this.webcamFrameSource = null;
- }
this.shadowCanvas = null;
this.shadowCtx = null;
this.compositeCanvas = null;
this.compositeCtx = null;
+ if (this.webcamVideoElement) {
+ this.webcamVideoElement.pause();
+ this.webcamVideoElement.src = "";
+ this.webcamVideoElement.load();
+ this.webcamVideoElement = null;
+ }
this.webcamFrameCacheCanvas = null;
this.webcamFrameCacheCtx = null;
- this.webcamFrameWidth = 0;
- this.webcamFrameHeight = 0;
+ this.lastSyncedWebcamTime = null;
}
}