Create polished demo videos without editing skills. Mac/Windows/Linux
refactoring
Siddharth4cc1ae7a56c3
diff --git a/src/components/video-editor/VideoPlayback.tsx b/src/components/video-editor/VideoPlayback.tsxindex fbf287e1..0277f7c9 100644--- a/src/components/video-editor/VideoPlayback.tsx+++ b/src/components/video-editor/VideoPlayback.tsx@@ -1,50 +1,15 @@import type React from "react";import { useEffect, useRef, useImperativeHandle, forwardRef, useState, useMemo, useCallback } from "react";import * as PIXI from 'pixi.js';-import { ZOOM_DEPTH_SCALES, clampFocusToDepth, type ZoomRegion, type ZoomFocus, type ZoomDepth } from "./types";--const DEFAULT_FOCUS: ZoomFocus = { cx: 0.5, cy: 0.5 };-const TRANSITION_WINDOW_MS = 320;-const SMOOTHING_FACTOR = 0.12;-const MIN_DELTA = 0.0001;-const VIEWPORT_SCALE = 0.8;--function clamp01(value: number) {- return Math.max(0, Math.min(1, value));-}--function smoothStep(t: number) {- const clamped = clamp01(t);- return clamped * clamped * (3 - 2 * clamped);-}--function computeRegionStrength(region: ZoomRegion, timeMs: number) {- const leadInStart = region.startMs - TRANSITION_WINDOW_MS;- const leadOutEnd = region.endMs + TRANSITION_WINDOW_MS;-- if (timeMs < leadInStart || timeMs > leadOutEnd) {- return 0;- }-- const fadeIn = smoothStep((timeMs - leadInStart) / TRANSITION_WINDOW_MS);- const fadeOut = smoothStep((leadOutEnd - timeMs) / TRANSITION_WINDOW_MS);- return Math.min(fadeIn, fadeOut);-}--function findDominantRegion(regions: ZoomRegion[], timeMs: number) {- let bestRegion: ZoomRegion | null = null;- let bestStrength = 0;-- for (const region of regions) {- const strength = computeRegionStrength(region, timeMs);- if (strength > bestStrength) {- bestStrength = strength;- bestRegion = region;- }- }-- return { region: bestRegion, strength: bestStrength };-}+import { ZOOM_DEPTH_SCALES, type ZoomRegion, type ZoomFocus, type ZoomDepth } from "./types";+import { DEFAULT_FOCUS, SMOOTHING_FACTOR, MIN_DELTA } from "./videoPlayback/constants";+import { clamp01 } from "./videoPlayback/mathUtils";+import { findDominantRegion } from "./videoPlayback/zoomRegionUtils";+import { clampFocusToStage as clampFocusToStageUtil } from "./videoPlayback/focusUtils";+import { updateOverlayIndicator } from "./videoPlayback/overlayUtils";+import { layoutVideoContent as layoutVideoContentUtil } from "./videoPlayback/layoutUtils";+import { applyZoomTransform } from "./videoPlayback/zoomTransform";+import { createVideoEventHandlers } from "./videoPlayback/videoEventHandlers";interface VideoPlaybackProps {videoPath: string;@@ -105,112 +70,34 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({const isSeekingRef = useRef(false);const clampFocusToStage = useCallback((focus: ZoomFocus, depth: ZoomDepth) => {- const stageSize = stageSizeRef.current;-- if (!stageSize.width || !stageSize.height) {- return clampFocusToDepth(focus, depth);- }-- const zoomScale = ZOOM_DEPTH_SCALES[depth];-- // The zoom window dimensions in stage space- const windowWidth = stageSize.width / zoomScale;- const windowHeight = stageSize.height / zoomScale;-- // Calculate margins - the focus point must stay far enough from edges- // so that the zoom window doesn't go out of bounds- const marginX = windowWidth / (2 * stageSize.width);- const marginY = windowHeight / (2 * stageSize.height);-- const baseFocus = clampFocusToDepth(focus, depth);-- // Clamp the focus to ensure the zoom window stays within stage bounds- return {- cx: Math.max(marginX, Math.min(1 - marginX, baseFocus.cx)),- cy: Math.max(marginY, Math.min(1 - marginY, baseFocus.cy)),- };- }, []);-- const stageFocusToVideoSpace = useCallback((focus: ZoomFocus): ZoomFocus => {- const stageSize = stageSizeRef.current;- const videoSize = videoSizeRef.current;- const baseScale = baseScaleRef.current;- const baseOffset = baseOffsetRef.current;-- if (!stageSize.width || !stageSize.height || !videoSize.width || !videoSize.height || baseScale <= 0) {- return focus;- }-- const stageX = focus.cx * stageSize.width;- const stageY = focus.cy * stageSize.height;-- const videoNormX = (stageX - baseOffset.x) / (videoSize.width * baseScale);- const videoNormY = (stageY - baseOffset.y) / (videoSize.height * baseScale);-- return {- cx: videoNormX,- cy: videoNormY,- };+ return clampFocusToStageUtil(focus, depth, stageSizeRef.current);}, []);const updateOverlayForRegion = useCallback((region: ZoomRegion | null, focusOverride?: ZoomFocus) => {const overlayEl = overlayRef.current;const indicatorEl = focusIndicatorRef.current;+if (!overlayEl || !indicatorEl) {return;}- if (!region) {- indicatorEl.style.display = 'none';- overlayEl.style.pointerEvents = 'none';- return;- }-+ // Update stage size from overlay dimensionsconst stageWidth = overlayEl.clientWidth;const stageHeight = overlayEl.clientHeight;- if (!stageWidth || !stageHeight) {- indicatorEl.style.display = 'none';- overlayEl.style.pointerEvents = 'none';- return;- }-- stageSizeRef.current = { width: stageWidth, height: stageHeight };-- const baseScale = baseScaleRef.current;- const videoSize = videoSizeRef.current;-- if (!videoSize.width || !videoSize.height || baseScale <= 0) {- indicatorEl.style.display = 'none';- overlayEl.style.pointerEvents = isPlayingRef.current ? 'none' : 'auto';- return;+ if (stageWidth && stageHeight) {+ stageSizeRef.current = { width: stageWidth, height: stageHeight };}- const zoomScale = ZOOM_DEPTH_SCALES[region.depth];- const focus = clampFocusToStage(focusOverride ?? region.focus, region.depth);-- // The zoom window should show what portion of the STAGE will be visible after zooming- // When we zoom by zoomScale, we're showing 1/zoomScale of the stage dimensions- const indicatorWidth = stageWidth / zoomScale;- const indicatorHeight = stageHeight / zoomScale;-- const rawLeft = focus.cx * stageWidth - indicatorWidth / 2;- const rawTop = focus.cy * stageHeight - indicatorHeight / 2;-- const adjustedLeft = indicatorWidth >= stageWidth- ? (stageWidth - indicatorWidth) / 2- : Math.max(0, Math.min(stageWidth - indicatorWidth, rawLeft));-- const adjustedTop = indicatorHeight >= stageHeight- ? (stageHeight - indicatorHeight) / 2- : Math.max(0, Math.min(stageHeight - indicatorHeight, rawTop));-- indicatorEl.style.display = 'block';- indicatorEl.style.width = `${indicatorWidth}px`;- indicatorEl.style.height = `${indicatorHeight}px`;- indicatorEl.style.left = `${adjustedLeft}px`;- indicatorEl.style.top = `${adjustedTop}px`;- overlayEl.style.pointerEvents = isPlayingRef.current ? 'none' : 'auto';- }, [clampFocusToStage]);+ updateOverlayIndicator({+ overlayEl,+ indicatorEl,+ region,+ focusOverride,+ videoSize: videoSizeRef.current,+ baseScale: baseScaleRef.current,+ isPlaying: isPlayingRef.current,+ });+ }, []);const layoutVideoContent = useCallback(() => {const container = containerRef.current;@@ -219,63 +106,31 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({const maskGraphics = maskGraphicsRef.current;const videoElement = videoRef.current;- if (!container || !app || !videoSprite || !videoElement) {+ if (!container || !app || !videoSprite || !maskGraphics || !videoElement) {return;}- const videoWidth = videoElement.videoWidth;- const videoHeight = videoElement.videoHeight;-- if (!videoWidth || !videoHeight) {- return;- }+ const result = layoutVideoContentUtil({+ container,+ app,+ videoSprite,+ maskGraphics,+ videoElement,+ });- const width = container.clientWidth;- const height = container.clientHeight;+ if (result) {+ stageSizeRef.current = result.stageSize;+ videoSizeRef.current = result.videoSize;+ baseScaleRef.current = result.baseScale;+ baseOffsetRef.current = result.baseOffset;- if (!width || !height) {- return;- }+ const selectedId = selectedZoomIdRef.current;+ const activeRegion = selectedId+ ? zoomRegionsRef.current.find((region) => region.id === selectedId) ?? null+ : null;- app.renderer.resize(width, height);- app.canvas.style.width = '100%';- app.canvas.style.height = '100%';-- const maxDisplayWidth = width * VIEWPORT_SCALE;- const maxDisplayHeight = height * VIEWPORT_SCALE;-- const scale = Math.min(- maxDisplayWidth / videoWidth,- maxDisplayHeight / videoHeight,- 1- );-- videoSprite.scale.set(scale);- const displayWidth = videoWidth * scale;- const displayHeight = videoHeight * scale;-- const offsetX = (width - displayWidth) / 2;- const offsetY = (height - displayHeight) / 2;- videoSprite.position.set(offsetX, offsetY);-- stageSizeRef.current = { width, height };- videoSizeRef.current = { width: videoWidth, height: videoHeight };- baseScaleRef.current = scale;- baseOffsetRef.current = { x: offsetX, y: offsetY };-- if (maskGraphics) {- const radius = Math.min(displayWidth, displayHeight) * 0.02;- maskGraphics.clear();- maskGraphics.roundRect(offsetX, offsetY, displayWidth, displayHeight, radius);- maskGraphics.fill({ color: 0xffffff });+ updateOverlayForRegion(activeRegion);}-- const selectedId = selectedZoomIdRef.current;- const activeRegion = selectedId- ? zoomRegionsRef.current.find((region) => region.id === selectedId) ?? null- : null;-- updateOverlayForRegion(activeRegion);}, [updateOverlayForRegion]);const selectedZoom = useMemo(() => {@@ -442,7 +297,6 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({appRef.current = app;container.appendChild(app.canvas);- // Create a container for the video (this will hold animations later)const videoContainer = new PIXI.Container();videoContainerRef.current = videoContainer;app.stage.addChild(videoContainer);@@ -450,7 +304,6 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({setPixiReady(true);})();- // Cleanupreturn () => {mounted = false;setPixiReady(false);@@ -463,7 +316,6 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({};}, []);- // Ensure video starts paused whenever the source changesuseEffect(() => {const video = videoRef.current;if (!video) return;@@ -471,7 +323,6 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({video.currentTime = 0;}, [videoPath]);- // Setup video sprite when both PixiJS and video are readyuseEffect(() => {if (!pixiReady || !videoReady) return;@@ -482,15 +333,12 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({if (!video || !app || !videoContainer) return;if (video.videoWidth === 0 || video.videoHeight === 0) return;- // Create texture from video elementconst source = PIXI.VideoSource.from(video);const videoTexture = PIXI.Texture.from(source);- // Create sprite with the video textureconst videoSprite = new PIXI.Sprite(videoTexture);videoSpriteRef.current = videoSprite;- // Create rounded rectangle maskconst maskGraphics = new PIXI.Graphics();videoContainer.addChild(videoSprite);videoContainer.addChild(maskGraphics);@@ -511,65 +359,17 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({blurFilterRef.current = blurFilter;layoutVideoContent();-- // Ensure Pixi does not trigger autoplayvideo.pause();- const emitTime = (timeValue: number) => {- currentTimeRef.current = timeValue * 1000;- onTimeUpdate(timeValue);- };-- function updateTime() {- if (!video) return;- emitTime(video.currentTime);- if (!video.paused && !video.ended) {- timeUpdateAnimationRef.current = requestAnimationFrame(updateTime);- }- }-- const handlePlay = () => {- // If we're seeking and the video auto-plays, pause it immediately- if (isSeekingRef.current) {- video.pause();- return;- }- isPlayingRef.current = true;- onPlayStateChange(true);- updateTime();- };-- const handlePause = () => {- isPlayingRef.current = false;- if (timeUpdateAnimationRef.current) {- cancelAnimationFrame(timeUpdateAnimationRef.current);- timeUpdateAnimationRef.current = null;- }- emitTime(video.currentTime);- onPlayStateChange(false);- };-- const handleSeeked = () => {- // Mark seeking as complete- isSeekingRef.current = false;-- // Ensure video stays paused if it wasn't playing before the seek- if (!isPlayingRef.current && !video.paused) {- video.pause();- }- emitTime(video.currentTime);- };-- const handleSeeking = () => {- // Mark that we're in the middle of a seek operation- isSeekingRef.current = true;-- // Prevent autoplay during seeking if video was paused- if (!isPlayingRef.current && !video.paused) {- video.pause();- }- emitTime(video.currentTime);- };+ const { handlePlay, handlePause, handleSeeked, handleSeeking } = createVideoEventHandlers({+ video,+ isSeekingRef,+ isPlayingRef,+ currentTimeRef,+ timeUpdateAnimationRef,+ onPlayStateChange,+ onTimeUpdate,+ });video.addEventListener('play', handlePlay);video.addEventListener('pause', handlePause);@@ -588,7 +388,6 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({cancelAnimationFrame(timeUpdateAnimationRef.current);}- // Clean up PixiJS resourcesif (videoSprite) {videoContainer.removeChild(videoSprite);videoSprite.destroy();@@ -619,101 +418,40 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({if (!app || !videoSprite || !videoContainer) return;const applyTransform = (motionIntensity: number) => {- const stageSize = stageSizeRef.current;- const videoSize = videoSizeRef.current;- const baseScale = baseScaleRef.current;- const baseOffset = baseOffsetRef.current;- const state = animationStateRef.current;-- if (!stageSize.width || !stageSize.height || !videoSize.width || !videoSize.height || baseScale <= 0) {- return;- }-- // Zoom scale determines how much we're zooming in- // scale=1 means show everything at normal size- // scale=2 means zoom in 2x (show half the stage, magnified 2x)- const zoomScale = state.scale;-- // The focus point in stage coordinates (0-1 normalized to actual pixels)- const focusStagePxX = state.focusX * stageSize.width;- const focusStagePxY = state.focusY * stageSize.height;-- // When zoomed, we want the focus point to remain at the center of the viewport- // The stage center in pixels- const stageCenterX = stageSize.width / 2;- const stageCenterY = stageSize.height / 2;-- // Calculate the video's new scale and position- // The video should scale up by the zoom factor- const actualScale = baseScale * zoomScale;- videoSprite.scale.set(actualScale);-- // To keep the focus point centered:- // 1. In the "virtual stage space", the focus is at (focusStagePxX, focusStagePxY)- // 2. We want this point to appear at the stage center after transformation- // 3. The video's position offset needs to shift so focus → center-- // The video's base position at no zoom- const baseVideoX = baseOffset.x;- const baseVideoY = baseOffset.y;-- // The focus point relative to the video's top-left (in stage pixels, no zoom)- const focusInVideoSpaceX = focusStagePxX - baseVideoX;- const focusInVideoSpaceY = focusStagePxY - baseVideoY;-- // After scaling the video by zoomScale, the focus point in video would be at:- // (focusInVideoSpaceX * zoomScale, focusInVideoSpaceY * zoomScale) relative to video's top-left-- // We want: videoPosition + focusInVideoSpace * zoomScale = stageCenterX- // So: videoPosition = stageCenterX - focusInVideoSpace * zoomScale- const newVideoX = stageCenterX - focusInVideoSpaceX * zoomScale;- const newVideoY = stageCenterY - focusInVideoSpaceY * zoomScale;-- videoSprite.position.set(newVideoX, newVideoY);+ const maskGraphics = maskGraphicsRef.current;+ if (!maskGraphics) return;- if (blurFilterRef.current) {- const shouldBlur = isPlayingRef.current && motionIntensity > 0.0005;- const motionBlur = shouldBlur ? Math.min(6, motionIntensity * 120) : 0;- blurFilterRef.current.blur = motionBlur;- }+ const state = animationStateRef.current;- const maskGraphics = maskGraphicsRef.current;- if (maskGraphics) {- const videoWidth = videoSize.width * actualScale;- const videoHeight = videoSize.height * actualScale;- const radius = Math.min(videoWidth, videoHeight) * 0.02;- maskGraphics.clear();- maskGraphics.roundRect(- newVideoX,- newVideoY,- videoWidth,- videoHeight,- radius- );- maskGraphics.fill({ color: 0xffffff });- }+ applyZoomTransform({+ videoSprite,+ maskGraphics,+ blurFilter: blurFilterRef.current,+ stageSize: stageSizeRef.current,+ videoSize: videoSizeRef.current,+ baseScale: baseScaleRef.current,+ baseOffset: baseOffsetRef.current,+ zoomScale: state.scale,+ focusX: state.focusX,+ focusY: state.focusY,+ motionIntensity,+ isPlaying: isPlayingRef.current,+ });};const ticker = () => {const { region, strength } = findDominantRegion(zoomRegionsRef.current, currentTimeRef.current);- // Default is to show the entire stage at centerconst defaultFocus = DEFAULT_FOCUS;-let targetScaleFactor = 1;let targetFocus = defaultFocus;if (region && strength > 0) {const zoomScale = ZOOM_DEPTH_SCALES[region.depth];-- // The region focus is already in stage space (0-1 normalized coordinates)- // We need to ensure it stays within valid bounds for the given zoom levelconst regionFocus = clampFocusToStage(region.focus, region.depth);- // Interpolate scale: from 1 (no zoom) to zoomScale (full zoom)+ // Interpolate scale and focus based on region strengthtargetScaleFactor = 1 + (zoomScale - 1) * strength;-- // Interpolate focus position: from center to region focustargetFocus = {cx: defaultFocus.cx + (regionFocus.cx - defaultFocus.cx) * strength,cy: defaultFocus.cy + (regionFocus.cy - defaultFocus.cy) * strength,@@ -769,9 +507,8 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(({return () => {app.ticker.remove(ticker);};- }, [pixiReady, videoReady, stageFocusToVideoSpace, clampFocusToStage]);+ }, [pixiReady, videoReady, clampFocusToStage]);- // Handle video metadata loadedconst handleLoadedMetadata = (e: React.SyntheticEvent<HTMLVideoElement, Event>) => {const video = e.currentTarget;onDurationChange(video.duration);diff --git a/src/components/video-editor/types.ts b/src/components/video-editor/types.tsindex 653eb1dd..fd9e8974 100644--- a/src/components/video-editor/types.ts+++ b/src/components/video-editor/types.ts@@ -15,8 +15,8 @@ export interface ZoomRegion {export const ZOOM_DEPTH_SCALES: Record<ZoomDepth, number> = {1: 1.25,- 2: 1.6,- 3: 2.2,+ 2: 1.5,+ 3: 2.5,};export const DEFAULT_ZOOM_DEPTH: ZoomDepth = 2;diff --git a/src/components/video-editor/videoPlayback/constants.ts b/src/components/video-editor/videoPlayback/constants.tsnew file mode 100644index 00000000..e0dbf6ba--- /dev/null+++ b/src/components/video-editor/videoPlayback/constants.ts@@ -0,0 +1,7 @@+import type { ZoomFocus } from "../types";++export const DEFAULT_FOCUS: ZoomFocus = { cx: 0.5, cy: 0.5 };+export const TRANSITION_WINDOW_MS = 320;+export const SMOOTHING_FACTOR = 0.12;+export const MIN_DELTA = 0.0001;+export const VIEWPORT_SCALE = 0.8;diff --git a/src/components/video-editor/videoPlayback/focusUtils.ts b/src/components/video-editor/videoPlayback/focusUtils.tsnew file mode 100644index 00000000..8228f3ee--- /dev/null+++ b/src/components/video-editor/videoPlayback/focusUtils.ts@@ -0,0 +1,55 @@+import { ZOOM_DEPTH_SCALES, clampFocusToDepth, type ZoomFocus, type ZoomDepth } from "../types";++interface StageSize {+ width: number;+ height: number;+}++export function clampFocusToStage(+ focus: ZoomFocus,+ depth: ZoomDepth,+ stageSize: StageSize+): ZoomFocus {+ if (!stageSize.width || !stageSize.height) {+ return clampFocusToDepth(focus, depth);+ }++ const zoomScale = ZOOM_DEPTH_SCALES[depth];++ const windowWidth = stageSize.width / zoomScale;+ const windowHeight = stageSize.height / zoomScale;++ // Calculate margins - focus must stay far enough from edges so zoom window stays within stage bounds+ const marginX = windowWidth / (2 * stageSize.width);+ const marginY = windowHeight / (2 * stageSize.height);++ const baseFocus = clampFocusToDepth(focus, depth);++ return {+ cx: Math.max(marginX, Math.min(1 - marginX, baseFocus.cx)),+ cy: Math.max(marginY, Math.min(1 - marginY, baseFocus.cy)),+ };+}++export function stageFocusToVideoSpace(+ focus: ZoomFocus,+ stageSize: StageSize,+ videoSize: { width: number; height: number },+ baseScale: number,+ baseOffset: { x: number; y: number }+): ZoomFocus {+ if (!stageSize.width || !stageSize.height || !videoSize.width || !videoSize.height || baseScale <= 0) {+ return focus;+ }++ const stageX = focus.cx * stageSize.width;+ const stageY = focus.cy * stageSize.height;++ const videoNormX = (stageX - baseOffset.x) / (videoSize.width * baseScale);+ const videoNormY = (stageY - baseOffset.y) / (videoSize.height * baseScale);++ return {+ cx: videoNormX,+ cy: videoNormY,+ };+}diff --git a/src/components/video-editor/videoPlayback/index.ts b/src/components/video-editor/videoPlayback/index.tsnew file mode 100644index 00000000..e5be6aaa--- /dev/null+++ b/src/components/video-editor/videoPlayback/index.ts@@ -0,0 +1,8 @@+export * from './constants';+export * from './mathUtils';+export * from './zoomRegionUtils';+export * from './focusUtils';+export * from './overlayUtils';+export * from './layoutUtils';+export * from './zoomTransform';+export * from './videoEventHandlers';diff --git a/src/components/video-editor/videoPlayback/layoutUtils.ts b/src/components/video-editor/videoPlayback/layoutUtils.tsnew file mode 100644index 00000000..0caef3f8--- /dev/null+++ b/src/components/video-editor/videoPlayback/layoutUtils.ts@@ -0,0 +1,68 @@+import * as PIXI from 'pixi.js';+import { VIEWPORT_SCALE } from "./constants";++interface LayoutParams {+ container: HTMLDivElement;+ app: PIXI.Application;+ videoSprite: PIXI.Sprite;+ maskGraphics: PIXI.Graphics;+ videoElement: HTMLVideoElement;+}++interface LayoutResult {+ stageSize: { width: number; height: number };+ videoSize: { width: number; height: number };+ baseScale: number;+ baseOffset: { x: number; y: number };+}++export function layoutVideoContent(params: LayoutParams): LayoutResult | null {+ const { container, app, videoSprite, maskGraphics, videoElement } = params;++ const videoWidth = videoElement.videoWidth;+ const videoHeight = videoElement.videoHeight;++ if (!videoWidth || !videoHeight) {+ return null;+ }++ const width = container.clientWidth;+ const height = container.clientHeight;++ if (!width || !height) {+ return null;+ }++ app.renderer.resize(width, height);+ app.canvas.style.width = '100%';+ app.canvas.style.height = '100%';++ const maxDisplayWidth = width * VIEWPORT_SCALE;+ const maxDisplayHeight = height * VIEWPORT_SCALE;++ const scale = Math.min(+ maxDisplayWidth / videoWidth,+ maxDisplayHeight / videoHeight,+ 1+ );++ videoSprite.scale.set(scale);+ const displayWidth = videoWidth * scale;+ const displayHeight = videoHeight * scale;++ const offsetX = (width - displayWidth) / 2;+ const offsetY = (height - displayHeight) / 2;+ videoSprite.position.set(offsetX, offsetY);++ const radius = Math.min(displayWidth, displayHeight) * 0.02;+ maskGraphics.clear();+ maskGraphics.roundRect(offsetX, offsetY, displayWidth, displayHeight, radius);+ maskGraphics.fill({ color: 0xffffff });++ return {+ stageSize: { width, height },+ videoSize: { width: videoWidth, height: videoHeight },+ baseScale: scale,+ baseOffset: { x: offsetX, y: offsetY },+ };+}diff --git a/src/components/video-editor/videoPlayback/mathUtils.ts b/src/components/video-editor/videoPlayback/mathUtils.tsnew file mode 100644index 00000000..c629d59f--- /dev/null+++ b/src/components/video-editor/videoPlayback/mathUtils.ts@@ -0,0 +1,8 @@+export function clamp01(value: number) {+ return Math.max(0, Math.min(1, value));+}++export function smoothStep(t: number) {+ const clamped = clamp01(t);+ return clamped * clamped * (3 - 2 * clamped);+}diff --git a/src/components/video-editor/videoPlayback/overlayUtils.ts b/src/components/video-editor/videoPlayback/overlayUtils.tsnew file mode 100644index 00000000..9acdca83--- /dev/null+++ b/src/components/video-editor/videoPlayback/overlayUtils.ts@@ -0,0 +1,66 @@+import { ZOOM_DEPTH_SCALES, type ZoomRegion, type ZoomFocus } from "../types";+import { clampFocusToStage } from "./focusUtils";++interface OverlayUpdateParams {+ overlayEl: HTMLDivElement;+ indicatorEl: HTMLDivElement;+ region: ZoomRegion | null;+ focusOverride?: ZoomFocus;+ videoSize: { width: number; height: number };+ baseScale: number;+ isPlaying: boolean;+}++export function updateOverlayIndicator(params: OverlayUpdateParams) {+ const { overlayEl, indicatorEl, region, focusOverride, videoSize, baseScale, isPlaying } = params;++ if (!region) {+ indicatorEl.style.display = 'none';+ overlayEl.style.pointerEvents = 'none';+ return;+ }++ const stageWidth = overlayEl.clientWidth;+ const stageHeight = overlayEl.clientHeight;++ if (!stageWidth || !stageHeight) {+ indicatorEl.style.display = 'none';+ overlayEl.style.pointerEvents = 'none';+ return;+ }++ if (!videoSize.width || !videoSize.height || baseScale <= 0) {+ indicatorEl.style.display = 'none';+ overlayEl.style.pointerEvents = isPlaying ? 'none' : 'auto';+ return;+ }++ const zoomScale = ZOOM_DEPTH_SCALES[region.depth];+ const focus = clampFocusToStage(+ focusOverride ?? region.focus,+ region.depth,+ { width: stageWidth, height: stageHeight }+ );++ // Zoom window shows the stage area that will be visible after zooming (1/zoomScale of stage dimensions)+ const indicatorWidth = stageWidth / zoomScale;+ const indicatorHeight = stageHeight / zoomScale;++ const rawLeft = focus.cx * stageWidth - indicatorWidth / 2;+ const rawTop = focus.cy * stageHeight - indicatorHeight / 2;++ const adjustedLeft = indicatorWidth >= stageWidth+ ? (stageWidth - indicatorWidth) / 2+ : Math.max(0, Math.min(stageWidth - indicatorWidth, rawLeft));++ const adjustedTop = indicatorHeight >= stageHeight+ ? (stageHeight - indicatorHeight) / 2+ : Math.max(0, Math.min(stageHeight - indicatorHeight, rawTop));++ indicatorEl.style.display = 'block';+ indicatorEl.style.width = `${indicatorWidth}px`;+ indicatorEl.style.height = `${indicatorHeight}px`;+ indicatorEl.style.left = `${adjustedLeft}px`;+ indicatorEl.style.top = `${adjustedTop}px`;+ overlayEl.style.pointerEvents = isPlaying ? 'none' : 'auto';+}diff --git a/src/components/video-editor/videoPlayback/videoEventHandlers.ts b/src/components/video-editor/videoPlayback/videoEventHandlers.tsnew file mode 100644index 00000000..06e6dec0--- /dev/null+++ b/src/components/video-editor/videoPlayback/videoEventHandlers.ts@@ -0,0 +1,82 @@+interface VideoEventHandlersParams {+ video: HTMLVideoElement;+ isSeekingRef: React.MutableRefObject<boolean>;+ isPlayingRef: React.MutableRefObject<boolean>;+ currentTimeRef: React.MutableRefObject<number>;+ timeUpdateAnimationRef: React.MutableRefObject<number | null>;+ onPlayStateChange: (playing: boolean) => void;+ onTimeUpdate: (time: number) => void;+}++export function createVideoEventHandlers(params: VideoEventHandlersParams) {+ const {+ video,+ isSeekingRef,+ isPlayingRef,+ currentTimeRef,+ timeUpdateAnimationRef,+ onPlayStateChange,+ onTimeUpdate,+ } = params;++ const emitTime = (timeValue: number) => {+ currentTimeRef.current = timeValue * 1000;+ onTimeUpdate(timeValue);+ };++ function updateTime() {+ if (!video) return;+ emitTime(video.currentTime);+ if (!video.paused && !video.ended) {+ timeUpdateAnimationRef.current = requestAnimationFrame(updateTime);+ }+ }++ const handlePlay = () => {+ // Prevent autoplay during seek operations+ if (isSeekingRef.current) {+ video.pause();+ return;+ }+ isPlayingRef.current = true;+ onPlayStateChange(true);+ updateTime();+ };++ const handlePause = () => {+ isPlayingRef.current = false;+ if (timeUpdateAnimationRef.current) {+ cancelAnimationFrame(timeUpdateAnimationRef.current);+ timeUpdateAnimationRef.current = null;+ }+ emitTime(video.currentTime);+ onPlayStateChange(false);+ };++ const handleSeeked = () => {+ isSeekingRef.current = false;++ // Keep video paused after seek if it wasn't playing+ if (!isPlayingRef.current && !video.paused) {+ video.pause();+ }+ emitTime(video.currentTime);+ };++ const handleSeeking = () => {+ isSeekingRef.current = true;++ // Prevent autoplay during seek if video was paused+ if (!isPlayingRef.current && !video.paused) {+ video.pause();+ }+ emitTime(video.currentTime);+ };++ return {+ handlePlay,+ handlePause,+ handleSeeked,+ handleSeeking,+ };+}diff --git a/src/components/video-editor/videoPlayback/zoomRegionUtils.ts b/src/components/video-editor/videoPlayback/zoomRegionUtils.tsnew file mode 100644index 00000000..26a3817c--- /dev/null+++ b/src/components/video-editor/videoPlayback/zoomRegionUtils.ts@@ -0,0 +1,31 @@+import type { ZoomRegion } from "../types";+import { smoothStep } from "./mathUtils";+import { TRANSITION_WINDOW_MS } from "./constants";++export function computeRegionStrength(region: ZoomRegion, timeMs: number) {+ const leadInStart = region.startMs - TRANSITION_WINDOW_MS;+ const leadOutEnd = region.endMs + TRANSITION_WINDOW_MS;++ if (timeMs < leadInStart || timeMs > leadOutEnd) {+ return 0;+ }++ const fadeIn = smoothStep((timeMs - leadInStart) / TRANSITION_WINDOW_MS);+ const fadeOut = smoothStep((leadOutEnd - timeMs) / TRANSITION_WINDOW_MS);+ return Math.min(fadeIn, fadeOut);+}++export function findDominantRegion(regions: ZoomRegion[], timeMs: number) {+ let bestRegion: ZoomRegion | null = null;+ let bestStrength = 0;++ for (const region of regions) {+ const strength = computeRegionStrength(region, timeMs);+ if (strength > bestStrength) {+ bestStrength = strength;+ bestRegion = region;+ }+ }++ return { region: bestRegion, strength: bestStrength };+}diff --git a/src/components/video-editor/videoPlayback/zoomTransform.ts b/src/components/video-editor/videoPlayback/zoomTransform.tsnew file mode 100644index 00000000..dce5fa3c--- /dev/null+++ b/src/components/video-editor/videoPlayback/zoomTransform.ts@@ -0,0 +1,70 @@+import * as PIXI from 'pixi.js';++interface TransformParams {+ videoSprite: PIXI.Sprite;+ maskGraphics: PIXI.Graphics;+ blurFilter: PIXI.BlurFilter | null;+ stageSize: { width: number; height: number };+ videoSize: { width: number; height: number };+ baseScale: number;+ baseOffset: { x: number; y: number };+ zoomScale: number;+ focusX: number;+ focusY: number;+ motionIntensity: number;+ isPlaying: boolean;+}++export function applyZoomTransform(params: TransformParams) {+ const {+ videoSprite,+ maskGraphics,+ blurFilter,+ stageSize,+ videoSize,+ baseScale,+ baseOffset,+ zoomScale,+ focusX,+ focusY,+ motionIntensity,+ isPlaying,+ } = params;++ if (!stageSize.width || !stageSize.height || !videoSize.width || !videoSize.height || baseScale <= 0) {+ return;+ }++ const focusStagePxX = focusX * stageSize.width;+ const focusStagePxY = focusY * stageSize.height;+ const stageCenterX = stageSize.width / 2;+ const stageCenterY = stageSize.height / 2;++ const actualScale = baseScale * zoomScale;+ videoSprite.scale.set(actualScale);++ // Keep the focus point centered in viewport after zoom transformation+ const baseVideoX = baseOffset.x;+ const baseVideoY = baseOffset.y;+ const focusInVideoSpaceX = focusStagePxX - baseVideoX;+ const focusInVideoSpaceY = focusStagePxY - baseVideoY;++ // Position formula: stageCenterX - focusInVideoSpace * zoomScale+ const newVideoX = stageCenterX - focusInVideoSpaceX * zoomScale;+ const newVideoY = stageCenterY - focusInVideoSpaceY * zoomScale;++ videoSprite.position.set(newVideoX, newVideoY);++ if (blurFilter) {+ const shouldBlur = isPlaying && motionIntensity > 0.0005;+ const motionBlur = shouldBlur ? Math.min(6, motionIntensity * 120) : 0;+ blurFilter.blur = motionBlur;+ }++ const videoWidth = videoSize.width * actualScale;+ const videoHeight = videoSize.height * actualScale;+ const radius = Math.min(videoWidth, videoHeight) * 0.02;+ maskGraphics.clear();+ maskGraphics.roundRect(newVideoX, newVideoY, videoWidth, videoHeight, radius);+ maskGraphics.fill({ color: 0xffffff });+}