Skip to content

🎥 Make videos programmatically with React

`remotion`: Replace imperative playing ref with `playbackStore` and `usePlaying()`

Noah Lindnerc18d16dda3b8
diff --git a/packages/core/src/TimelineContext.tsx b/packages/core/src/TimelineContext.tsx
index 303adb86f7..ac7d2f60c9 100644
--- a/packages/core/src/TimelineContext.tsx
+++ b/packages/core/src/TimelineContext.tsx
@@ -6,6 +6,10 @@ import React, {
useRef,
useState,
} from 'react';
+import {
+ createRuntimeValueStore,
+ type RuntimeValueStoreController,
+} from './runtime-value-store.js';
import {
getInitialFrameState,
type PlayableMediaTag,
@@ -14,14 +18,7 @@ import {useDelayRender} from './use-delay-render';
export type TimelineContextValue = {
frame: Record<string, number>;
- playing: boolean;
- imperativePlaying: RefObject<boolean>;
- audioAndVideoTags: RefObject<PlayableMediaTag[]>;
-};
-
-export type TimelineImperativeContextValue = {
- frameRef: RefObject<Record<string, number>>;
- imperativePlaying: RefObject<boolean>;
+ playbackStore: RuntimeValueStoreController;
audioAndVideoTags: RefObject<PlayableMediaTag[]>;
};
@@ -46,9 +43,6 @@ export const SetTimelineContext = createContext<SetTimelineContextValue>({
export const TimelineContext = createContext<TimelineContextValue | null>(null);
-export const TimelineImperativeContext =
- createContext<TimelineImperativeContextValue | null>(null);
-
export const PlaybackRateContext =
createContext<PlaybackRateContextValue | null>(null);
@@ -60,8 +54,10 @@ export const TimelineContextProvider: React.FC<{
readonly children: React.ReactNode;
readonly frameState: Record<string, number> | null;
}> = ({children, frameState}) => {
- const [playing, setPlaying] = useState<boolean>(false);
- const imperativePlaying = useRef<boolean>(false);
+ const playbackStore = useMemo(
+ () => createRuntimeValueStore({playing: false}),
+ [],
+ );
const [playbackRate, setPlaybackRate] = useState(1);
const audioAndVideoTags = useRef<PlayableMediaTag[]>([]);
@@ -113,20 +109,10 @@ export const TimelineContextProvider: React.FC<{
const timelineContextValue = useMemo((): TimelineContextValue => {
return {
frame,
- playing,
- imperativePlaying,
+ playbackStore,
audioAndVideoTags,
};
- }, [frame, playing]);
-
- const timelineImperativeContextValue =
- useMemo((): TimelineImperativeContextValue => {
- return {
- frameRef,
- imperativePlaying,
- audioAndVideoTags,
- };
- }, []);
+ }, [frame, playbackStore]);
const playbackRateContextValue = useMemo((): PlaybackRateContextValue => {
return {
@@ -138,22 +124,25 @@ export const TimelineContextProvider: React.FC<{
const setTimelineContextValue = useMemo((): SetTimelineContextValue => {
return {
setFrame,
- setPlaying,
+ setPlaying: (updater) => {
+ if (typeof updater === 'function') {
+ const current = playbackStore.store.getSnapshot().playing as boolean;
+ playbackStore.setSnapshot({playing: updater(current)});
+ } else {
+ playbackStore.setSnapshot({playing: updater});
+ }
+ },
};
- }, []);
+ }, [playbackStore]);
return (
<AbsoluteTimeContext.Provider value={timelineContextValue}>
<PlaybackRateContext.Provider value={playbackRateContextValue}>
- <TimelineImperativeContext.Provider
- value={timelineImperativeContextValue}
- >
- <TimelineContext.Provider value={timelineContextValue}>
- <SetTimelineContext.Provider value={setTimelineContextValue}>
- {children}
- </SetTimelineContext.Provider>
- </TimelineContext.Provider>
- </TimelineImperativeContext.Provider>
+ <TimelineContext.Provider value={timelineContextValue}>
+ <SetTimelineContext.Provider value={setTimelineContextValue}>
+ {children}
+ </SetTimelineContext.Provider>
+ </TimelineContext.Provider>
</PlaybackRateContext.Provider>
</AbsoluteTimeContext.Provider>
);
diff --git a/packages/core/src/freeze.tsx b/packages/core/src/freeze.tsx
index 2f911f6c46..48264e9b99 100644
--- a/packages/core/src/freeze.tsx
+++ b/packages/core/src/freeze.tsx
@@ -1,4 +1,5 @@
import React, {useContext, useMemo} from 'react';
+import {createRuntimeValueStore} from './runtime-value-store.js';
import type {SequenceContextType} from './SequenceContext.js';
import {SequenceContext} from './SequenceContext.js';
import {useTimelineContext} from './timeline-position-state.js';
@@ -69,12 +70,11 @@ export const Freeze: React.FC<FreezeProps> = ({
return timelineContext;
}
+ const frozenStore = createRuntimeValueStore({playing: false});
+
return {
...timelineContext,
- playing: false,
- imperativePlaying: {
- current: false,
- },
+ playbackStore: frozenStore,
frame: {
[videoConfig.id]: frameToFreeze + relativeFrom,
},
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 7948e6e5ff..1105b8c155 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -250,6 +250,7 @@ export * from './Still.js';
export type {PlayableMediaTag} from './timeline-position-state.js';
export {useBufferState} from './use-buffer-state';
export {useCurrentFrame} from './use-current-frame.js';
+export {usePlaying} from './use-playing.js';
export {
CurrentScaleContextType,
PreviewSize,
diff --git a/packages/core/src/internals.ts b/packages/core/src/internals.ts
index c6ead6ff78..eafd73f022 100644
--- a/packages/core/src/internals.ts
+++ b/packages/core/src/internals.ts
@@ -157,6 +157,7 @@ import {
resolveCompositionsRef,
useResolvedVideoConfig,
} from './ResolveCompositionConfig.js';
+import {createRuntimeValueStore} from './runtime-value-store.js';
import {resolveSequenceCrop} from './sequence-crop.js';
import type {
OverrideIdToNodePaths,
@@ -206,10 +207,8 @@ import {
PlaybackRateContext,
SetTimelineContext,
TimelineContext,
- TimelineImperativeContext,
type PlaybackRateContextValue,
type SetTimelineContextValue,
- type TimelineImperativeContextValue,
type TimelineContextValue,
} from './TimelineContext.js';
import {truthy} from './truthy.js';
@@ -227,6 +226,7 @@ import {
useMediaInTimeline,
} from './use-media-in-timeline.js';
import {PixelDensityContext} from './use-pixel-density.js';
+import {usePlaying} from './use-playing.js';
import {usePremounting} from './use-premounting.js';
import type {
CanUpdateSequencePropStatusFalse,
@@ -309,6 +309,7 @@ export const Internals = {
MEDIABUNNY_DURATION_VALUE_KEY,
makeRenderResourceManager,
RenderResourceManagerContext,
+ createRuntimeValueStore,
useUnsafeVideoConfig,
useFrameForVolumeProp,
useTimelinePosition: TimelinePosition.useTimelinePosition,
@@ -439,7 +440,7 @@ export const Internals = {
TimelinePosition,
DelayRenderContextType,
TimelineContext,
- TimelineImperativeContext,
+ usePlaying,
PlaybackRateContext,
AbsoluteTimeContext,
RenderAssetManagerProvider,
@@ -528,7 +529,6 @@ export type {
TCompMetadata,
TComposition,
TimelineContextValue,
- TimelineImperativeContextValue,
TRenderAsset,
TSequence,
VisibleFieldSchema,
diff --git a/packages/core/src/test/nested-sequences.test.tsx b/packages/core/src/test/nested-sequences.test.tsx
index d745c953ee..32bc710194 100644
--- a/packages/core/src/test/nested-sequences.test.tsx
+++ b/packages/core/src/test/nested-sequences.test.tsx
@@ -3,6 +3,7 @@ import {cleanup, render} from '@testing-library/react';
import {useEffect} from 'react';
import {AbsoluteFill} from '../AbsoluteFill.js';
import {getTimelineDuration} from '../get-timeline-duration.js';
+import {createRuntimeValueStore} from '../runtime-value-store.js';
import {Sequence} from '../Sequence.js';
import {TimelineContext} from '../TimelineContext.js';
import {useCurrentFrame} from '../use-current-frame.js';
@@ -18,10 +19,7 @@ const getForFrame = (frame: number, content: React.ReactNode) => {
frame: {
'my-comp': frame,
},
- playing: false,
- imperativePlaying: {
- current: false,
- },
+ playbackStore: createRuntimeValueStore({playing: false}),
audioAndVideoTags: {
current: [],
},
@@ -258,10 +256,7 @@ test('Sequence freeze pins the child frame without remounting the sequence', ()
frame: {
'my-comp': 15,
},
- playing: false,
- imperativePlaying: {
- current: false,
- },
+ playbackStore: createRuntimeValueStore({playing: false}),
audioAndVideoTags: {
current: [],
},
@@ -282,10 +277,7 @@ test('Sequence freeze pins the child frame without remounting the sequence', ()
frame: {
'my-comp': 25,
},
- playing: false,
- imperativePlaying: {
- current: false,
- },
+ playbackStore: createRuntimeValueStore({playing: false}),
audioAndVideoTags: {
current: [],
},
diff --git a/packages/core/src/test/series.test.tsx b/packages/core/src/test/series.test.tsx
index 629c6a7187..991896089a 100644
--- a/packages/core/src/test/series.test.tsx
+++ b/packages/core/src/test/series.test.tsx
@@ -4,6 +4,7 @@ import {renderToString} from 'react-dom/server';
import {AbsoluteFill} from '../AbsoluteFill.js';
import {CanUseRemotionHooksProvider} from '../CanUseRemotionHooks.js';
import {Internals} from '../internals.js';
+import {createRuntimeValueStore} from '../runtime-value-store.js';
import {Sequence} from '../Sequence.js';
import {Series} from '../series/index.js';
import type {TimelineContextValue} from '../TimelineContext.js';
@@ -50,10 +51,7 @@ const renderForFrame = (frame: number, markup: React.ReactNode) => {
frame: {
'my-comp': frame,
},
- playing: false,
- imperativePlaying: {
- current: false,
- },
+ playbackStore: createRuntimeValueStore({playing: false}),
audioAndVideoTags: {current: []},
};
diff --git a/packages/core/src/test/wrap-sequence-context.tsx b/packages/core/src/test/wrap-sequence-context.tsx
index 09a2f7b699..dd1480741c 100644
--- a/packages/core/src/test/wrap-sequence-context.tsx
+++ b/packages/core/src/test/wrap-sequence-context.tsx
@@ -5,6 +5,7 @@ import type {CompositionManagerContext} from '../CompositionManagerContext.js';
import {CompositionManager} from '../CompositionManagerContext.js';
import type {LoggingContextValue} from '../log-level-context.js';
import {LogLevelContext} from '../log-level-context.js';
+import {createRuntimeValueStore} from '../runtime-value-store.js';
import {SequenceManagerProvider} from '../SequenceManager.js';
import type {
PlaybackRateContextValue,
@@ -115,8 +116,7 @@ export const WrapSequenceContext: React.FC<{
const timelineContext = useMemo<TimelineContextValue>(
() => ({
frame: {'my-comp': currentFrame},
- playing: false,
- imperativePlaying: {current: false},
+ playbackStore: createRuntimeValueStore({playing: false}),
audioAndVideoTags: {current: []},
}),
[currentFrame],
diff --git a/packages/core/src/timeline-position-state.ts b/packages/core/src/timeline-position-state.ts
index d5ad0acb61..c42d10b803 100644
--- a/packages/core/src/timeline-position-state.ts
+++ b/packages/core/src/timeline-position-state.ts
@@ -8,6 +8,7 @@ import {
type PlaybackRateContextValue,
type TimelineContextValue,
} from './TimelineContext.js';
+import {usePlaying} from './use-playing.js';
import {useRemotionEnvironment} from './use-remotion-environment.js';
import {useVideo} from './use-video.js';
@@ -125,11 +126,25 @@ type PlayingReturnType = readonly [
];
export const usePlayingState = (): PlayingReturnType => {
- const {playing, imperativePlaying} = useTimelineContext();
+ const {playbackStore} = useTimelineContext();
+ const playing = usePlaying();
const {setPlaying} = useContext(SetTimelineContext);
return useMemo(
- () => [playing, setPlaying, imperativePlaying],
- [imperativePlaying, playing, setPlaying],
+ () => [
+ playing,
+ setPlaying,
+ {
+ get current() {
+ return playbackStore.store.getSnapshot().playing as boolean;
+ },
+ set current(val) {
+ playbackStore.setSnapshot({playing: val});
+ },
+ },
+ ],
+ [playbackStore, playing, setPlaying],
);
};
+
+export {usePlaying} from './use-playing.js';
diff --git a/packages/core/src/use-media-playback.ts b/packages/core/src/use-media-playback.ts
index 2c80e83cc8..74d1ec6036 100644
--- a/packages/core/src/use-media-playback.ts
+++ b/packages/core/src/use-media-playback.ts
@@ -17,7 +17,7 @@ import {playAndHandleNotAllowedError} from './play-and-handle-not-allowed-error.
import {playbackLogging} from './playback-logging.js';
import {seek} from './seek.js';
import {
- usePlayingState,
+ usePlaying,
usePlaybackRate,
useTimelinePosition,
} from './timeline-position-state.js';
@@ -57,7 +57,7 @@ export const useMediaPlayback = ({
const {playbackRate: globalPlaybackRate} = usePlaybackRate();
const frame = useCurrentFrame();
const absoluteFrame = useTimelinePosition();
- const [playing] = usePlayingState();
+ const playing = usePlaying();
const buffering = useContext(BufferingContextReact);
const {fps} = useVideoConfig();
const mediaStartsAt = useMediaStartsAt();
diff --git a/packages/core/src/use-media-tag.ts b/packages/core/src/use-media-tag.ts
index 2b507ba880..792335cafc 100644
--- a/packages/core/src/use-media-tag.ts
+++ b/packages/core/src/use-media-tag.ts
@@ -21,7 +21,7 @@ export const useMediaTag = ({
isPremounting: boolean;
isPostmounting: boolean;
}) => {
- const {audioAndVideoTags, imperativePlaying} = useTimelineContext();
+ const {audioAndVideoTags, playbackStore} = useTimelineContext();
const logLevel = useLogLevel();
const mountTime = useMountTime();
const env = useRemotionEnvironment();
@@ -30,7 +30,7 @@ export const useMediaTag = ({
const tag: PlayableMediaTag = {
id,
play: (reason) => {
- if (!imperativePlaying.current) {
+ if (!playbackStore.store.getSnapshot().playing) {
// Don't play if for example in a <Freeze> state.
return;
}
@@ -63,7 +63,7 @@ export const useMediaTag = ({
mediaRef,
mediaType,
onAutoPlayError,
- imperativePlaying,
+ playbackStore,
isPremounting,
isPostmounting,
logLevel,
diff --git a/packages/core/src/use-playing.ts b/packages/core/src/use-playing.ts
new file mode 100644
index 0000000000..b2573d4b27
--- /dev/null
+++ b/packages/core/src/use-playing.ts
@@ -0,0 +1,11 @@
+import {useSyncExternalStore} from 'react';
+import {useTimelineContext} from './timeline-position-state.js';
+
+export const usePlaying = () => {
+ const {playbackStore} = useTimelineContext();
+ return useSyncExternalStore(
+ playbackStore.store.subscribe,
+ () => playbackStore.store.getSnapshot().playing as boolean,
+ () => playbackStore.store.getSnapshot().playing as boolean,
+ );
+};
diff --git a/packages/core/src/wrap-remotion-context.tsx b/packages/core/src/wrap-remotion-context.tsx
index c2772fec89..5029853e21 100644
--- a/packages/core/src/wrap-remotion-context.tsx
+++ b/packages/core/src/wrap-remotion-context.tsx
@@ -17,16 +17,11 @@ import {
SequenceManagerRefContext,
VisualModePropStatusesRefContext,
} from './SequenceManager.js';
-import {
- SetTimelineContext,
- TimelineContext,
- TimelineImperativeContext,
-} from './TimelineContext.js';
+import {SetTimelineContext, TimelineContext} from './TimelineContext.js';
export function useRemotionContexts() {
const compositionManagerCtx = React.useContext(CompositionManager);
const timelineContext = React.useContext(TimelineContext);
- const timelineImperativeContext = React.useContext(TimelineImperativeContext);
const setTimelineContext = React.useContext(SetTimelineContext);
const sequenceContext = React.useContext(SequenceContext);
const nonceContext = React.useContext(NonceContext);
@@ -46,7 +41,6 @@ export function useRemotionContexts() {
() => ({
compositionManagerCtx,
timelineContext,
- timelineImperativeContext,
setTimelineContext,
sequenceContext,
nonceContext,
@@ -66,7 +60,6 @@ export function useRemotionContexts() {
sequenceContext,
setTimelineContext,
timelineContext,
- timelineImperativeContext,
canUseRemotionHooksContext,
preloadContext,
resolveCompositionContext,
@@ -110,27 +103,23 @@ export const RemotionContextProvider = (
<ResolveCompositionContext.Provider
value={contexts.resolveCompositionContext}
>
- <TimelineImperativeContext.Provider
- value={contexts.timelineImperativeContext}
+ <TimelineContext.Provider
+ value={contexts.timelineContext}
>
- <TimelineContext.Provider
- value={contexts.timelineContext}
+ <SetTimelineContext.Provider
+ value={contexts.setTimelineContext}
>
- <SetTimelineContext.Provider
- value={contexts.setTimelineContext}
+ <SequenceContext.Provider
+ value={contexts.sequenceContext}
>
- <SequenceContext.Provider
- value={contexts.sequenceContext}
+ <BufferingContextReact.Provider
+ value={contexts.bufferManagerContext}
>
- <BufferingContextReact.Provider
- value={contexts.bufferManagerContext}
- >
- {children}
- </BufferingContextReact.Provider>
- </SequenceContext.Provider>
- </SetTimelineContext.Provider>
- </TimelineContext.Provider>
- </TimelineImperativeContext.Provider>
+ {children}
+ </BufferingContextReact.Provider>
+ </SequenceContext.Provider>
+ </SetTimelineContext.Provider>
+ </TimelineContext.Provider>
</ResolveCompositionContext.Provider>
</RenderAssetManager.Provider>
</VisualModePropStatusesRefContext.Provider>
diff --git a/packages/gif/src/test/Gif.test.tsx b/packages/gif/src/test/Gif.test.tsx
index accf55b6c6..237216c1a4 100644
--- a/packages/gif/src/test/Gif.test.tsx
+++ b/packages/gif/src/test/Gif.test.tsx
@@ -107,8 +107,7 @@ const compositionContext = {
const timelineContext = {
frame: {},
- playing: false,
- imperativePlaying: {current: false},
+ playbackStore: Internals.createRuntimeValueStore({playing: false}),
audioAndVideoTags: {current: []},
} as React.ContextType<typeof Internals.TimelineContext>;
diff --git a/packages/mac-cursors/src/test/resolve-cursor.test.ts b/packages/mac-cursors/src/test/resolve-cursor.test.ts
index 361769e6a7..2af3628a9d 100644
--- a/packages/mac-cursors/src/test/resolve-cursor.test.ts
+++ b/packages/mac-cursors/src/test/resolve-cursor.test.ts
@@ -106,8 +106,7 @@ test('<MacOSCursor> renders the default cursor when the cursor prop is omitted',
} as React.ContextType<typeof Internals.CompositionManager>;
const timeline = {
frame: {comp: 0},
- playing: false,
- imperativePlaying: {current: false},
+ playbackStore: Internals.createRuntimeValueStore({playing: false}),
audioAndVideoTags: {current: []},
} as React.ContextType<typeof Internals.TimelineContext>;
const markup = renderToString(
diff --git a/packages/media/src/audio/audio-for-preview.tsx b/packages/media/src/audio/audio-for-preview.tsx
index df3b0da4e3..6a4742088a 100644
--- a/packages/media/src/audio/audio-for-preview.tsx
+++ b/packages/media/src/audio/audio-for-preview.tsx
@@ -16,7 +16,6 @@ import type {FallbackHtml5AudioProps} from './props';
const {
useUnsafeVideoConfig,
- Timeline,
SharedAudioContext,
usePlayerMutedState,
useMediaVolumeState,
@@ -25,6 +24,7 @@ const {
warnAboutTooHighVolume,
usePreload,
SequenceContext,
+ usePlaying,
} = Internals;
type NewAudioForPreviewProps = {
@@ -85,7 +85,7 @@ const AudioForPreviewAssertedShowing: React.FC<NewAudioForPreviewProps> = ({
const [shouldFallbackToNativeAudio, setShouldFallbackToNativeAudio] =
useState(false);
- const [playing] = Timeline.usePlayingState();
+ const playing = usePlaying();
const {playbackRate: globalPlaybackRate} = Internals.usePlaybackRate();
const sharedAudioContext = useContext(SharedAudioContext);
const buffer = useBufferState();
diff --git a/packages/media/src/video/video-for-preview.tsx b/packages/media/src/video/video-for-preview.tsx
index a32b791ed1..1191ca0d42 100644
--- a/packages/media/src/video/video-for-preview.tsx
+++ b/packages/media/src/video/video-for-preview.tsx
@@ -37,7 +37,6 @@ import {warnAboutObjectFitInStyleOrClassName} from './warn-object-fit-css';
const {
useUnsafeVideoConfig,
- Timeline,
SharedAudioContext,
usePlayerMutedState,
useMediaVolumeState,
@@ -47,6 +46,7 @@ const {
usePreload,
SequenceContext,
useEffectChainState,
+ usePlaying,
} = Internals;
type VideoForPreviewProps = NativeVideoProps & {
@@ -128,7 +128,7 @@ const VideoForPreviewAssertedShowing: React.FC<
const [shouldFallbackToNativeVideo, setShouldFallbackToNativeVideo] =
useState(false);
- const [playing] = Timeline.usePlayingState();
+ const playing = usePlaying();
const {playbackRate: globalPlaybackRate} = Internals.usePlaybackRate();
const sharedAudioContext = useContext(SharedAudioContext);
const buffer = useBufferState();
diff --git a/packages/player/src/EmitterProvider.tsx b/packages/player/src/EmitterProvider.tsx
index 3951660f2c..f0d1059919 100644
--- a/packages/player/src/EmitterProvider.tsx
+++ b/packages/player/src/EmitterProvider.tsx
@@ -2,7 +2,6 @@ import React, {useContext, useEffect, useState} from 'react';
import {Internals} from 'remotion';
import {PlayerEventEmitterContext} from './emitter-context.js';
import {PlayerEmitter} from './event-emitter.js';
-import {TimelineImperativeCompatibilityProvider} from './timeline-imperative-context.js';
import {useBufferStateEmitter} from './use-buffer-state-emitter.js';
export const PlayerEmitterProvider: React.FC<{
@@ -24,10 +23,8 @@ export const PlayerEmitterProvider: React.FC<{
useBufferStateEmitter(emitter);
return (
- <TimelineImperativeCompatibilityProvider>
- <PlayerEventEmitterContext.Provider value={emitter}>
- {children}
- </PlayerEventEmitterContext.Provider>
- </TimelineImperativeCompatibilityProvider>
+ <PlayerEventEmitterContext.Provider value={emitter}>
+ {children}
+ </PlayerEventEmitterContext.Provider>
);
};
diff --git a/packages/player/src/Player.tsx b/packages/player/src/Player.tsx
index 606885ba3a..7f70437416 100644
--- a/packages/player/src/Player.tsx
+++ b/packages/player/src/Player.tsx
@@ -242,10 +242,12 @@ const PlayerFn = <
const [frame, setFrame] = useState<Record<string, number>>(() => ({
[PLAYER_COMP_ID]: initialFrame ?? 0,
}));
- const [playing, setPlaying] = useState<boolean>(false);
const rootRef = useRef<PlayerRef>(null);
const audioAndVideoTags = useRef<PlayableMediaTag[]>([]);
- const imperativePlaying = useRef(false);
+ const playbackStore = useMemo(
+ () => Internals.createRuntimeValueStore({playing: false}),
+ [],
+ );
const [currentPlaybackRate, setCurrentPlaybackRate] = useState(playbackRate);
if (typeof compositionHeight !== 'number') {
@@ -410,11 +412,10 @@ const PlayerFn = <
const timelineContextValue = useMemo((): TimelineContextValue => {
return {
frame,
- playing,
- imperativePlaying,
+ playbackStore,
audioAndVideoTags,
};
- }, [frame, playing]);
+ }, [frame, playbackStore]);
const playbackRateContextValue = useMemo((): PlaybackRateContextValue => {
return {
@@ -426,9 +427,19 @@ const PlayerFn = <
const setTimelineContextValue = useMemo((): SetTimelineContextValue => {
return {
setFrame,
- setPlaying,
+ setPlaying: (updater) => {
+ if (typeof updater === 'function') {
+ playbackStore.setSnapshot({
+ playing: updater(
+ playbackStore.store.getSnapshot().playing as boolean,
+ ),
+ });
+ } else {
+ playbackStore.setSnapshot({playing: updater});
+ }
+ },
};
- }, [setFrame]);
+ }, [playbackStore, setFrame]);
if (typeof window !== 'undefined') {
// eslint-disable-next-line react-hooks/rules-of-hooks
diff --git a/packages/player/src/PlayerUI.tsx b/packages/player/src/PlayerUI.tsx
index 0e790aabb7..ef75b1480c 100644
--- a/packages/player/src/PlayerUI.tsx
+++ b/packages/player/src/PlayerUI.tsx
@@ -169,7 +169,7 @@ const PlayerUI: React.ForwardRefRenderFunction<
}, []);
const player = usePlayerMethods();
- const [playing] = Internals.Timeline.usePlayingState();
+ const playing = Internals.usePlaying();
const frame = Internals.Timeline.useTimelinePosition();
const play = useCallback(
diff --git a/packages/player/src/SharedPlayerContext.tsx b/packages/player/src/SharedPlayerContext.tsx
index cf10873020..a759fdc0db 100644
--- a/packages/player/src/SharedPlayerContext.tsx
+++ b/packages/player/src/SharedPlayerContext.tsx
@@ -10,11 +10,9 @@ import type {
PlaybackRateContextValue,
RemotionEnvironment,
SetMediaVolumeContextValue,
- TimelineImperativeContextValue,
TimelineContextValue,
} from 'remotion';
import {Internals} from 'remotion';
-import {CoreTimelineImperativeContextProvider} from './timeline-imperative-context.js';
import {getPreferredVolume, persistVolume} from './volume-persistence.js';
export const PLAYER_COMP_ID = 'player-comp';
@@ -162,14 +160,6 @@ export const SharedPlayerContexts: React.FC<{
const frameRef = useRef(timelineContext.frame);
frameRef.current = timelineContext.frame;
- const timelineImperativeContextValue =
- useMemo((): TimelineImperativeContextValue => {
- return {
- frameRef,
- imperativePlaying: timelineContext.imperativePlaying,
- audioAndVideoTags: timelineContext.audioAndVideoTags,
- };
- }, [timelineContext.audioAndVideoTags, timelineContext.imperativePlaying]);
return (
<Internals.RemotionEnvironmentContext.Provider value={env}>
@@ -177,44 +167,40 @@ export const SharedPlayerContexts: React.FC<{
<Internals.CanUseRemotionHooksProvider>
<Internals.AbsoluteTimeContext.Provider value={timelineContext}>
<Internals.PlaybackRateContext.Provider value={playbackRateContext}>
- <CoreTimelineImperativeContextProvider
- value={timelineImperativeContextValue}
- >
- <Internals.TimelineContext.Provider value={timelineContext}>
- <Internals.CompositionManager.Provider
- value={compositionManagerContext}
- >
- <Internals.PrefetchProvider>
- <Internals.DurationsContextProvider>
- <Internals.MediaVolumeContext.Provider
- value={mediaVolumeContextValue}
+ <Internals.TimelineContext.Provider value={timelineContext}>
+ <Internals.CompositionManager.Provider
+ value={compositionManagerContext}
+ >
+ <Internals.PrefetchProvider>
+ <Internals.DurationsContextProvider>
+ <Internals.MediaVolumeContext.Provider
+ value={mediaVolumeContextValue}
+ >
+ <Internals.SetMediaVolumeContext.Provider
+ value={setMediaVolumeContextValue}
>
- <Internals.SetMediaVolumeContext.Provider
- value={setMediaVolumeContextValue}
- >
- <Internals.BufferingProvider>
- <Internals.SharedAudioContextProvider
- audioLatencyHint={audioLatencyHint}
- audioEnabled={shouldCreateAudioContext}
- previewSampleRate={sampleRate}
- _experimentalKeepAudioContextAlive={
- _experimentalKeepAudioContextAlive
- }
+ <Internals.BufferingProvider>
+ <Internals.SharedAudioContextProvider
+ audioLatencyHint={audioLatencyHint}
+ audioEnabled={shouldCreateAudioContext}
+ previewSampleRate={sampleRate}
+ _experimentalKeepAudioContextAlive={
+ _experimentalKeepAudioContextAlive
+ }
+ >
+ <Internals.SharedAudioTagsContextProvider
+ numberOfAudioTags={numberOfSharedAudioTags}
>
- <Internals.SharedAudioTagsContextProvider
- numberOfAudioTags={numberOfSharedAudioTags}
- >
- {children}
- </Internals.SharedAudioTagsContextProvider>
- </Internals.SharedAudioContextProvider>
- </Internals.BufferingProvider>
- </Internals.SetMediaVolumeContext.Provider>
- </Internals.MediaVolumeContext.Provider>
- </Internals.DurationsContextProvider>
- </Internals.PrefetchProvider>
- </Internals.CompositionManager.Provider>
- </Internals.TimelineContext.Provider>
- </CoreTimelineImperativeContextProvider>
+ {children}
+ </Internals.SharedAudioTagsContextProvider>
+ </Internals.SharedAudioContextProvider>
+ </Internals.BufferingProvider>
+ </Internals.SetMediaVolumeContext.Provider>
+ </Internals.MediaVolumeContext.Provider>
+ </Internals.DurationsContextProvider>
+ </Internals.PrefetchProvider>
+ </Internals.CompositionManager.Provider>
+ </Internals.TimelineContext.Provider>
</Internals.PlaybackRateContext.Provider>
</Internals.AbsoluteTimeContext.Provider>
</Internals.CanUseRemotionHooksProvider>
diff --git a/packages/player/src/Thumbnail.tsx b/packages/player/src/Thumbnail.tsx
index 849a48d215..378e0656a8 100644
--- a/packages/player/src/Thumbnail.tsx
+++ b/packages/player/src/Thumbnail.tsx
@@ -83,16 +83,14 @@ const ThumbnailFn = <
}
const rootRef = useRef<ThumbnailMethods>(null);
- const imperativePlaying = useRef(false);
const audioAndVideoTags = useRef<PlayableMediaTag[]>([]);
const timelineState: TimelineContextValue = useMemo(() => {
const value: TimelineContextValue = {
- playing: false,
+ playbackStore: Internals.createRuntimeValueStore({playing: false}),
frame: {
[PLAYER_COMP_ID]: frameToDisplay,
},
- imperativePlaying,
audioAndVideoTags,
};
diff --git a/packages/player/src/browser-mediasession.ts b/packages/player/src/browser-mediasession.ts
index b8290c032d..6730cc9e67 100644
--- a/packages/player/src/browser-mediasession.ts
+++ b/packages/player/src/browser-mediasession.ts
@@ -23,7 +23,7 @@ export const useBrowserMediaSession = ({
videoConfig: VideoConfig | null;
playbackRate: number;
}) => {
- const [playing] = Internals.Timeline.usePlayingState();
+ const playing = Internals.usePlaying();
const {pause, play, emitter, getCurrentFrame, seek} = usePlayerMethods();
const hasEverPlayed = useRef(false);
diff --git a/packages/player/src/test/index.test.ts b/packages/player/src/test/index.test.ts
index 6059ed025d..5cad85e76f 100644
--- a/packages/player/src/test/index.test.ts
+++ b/packages/player/src/test/index.test.ts
@@ -104,44 +104,6 @@ test('Imperative player methods do not rerender when the frame changes', () => {
expect(methodRenders).toBe(rendersAfterMount);
});
-test('Player methods fall back when core has no timeline imperative context', () => {
- const internalsWithOptionalContext = Internals as {
- TimelineImperativeContext?: typeof Internals.TimelineImperativeContext;
- };
- const timelineImperativeContext =
- internalsWithOptionalContext.TimelineImperativeContext;
- delete internalsWithOptionalContext.TimelineImperativeContext;
-
- try {
- const methodsRef: {current: UsePlayerMethods | null} = {current: null};
- const renderCustomControls = () =>
- React.createElement(PlayerMethodsProbe, {
- onRender: (methods) => {
- methodsRef.current = methods;
- },
- });
-
- render(
- React.createElement(Player, {
- component: () => null,
- durationInFrames: 100,
- compositionWidth: 1920,
- compositionHeight: 1080,
- fps: 30,
- controls: true,
- renderCustomControls,
- }),
- );
-
- expect(methodsRef.current?.getCurrentFrame()).toBe(0);
- act(() => methodsRef.current?.seek(20));
- expect(methodsRef.current?.getCurrentFrame()).toBe(20);
- } finally {
- internalsWithOptionalContext.TimelineImperativeContext =
- timelineImperativeContext;
- }
-});
-
test('Playing from the last frame resets playback and dismisses the unplayed poster', () => {
const playerRef = createRef<PlayerRef>();
const Composition = () => null;
diff --git a/packages/player/src/timeline-imperative-context.tsx b/packages/player/src/timeline-imperative-context.tsx
deleted file mode 100644
index 339c013639..0000000000
--- a/packages/player/src/timeline-imperative-context.tsx
+++ /dev/null
@@ -1,72 +0,0 @@
-import type {Context} from 'react';
-import React, {useMemo, useRef} from 'react';
-import type {TimelineImperativeContextValue} from 'remotion';
-import {Internals} from 'remotion';
-
-const PlayerTimelineImperativeContext =
- React.createContext<TimelineImperativeContextValue | null>(null);
-
-const getCoreTimelineImperativeContext = () => {
- return (
- Internals as typeof Internals & {
- TimelineImperativeContext?: Context<TimelineImperativeContextValue | null>;
- }
- ).TimelineImperativeContext;
-};
-
-export const getTimelineImperativeContext = () => {
- return getCoreTimelineImperativeContext() ?? PlayerTimelineImperativeContext;
-};
-
-export const CoreTimelineImperativeContextProvider: React.FC<{
- readonly children: React.ReactNode;
- readonly value: TimelineImperativeContextValue;
-}> = ({children, value}) => {
- const TimelineImperativeContext = getCoreTimelineImperativeContext();
-
- if (!TimelineImperativeContext) {
- return children;
- }
-
- return (
- <TimelineImperativeContext.Provider value={value}>
- {children}
- </TimelineImperativeContext.Provider>
- );
-};
-
-const LegacyTimelineImperativeContextProvider: React.FC<{
- readonly children: React.ReactNode;
-}> = ({children}) => {
- const timelineContext = Internals.Timeline.useTimelineContext();
- const frameRef = useRef(timelineContext.frame);
- frameRef.current = timelineContext.frame;
-
- const value = useMemo((): TimelineImperativeContextValue => {
- return {
- frameRef,
- imperativePlaying: timelineContext.imperativePlaying,
- audioAndVideoTags: timelineContext.audioAndVideoTags,
- };
- }, [timelineContext.audioAndVideoTags, timelineContext.imperativePlaying]);
-
- return (
- <PlayerTimelineImperativeContext.Provider value={value}>
- {children}
- </PlayerTimelineImperativeContext.Provider>
- );
-};
-
-export const TimelineImperativeCompatibilityProvider: React.FC<{
- readonly children: React.ReactNode;
-}> = ({children}) => {
- if (getCoreTimelineImperativeContext()) {
- return children;
- }
-
- return (
- <LegacyTimelineImperativeContextProvider>
- {children}
- </LegacyTimelineImperativeContextProvider>
- );
-};
diff --git a/packages/player/src/use-playback.ts b/packages/player/src/use-playback.ts
index 0e10fd075c..f3de81a6d5 100644
--- a/packages/player/src/use-playback.ts
+++ b/packages/player/src/use-playback.ts
@@ -50,7 +50,7 @@ export const usePlayback = ({
}) => {
const config = Internals.useUnsafeVideoConfig();
const frame = Internals.Timeline.useTimelinePosition();
- const [playing] = Internals.Timeline.usePlayingState();
+ const playing = Internals.usePlaying();
const {pause, emitter, isPlaying} = usePlayerMethods();
const setFrame = Internals.Timeline.useTimelineSetFrame();
const sharedAudioContext = useContext(Internals.SharedAudioContext);
diff --git a/packages/player/src/use-player-methods.ts b/packages/player/src/use-player-methods.ts
index e140726c08..2accce5978 100644
--- a/packages/player/src/use-player-methods.ts
+++ b/packages/player/src/use-player-methods.ts
@@ -3,7 +3,6 @@ import {useCallback, useContext, useMemo, useRef} from 'react';
import {Internals, useRemotionEnvironment} from 'remotion';
import {PlayerEventEmitterContext} from './emitter-context.js';
import type {PlayerEmitter} from './event-emitter.js';
-import {getTimelineImperativeContext} from './timeline-imperative-context.js';
export type UsePlayerMethods = {
frameBack: (frames: number) => void;
@@ -22,8 +21,7 @@ export type UsePlayerMethods = {
export const usePlayerMethods = (): UsePlayerMethods => {
const setFrame = Internals.Timeline.useTimelineSetFrame();
const setTimelinePosition = Internals.Timeline.useTimelineSetFrame();
- const {setPlaying} = useContext(Internals.SetTimelineContext);
- const timelineImperativeContext = useContext(getTimelineImperativeContext());
+ const timelineContext = useContext(Internals.TimelineContext);
const audioContext = useContext(Internals.SharedAudioContext);
const audioTagsContext = useContext(Internals.SharedAudioTagsContext);
const environment = useRemotionEnvironment();
@@ -33,9 +31,9 @@ export const usePlayerMethods = (): UsePlayerMethods => {
const playStart = useRef(0);
const fallbackFrame = useRef<number | null>(null);
- if (!timelineImperativeContext) {
+ if (!timelineContext) {
throw new Error(
- 'Timeline imperative context is not available. This hook must be used inside a <Player> or the Remotion Studio.',
+ 'Timeline context is not available. This hook must be used inside a <Player> or the Remotion Studio.',
);
}
@@ -61,7 +59,7 @@ export const usePlayerMethods = (): UsePlayerMethods => {
}
const unclamped =
- timelineImperativeContext.frameRef.current[video.id] ??
+ timelineContext.frame[video.id] ??
(environment.isPlayer
? 0
: Internals.Timeline.getFrameForComposition(video.id));
@@ -70,7 +68,7 @@ export const usePlayerMethods = (): UsePlayerMethods => {
unclamped,
video.durationInFrames,
);
- }, [environment.isPlayer, timelineImperativeContext, video]);
+ }, [environment.isPlayer, timelineContext, video]);
const seek = useCallback(
(newFrame: number) => {
@@ -84,11 +82,9 @@ export const usePlayerMethods = (): UsePlayerMethods => {
fallbackFrame.current = frameToSeekTo;
if (video?.id) {
- if (
- timelineImperativeContext.frameRef.current[video.id] !== frameToSeekTo
- ) {
- timelineImperativeContext.frameRef.current = {
- ...timelineImperativeContext.frameRef.current,
+ if (timelineContext.frame[video.id] !== frameToSeekTo) {
+ timelineContext.frame = {
+ ...timelineContext.frame,
[video.id]: frameToSeekTo,
};
}
@@ -102,18 +98,12 @@ export const usePlayerMethods = (): UsePlayerMethods => {
emitter.dispatchSeek(frameToSeekTo);
},
- [
- config,
- emitter,
- setTimelinePosition,
- timelineImperativeContext,
- video?.id,
- ],
+ [config, emitter, setTimelinePosition, timelineContext, video?.id],
);
const play = useCallback(
(e?: SyntheticEvent | PointerEvent) => {
- if (timelineImperativeContext.imperativePlaying.current) {
+ if (timelineContext.playbackStore.store.getSnapshot().playing) {
return;
}
@@ -135,12 +125,11 @@ export const usePlayerMethods = (): UsePlayerMethods => {
* Play audios and videos directly here so they can benefit from
* being triggered by a click
*/
- timelineImperativeContext.audioAndVideoTags.current.forEach((tag) =>
+ timelineContext.audioAndVideoTags.current.forEach((tag) =>
tag.play('player play() was called and playing audio from a click'),
);
- timelineImperativeContext.imperativePlaying.current = true;
- setPlaying(true);
+ timelineContext.playbackStore.setSnapshot({playing: true});
playStart.current = getCurrentFrame();
emitter.dispatchPlay();
},
@@ -151,45 +140,36 @@ export const usePlayerMethods = (): UsePlayerMethods => {
emitter,
getCurrentFrame,
seek,
- setPlaying,
- timelineImperativeContext,
+ timelineContext,
],
);
const pause = useCallback(() => {
- if (timelineImperativeContext.imperativePlaying.current) {
- timelineImperativeContext.imperativePlaying.current = false;
+ if (timelineContext.playbackStore.store.getSnapshot().playing) {
+ timelineContext.playbackStore.setSnapshot({playing: false});
- setPlaying(false);
emitter.dispatchPause();
audioContext?.suspend();
}
- }, [audioContext, emitter, setPlaying, timelineImperativeContext]);
+ }, [audioContext, emitter, timelineContext]);
const pauseAndReturnToPlayStart = useCallback(() => {
- if (timelineImperativeContext.imperativePlaying.current) {
- timelineImperativeContext.imperativePlaying.current = false;
+ if (timelineContext.playbackStore.store.getSnapshot().playing) {
+ timelineContext.playbackStore.setSnapshot({playing: false});
fallbackFrame.current = playStart.current;
if (config) {
- timelineImperativeContext.frameRef.current = {
- ...timelineImperativeContext.frameRef.current,
+ timelineContext.frame = {
+ ...timelineContext.frame,
[config.id]: playStart.current,
};
setTimelinePosition((currentFrames) => ({
...currentFrames,
[config.id]: playStart.current,
}));
- setPlaying(false);
emitter.dispatchPause();
}
}
- }, [
- config,
- emitter,
- setPlaying,
- setTimelinePosition,
- timelineImperativeContext,
- ]);
+ }, [config, emitter, setTimelinePosition, timelineContext]);
const videoId = video?.id;
const lastFrame = (config?.durationInFrames ?? 1) - 1;
@@ -200,21 +180,19 @@ export const usePlayerMethods = (): UsePlayerMethods => {
return null;
}
- if (timelineImperativeContext.imperativePlaying.current) {
+ if (timelineContext.playbackStore.store.getSnapshot().playing) {
return;
}
const previousFrame =
- timelineImperativeContext.frameRef.current[videoId] ??
- window.remotion_initialFrame ??
- 0;
+ timelineContext.frame[videoId] ?? window.remotion_initialFrame ?? 0;
const newFrame = Math.max(0, previousFrame - frames);
if (previousFrame === newFrame) {
return;
}
- timelineImperativeContext.frameRef.current = {
- ...timelineImperativeContext.frameRef.current,
+ timelineContext.frame = {
+ ...timelineContext.frame,
[videoId]: newFrame,
};
setFrame((currentFrames) =>
@@ -223,7 +201,7 @@ export const usePlayerMethods = (): UsePlayerMethods => {
: {...currentFrames, [videoId]: newFrame},
);
},
- [setFrame, timelineImperativeContext, videoId],
+ [setFrame, timelineContext, videoId],
);
const frameForward = useCallback(
@@ -232,21 +210,19 @@ export const usePlayerMethods = (): UsePlayerMethods => {
return null;
}
- if (timelineImperativeContext.imperativePlaying.current) {
+ if (timelineContext.playbackStore.store.getSnapshot().playing) {
return;
}
const previousFrame =
- timelineImperativeContext.frameRef.current[videoId] ??
- window.remotion_initialFrame ??
- 0;
+ timelineContext.frame[videoId] ?? window.remotion_initialFrame ?? 0;
const newFrame = Math.min(lastFrame, previousFrame + frames);
if (previousFrame === newFrame) {
return;
}
- timelineImperativeContext.frameRef.current = {
- ...timelineImperativeContext.frameRef.current,
+ timelineContext.frame = {
+ ...timelineContext.frame,
[videoId]: newFrame,
};
setFrame((currentFrames) =>
@@ -255,23 +231,23 @@ export const usePlayerMethods = (): UsePlayerMethods => {
: {...currentFrames, [videoId]: newFrame},
);
},
- [lastFrame, setFrame, timelineImperativeContext, videoId],
+ [lastFrame, setFrame, timelineContext, videoId],
);
const toggle = useCallback(
(e?: SyntheticEvent | PointerEvent) => {
- if (timelineImperativeContext.imperativePlaying.current) {
+ if (timelineContext.playbackStore.store.getSnapshot().playing) {
pause();
} else {
play(e);
}
},
- [pause, play, timelineImperativeContext],
+ [pause, play, timelineContext],
);
const isPlaying = useCallback(() => {
- return timelineImperativeContext.imperativePlaying.current;
- }, [timelineImperativeContext]);
+ return timelineContext.playbackStore.store.getSnapshot().playing as boolean;
+ }, [timelineContext]);
const isBuffering = useCallback(() => {
return bufferingContext.buffering.current;
diff --git a/packages/studio/src/components/FpsCounter.tsx b/packages/studio/src/components/FpsCounter.tsx
index 8417440e4f..268a73c09b 100644
--- a/packages/studio/src/components/FpsCounter.tsx
+++ b/packages/studio/src/components/FpsCounter.tsx
@@ -28,7 +28,7 @@ export const FpsCounter: React.FC<{
readonly playbackSpeed: number;
}> = ({playbackSpeed}) => {
const videoConfig = Internals.useUnsafeVideoConfig();
- const [playing] = Internals.Timeline.usePlayingState();
+ const playing = Internals.usePlaying();
const frame = Internals.Timeline.useTimelinePosition();
const [marker, rerender] = useState({});
diff --git a/packages/studio/src/components/FramePersistor.tsx b/packages/studio/src/components/FramePersistor.tsx
index 331772595f..942da00689 100644
--- a/packages/studio/src/components/FramePersistor.tsx
+++ b/packages/studio/src/components/FramePersistor.tsx
@@ -3,7 +3,7 @@ import {useEffect} from 'react';
import {Internals, useVideoConfig} from 'remotion';
export const FramePersistor: React.FC = () => {
- const [playing] = Internals.Timeline.usePlayingState();
+ const playing = Internals.usePlaying();
const config = useVideoConfig();
const frame = Internals.Timeline.useTimelinePosition();
const setFrame = Internals.useTimelineSetFrame();
diff --git a/packages/studio/src/components/Timeline/TimelinePlayCursorSyncer.tsx b/packages/studio/src/components/Timeline/TimelinePlayCursorSyncer.tsx
index 1c66e14e0c..6d50312f36 100644
--- a/packages/studio/src/components/Timeline/TimelinePlayCursorSyncer.tsx
+++ b/packages/studio/src/components/Timeline/TimelinePlayCursorSyncer.tsx
@@ -31,7 +31,7 @@ let lastTimelinePositionWhileScrolling: TimelinePosition | null = null;
export const TimelinePlayCursorSyncer: React.FC = () => {
const video = Internals.useVideo();
const timelinePosition = Internals.Timeline.useTimelinePosition();
- const [playing] = Internals.Timeline.usePlayingState();
+ const playing = Internals.usePlaying();
const {playbackRate} = Internals.usePlaybackRate();
const {canvasContent} = useContext(Internals.CompositionManager);
const {zoom: zoomMap} = useContext(TimelineZoomCtx);
diff --git a/packages/studio/src/components/WebMcp.tsx b/packages/studio/src/components/WebMcp.tsx
index 5132946e60..45debd3bea 100644
--- a/packages/studio/src/components/WebMcp.tsx
+++ b/packages/studio/src/components/WebMcp.tsx
@@ -129,7 +129,7 @@ export const WebMcp: FC = () => {
useContext(Internals.CompositionManager);
const {playbackRate: currentPlaybackRate, setPlaybackRate} =
Internals.usePlaybackRate();
- const [, , imperativePlaying] = Internals.Timeline.usePlayingState();
+ const {playbackStore} = Internals.Timeline.useTimelineContext();
const {mediaVolume, playerMuted} = useContext(Internals.MediaVolumeContext);
const {setPlayerMuted} = useContext(Internals.SetMediaVolumeContext);
const {setZoom: setTimelineZoom, zoom: timelineZoomMap} =
@@ -688,7 +688,7 @@ export const WebMcp: FC = () => {
return Promise.resolve({
currentComposition: compositionId,
currentFrame: getCurrentFrame(),
- playing: imperativePlaying.current,
+ playing: playbackStore.store.getSnapshot().playing as boolean,
muted: playerMutedRef.current,
volume: mediaVolumeRef.current,
playbackRate: playbackRateRef.current,
@@ -1218,7 +1218,7 @@ export const WebMcp: FC = () => {
};
}, [
clearSelection,
- imperativePlaying,
+ playbackStore,
selectComposition,
selectItems,
setEditorShowGuides,
diff --git a/packages/studio/src/components/ZoomPersistor.tsx b/packages/studio/src/components/ZoomPersistor.tsx
index 523412594e..89de1eeaa5 100644
--- a/packages/studio/src/components/ZoomPersistor.tsx
+++ b/packages/studio/src/components/ZoomPersistor.tsx
@@ -18,7 +18,7 @@ export const getZoomFromLocalStorage = (): Record<string, number> => {
};
export const ZoomPersistor: React.FC = () => {
- const [playing] = Internals.Timeline.usePlayingState();
+ const playing = Internals.usePlaying();
const {zoom} = useContext(TimelineZoomCtx);
const {canvasContent} = useContext(Internals.CompositionManager);
diff --git a/packages/test-utils/src/timeline-context.ts b/packages/test-utils/src/timeline-context.ts
index 87be200f7a..07624817b6 100644
--- a/packages/test-utils/src/timeline-context.ts
+++ b/packages/test-utils/src/timeline-context.ts
@@ -1,4 +1,5 @@
import type {TimelineContextValue} from 'remotion';
+import {Internals} from 'remotion';
import {ID} from './id.js';
export const makeTimelineContext = (frame: number): TimelineContextValue => {
@@ -6,10 +7,7 @@ export const makeTimelineContext = (frame: number): TimelineContextValue => {
frame: {
[ID]: frame,
},
- playing: false,
- imperativePlaying: {
- current: false,
- },
+ playbackStore: Internals.createRuntimeValueStore({playing: false}),
audioAndVideoTags: {current: []},
};
};