Skip to content

🎥 Make videos programmatically with React

fix(media): cancel disposed initialization before it paints

Alec Watts290f8a3c5475
diff --git a/packages/media/src/media-player.ts b/packages/media/src/media-player.ts
index b06748a9b7..e0784637f4 100644
--- a/packages/media/src/media-player.ts
+++ b/packages/media/src/media-player.ts
@@ -378,6 +378,7 @@ export class MediaPlayer {
}
this.videoIteratorManager = await videoIteratorManager({
+ getIsDisposed: () => this.isDisposalError(),
videoTrack,
delayPlaybackHandleIfNotPremounting:
this.delayPlaybackHandleIfNotPremounting,
@@ -396,6 +397,10 @@ export class MediaPlayer {
});
}
+ if (this.isDisposalError()) {
+ return {type: 'disposed'};
+ }
+
const startTime = this.getTrimmedTime(startTimeUnresolved);
if (startTime === null) {
@@ -480,6 +485,10 @@ export class MediaPlayer {
);
}
+ if (this.isDisposalError()) {
+ return {type: 'disposed'};
+ }
+
return {type: 'success', durationInSeconds};
} catch (error) {
const err = error as Error;
@@ -772,6 +781,9 @@ export class MediaPlayer {
}
this.disposed = true;
+ // Cancel pending paints before waiting for initialization to settle.
+ this.nonceManager.createAsyncOperation();
+ this.videoIteratorManager?.destroy();
if (this.initializationPromise) {
try {
@@ -784,8 +796,6 @@ export class MediaPlayer {
}
}
- // Mark all async operations as stale
- this.nonceManager.createAsyncOperation();
this.videoIteratorManager?.destroy();
this.audioIteratorManager?.destroyIterator();
// Release our reference to the shared Input; it is only disposed once the
diff --git a/packages/media/src/test/media-player.test.ts b/packages/media/src/test/media-player.test.ts
index 91724f2ff4..248151b8cf 100644
--- a/packages/media/src/test/media-player.test.ts
+++ b/packages/media/src/test/media-player.test.ts
@@ -1,4 +1,4 @@
-import {AudioBufferSink} from 'mediabunny';
+import {AudioBufferSink, CanvasSink, InputVideoTrack} from 'mediabunny';
import {expect, test, vi} from 'vitest';
import {MediaPlayer} from '../media-player';
import type {SharedAudioContextForMediaPlayer} from '../shared-audio-context-for-media-player';
@@ -38,10 +38,16 @@ const makeAudioPlayer = (
sharedAudioContext: SharedAudioContextForMediaPlayer | null,
onError: ((error: Error) => void) | null = null,
tagType: 'audio' | 'video' = 'audio',
+ options: Pick<
+ ConstructorParameters<typeof MediaPlayer>[0],
+ 'canvas' | 'onVideoFrameCallback' | 'src'
+ > | null = null,
) => {
return new MediaPlayer({
- canvas: null,
- src: tagType === 'audio' ? '/voice-note.m4a' : '/bigbuckbunny.mp4',
+ canvas: options?.canvas ?? null,
+ src:
+ options?.src ??
+ (tagType === 'audio' ? '/voice-note.m4a' : '/bigbuckbunny.mp4'),
logLevel: 'error',
sharedAudioContext,
loop: false,
@@ -57,7 +63,7 @@ const makeAudioPlayer = (
isPremounting: false,
isPostmounting: false,
durationInFrames: 300,
- onVideoFrameCallback: null,
+ onVideoFrameCallback: options?.onVideoFrameCallback ?? null,
playing: false,
sequenceOffset: 0,
credentials: undefined,
@@ -325,3 +331,109 @@ test('ignores pending seek failures after disposal and skips new seeks', async (
expect(seek).toHaveBeenCalledOnce();
player.videoIteratorManager = null;
});
+
+// A disposed initialization must not repaint a canvas reused by its replacement.
+test.each(['dimensions', 'first frame'] as const)(
+ 'disposing during %s initialization preserves the replacement picture',
+ async (boundary) => {
+ let release = () => {};
+ const gate = new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ let reached = () => {};
+ const held = new Promise<void>((resolve) => {
+ reached = resolve;
+ });
+ const canvas = document.createElement('canvas');
+ const onFrame = vi.fn();
+ const oldPlayer = makeAudioPlayer(null, null, 'video', {
+ canvas,
+ onVideoFrameCallback: onFrame,
+ src: '/bigbuckbunny.mp4',
+ });
+ const replacement = makeAudioPlayer(null, null, 'video', {
+ canvas,
+ onVideoFrameCallback: null,
+ src: '/red-heart-1x.webm',
+ });
+ const originalWidth = InputVideoTrack.prototype.getDisplayWidth;
+ const originalCanvases = CanvasSink.prototype.canvases;
+ const spy =
+ boundary === 'dimensions'
+ ? vi
+ .spyOn(InputVideoTrack.prototype, 'getDisplayWidth')
+ .mockImplementationOnce(async function (this: InputVideoTrack) {
+ const width = await originalWidth.call(this);
+ reached();
+ await gate;
+ return width;
+ })
+ : vi
+ .spyOn(CanvasSink.prototype, 'canvases')
+ .mockImplementationOnce(function (this: CanvasSink, ...args) {
+ const iterator = originalCanvases.apply(this, args);
+ const next = iterator.next.bind(iterator);
+ iterator.next = async (...nextArgs) => {
+ const frame = await next(...nextArgs);
+ reached();
+ await gate;
+ return frame;
+ };
+
+ return iterator;
+ });
+ const initialization = oldPlayer.initialize(1, true, 1);
+ let disposal: Promise<void> | null = null;
+ const picture = async () => {
+ const pixels = canvas
+ .getContext('2d')!
+ .getImageData(0, 0, canvas.width, canvas.height).data;
+ return Array.from(
+ new Uint8Array(await crypto.subtle.digest('SHA-256', pixels)),
+ );
+ };
+
+ try {
+ await held;
+ disposal = oldPlayer.dispose();
+ expect((await replacement.initialize(1, true, 1)).type).toBe('success');
+ expect(
+ replacement.videoIteratorManager!.getFramesRendered(),
+ ).toBeGreaterThan(0);
+ const expected = await picture();
+ release();
+ await disposal;
+ expect(await picture()).toEqual(expected);
+ expect(onFrame).not.toHaveBeenCalled();
+ expect((await initialization).type).toBe('disposed');
+ } finally {
+ release();
+ await initialization;
+ await disposal;
+ spy.mockRestore();
+ await oldPlayer.dispose();
+ await replacement.dispose();
+ }
+ },
+);
+
+test('disposal clears a rendered canvas only once', async () => {
+ const canvas = document.createElement('canvas');
+ const player = makeAudioPlayer(null, null, 'video', {
+ canvas,
+ onVideoFrameCallback: null,
+ src: '/bigbuckbunny.mp4',
+ });
+ try {
+ expect((await player.initialize(1, true, 1)).type).toBe('success');
+ const clear = vi.spyOn(canvas.getContext('2d')!, 'clearRect');
+ try {
+ await player.dispose();
+ expect(clear).toHaveBeenCalledOnce();
+ } finally {
+ clear.mockRestore();
+ }
+ } finally {
+ await player.dispose();
+ }
+});
diff --git a/packages/media/src/test/video-iterator-manager.test.ts b/packages/media/src/test/video-iterator-manager.test.ts
index 7939873dd9..482a945788 100644
--- a/packages/media/src/test/video-iterator-manager.test.ts
+++ b/packages/media/src/test/video-iterator-manager.test.ts
@@ -79,6 +79,7 @@ const makeManager = (
videoTrack: Awaited<ReturnType<typeof prepare>>['videoTrack'],
) =>
videoIteratorManager({
+ getIsDisposed: () => false,
videoTrack,
delayPlaybackHandleIfNotPremounting: () => ({
unblock: () => {},
@@ -170,6 +171,7 @@ test('seek should not cause overlapping block/unblock cycles', async () => {
let maxConcurrentBlocks = 0;
const manager = await videoIteratorManager({
+ getIsDisposed: () => false,
videoTrack,
delayPlaybackHandleIfNotPremounting: () => {
activeBlocks++;
@@ -245,6 +247,7 @@ test('rapid sequential seeks should not cause overlapping blocks', async () => {
let maxConcurrentBlocks = 0;
const manager = await videoIteratorManager({
+ getIsDisposed: () => false,
videoTrack,
delayPlaybackHandleIfNotPremounting: () => {
activeBlocks++;
@@ -303,6 +306,7 @@ test('redrawCurrentFrame should not create a new video iterator', async () => {
const {videoTrack} = await prepare();
const manager = await videoIteratorManager({
+ getIsDisposed: () => false,
videoTrack,
delayPlaybackHandleIfNotPremounting: () => ({
unblock: () => {},
diff --git a/packages/media/src/test/video-with-no-frames-in-beginning.test.ts b/packages/media/src/test/video-with-no-frames-in-beginning.test.ts
index 40348a8ded..256bcf0b5a 100644
--- a/packages/media/src/test/video-with-no-frames-in-beginning.test.ts
+++ b/packages/media/src/test/video-with-no-frames-in-beginning.test.ts
@@ -27,6 +27,7 @@ test('in preview, should properly buffer and draw frames', async (t) => {
}
const manager = await videoIteratorManager({
+ getIsDisposed: () => false,
getIsLooping: () => false,
getLoopSegmentMediaEndTimestamp: () => {
throw new Error('not implemented');
diff --git a/packages/media/src/video-iterator-manager.ts b/packages/media/src/video-iterator-manager.ts
index 74732d8e0b..d3ea81423e 100644
--- a/packages/media/src/video-iterator-manager.ts
+++ b/packages/media/src/video-iterator-manager.ts
@@ -44,6 +44,7 @@ export const isSequentialMediaTimeAdvance = ({
};
export const videoIteratorManager = async ({
+ getIsDisposed,
delayPlaybackHandleIfNotPremounting,
canvas,
context,
@@ -58,6 +59,7 @@ export const videoIteratorManager = async ({
getEffectChainState,
maxCanvasSinkFrameSize,
}: {
+ getIsDisposed: () => boolean;
videoTrack: InputVideoTrack;
delayPlaybackHandleIfNotPremounting: () => DelayPlaybackIfNotPremounting;
context: OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D | null;
@@ -89,7 +91,7 @@ export const videoIteratorManager = async ({
const displayWidth = await videoTrack.getDisplayWidth();
const displayHeight = await videoTrack.getDisplayHeight();
- if (canvas) {
+ if (canvas && !getIsDisposed()) {
if (canvas.width !== displayWidth || canvas.height !== displayHeight) {
canvas.width = displayWidth;
canvas.height = displayHeight;
@@ -348,11 +350,15 @@ export const videoIteratorManager = async ({
getVideoIteratorsCreated: () => videoIteratorsCreated,
seek,
destroy: () => {
+ if (destroyed) {
+ return;
+ }
+
destroyed = true;
clearLastDrawnFrame();
prewarmedVideoIteratorCache.destroy();
videoFrameIterator?.destroy();
- if (context && canvas) {
+ if (context && canvas && framesRendered > 0) {
context.clearRect(0, 0, canvas.width, canvas.height);
}