Skip to content

πŸŽ₯ Make videos programmatically with React

Avoid idle frame waits while preserving canvas paint ordering

Jonny Burgerdb54dde0f3e6
diff --git a/packages/core/src/HtmlInCanvas.tsx b/packages/core/src/HtmlInCanvas.tsx
index b396feac1b..f2417fe106 100644
--- a/packages/core/src/HtmlInCanvas.tsx
+++ b/packages/core/src/HtmlInCanvas.tsx
@@ -459,7 +459,15 @@ export type HtmlInCanvasProps = Omit<InteractiveBaseProps, 'children'> &
};
/* eslint-enable react/require-default-props */
-const HtmlInCanvasAncestorContext = createContext(false);
+type HtmlInCanvasPaintState = {
+ pendingChildren: number;
+ generation: number;
+ release: (() => void) | null;
+ blockPaint: () => () => void;
+};
+
+const HtmlInCanvasAncestorContext =
+ createContext<HtmlInCanvasPaintState | null>(null);
type HtmlInCanvasContentProps = {
readonly width: number;
@@ -476,7 +484,7 @@ type HtmlInCanvasContentProps = {
const HtmlInCanvasContent = forwardRef<
HTMLCanvasElement,
- HtmlInCanvasContentProps
+ HtmlInCanvasContentProps & {readonly renderFrame: number | null}
>(
(
{
@@ -490,14 +498,13 @@ const HtmlInCanvasContent = forwardRef<
pixelDensity,
controls,
style,
+ renderFrame,
},
ref,
) => {
- const isInsideAncestorHtmlInCanvas = useContext(
- HtmlInCanvasAncestorContext,
- );
+ const ancestorPaintState = useContext(HtmlInCanvasAncestorContext);
assertHtmlInCanvasDimensions(width, height);
- if (isInsideAncestorHtmlInCanvas && !isHtmlInCanvasNestingSupported()) {
+ if (ancestorPaintState && !isHtmlInCanvasNestingSupported()) {
throw new Error(
`Nested <HtmlInCanvas> components require Chrome ${MINIMUM_CHROME_VERSION_FOR_NESTED_HTML_IN_CANVAS} or newer with HTML-in-canvas enabled.`,
);
@@ -508,8 +515,6 @@ const HtmlInCanvasContent = forwardRef<
const canvasHeight = Math.ceil(height * resolvedPixelDensity);
const {delayRender, continueRender, cancelRender} = useDelayRender();
const {isClientSideRendering, isRendering} = useRemotionEnvironment();
- const frame = useCurrentFrame();
- const renderFrame = isRendering ? frame : null;
const canRetryMissingPaintRecord = !isRendering || isClientSideRendering;
const usesDirectLayoutCanvas =
onPaint === undefined && onInit === undefined;
@@ -528,6 +533,41 @@ const HtmlInCanvasContent = forwardRef<
const paintTargetRef = useRef<HtmlInCanvasPaintTarget | null>(null);
const divRef = useRef<HTMLDivElement | null>(null);
const canvasSizeKey = `${width}x${height}@${resolvedPixelDensity}-${paintTargetMode}`;
+ const paintState = useMemo<HtmlInCanvasPaintState>(() => {
+ const state: HtmlInCanvasPaintState = {
+ pendingChildren: 0,
+ generation: 0,
+ release: null,
+ blockPaint: () => {
+ state.pendingChildren++;
+ state.generation++;
+ if (state.release === null) {
+ const handle = delayRender('waiting for nested HtmlInCanvas paint');
+ const releaseAncestor = ancestorPaintState?.blockPaint();
+ state.release = () => {
+ continueRender(handle);
+ releaseAncestor?.();
+ };
+ }
+
+ let released = false;
+ return () => {
+ if (released) {
+ return;
+ }
+
+ released = true;
+ state.pendingChildren--;
+ if (state.pendingChildren === 0) {
+ // A child can finish asynchronously after our paint record was
+ // taken. Keep capture blocked until we paint its finished pixels.
+ canvas2dRef.current?.requestPaint?.();
+ }
+ };
+ },
+ };
+ return state;
+ }, [continueRender, delayRender, ancestorPaintState]);
const setVisibleCanvasRef = useCallback(
(node: HTMLCanvasElement | null) => {
@@ -564,8 +604,16 @@ const HtmlInCanvasContent = forwardRef<
const initializedRef = useRef(false);
const onInitCleanupRef = useRef<HtmlInCanvasOnInitCleanup | null>(null);
const unmountedRef = useRef(false);
+ const paintingTargets = useRef(
+ new WeakMap<HtmlInCanvasPaintTarget, {repaint: boolean}>(),
+ );
const onPaintCb = useCallback(async () => {
+ if (isRendering && paintState.pendingChildren > 0) {
+ return;
+ }
+
+ const childrenGeneration = paintState.generation;
const element = divRef.current;
if (!element) {
@@ -579,12 +627,29 @@ const HtmlInCanvasContent = forwardRef<
);
}
+ const inProgress = paintingTargets.current.get(paintTarget);
+ if (isRendering && inProgress) {
+ // In particular, do not run onPaint while an earlier event is still
+ // awaiting onInit (e.g. a WebGPU device).
+ inProgress.repaint = true;
+ return;
+ }
+
+ const painting = {repaint: false};
+ if (isRendering) {
+ paintingTargets.current.set(paintTarget, painting);
+ }
+
resizePaintTarget({
target: paintTarget,
width: canvasWidth,
height: canvasHeight,
});
+ const releaseAncestor = isRendering
+ ? ancestorPaintState?.blockPaint()
+ : null;
+ let canReleasePaint = false;
try {
const placeholderCanvas = canvas2dRef.current;
if (!placeholderCanvas) {
@@ -611,6 +676,7 @@ const HtmlInCanvasContent = forwardRef<
) {
// The web renderer explicitly drives additional paint cycles, so a
// transient missing record can be retried without failing the render.
+ canReleasePaint = true;
continueRender(handle);
return;
}
@@ -666,6 +732,7 @@ const HtmlInCanvasContent = forwardRef<
// element is outside the viewport (no cached paint record).
// Skip this paint cycle β€” the canvas retains its last state.
if (isMissingPaintRecordError(error) && canRetryMissingPaintRecord) {
+ canReleasePaint = true;
continueRender(handle);
return;
}
@@ -739,9 +806,26 @@ const HtmlInCanvasContent = forwardRef<
ctx.drawImage(paintTarget, 0, 0);
}
+ canReleasePaint = true;
continueRender(handle);
} catch (error) {
cancelRender(error);
+ } finally {
+ if (
+ canReleasePaint &&
+ paintState.pendingChildren === 0 &&
+ paintState.generation === childrenGeneration
+ ) {
+ const {release} = paintState;
+ paintState.release = null;
+ release?.();
+ }
+
+ releaseAncestor?.();
+ paintingTargets.current.delete(paintTarget);
+ if (painting.repaint && paintTargetRef.current === paintTarget) {
+ canvas2dRef.current?.requestPaint?.();
+ }
}
}, [
canvasHeight,
@@ -753,8 +837,18 @@ const HtmlInCanvasContent = forwardRef<
resolvedPixelDensity,
canRetryMissingPaintRecord,
paintTargetMode,
+ isRendering,
+ paintState,
+ ancestorPaintState,
]);
+ useLayoutEffect(() => {
+ return () => {
+ paintState.release?.();
+ paintState.release = null;
+ };
+ }, [paintState]);
+
// Default paint handlers draw synchronously on the layout canvas itself.
// ElementImage can only be drawn into its associated canvas, so custom
// handlers retain a transferred target. Rendering copies it to a separate
@@ -820,13 +914,20 @@ const HtmlInCanvasContent = forwardRef<
// Block capture before the paint event begins, including updates that
// keep the same canvas. onPaintCb holds its own handle through async work.
const handle = delayRender('waiting for HtmlInCanvas paint');
- const onPainted = () => continueRender(handle);
+ const releaseAncestor = isRendering
+ ? ancestorPaintState?.blockPaint()
+ : null;
+ const onPainted = () => {
+ continueRender(handle);
+ releaseAncestor?.();
+ };
+
canvas.addEventListener('paint', onPainted, {once: true});
canvas.requestPaint?.();
return () => {
canvas.removeEventListener('paint', onPainted);
- continueRender(handle);
+ onPainted();
};
}, [
width,
@@ -835,6 +936,8 @@ const HtmlInCanvasContent = forwardRef<
delayRender,
canvasSizeKey,
renderFrame,
+ isRendering,
+ ancestorPaintState,
]);
const innerStyle = useMemo(() => {
@@ -853,7 +956,7 @@ const HtmlInCanvasContent = forwardRef<
}, [height, style, width]);
return (
- <HtmlInCanvasAncestorContext.Provider value>
+ <HtmlInCanvasAncestorContext.Provider value={paintState}>
<canvas
key={canvasSizeKey}
ref={paintTargetMode === 'copied' ? canvas2dRef : setVisibleCanvasRef}
@@ -900,6 +1003,18 @@ const HtmlInCanvasContent = forwardRef<
HtmlInCanvasContent.displayName = 'HtmlInCanvasContent';
+// Subscribe to frame changes only while rendering. Preview keeps relying on
+// the browser's paints and does not need a capture barrier on every frame.
+const HtmlInCanvasContentForRendering = forwardRef<
+ HTMLCanvasElement,
+ HtmlInCanvasContentProps
+>((props, ref) => {
+ const frame = useCurrentFrame();
+ return <HtmlInCanvasContent {...props} ref={ref} renderFrame={frame} />;
+});
+
+HtmlInCanvasContentForRendering.displayName = 'HtmlInCanvasContentForRendering';
+
const HtmlInCanvasInner = forwardRef<
HTMLCanvasElement,
HtmlInCanvasProps & {
@@ -932,6 +1047,10 @@ const HtmlInCanvasInner = forwardRef<
},
ref,
) => {
+ const {isRendering} = useRemotionEnvironment();
+ const Content = isRendering
+ ? HtmlInCanvasContentForRendering
+ : HtmlInCanvasContent;
const memoizedEffectDefinitions = useMemoizedEffectDefinitions(effects);
const actualRef = useRef<HTMLCanvasElement | null>(null);
const setCanvasRef = useCallback(
@@ -996,8 +1115,9 @@ const HtmlInCanvasInner = forwardRef<
_remotionInternalIsPremounting={premountingActive}
_remotionInternalIsPostmounting={postmountingActive}
>
- <HtmlInCanvasContent
+ <Content
ref={setCanvasRef}
+ renderFrame={null}
width={width}
height={height}
effects={effects}
@@ -1009,7 +1129,7 @@ const HtmlInCanvasInner = forwardRef<
style={croppedStyle ?? undefined}
>
{children}
- </HtmlInCanvasContent>
+ </Content>
</Sequence>
</Freeze>
);
diff --git a/packages/core/src/delay-render.ts b/packages/core/src/delay-render.ts
index 8f45714348..01490e839f 100644
--- a/packages/core/src/delay-render.ts
+++ b/packages/core/src/delay-render.ts
@@ -12,6 +12,7 @@ import {getRemotionEnvironment} from './get-remotion-environment.js';
import type {LogLevel} from './log.js';
import {Log} from './log.js';
import type {RemotionEnvironment} from './remotion-environment-context.js';
+import {notifyRenderReady} from './render-ready.js';
import {truthy} from './truthy.js';
export {
@@ -194,6 +195,9 @@ export const continueRenderInternal = ({
if (scope.remotion_delayRenderHandles.length === 0) {
scope.remotion_renderReady = true;
+ if (environment.isRendering) {
+ notifyRenderReady(scope);
+ }
}
};
diff --git a/packages/core/src/internals.ts b/packages/core/src/internals.ts
index 799757d281..764180ed39 100644
--- a/packages/core/src/internals.ts
+++ b/packages/core/src/internals.ts
@@ -158,6 +158,7 @@ import {getRoot, waitForRoot} from './register-root.js';
import type {RemotionEnvironment} from './remotion-environment-context.js';
import {RemotionEnvironmentContext} from './remotion-environment-context.js';
import {RemotionRootContexts} from './RemotionRoot.js';
+import {subscribeToRenderReady} from './render-ready.js';
import {
makeRenderResourceManager,
RenderResourceManagerContext,
@@ -345,6 +346,7 @@ const compositionSelectorRef = createRef<{
// Mark them as Internals so use don't assume this is public
// API and are less likely to use it
export const Internals = {
+ subscribeToRenderReady,
CommittedMetadataProvider,
withCommittedMetadata,
DefaultPremountContext,
diff --git a/packages/core/src/no-react.ts b/packages/core/src/no-react.ts
index 0ee1fc48ef..440c06bbeb 100644
--- a/packages/core/src/no-react.ts
+++ b/packages/core/src/no-react.ts
@@ -2,6 +2,7 @@ import {
evaluateSourceNumericValue,
evaluateSourcePropStatuses,
} from './evaluate-source-expressions.js';
+import {RENDER_READY_EVENT} from './render-ready.js';
export type {
ArtifactAsset,
AudioOrVideoAsset,
@@ -62,6 +63,7 @@ import {getExpectedMediaFrameUncorrected} from './video/get-current-time';
import {getOffthreadVideoSource} from './video/offthread-video-source';
export const NoReactInternals = {
+ RENDER_READY_EVENT,
DEFAULT_PREMOUNT_IN_SECONDS,
validateDefaultPremountInSeconds,
evaluateSourceNumericValue,
diff --git a/packages/core/src/render-ready.ts b/packages/core/src/render-ready.ts
new file mode 100644
index 0000000000..707271f605
--- /dev/null
+++ b/packages/core/src/render-ready.ts
@@ -0,0 +1,28 @@
+import type {DelayRenderScope} from './delay-render.js';
+
+export const RENDER_READY_EVENT = 'remotion-render-ready';
+
+const listeners = new WeakMap<DelayRenderScope, Set<() => void>>();
+
+export const subscribeToRenderReady = (
+ scope: DelayRenderScope,
+ listener: () => void,
+) => {
+ let scopedListeners = listeners.get(scope);
+ if (!scopedListeners) {
+ scopedListeners = new Set();
+ listeners.set(scope, scopedListeners);
+ }
+
+ scopedListeners.add(listener);
+ return () => {
+ scopedListeners.delete(listener);
+ };
+};
+
+export const notifyRenderReady = (scope: DelayRenderScope) => {
+ listeners.get(scope)?.forEach((listener) => listener());
+ if (typeof window !== 'undefined' && scope === window) {
+ window.dispatchEvent(new Event(RENDER_READY_EVENT));
+ }
+};
diff --git a/packages/core/src/test/html-in-canvas.test.tsx b/packages/core/src/test/html-in-canvas.test.tsx
index 688cff7b2f..6a24524bd9 100644
--- a/packages/core/src/test/html-in-canvas.test.tsx
+++ b/packages/core/src/test/html-in-canvas.test.tsx
@@ -713,12 +713,21 @@ test('<HtmlInCanvas> retries a missing paint record during client-side rendering
const w = window as unknown as {remotion_cancelledError?: string};
w.remotion_cancelledError = undefined;
+ const originalUserAgent = Object.getOwnPropertyDescriptor(
+ navigator,
+ 'userAgent',
+ );
+ Object.defineProperty(navigator, 'userAgent', {
+ configurable: true,
+ value: 'Chrome/157.0.0.0',
+ });
+
let captureCalls = 0;
Object.defineProperty(HTMLCanvasElement.prototype, 'captureElementImage', {
configurable: true,
value: () => {
captureCalls++;
- if (captureCalls === 1) {
+ if (captureCalls === 2) {
throw new DOMException(
'No cached paint record for element',
'InvalidStateError',
@@ -749,7 +758,9 @@ test('<HtmlInCanvas> retries a missing paint record during client-side rendering
paintCalled = true;
}}
>
- <div>Test</div>
+ <HtmlInCanvas width={25} height={25}>
+ <div>Test</div>
+ </HtmlInCanvas>
</HtmlInCanvas>
</SequenceTestWrapper>,
);
@@ -759,18 +770,28 @@ test('<HtmlInCanvas> retries a missing paint record during client-side rendering
});
const canvas = container.querySelector('canvas')!;
+ canvas.querySelector('canvas')!.dispatchEvent(new Event('paint'));
+ await new Promise((resolve) => setTimeout(resolve, 0));
canvas.dispatchEvent(new Event('paint'));
expect(paintCalled).toBe(false);
+ // Skipping an unavailable record must also release the nested paint barrier.
+ expect(window.remotion_renderReady).toBe(true);
expect(w.remotion_cancelledError).toBeUndefined();
canvas.dispatchEvent(new Event('paint'));
await waitFor(() => {
expect(paintCalled).toBe(true);
});
- expect(captureCalls).toBe(2);
+ expect(captureCalls).toBe(3);
expect(w.remotion_cancelledError).toBeUndefined();
} finally {
+ if (originalUserAgent) {
+ Object.defineProperty(navigator, 'userAgent', originalUserAgent);
+ } else {
+ Reflect.deleteProperty(navigator, 'userAgent');
+ }
+
if (originalDescriptor) {
Object.defineProperty(
HTMLCanvasElement.prototype,
diff --git a/packages/renderer/src/browser/DOMWorld.ts b/packages/renderer/src/browser/DOMWorld.ts
index d760d9d8dd..390437e48d 100644
--- a/packages/renderer/src/browser/DOMWorld.ts
+++ b/packages/renderer/src/browser/DOMWorld.ts
@@ -122,11 +122,13 @@ export class DOMWorld {
timeout,
pageFunction,
title,
+ wakeUpEvent,
}: {
browser: HeadlessBrowser;
timeout: number | null;
pageFunction: Function | string;
title: string;
+ wakeUpEvent: string | null;
}): WaitTask {
return new WaitTask({
domWorld: this,
@@ -134,6 +136,7 @@ export class DOMWorld {
title,
timeout,
args: [],
+ wakeUpEvent,
browser,
});
}
@@ -146,6 +149,7 @@ interface WaitTaskOptions {
timeout: number | null;
browser: HeadlessBrowser;
args: SerializableOrJSHandle[];
+ wakeUpEvent: string | null;
}
const noop = (): void => undefined;
@@ -155,6 +159,7 @@ class WaitTask {
#timeout: number | null;
#predicateBody: string;
#args: SerializableOrJSHandle[];
+ #wakeUpEvent: string | null;
#runCount = 0;
#resolve: (x: JSHandle) => void = noop;
#reject: (x: Error) => void = noop;
@@ -177,6 +182,7 @@ class WaitTask {
this.#timeout = options.timeout;
this.#predicateBody = getPredicateBody(options.predicateBody);
this.#args = options.args;
+ this.#wakeUpEvent = options.wakeUpEvent;
this.#runCount = 0;
this.#domWorld._waitTasks.add(this);
@@ -238,6 +244,7 @@ class WaitTask {
waitForPredicatePageFunction,
this.#predicateBody,
this.#timeout,
+ this.#wakeUpEvent,
...this.#args,
);
} catch (error_) {
@@ -347,32 +354,77 @@ class WaitTask {
function waitForPredicatePageFunction(
predicateBody: string,
timeout: number,
+ wakeUpEvent: string | null,
...args: unknown[]
): Promise<unknown> {
// eslint-disable-next-line no-new-func
const predicate = new Function('...args', predicateBody);
- let timedOut = false;
- if (timeout) {
- setTimeout(() => {
- timedOut = true;
- }, timeout);
- }
- return new Promise<JSHandle | undefined>((resolve) => {
- async function onRaf(): Promise<void> {
- if (timedOut) {
- resolve(undefined);
+ return new Promise<JSHandle | undefined>((resolve, reject) => {
+ let finished = false;
+ let checking = false;
+ let rafId: number | null = null;
+ let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+ const cleanup = () => {
+ finished = true;
+ if (rafId !== null) {
+ cancelAnimationFrame(rafId);
+ }
+
+ if (timeoutId !== null) {
+ clearTimeout(timeoutId);
+ }
+
+ if (wakeUpEvent !== null) {
+ window.removeEventListener(wakeUpEvent, onReady);
+ }
+ };
+
+ const check = async () => {
+ if (finished || checking) {
return;
}
- const success = await predicate(...args);
- if (success) {
- resolve(success);
- } else {
- requestAnimationFrame(onRaf);
+ checking = true;
+ try {
+ const success = await predicate(...args);
+ if (!finished && success) {
+ cleanup();
+ resolve(success);
+ }
+ } catch (error) {
+ cleanup();
+ reject(error);
+ } finally {
+ checking = false;
+ }
+ };
+
+ const onReady = () => {
+ // Let effects finish replacing handles before testing readiness.
+ queueMicrotask(check);
+ };
+
+ async function onRaf(): Promise<void> {
+ await check();
+ if (!finished) {
+ rafId = requestAnimationFrame(onRaf);
}
}
+ if (timeout) {
+ timeoutId = setTimeout(() => {
+ cleanup();
+ resolve(undefined);
+ }, timeout);
+ }
+
+ if (wakeUpEvent !== null) {
+ window.addEventListener(wakeUpEvent, onReady);
+ }
+
+ // Keep polling for errors and for bundles predating the ready event.
onRaf();
});
}
diff --git a/packages/renderer/src/seek-to-frame.ts b/packages/renderer/src/seek-to-frame.ts
index b9f173bcca..8b7135451b 100644
--- a/packages/renderer/src/seek-to-frame.ts
+++ b/packages/renderer/src/seek-to-frame.ts
@@ -1,3 +1,4 @@
+import {NoReactInternals} from 'remotion/no-react';
import {BrowserEmittedEvents} from './browser/Browser';
import type {Page} from './browser/BrowserPage';
import {PageEmittedEvents} from './browser/BrowserPage';
@@ -67,6 +68,7 @@ export const waitForReady = ({
const waitForReadyProm = new Promise<JSHandle>((resolve, reject) => {
const waitTask = page.mainFrame()._mainWorld.waitForFunction({
browser: page.browser,
+ wakeUpEvent: NoReactInternals.RENDER_READY_EVENT,
// Increase timeout so the delayRender() timeout fires earlier
timeout: timeoutInMilliseconds + 3000,
pageFunction: `window.remotion_renderReady === true ? "${readyToken}" : window.remotion_cancelledError !== undefined ? "${cancelledToken}" : false`,
diff --git a/packages/web-renderer/src/test/delay-render.test.tsx b/packages/web-renderer/src/test/delay-render.test.tsx
index 15023344f8..64f13735e1 100644
--- a/packages/web-renderer/src/test/delay-render.test.tsx
+++ b/packages/web-renderer/src/test/delay-render.test.tsx
@@ -14,12 +14,18 @@ test('should be able to use delayRender()', async () => {
useEffect(() => {
setTimeout(() => {
- flushSync(() => {
- setData(true);
- });
continueRender(handle);
+ // Replacing the last handle in the same task must not expose the
+ // intermediate red frame to an event-driven readiness waiter.
+ const nextHandle = delayRender('Loading the next piece of data');
+ setTimeout(() => {
+ flushSync(() => {
+ setData(true);
+ });
+ continueRender(nextHandle);
+ }, 50);
}, 50);
- }, [continueRender, handle]);
+ }, [continueRender, delayRender, handle]);
return data ? (
<svg viewBox="0 0 100 100" style={{backgroundColor: 'green'}} />
diff --git a/packages/web-renderer/src/test/fixtures/html-in-canvas-frames.tsx b/packages/web-renderer/src/test/fixtures/html-in-canvas-frames.tsx
index 8fb65eb0cd..7e2dceb294 100644
--- a/packages/web-renderer/src/test/fixtures/html-in-canvas-frames.tsx
+++ b/packages/web-renderer/src/test/fixtures/html-in-canvas-frames.tsx
@@ -47,10 +47,13 @@ const Paint: React.FC<HtmlInCanvasFramesProps & {readonly frame: number}> = ({
);
const gpuRef = useRef<{device: GpuDevice; context: GpuContext} | null>(null);
const onInit: HtmlInCanvasOnInit = useCallback(
- async ({canvas}) => {
+ async ({canvas, element}) => {
// Exercise asynchronous initialization, including the first mounted frame.
await Promise.resolve();
if (backend === 'webgpu') {
+ // Initialization can span multiple browser paint events.
+ (element.parentElement as HTMLCanvasElement).requestPaint?.();
+ await new Promise((resolve) => setTimeout(resolve, 30));
const {gpu} = navigator as unknown as {
gpu: {
requestAdapter(): Promise<{
@@ -110,6 +113,9 @@ const Paint: React.FC<HtmlInCanvasFramesProps & {readonly frame: number}> = ({
const onPaint: HtmlInCanvasOnPaint = useCallback(
async ({canvas, elementImage}) => {
if (backend === '2d') {
+ // Finish outside the paint event's task: a ready notification must
+ // still wait for this handler and its pixel copy.
+ await new Promise((resolve) => setTimeout(resolve, 5));
const ctx = canvas.getContext('2d')!;
ctx.reset();
ctx.drawElementImage(elementImage, 0, 0);
@@ -232,7 +238,9 @@ const paint: HtmlInCanvasOnPaint = ({canvas, elementImage}) => {
const Nested: React.FC<HtmlInCanvasFramesProps> = (props) => {
return (
<HtmlInCanvas width={100} height={100} onPaint={paint} effects={[invert()]}>
- <Component {...props} />
+ <HtmlInCanvas width={100} height={100}>
+ <Component {...props} />
+ </HtmlInCanvas>
</HtmlInCanvas>
);
};
diff --git a/packages/web-renderer/src/wait-for-ready.ts b/packages/web-renderer/src/wait-for-ready.ts
index e77cf1bc9d..2b1d7a52bd 100644
--- a/packages/web-renderer/src/wait-for-ready.ts
+++ b/packages/web-renderer/src/wait-for-ready.ts
@@ -1,5 +1,5 @@
/* eslint-disable @typescript-eslint/no-use-before-define */
-import type {DelayRenderScope} from 'remotion';
+import {Internals, type DelayRenderScope} from 'remotion';
import type {BackgroundKeepalive} from './background-keepalive';
import type {InternalState} from './internal-state';
import {withResolvers} from './with-resolvers';
@@ -22,29 +22,43 @@ export const waitForReady = ({
const start = performance.now();
const {promise, resolve, reject} = withResolvers<void>();
- let cancelled = false;
+ let completed = false;
+ let rafId: number | null = null;
+ const unsubscribe = Internals.subscribeToRenderReady(scope, () => {
+ // A layout effect may clear an old handle and open a new one in the
+ // same commit. Check after that stack has finished.
+ queueMicrotask(check);
+ });
+
+ const finish = () => {
+ completed = true;
+ unsubscribe();
+ if (rafId !== null) {
+ cancelAnimationFrame(rafId);
+ }
+
+ internalState?.addWaitForReadyTime(performance.now() - start);
+ };
const check = () => {
- if (cancelled) {
+ if (completed) {
return;
}
if (signal?.aborted) {
- cancelled = true;
- internalState?.addWaitForReadyTime(performance.now() - start);
+ finish();
reject(new Error(`${apiName}() was cancelled`));
return;
}
if (scope.remotion_renderReady === true) {
- internalState?.addWaitForReadyTime(performance.now() - start);
+ finish();
resolve();
return;
}
if (scope.remotion_cancelledError !== undefined) {
- cancelled = true;
- internalState?.addWaitForReadyTime(performance.now() - start);
+ finish();
const stack = scope.remotion_cancelledError;
const message = stack.split('\n')[0].replace(/^Error: /, '');
const error = new Error(message);
@@ -54,8 +68,7 @@ export const waitForReady = ({
}
if (performance.now() - start > timeoutInMilliseconds + 3000) {
- cancelled = true;
- internalState?.addWaitForReadyTime(performance.now() - start);
+ finish();
reject(
new Error(
Object.values(scope.remotion_delayRenderTimeouts)
@@ -63,17 +76,14 @@ export const waitForReady = ({
.join(', '),
),
);
- return;
}
-
- scheduleNextCheck();
};
// schedule both raf and worker timer - whichever fires first wins.
// when tab is visible, raf fires first. when backgrounded, worker wins.
const scheduleNextCheck = () => {
const rafTick = new Promise<void>((res) => {
- requestAnimationFrame(() => res());
+ rafId = requestAnimationFrame(() => res());
});
// browsers throttle RAF when tab is backgrounded, so race against worker
@@ -81,11 +91,24 @@ export const waitForReady = ({
? Promise.race([rafTick, keepalive.waitForTick()])
: rafTick;
- backgroundSafeTick.then(check);
+ backgroundSafeTick.then(() => {
+ if (rafId !== null) {
+ cancelAnimationFrame(rafId);
+ rafId = null;
+ }
+
+ check();
+ if (!completed) {
+ scheduleNextCheck();
+ }
+ });
};
// check immediately first - if already ready, don't wait for RAF
check();
+ if (!completed) {
+ scheduleNextCheck();
+ }
return promise;
};