Skip to content

Free Motion Capture for Everyone πŸ’€βœ¨

TypeScript

chkpt

jonmatthis7fcebdd965fe
diff --git a/.claude/settings.local.json b/.claude/settings.local.json
deleted file mode 100644
index d5b17cb2..00000000
--- a/.claude/settings.local.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
- "permissions": {
- "allow": [
- "WebSearch",
- "WebFetch(domain:github.com)",
- "Bash(.venv/Scripts/python -m pytest freemocap/tests/test_http_config_endpoints.py -v --timeout=30)",
- "Bash(.venv/Scripts/python -m pytest freemocap/tests/test_http_config_endpoints.py --timeout=30 -x)",
- "Bash(git stash:*)",
- "Bash(.venv/Scripts/python -m pytest freemocap/tests/ -m \"not e2e\" --timeout=30 --ignore=freemocap/tests/test_e2e_pipeline.py -q)",
- "Bash(.venv/Scripts/python -m pytest freemocap/tests/test_http_config_endpoints.py freemocap/tests/test_schema_contract.py -q --timeout=30)",
- "Bash(__NEW_LINE_6841038b284b2773__ git:*)",
- "Bash(__NEW_LINE_a0cc91ae49b2097e__ git:*)",
- "Bash(git grep:*)",
- "Bash(git status:*)",
- "Bash(grep -RIn \"connected\" freemocap)",
- "Bash(grep -RIn \"RecordingInfoModel\" -n freemocap)",
- "Bash(grep -RIn \"websocket\\\\|ws://\\\\|WebSocket\" freemocap)",
- "Bash(grep -RIn \"freemocap/api/http/blender\\\\|api/http/blender\\\\|blender.*export\" -n)"
- ]
- }
-}
diff --git a/freemocap-ui/src/app/AppContent.tsx b/freemocap-ui/src/app/AppContent.tsx
index b3000ca8..a90f713e 100644
--- a/freemocap-ui/src/app/AppContent.tsx
+++ b/freemocap-ui/src/app/AppContent.tsx
@@ -1,18 +1,19 @@
import * as React from 'react';
-import {ThemeProvider} from '@mui/material/styles';
-import {HashRouter} from 'react-router-dom';
-import {CssBaseline} from "@mui/material";
-import {BasePanelLayout} from "@/layout/BasePanelLayout";
-import {createExtendedTheme} from "@/layout/paperbase-theme";
-import {useAppSelector} from "@/store";
-import {BaseContentRouter} from "@/layout/content/BaseContentRouter";
-import {UpdateBanner} from "@/components/ui-components/UpdateBanner";
-import {AutoUpdateProvider} from "@/hooks/AutoUpdateContext";
-import {useTranslation} from "react-i18next";
-import {getLocaleDirection} from "@/i18n";
+import { ThemeProvider } from '@mui/material/styles';
+import { HashRouter } from 'react-router-dom';
+import { CssBaseline } from "@mui/material";
+import { BasePanelLayout } from "@/layout/BasePanelLayout";
+import { createExtendedTheme } from "@/layout/paperbase-theme";
+import { useAppSelector } from "@/store";
+import { BaseContentRouter } from "@/layout/content/BaseContentRouter";
+import { UpdateBanner } from "@/components/ui-components/UpdateBanner";
+import { AutoUpdateProvider } from "@/hooks/AutoUpdateContext";
+import { PlaybackProvider } from "@/components/playback/PlaybackContext";
+import { useTranslation } from "react-i18next";
+import { getLocaleDirection } from "@/i18n";
export const AppContent = function () {
- const {i18n} = useTranslation();
+ const { i18n } = useTranslation();
const themeMode = useAppSelector(state => state.theme.mode);
const direction = getLocaleDirection(i18n.language);
@@ -24,18 +25,20 @@ export const AppContent = function () {
const theme = React.useMemo(() => {
const base = createExtendedTheme(themeMode);
- return {...base, direction};
+ return { ...base, direction };
}, [themeMode, direction]);
return (
<ThemeProvider theme={theme}>
- <CssBaseline/>
+ <CssBaseline />
<HashRouter>
<AutoUpdateProvider>
- <BasePanelLayout>
- <BaseContentRouter/>
- </BasePanelLayout>
- <UpdateBanner/>
+ <PlaybackProvider>
+ <BasePanelLayout>
+ <BaseContentRouter />
+ </BasePanelLayout>
+ </PlaybackProvider>
+ <UpdateBanner />
</AutoUpdateProvider>
</HashRouter>
</ThemeProvider>
diff --git a/freemocap-ui/src/components/control-panels/post-processing-panel/MocapSubsection.tsx b/freemocap-ui/src/components/control-panels/post-processing-panel/MocapSubsection.tsx
index 0748b3dc..3bedc7a2 100644
--- a/freemocap-ui/src/components/control-panels/post-processing-panel/MocapSubsection.tsx
+++ b/freemocap-ui/src/components/control-panels/post-processing-panel/MocapSubsection.tsx
@@ -42,6 +42,8 @@ export const MocapSubsection: React.FC = () => {
isLoading,
isRecording,
recordingProgress,
+ processingProgress,
+ processingPhase,
canStartRecording,
canProcessMocapRecording,
mocapRecordingPath,
@@ -71,7 +73,7 @@ export const MocapSubsection: React.FC = () => {
);
// Pipeline stage toggles (local state β€” posthoc pipeline stages)
- const [charucoEnabled, setCharucoEnabled] = useState(false);
+ const [charucoEnabled, setCharucoEnabled] = useState(true);
const [skeletonEnabled, setSkeletonEnabled] = useState(true);
useEffect(() => {
@@ -160,10 +162,22 @@ export const MocapSubsection: React.FC = () => {
return parts[parts.length - 1] || null;
}, [mocapRecordingPath]);
+ const formatPhase = (phase: string): string => {
+ const labels: Record<string, string> = {
+ detecting_frames: "Detecting",
+ collecting_frames: "Collecting",
+ all_frames_collected: "Collected",
+ running_task: "Processing",
+ complete: "Done",
+ failed: "Failed",
+ };
+ return labels[phase] ?? "Processing";
+ };
+
const statusLabel = isRecording
? `Recording ${recordingProgress.toFixed(0)}%`
: isLoading
- ? "Processing..."
+ ? `${formatPhase(processingPhase)} ${processingProgress}%`
: effectiveCalibrationTomlPath
? "Ready"
: "Idle";
@@ -355,6 +369,33 @@ export const MocapSubsection: React.FC = () => {
</Box>
)}
+ {/* Processing Progress */}
+ {isLoading && !isRecording && processingProgress > 0 && (
+ <Box sx={{width: "100%"}}>
+ <Typography variant="caption" color="text.secondary" gutterBottom>
+ {formatPhase(processingPhase)}: {processingProgress}%
+ </Typography>
+ <Box
+ sx={{
+ width: "100%",
+ height: 8,
+ bgcolor: "grey.300",
+ borderRadius: 1,
+ overflow: "hidden",
+ }}
+ >
+ <Box
+ sx={{
+ width: `${processingProgress}%`,
+ height: "100%",
+ bgcolor: theme.palette.warning.main,
+ transition: "width 0.4s",
+ }}
+ />
+ </Box>
+ </Box>
+ )}
+
{/* Hierarchical pipeline config (replaces flat MediapipeConfigPanel + SkeletonFilterConfigPanel) */}
<RealtimePipelineConfigTree
context="posthoc"
diff --git a/freemocap-ui/src/components/control-panels/recording-info-panel/RecordingInfoPanel.tsx b/freemocap-ui/src/components/control-panels/recording-info-panel/RecordingInfoPanel.tsx
index 6deede38..f74eb910 100644
--- a/freemocap-ui/src/components/control-panels/recording-info-panel/RecordingInfoPanel.tsx
+++ b/freemocap-ui/src/components/control-panels/recording-info-panel/RecordingInfoPanel.tsx
@@ -12,7 +12,6 @@ import {RecordingPathTreeItem} from "@/components/control-panels/recording-info-
import {useElectronIPC} from "@/services/electron-ipc/electron-ipc";
import {useServer} from "@/services/server/ServerContextProvider";
import {getTimestampString} from "@/components/control-panels/recording-info-panel/getTimestampString";
-import {RecordingCompleteDialog} from "@/components/control-panels/recording-info-panel/RecordingCompleteDialog";
import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";
import {RecordingSummary} from "./RecordingSummary";
import {RecordingHeaderButton} from "./RecordingHeaderButton";
@@ -317,7 +316,6 @@ export const RecordingInfoPanel: React.FC = () => {
onCustomSubfolderNameChange={setCustomSubfolderName}
/>
</SimpleTreeView>
- <RecordingCompleteDialog/>
</Box>
</CollapsibleSidebarSection>
);
diff --git a/freemocap-ui/src/components/playback/PlaybackContext.tsx b/freemocap-ui/src/components/playback/PlaybackContext.tsx
new file mode 100644
index 00000000..1b32e759
--- /dev/null
+++ b/freemocap-ui/src/components/playback/PlaybackContext.tsx
@@ -0,0 +1,138 @@
+import React, {createContext, useCallback, useContext, useEffect, useState} from 'react';
+import type {LoadedVideo} from './RecordingBrowser';
+import {serverUrls} from '@/constants/server-urls';
+
+// Module-level cache so playback state survives tab switches
+let cachedPlaybackState = {
+ loadedVideos: [] as LoadedVideo[],
+ recordingPath: null as string | null,
+ recordingFps: undefined as number | undefined,
+ frameTimestamps: null as Record<string, number[]> | null,
+ currentFrame: 0,
+};
+
+interface PlaybackContextValue {
+ loadedVideos: LoadedVideo[];
+ recordingPath: string | null;
+ recordingFps: number | undefined;
+ frameTimestamps: Record<string, number[]> | null;
+ initialLoadPath: string | null;
+ cachedCurrentFrame: number;
+ onRecordingLoaded: (videos: LoadedVideo[], recordingPath: string, recordingFps?: number) => void;
+ onFrameChange: (frame: number) => void;
+ setInitialLoadPath: (path: string | null) => void;
+}
+
+const PlaybackContext = createContext<PlaybackContextValue | null>(null);
+
+export const PlaybackProvider: React.FC<{ children: React.ReactNode }> = ({children}) => {
+ const [initialLoadPath, setInitialLoadPath] = useState<string | null>(null);
+
+ const initState = (initialLoadPath && initialLoadPath !== cachedPlaybackState.recordingPath)
+ ? {
+ loadedVideos: [] as LoadedVideo[],
+ recordingPath: null,
+ recordingFps: undefined,
+ frameTimestamps: null,
+ currentFrame: 0,
+ }
+ : cachedPlaybackState;
+
+ const [loadedVideos, setLoadedVideos] = useState<LoadedVideo[]>(initState.loadedVideos);
+ const [recordingPath, setRecordingPath] = useState<string | null>(initState.recordingPath);
+ const [recordingFps, setRecordingFps] = useState<number | undefined>(initState.recordingFps);
+ const [frameTimestamps, setFrameTimestamps] = useState<Record<string, number[]> | null>(initState.frameTimestamps);
+
+ const onRecordingLoaded = useCallback((videos: LoadedVideo[], path: string, fps?: number) => {
+ setLoadedVideos(videos);
+ setRecordingPath(path);
+ setRecordingFps(fps);
+ setFrameTimestamps(null);
+ cachedPlaybackState = {
+ loadedVideos: videos,
+ recordingPath: path,
+ recordingFps: fps,
+ frameTimestamps: null,
+ currentFrame: 0,
+ };
+ }, []);
+
+ const onFrameChange = useCallback((frame: number) => {
+ cachedPlaybackState.currentFrame = frame;
+ }, []);
+
+ // After a recording is loaded, fetch real timestamps from the server
+ useEffect(() => {
+ if (loadedVideos.length === 0) return;
+ const fetchTimestamps = async () => {
+ try {
+ if (recordingPath) {
+ const response = await fetch(serverUrls.endpoints.playbackAllTimestamps(recordingPath));
+ if (!response.ok) return;
+ const data = await response.json();
+ if (data.timestamps && Object.keys(data.timestamps).length > 0) {
+ setFrameTimestamps(data.timestamps);
+ cachedPlaybackState.frameTimestamps = data.timestamps;
+ }
+ }
+ } catch {
+ // Timestamps not available
+ }
+ };
+ fetchTimestamps();
+ }, [loadedVideos, recordingPath]);
+
+ // Auto-load latest recording on mount if nothing is loaded
+ useEffect(() => {
+ if (initialLoadPath || initState.loadedVideos.length > 0) return;
+
+ let isMounted = true;
+ const fetchLatest = async () => {
+ try {
+ const response = await fetch(serverUrls.endpoints.playbackRecordings);
+ if (response.ok && isMounted) {
+ const data = await response.json();
+ if (data && data.length > 0) {
+ const latest = data[0];
+ const vidResp = await fetch(serverUrls.endpoints.playbackVideos(latest.name));
+ if (vidResp.ok && isMounted) {
+ const vidsData = await vidResp.json();
+ const baseUrl = serverUrls.getHttpUrl();
+ const vids = vidsData.map((v: any) => ({
+ videoId: v.video_id,
+ filename: v.filename,
+ streamUrl: `${baseUrl}${v.stream_url}`,
+ sizeBytes: v.size_bytes,
+ }));
+ onRecordingLoaded(vids, latest.name, latest.fps);
+ }
+ }
+ }
+ } catch {
+ // Ignore errors
+ }
+ };
+ fetchLatest();
+ return () => { isMounted = false; };
+ }, [initialLoadPath, initState.loadedVideos.length]);
+
+ return (
+ <PlaybackContext.Provider value={{
+ loadedVideos,
+ recordingPath,
+ recordingFps,
+ frameTimestamps,
+ initialLoadPath,
+ cachedCurrentFrame: initState.currentFrame,
+ onRecordingLoaded,
+ onFrameChange,
+ setInitialLoadPath,
+ }}>
+ {children}
+ </PlaybackContext.Provider>
+ );
+};
+
+export function usePlaybackContext(): PlaybackContextValue | null {
+ return useContext(PlaybackContext);
+}
diff --git a/freemocap-ui/src/components/playback/RecordingBrowser.tsx b/freemocap-ui/src/components/playback/RecordingBrowser.tsx
index e869324e..02942e08 100644
--- a/freemocap-ui/src/components/playback/RecordingBrowser.tsx
+++ b/freemocap-ui/src/components/playback/RecordingBrowser.tsx
@@ -266,11 +266,11 @@ export const RecordingBrowser: React.FC<RecordingBrowserProps> = ({ onRecordingL
setError(null);
try {
- const response = await fetch(serverUrls.endpoints.playbackLoad, {
- method: 'POST',
- headers: { 'Content-Type': 'application/json' },
- body: JSON.stringify({ recording_path: recordingPath }),
- });
+ // Determine recording ID (name)
+ const rec = recordings.find((r) => r.path === recordingPath);
+ const recName = rec ? rec.name : recordingPath.split(/[\\/]/).pop() || recordingPath;
+
+ const response = await fetch(serverUrls.endpoints.playbackVideos(recName));
if (!response.ok) {
const detail = await response
@@ -282,7 +282,7 @@ export const RecordingBrowser: React.FC<RecordingBrowserProps> = ({ onRecordingL
const data = await response.json();
const baseUrl = serverUrls.getHttpUrl();
- const videos: LoadedVideo[] = data.videos.map(
+ const videos: LoadedVideo[] = data.map(
(v: {
video_id: string;
filename: string;
@@ -296,11 +296,10 @@ export const RecordingBrowser: React.FC<RecordingBrowserProps> = ({ onRecordingL
}),
);
- // Look up recording fps from our cached list
- const rec = recordings.find((r) => r.path === recordingPath);
const recFps = rec?.fps ?? undefined;
- onRecordingLoaded(videos, data.recording_path, recFps);
+ // Send recName as the recording path to identify it successfully in playbackpage
+ onRecordingLoaded(videos, recName, recFps);
} catch (e) {
setError(e instanceof Error ? e.message : 'Failed to load recording');
} finally {
diff --git a/freemocap-ui/src/components/playback/RecordingBrowserSection.tsx b/freemocap-ui/src/components/playback/RecordingBrowserSection.tsx
new file mode 100644
index 00000000..404eaad9
--- /dev/null
+++ b/freemocap-ui/src/components/playback/RecordingBrowserSection.tsx
@@ -0,0 +1,26 @@
+import React from 'react';
+import VideoLibraryIcon from '@mui/icons-material/VideoLibrary';
+import {CollapsibleSidebarSection} from '@/components/common/CollapsibleSidebarSection';
+import {RecordingBrowser} from './RecordingBrowser';
+import {usePlaybackContext} from './PlaybackContext';
+import {useTranslation} from 'react-i18next';
+
+export const RecordingBrowserSection: React.FC = () => {
+ const {t} = useTranslation();
+ const ctx = usePlaybackContext();
+
+ if (!ctx) return null;
+
+ return (
+ <CollapsibleSidebarSection
+ icon={<VideoLibraryIcon sx={{fontSize: 20}}/>}
+ title={t('recordings')}
+ defaultExpanded
+ >
+ <RecordingBrowser
+ onRecordingLoaded={ctx.onRecordingLoaded}
+ initialLoadPath={ctx.initialLoadPath}
+ />
+ </CollapsibleSidebarSection>
+ );
+};
diff --git a/freemocap-ui/src/components/playback/SyncedVideoPlayer.tsx b/freemocap-ui/src/components/playback/SyncedVideoPlayer.tsx
index 3d5ce0e7..200827a1 100644
--- a/freemocap-ui/src/components/playback/SyncedVideoPlayer.tsx
+++ b/freemocap-ui/src/components/playback/SyncedVideoPlayer.tsx
@@ -4,8 +4,8 @@ import type {Layout, LayoutItem} from 'react-grid-layout';
import ReactGridLayout, {noCompactor} from 'react-grid-layout';
import 'react-grid-layout/css/styles.css';
import 'react-resizable/css/styles.css';
-import {PlaybackControls} from './PlaybackControls';
import {useTranslation} from 'react-i18next';
+import type {PlaybackController} from './usePlaybackController';
interface VideoEntry {
videoId: string;
@@ -20,17 +20,22 @@ export interface PlaybackSettings {
interface SyncedVideoPlayerProps {
videos: VideoEntry[];
- recordingFps?: number;
- /** Per-camera frame timestamps in seconds from recording start, loaded from CSV files */
- frameTimestamps?: Record<string, number[]> | null;
/** null = auto-optimize, number = manual column count */
manualColumns: number | null;
/** Increment to force layout reset */
resetKey: number;
- /** Frame to seek to once all videos are ready (default 0) */
- initialFrame?: number;
- /** Called when the current frame changes (throttled to ~5Hz) */
- onFrameChange?: (frame: number) => void;
+ /** Playback controller from usePlaybackController */
+ controller: PlaybackController;
+}
+
+function formatTimecodeFromSeconds(seconds: number, fps: number): string {
+ if (fps <= 0) return '00:00:00:00';
+ const h = Math.floor(seconds / 3600);
+ const m = Math.floor((seconds % 3600) / 60);
+ const s = Math.floor(seconds % 60);
+ const f = Math.floor((seconds % 1) * fps);
+ const pad = (n: number) => n.toString().padStart(2, '0');
+ return `${pad(h)}:${pad(m)}:${pad(s)}:${pad(f)}`;
}
function formatTimecode(frame: number, fps: number): string {
@@ -44,95 +49,42 @@ function formatTimecode(frame: number, fps: number): string {
return `${pad(h)}:${pad(m)}:${pad(s)}:${pad(f)}`;
}
-function formatTimecodeFromSeconds(seconds: number, fps: number): string {
- if (fps <= 0) return '00:00:00:00';
- const h = Math.floor(seconds / 3600);
- const m = Math.floor((seconds % 3600) / 60);
- const s = Math.floor(seconds % 60);
- const f = Math.floor((seconds % 1) * fps);
- const pad = (n: number) => n.toString().padStart(2, '0');
- return `${pad(h)}:${pad(m)}:${pad(s)}:${pad(f)}`;
-}
-
function formatSeconds(frame: number, fps: number): string {
if (fps <= 0) return '0.000s';
return `${(frame / fps).toFixed(3)}s`;
}
/**
- * Frame-locked multi-video player using a "leader" video element as the
- * canonical time source. All other videos sync to the leader.
- *
- * SYNC STRATEGY:
- * - The first video is the "leader" and drives canonical time via its
- * native currentTime property, which naturally accounts for decode
- * latency, buffering, and rate changes.
- * - The rAF loop reads leader.currentTime to derive the frame number.
- * - Follower videos are corrected ONLY when they drift beyond a generous
- * tolerance (2 frames), avoiding micro-stutter from frequent seeks.
- * - Overlays update via direct DOM manipulation (zero React re-renders).
- * - React state for controls/slider updates at ~5Hz.
+ * Pure video grid renderer. All playback state is managed externally
+ * via the PlaybackController from usePlaybackController.
*/
-export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, recordingFps, frameTimestamps, manualColumns, resetKey, initialFrame = 0, onFrameChange }) => {
+export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({
+ videos,
+ manualColumns,
+ resetKey,
+ controller,
+}) => {
const theme = useTheme();
- const { t } = useTranslation();
- const videoRefs = useRef<Map<string, HTMLVideoElement>>(new Map());
-
- // Direct DOM refs for overlays β€” updated WITHOUT React re-renders
- const frameOverlayRefs = useRef<Map<string, HTMLElement>>(new Map());
- const timeOverlayRefs = useRef<Map<string, HTMLElement>>(new Map());
-
- // Playback refs (rAF loop reads these, never stale)
- const isPlayingRef = useRef(false);
- const currentFrameRef = useRef(0);
- const totalFramesRef = useRef(0);
- const fpsRef = useRef(recordingFps || 30);
- const playbackRateRef = useRef(1);
- const rafRef = useRef<number | null>(null);
- const settingsRef = useRef<PlaybackSettings>({ showOverlays: true, timestampFormat: 'seconds' });
- const frameTimestampsRef = useRef<Record<string, number[]> | null>(null);
- const onFrameChangeRef = useRef(onFrameChange);
- onFrameChangeRef.current = onFrameChange;
- const didSeekInitialRef = useRef(false);
-
- // Leader-based sync: first video is the time authority
- const leaderIdRef = useRef<string | null>(null);
-
- // Follower drift correction: generous tolerance to avoid stutter.
- // Only correct followers that are more than 2 frames away from leader.
- const FOLLOWER_DRIFT_TOLERANCE_FRAMES = 2;
- // Check followers every N rAF ticks (~250ms at 60fps)
- const FOLLOWER_CHECK_INTERVAL = 15;
- const followerCheckCounter = useRef(0);
-
- // Throttle React state updates to ~5Hz
- const lastReactUpdateRef = useRef(0);
- const REACT_UPDATE_INTERVAL_MS = 200;
-
- // Slider drag state
- const isDraggingRef = useRef(false);
- const wasPlayingBeforeDragRef = useRef(false);
-
- // React state β€” ONLY for controls/slider, NOT updated per-frame
- const [isPlaying, setIsPlaying] = useState(false);
- const [currentFrame, setCurrentFrame] = useState(0);
- const [totalFrames, setTotalFrames] = useState(0);
- const [duration, setDuration] = useState(0);
- const [playbackRate, setPlaybackRate] = useState(1);
- const [videosReady, setVideosReady] = useState(0);
- const [settings, setSettings] = useState<PlaybackSettings>({
- showOverlays: true,
- timestampFormat: 'timecode',
- });
- const [isLooping, setIsLooping] = useState(false);
- const isLoopingRef = useRef(false);
-
- const fps = recordingFps || 30;
- const allReady = videosReady >= videos.length && videos.length > 0;
- const currentTime = fpsRef.current > 0 ? currentFrameRef.current / fpsRef.current : 0;
+ const {t} = useTranslation();
+
+ const {
+ currentFrame,
+ totalFrames,
+ fps,
+ settings,
+ allReady,
+ videosReady,
+ setVideoRef,
+ setFrameOverlayRef,
+ setTimeOverlayRef,
+ handleLoadedMetadata,
+ settingsRef,
+ frameTimestampsRef,
+ fpsRef,
+ } = controller;
// -----------------------------------------------------------------------
- // Grid layout (same auto-tiling as CameraViewsGrid)
+ // Grid layout
// -----------------------------------------------------------------------
const GRID_COLS = 12;
const GRID_MARGIN: [number, number] = [2, 2];
@@ -156,24 +108,30 @@ export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, re
}, []);
const computeTiling = (n: number, w: number, h: number) => {
- if (n <= 1) return { cols: 1, rows: 1 };
+ if (n <= 1) return {cols: 1, rows: 1};
let bestCols = 1;
let bestArea = 0;
+ const TARGET_AR = 16 / 9; // Assume standard video aspect ratio
for (let cols = 1; cols <= n; cols++) {
const rows = Math.ceil(n / cols);
const cellW = (w - GRID_MARGIN[0] * (cols - 1)) / cols;
const cellH = (h - GRID_MARGIN[1] * (rows - 1)) / rows;
if (cellW < 80 || cellH < 60) continue;
- const area = n * cellW * cellH;
+
+ // Calculate actual media fitted area preserving aspect ratio
+ const fittedW = Math.min(cellW, cellH * TARGET_AR);
+ const fittedH = fittedW / TARGET_AR;
+ const area = n * fittedW * fittedH;
+
if (area > bestArea) { bestArea = area; bestCols = cols; }
}
- return { cols: bestCols, rows: Math.ceil(n / bestCols) };
+ return {cols: bestCols, rows: Math.ceil(n / bestCols)};
};
- const prevTilingRef = useRef({ cols: 1, rows: 1 });
+ const prevTilingRef = useRef({cols: 1, rows: 1});
const tiling = useMemo(() => {
const candidate = manualColumns !== null
- ? { cols: Math.max(1, Math.min(manualColumns, videos.length || 1)), rows: Math.ceil((videos.length || 1) / Math.max(1, Math.min(manualColumns, videos.length || 1))) }
+ ? {cols: Math.max(1, Math.min(manualColumns, videos.length || 1)), rows: Math.ceil((videos.length || 1) / Math.max(1, Math.min(manualColumns, videos.length || 1)))}
: computeTiling(videos.length, gridWidth, gridHeight);
const prev = prevTilingRef.current;
if (candidate.cols === prev.cols && candidate.rows === prev.rows) return prev;
@@ -221,8 +179,8 @@ export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, re
if (swapTarget) {
setGridLayout(preDrag.map((l) => {
- if (l.i === newItem.i) return { ...l, x: swapTarget.x, y: swapTarget.y };
- if (l.i === swapTarget.i) return { ...l, x: draggedBefore.x, y: draggedBefore.y };
+ if (l.i === newItem.i) return {...l, x: swapTarget.x, y: swapTarget.y};
+ if (l.i === swapTarget.i) return {...l, x: draggedBefore.x, y: draggedBefore.y};
return l;
}));
} else {
@@ -230,7 +188,7 @@ export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, re
const maxY = tiling.rows - newItem.h;
setGridLayout(preDrag.map((l) => {
if (l.i === newItem.i) {
- return { ...l, x: Math.max(0, Math.min(newItem.x, maxX)), y: Math.max(0, Math.min(newItem.y, maxY)) };
+ return {...l, x: Math.max(0, Math.min(newItem.x, maxX)), y: Math.max(0, Math.min(newItem.y, maxY))};
}
return l;
}));
@@ -245,341 +203,12 @@ export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, re
return Math.max(30, (gridHeight - totalMargin) / tiling.rows);
}, [gridHeight, tiling.rows]);
- // Keep refs in sync with props/state
- useEffect(() => { settingsRef.current = settings; }, [settings]);
- useEffect(() => { isLoopingRef.current = isLooping; }, [isLooping]);
- useEffect(() => { frameTimestampsRef.current = frameTimestamps ?? null; }, [frameTimestamps]);
- useEffect(() => {
- if (recordingFps && recordingFps > 0) fpsRef.current = recordingFps;
- }, [recordingFps]);
-
- // Elect leader whenever video list changes
- useEffect(() => {
- leaderIdRef.current = videos.length > 0 ? videos[0].videoId : null;
- }, [videos]);
-
- // -----------------------------------------------------------------------
- // Direct DOM overlay updates β€” fast, no React involved
- // -----------------------------------------------------------------------
- const updateOverlays = useCallback((frame: number) => {
- const s = settingsRef.current;
- const ts = frameTimestampsRef.current;
- const padLen = Math.max(String(totalFramesRef.current).length, 1);
- const frameText = 'F' + String(frame).padStart(padLen, '0');
-
- let timeText: string;
- if (ts) {
- const firstKey = Object.keys(ts)[0];
- const camTs = firstKey ? ts[firstKey] : null;
- if (camTs && frame < camTs.length) {
- const realSec = camTs[frame];
- timeText = s.timestampFormat === 'timecode'
- ? formatTimecodeFromSeconds(realSec, fpsRef.current)
- : `${realSec.toFixed(3)}s`;
- } else {
- timeText = '~' + (s.timestampFormat === 'timecode'
- ? formatTimecode(frame, fpsRef.current)
- : formatSeconds(frame, fpsRef.current));
- }
- } else {
- timeText = '~' + (s.timestampFormat === 'timecode'
- ? formatTimecode(frame, fpsRef.current)
- : formatSeconds(frame, fpsRef.current));
- }
-
- frameOverlayRefs.current.forEach((el) => { el.textContent = frameText; });
- timeOverlayRefs.current.forEach((el) => { el.textContent = timeText; });
- }, []);
-
- // -----------------------------------------------------------------------
- // Ref registration
- // -----------------------------------------------------------------------
- const setVideoRef = useCallback((videoId: string, el: HTMLVideoElement | null) => {
- if (el) videoRefs.current.set(videoId, el);
- else videoRefs.current.delete(videoId);
- }, []);
-
- const setFrameOverlayRef = useCallback((videoId: string, el: HTMLElement | null) => {
- if (el) frameOverlayRefs.current.set(videoId, el);
- else frameOverlayRefs.current.delete(videoId);
- }, []);
-
- const setTimeOverlayRef = useCallback((videoId: string, el: HTMLElement | null) => {
- if (el) timeOverlayRefs.current.set(videoId, el);
- else timeOverlayRefs.current.delete(videoId);
- }, []);
-
- // -----------------------------------------------------------------------
- // Seek all videos to a frame (used when PAUSED / stepping only)
- // -----------------------------------------------------------------------
- const seekAllToFrame = useCallback((frame: number) => {
- const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
- const targetTime = fpsRef.current > 0 ? clamped / fpsRef.current : 0;
- videoRefs.current.forEach((el) => { el.currentTime = targetTime; });
- currentFrameRef.current = clamped;
- setCurrentFrame(clamped);
- onFrameChangeRef.current?.(clamped);
- updateOverlays(clamped);
- }, [updateOverlays]);
-
- // -----------------------------------------------------------------------
- // Native play/pause
- // -----------------------------------------------------------------------
- const playAllVideos = useCallback(() => {
- const rate = playbackRateRef.current;
- // Play leader first so it starts decoding immediately
- const leaderId = leaderIdRef.current;
- const leader = leaderId ? videoRefs.current.get(leaderId) : null;
- if (leader) {
- leader.playbackRate = rate;
- leader.play().catch(() => {});
- }
- videoRefs.current.forEach((el, id) => {
- if (id === leaderId) return;
- el.playbackRate = rate;
- el.play().catch(() => {});
- });
- }, []);
-
- const pauseAllVideos = useCallback(() => {
- videoRefs.current.forEach((el) => { el.pause(); });
- }, []);
-
- // -----------------------------------------------------------------------
- // rAF playback loop β€” reads leader.currentTime as the time source.
- //
- // This eliminates the wall-clock-vs-decode-pipeline fight that causes
- // stutter. The leader's currentTime naturally accounts for buffering,
- // decode latency, and rate changes. We just read it and derive frames.
- // -----------------------------------------------------------------------
- const tick = useCallback((timestamp: DOMHighResTimeStamp) => {
- if (!isPlayingRef.current) return;
-
- const leaderId = leaderIdRef.current;
- const leader = leaderId ? videoRefs.current.get(leaderId) : null;
- if (!leader) {
- rafRef.current = requestAnimationFrame(tick);
- return;
- }
-
- const leaderTime = leader.currentTime;
- const newFrame = leaderTime * fpsRef.current;
-
- // End of video β€” loop back to start or stop
- if (newFrame >= totalFramesRef.current) {
- if (isLoopingRef.current) {
- // Pause all videos, seek cleanly to frame 0, then restart playback.
- // Seeking while videos are still playing causes the browser's decode
- // pipeline to stall, producing choppy playback on subsequent loops.
- pauseAllVideos();
- const targetTime = 0;
- videoRefs.current.forEach((el) => { el.currentTime = targetTime; });
- currentFrameRef.current = 0;
- followerCheckCounter.current = 0;
- updateOverlays(0);
- setCurrentFrame(0);
- playAllVideos();
- rafRef.current = requestAnimationFrame(tick);
- return;
- }
- pauseAllVideos();
- isPlayingRef.current = false;
- const endFrame = totalFramesRef.current - 1;
- currentFrameRef.current = endFrame;
- updateOverlays(endFrame);
- setIsPlaying(false);
- setCurrentFrame(endFrame);
- return;
- }
-
- const intFrame = Math.floor(newFrame);
- const prevIntFrame = Math.floor(currentFrameRef.current);
- currentFrameRef.current = newFrame;
-
- // Update DOM overlays on frame change
- if (intFrame !== prevIntFrame) {
- updateOverlays(intFrame);
- }
-
- // Throttled React update for slider (~5Hz)
- if (timestamp - lastReactUpdateRef.current >= REACT_UPDATE_INTERVAL_MS) {
- lastReactUpdateRef.current = timestamp;
- setCurrentFrame(intFrame);
- onFrameChangeRef.current?.(intFrame);
- }
-
- // Periodic follower drift correction β€” only when drift exceeds tolerance.
- // This is the key to smooth playback: let browser-native playback run
- // undisturbed and only intervene when followers genuinely desync.
- followerCheckCounter.current++;
- if (followerCheckCounter.current >= FOLLOWER_CHECK_INTERVAL) {
- followerCheckCounter.current = 0;
- const toleranceSec = FOLLOWER_DRIFT_TOLERANCE_FRAMES / fpsRef.current;
- const rate = playbackRateRef.current;
- videoRefs.current.forEach((el, id) => {
- if (id === leaderId) return;
- if (Math.abs(el.currentTime - leaderTime) > toleranceSec) {
- el.currentTime = leaderTime;
- }
- if (Math.abs(el.playbackRate - rate) > 0.01) {
- el.playbackRate = rate;
- }
- });
- }
-
- rafRef.current = requestAnimationFrame(tick);
- }, [pauseAllVideos, playAllVideos, updateOverlays]);
-
- const startLoop = useCallback(() => {
- followerCheckCounter.current = 0;
- lastReactUpdateRef.current = 0;
- rafRef.current = requestAnimationFrame(tick);
- }, [tick]);
-
- const stopLoop = useCallback(() => {
- if (rafRef.current !== null) { cancelAnimationFrame(rafRef.current); rafRef.current = null; }
- }, []);
-
- useEffect(() => stopLoop, [stopLoop]);
-
- // -----------------------------------------------------------------------
- // Metadata
- // -----------------------------------------------------------------------
- const handleLoadedMetadata = useCallback((e: React.SyntheticEvent<HTMLVideoElement>) => {
- const el = e.currentTarget;
- if (el.duration && el.duration !== Infinity) {
- const d = el.duration;
- setDuration((prev) => Math.max(prev, d));
- const frames = Math.floor(d * fpsRef.current);
- if (totalFramesRef.current === 0 || frames < totalFramesRef.current) {
- totalFramesRef.current = frames;
- setTotalFrames(frames);
- }
- }
- el.pause();
- setVideosReady((prev) => prev + 1);
- }, []);
-
- // -----------------------------------------------------------------------
- // Playback commands
- // -----------------------------------------------------------------------
- const handlePlayPause = useCallback(() => {
- if (isPlayingRef.current) {
- isPlayingRef.current = false;
- stopLoop();
- pauseAllVideos();
- setIsPlaying(false);
- // Snap all videos to leader's position on pause for perfect alignment
- const leaderId = leaderIdRef.current;
- const leader = leaderId ? videoRefs.current.get(leaderId) : null;
- if (leader) {
- const pauseFrame = Math.floor(leader.currentTime * fpsRef.current);
- seekAllToFrame(pauseFrame);
- }
- } else {
- if (Math.floor(currentFrameRef.current) >= totalFramesRef.current - 1) {
- seekAllToFrame(0);
- }
- isPlayingRef.current = true;
- setIsPlaying(true);
- playAllVideos();
- startLoop();
- }
- }, [seekAllToFrame, startLoop, stopLoop, playAllVideos, pauseAllVideos]);
-
- // Slider DRAG β€” pause once, then scrub as user drags
- const handleSeekDrag = useCallback((frame: number) => {
- if (!isDraggingRef.current) {
- isDraggingRef.current = true;
- wasPlayingBeforeDragRef.current = isPlayingRef.current;
- if (isPlayingRef.current) {
- isPlayingRef.current = false;
- stopLoop();
- pauseAllVideos();
- }
- }
- const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
- currentFrameRef.current = clamped;
- updateOverlays(clamped);
- setCurrentFrame(clamped);
- const targetTime = fpsRef.current > 0 ? clamped / fpsRef.current : 0;
- videoRefs.current.forEach((el) => { el.currentTime = targetTime; });
- }, [stopLoop, pauseAllVideos, updateOverlays]);
-
- // Slider COMMIT β€” final seek + resume if was playing
- const handleSeekCommit = useCallback((frame: number) => {
- const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
- seekAllToFrame(clamped);
- if (wasPlayingBeforeDragRef.current) {
- isPlayingRef.current = true;
- setIsPlaying(true);
- playAllVideos();
- startLoop();
- }
- isDraggingRef.current = false;
- wasPlayingBeforeDragRef.current = false;
- }, [seekAllToFrame, playAllVideos, startLoop]);
-
- const handleFrameStep = useCallback((delta: number) => {
- if (isPlayingRef.current) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); setIsPlaying(false); }
- seekAllToFrame(Math.floor(currentFrameRef.current) + delta);
- }, [seekAllToFrame, stopLoop, pauseAllVideos]);
-
- const handlePlaybackRateChange = useCallback((rate: number) => {
- playbackRateRef.current = rate;
- setPlaybackRate(rate);
- videoRefs.current.forEach((el) => { el.playbackRate = rate; });
- }, []);
-
- const handleSeekToStart = useCallback(() => {
- const wasPlaying = isPlayingRef.current;
- if (wasPlaying) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); }
- seekAllToFrame(0);
- if (wasPlaying) { isPlayingRef.current = true; setIsPlaying(true); playAllVideos(); startLoop(); }
- }, [seekAllToFrame, stopLoop, startLoop, playAllVideos, pauseAllVideos]);
-
- const handleSeekToEnd = useCallback(() => {
- if (isPlayingRef.current) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); setIsPlaying(false); }
- seekAllToFrame(totalFramesRef.current - 1);
- }, [seekAllToFrame, stopLoop, pauseAllVideos]);
-
- const handleToggleLoop = useCallback(() => {
- setIsLooping((prev) => !prev);
- }, []);
-
- // Seek to initialFrame once all videos are ready (e.g. restoring position after tab switch)
- useEffect(() => {
- if (allReady && !didSeekInitialRef.current && initialFrame > 0) {
- didSeekInitialRef.current = true;
- seekAllToFrame(initialFrame);
- }
- }, [allReady, initialFrame, seekAllToFrame]);
-
- // -----------------------------------------------------------------------
- // Keyboard
- // -----------------------------------------------------------------------
- useEffect(() => {
- const handleKeyDown = (e: KeyboardEvent) => {
- if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return;
- switch (e.key) {
- case ' ': if (e.shiftKey) break; e.preventDefault(); handlePlayPause(); break;
- case 'ArrowLeft': e.preventDefault(); handleFrameStep(e.shiftKey ? -10 : -1); break;
- case 'ArrowRight': e.preventDefault(); handleFrameStep(e.shiftKey ? 10 : 1); break;
- case 'Home': e.preventDefault(); handleSeekToStart(); break;
- case 'End': e.preventDefault(); handleSeekToEnd(); break;
- case 'l': case 'L': e.preventDefault(); handleToggleLoop(); break;
- }
- };
- window.addEventListener('keydown', handleKeyDown);
- return () => window.removeEventListener('keydown', handleKeyDown);
- }, [handlePlayPause, handleFrameStep, handleSeekToStart, handleSeekToEnd, handleToggleLoop]);
-
// -----------------------------------------------------------------------
// Render
// -----------------------------------------------------------------------
if (videos.length === 0) {
return (
- <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'center', height: '100%', color: 'text.secondary' }}>
+ <Box sx={{display: 'flex', alignItems: 'center', justifyContent: 'center', height: '100%', color: 'text.secondary'}}>
<Typography>{t("noVideosLoaded")}</Typography>
</Box>
);
@@ -588,8 +217,10 @@ export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, re
const framePadLen = Math.max(String(totalFrames).length, 1);
const initialFrameText = 'F' + String(currentFrame).padStart(framePadLen, '0');
+ // Compute initial time text for overlay SSR
let initialTimeText: string;
let timestampsAreReal = false;
+ const frameTimestamps = frameTimestampsRef.current;
if (frameTimestamps) {
const firstKey = Object.keys(frameTimestamps)[0];
const camTs = firstKey ? frameTimestamps[firstKey] : null;
@@ -611,7 +242,7 @@ export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, re
}
return (
- <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', width: '100%' }}>
+ <Box sx={{display: 'flex', flexDirection: 'column', height: '100%', width: '100%'}}>
{/* Video grid */}
<Box
ref={gridContainerRef}
@@ -640,119 +271,97 @@ export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, re
margin: GRID_MARGIN,
containerPadding: [0, 0] as [number, number],
}}
- dragConfig={{ enabled: true }}
- resizeConfig={{ enabled: true }}
+ dragConfig={{enabled: true}}
+ resizeConfig={{enabled: true}}
compactor={noCompactor}
onLayoutChange={handleGridLayoutChange}
onDragStart={handleGridDragStart}
onDragStop={handleGridDragStop}
onResizeStop={handleGridResizeStop}
>
- {videos.map((video) => (
- <div
- key={video.videoId}
- style={{
- position: 'relative',
- overflow: 'hidden',
- backgroundColor: '#000',
- borderRadius: '4px',
- border: '1px solid rgba(255,255,255,0.15)',
- }}
- >
- <video
- ref={(el) => setVideoRef(video.videoId, el)}
- src={video.streamUrl}
- preload="auto"
- muted
- playsInline
- style={{ width: '100%', height: '100%', objectFit: 'contain' }}
- onLoadedMetadata={handleLoadedMetadata}
- />
-
- {settings.showOverlays && (
- <>
- {/* FRAME NUMBER β€” DOM ref, updated directly */}
- <Box
- ref={(el: HTMLElement | null) => setFrameOverlayRef(video.videoId, el)}
- sx={{
- position: 'absolute', top: 6, right: 6,
- backgroundColor: 'rgba(0, 0, 0, 0.88)',
- color: '#00ff88',
- px: 1.25, py: 0.4, borderRadius: '4px',
- fontSize: '14px', fontWeight: 700,
- fontFamily: '"JetBrains Mono", "Fira Code", "SF Mono", "Cascadia Code", monospace',
- letterSpacing: '0.5px', lineHeight: 1,
- border: '1px solid rgba(0, 255, 136, 0.3)',
- textShadow: '0 0 6px rgba(0, 255, 136, 0.4)',
- minWidth: 60, textAlign: 'center',
- userSelect: 'none', pointerEvents: 'none', zIndex: 10,
- }}
- >
- {initialFrameText}
- </Box>
-
- {/* CAMERA ID β€” static */}
- <Box sx={{
- position: 'absolute', bottom: 6, left: 6,
- backgroundColor: 'rgba(0, 0, 0, 0.75)',
- color: '#ccc', px: 1, py: 0.25, borderRadius: '3px',
- fontSize: '11px',
- fontFamily: '"JetBrains Mono", "Fira Code", monospace',
- userSelect: 'none', pointerEvents: 'none', zIndex: 10,
- }}>
- {video.videoId}
- </Box>
-
- {/* TIMECODE β€” DOM ref, updated directly */}
- <Tooltip title={timestampsAreReal ? t("timestampFromRecording") : t("estimatedFromFrameNumber")} placement="top-end">
+ {videos.map((video) => (
+ <div
+ key={video.videoId}
+ style={{
+ position: 'relative',
+ overflow: 'hidden',
+ backgroundColor: '#000',
+ borderRadius: '4px',
+ border: '1px solid rgba(255,255,255,0.15)',
+ }}
+ >
+ <video
+ ref={(el) => setVideoRef(video.videoId, el)}
+ src={video.streamUrl}
+ preload="auto"
+ muted
+ playsInline
+ style={{width: '100%', height: '100%', objectFit: 'contain'}}
+ onLoadedMetadata={handleLoadedMetadata}
+ />
+
+ {settings.showOverlays && (
+ <>
+ {/* FRAME NUMBER */}
<Box
- ref={(el: HTMLElement | null) => setTimeOverlayRef(video.videoId, el)}
+ ref={(el: HTMLElement | null) => setFrameOverlayRef(video.videoId, el)}
sx={{
- position: 'absolute', bottom: 6, right: 6,
- backgroundColor: 'rgba(0, 0, 0, 0.75)',
- color: '#aaa', px: 0.75, py: 0.25, borderRadius: '3px',
- fontSize: '10px',
- fontFamily: '"JetBrains Mono", "Fira Code", monospace',
- userSelect: 'none', zIndex: 10,
+ position: 'absolute', top: 6, right: 6,
+ backgroundColor: 'rgba(0, 0, 0, 0.88)',
+ color: '#00ff88',
+ px: 1.25, py: 0.4, borderRadius: '4px',
+ fontSize: '14px', fontWeight: 700,
+ fontFamily: '"JetBrains Mono", "Fira Code", "SF Mono", "Cascadia Code", monospace',
+ letterSpacing: '0.5px', lineHeight: 1,
+ border: '1px solid rgba(0, 255, 136, 0.3)',
+ textShadow: '0 0 6px rgba(0, 255, 136, 0.4)',
+ minWidth: 60, textAlign: 'center',
+ userSelect: 'none', pointerEvents: 'none', zIndex: 10,
}}
>
- {initialTimeText}
+ {initialFrameText}
</Box>
- </Tooltip>
- </>
- )}
- </div>
- ))}
+
+ {/* CAMERA ID */}
+ <Box sx={{
+ position: 'absolute', bottom: 6, left: 6,
+ backgroundColor: 'rgba(0, 0, 0, 0.75)',
+ color: '#ccc', px: 1, py: 0.25, borderRadius: '3px',
+ fontSize: '11px',
+ fontFamily: '"JetBrains Mono", "Fira Code", monospace',
+ userSelect: 'none', pointerEvents: 'none', zIndex: 10,
+ }}>
+ {video.videoId}
+ </Box>
+
+ {/* TIMECODE */}
+ <Tooltip title={timestampsAreReal ? t("timestampFromRecording") : t("estimatedFromFrameNumber")} placement="top-end">
+ <Box
+ ref={(el: HTMLElement | null) => setTimeOverlayRef(video.videoId, el)}
+ sx={{
+ position: 'absolute', bottom: 6, right: 6,
+ backgroundColor: 'rgba(0, 0, 0, 0.75)',
+ color: '#aaa', px: 0.75, py: 0.25, borderRadius: '3px',
+ fontSize: '10px',
+ fontFamily: '"JetBrains Mono", "Fira Code", monospace',
+ userSelect: 'none', zIndex: 10,
+ }}
+ >
+ {initialTimeText}
+ </Box>
+ </Tooltip>
+ </>
+ )}
+ </div>
+ ))}
</ReactGridLayout>
</Box>
{!allReady && videos.length > 0 && (
- <Box sx={{ textAlign: 'center', py: 0.5, backgroundColor: theme.palette.warning.dark, color: '#fff' }}>
- <Typography variant="caption">{t("loadingVideos", { ready: videosReady, total: videos.length })}</Typography>
+ <Box sx={{textAlign: 'center', py: 0.5, backgroundColor: theme.palette.warning.dark, color: '#fff'}}>
+ <Typography variant="caption">{t("loadingVideos", {ready: videosReady, total: videos.length})}</Typography>
</Box>
)}
-
- <PlaybackControls
- isPlaying={isPlaying}
- currentTime={currentTime}
- duration={duration}
- playbackRate={playbackRate}
- currentFrame={currentFrame}
- totalFrames={totalFrames}
- fps={fps}
- recordingFps={recordingFps}
- settings={settings}
- onSettingsChange={setSettings}
- onPlayPause={handlePlayPause}
- onSeekDrag={handleSeekDrag}
- onSeekCommit={handleSeekCommit}
- onFrameStep={handleFrameStep}
- onPlaybackRateChange={handlePlaybackRateChange}
- onSeekToStart={handleSeekToStart}
- onSeekToEnd={handleSeekToEnd}
- isLooping={isLooping}
- onToggleLoop={handleToggleLoop}
- />
</Box>
);
};
diff --git a/freemocap-ui/src/components/playback/usePlaybackController.ts b/freemocap-ui/src/components/playback/usePlaybackController.ts
new file mode 100644
index 00000000..90835c90
--- /dev/null
+++ b/freemocap-ui/src/components/playback/usePlaybackController.ts
@@ -0,0 +1,437 @@
+import {useCallback, useEffect, useRef, useState} from 'react';
+import type {PlaybackSettings} from './SyncedVideoPlayer';
+
+interface VideoEntry {
+ videoId: string;
+ filename: string;
+ streamUrl: string;
+}
+
+interface UsePlaybackControllerArgs {
+ videos: VideoEntry[];
+ recordingFps?: number;
+ frameTimestamps?: Record<string, number[]> | null;
+ initialFrame?: number;
+ onFrameChange?: (frame: number) => void;
+}
+
+function formatTimecodeFromSeconds(seconds: number, fps: number): string {
+ if (fps <= 0) return '00:00:00:00';
+ const h = Math.floor(seconds / 3600);
+ const m = Math.floor((seconds % 3600) / 60);
+ const s = Math.floor(seconds % 60);
+ const f = Math.floor((seconds % 1) * fps);
+ const pad = (n: number) => n.toString().padStart(2, '0');
+ return `${pad(h)}:${pad(m)}:${pad(s)}:${pad(f)}`;
+}
+
+function formatTimecode(frame: number, fps: number): string {
+ if (fps <= 0) return '00:00:00:00';
+ const totalSec = frame / fps;
+ const h = Math.floor(totalSec / 3600);
+ const m = Math.floor((totalSec % 3600) / 60);
+ const s = Math.floor(totalSec % 60);
+ const f = frame % Math.round(fps);
+ const pad = (n: number) => n.toString().padStart(2, '0');
+ return `${pad(h)}:${pad(m)}:${pad(s)}:${pad(f)}`;
+}
+
+function formatSeconds(frame: number, fps: number): string {
+ if (fps <= 0) return '0.000s';
+ return `${(frame / fps).toFixed(3)}s`;
+}
+
+export function usePlaybackController({
+ videos,
+ recordingFps,
+ frameTimestamps,
+ initialFrame = 0,
+ onFrameChange,
+}: UsePlaybackControllerArgs) {
+ const videoRefs = useRef<Map<string, HTMLVideoElement>>(new Map());
+ const frameOverlayRefs = useRef<Map<string, HTMLElement>>(new Map());
+ const timeOverlayRefs = useRef<Map<string, HTMLElement>>(new Map());
+
+ // Playback refs (rAF loop reads these, never stale)
+ const isPlayingRef = useRef(false);
+ const currentFrameRef = useRef(0);
+ const totalFramesRef = useRef(0);
+ const fpsRef = useRef(recordingFps || 30);
+ const playbackRateRef = useRef(1);
+ const rafRef = useRef<number | null>(null);
+ const settingsRef = useRef<PlaybackSettings>({showOverlays: true, timestampFormat: 'seconds'});
+ const frameTimestampsRef = useRef<Record<string, number[]> | null>(null);
+ const onFrameChangeRef = useRef(onFrameChange);
+ onFrameChangeRef.current = onFrameChange;
+ const didSeekInitialRef = useRef(false);
+
+ // Leader-based sync
+ const leaderIdRef = useRef<string | null>(null);
+ const FOLLOWER_DRIFT_TOLERANCE_FRAMES = 2;
+ const FOLLOWER_CHECK_INTERVAL = 15;
+ const followerCheckCounter = useRef(0);
+
+ // Throttle React state updates to ~5Hz
+ const lastReactUpdateRef = useRef(0);
+ const REACT_UPDATE_INTERVAL_MS = 200;
+
+ // Slider drag state
+ const isDraggingRef = useRef(false);
+ const wasPlayingBeforeDragRef = useRef(false);
+
+ // React state β€” ONLY for controls/slider
+ const [isPlaying, setIsPlaying] = useState(false);
+ const [currentFrame, setCurrentFrame] = useState(0);
+ const [totalFrames, setTotalFrames] = useState(0);
+ const [duration, setDuration] = useState(0);
+ const [playbackRate, setPlaybackRate] = useState(1);
+ const [videosReady, setVideosReady] = useState(0);
+ const [settings, setSettings] = useState<PlaybackSettings>({
+ showOverlays: true,
+ timestampFormat: 'timecode',
+ });
+ const [isLooping, setIsLooping] = useState(false);
+ const isLoopingRef = useRef(false);
+
+ const fps = recordingFps || 30;
+ const allReady = videosReady >= videos.length && videos.length > 0;
+ const currentTime = fpsRef.current > 0 ? currentFrameRef.current / fpsRef.current : 0;
+
+ // Keep refs in sync
+ useEffect(() => { settingsRef.current = settings; }, [settings]);
+ useEffect(() => { isLoopingRef.current = isLooping; }, [isLooping]);
+ useEffect(() => { frameTimestampsRef.current = frameTimestamps ?? null; }, [frameTimestamps]);
+ useEffect(() => {
+ if (recordingFps && recordingFps > 0) fpsRef.current = recordingFps;
+ }, [recordingFps]);
+
+ // Elect leader whenever video list changes
+ useEffect(() => {
+ leaderIdRef.current = videos.length > 0 ? videos[0].videoId : null;
+ }, [videos]);
+
+ // Direct DOM overlay updates
+ const updateOverlays = useCallback((frame: number) => {
+ const s = settingsRef.current;
+ const ts = frameTimestampsRef.current;
+ const padLen = Math.max(String(totalFramesRef.current).length, 1);
+ const frameText = 'F' + String(frame).padStart(padLen, '0');
+
+ let timeText: string;
+ if (ts) {
+ const firstKey = Object.keys(ts)[0];
+ const camTs = firstKey ? ts[firstKey] : null;
+ if (camTs && frame < camTs.length) {
+ const realSec = camTs[frame];
+ timeText = s.timestampFormat === 'timecode'
+ ? formatTimecodeFromSeconds(realSec, fpsRef.current)
+ : `${realSec.toFixed(3)}s`;
+ } else {
+ timeText = '~' + (s.timestampFormat === 'timecode'
+ ? formatTimecode(frame, fpsRef.current)
+ : formatSeconds(frame, fpsRef.current));
+ }
+ } else {
+ timeText = '~' + (s.timestampFormat === 'timecode'
+ ? formatTimecode(frame, fpsRef.current)
+ : formatSeconds(frame, fpsRef.current));
+ }
+
+ frameOverlayRefs.current.forEach((el) => { el.textContent = frameText; });
+ timeOverlayRefs.current.forEach((el) => { el.textContent = timeText; });
+ }, []);
+
+ // Seek all videos to a frame
+ const seekAllToFrame = useCallback((frame: number) => {
+ const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
+ const targetTime = fpsRef.current > 0 ? clamped / fpsRef.current : 0;
+ videoRefs.current.forEach((el) => { el.currentTime = targetTime; });
+ currentFrameRef.current = clamped;
+ setCurrentFrame(clamped);
+ onFrameChangeRef.current?.(clamped);
+ updateOverlays(clamped);
+ }, [updateOverlays]);
+
+ // Native play/pause
+ const playAllVideos = useCallback(() => {
+ const rate = playbackRateRef.current;
+ const leaderId = leaderIdRef.current;
+ const leader = leaderId ? videoRefs.current.get(leaderId) : null;
+ if (leader) {
+ leader.playbackRate = rate;
+ leader.play().catch(() => {});
+ }
+ videoRefs.current.forEach((el, id) => {
+ if (id === leaderId) return;
+ el.playbackRate = rate;
+ el.play().catch(() => {});
+ });
+ }, []);
+
+ const pauseAllVideos = useCallback(() => {
+ videoRefs.current.forEach((el) => { el.pause(); });
+ }, []);
+
+ // rAF playback loop
+ const tick = useCallback((timestamp: DOMHighResTimeStamp) => {
+ if (!isPlayingRef.current) return;
+
+ const leaderId = leaderIdRef.current;
+ const leader = leaderId ? videoRefs.current.get(leaderId) : null;
+ if (!leader) {
+ rafRef.current = requestAnimationFrame(tick);
+ return;
+ }
+
+ const leaderTime = leader.currentTime;
+ const newFrame = leaderTime * fpsRef.current;
+
+ if (newFrame >= totalFramesRef.current) {
+ if (isLoopingRef.current) {
+ pauseAllVideos();
+ videoRefs.current.forEach((el) => { el.currentTime = 0; });
+ currentFrameRef.current = 0;
+ followerCheckCounter.current = 0;
+ updateOverlays(0);
+ setCurrentFrame(0);
+ playAllVideos();
+ rafRef.current = requestAnimationFrame(tick);
+ return;
+ }
+ pauseAllVideos();
+ isPlayingRef.current = false;
+ const endFrame = totalFramesRef.current - 1;
+ currentFrameRef.current = endFrame;
+ updateOverlays(endFrame);
+ setIsPlaying(false);
+ setCurrentFrame(endFrame);
+ return;
+ }
+
+ const intFrame = Math.floor(newFrame);
+ const prevIntFrame = Math.floor(currentFrameRef.current);
+ currentFrameRef.current = newFrame;
+
+ if (intFrame !== prevIntFrame) {
+ updateOverlays(intFrame);
+ }
+
+ if (timestamp - lastReactUpdateRef.current >= REACT_UPDATE_INTERVAL_MS) {
+ lastReactUpdateRef.current = timestamp;
+ setCurrentFrame(intFrame);
+ onFrameChangeRef.current?.(intFrame);
+ }
+
+ followerCheckCounter.current++;
+ if (followerCheckCounter.current >= FOLLOWER_CHECK_INTERVAL) {
+ followerCheckCounter.current = 0;
+ const toleranceSec = FOLLOWER_DRIFT_TOLERANCE_FRAMES / fpsRef.current;
+ const rate = playbackRateRef.current;
+ videoRefs.current.forEach((el, id) => {
+ if (id === leaderId) return;
+ if (Math.abs(el.currentTime - leaderTime) > toleranceSec) {
+ el.currentTime = leaderTime;
+ }
+ if (Math.abs(el.playbackRate - rate) > 0.01) {
+ el.playbackRate = rate;
+ }
+ });
+ }
+
+ rafRef.current = requestAnimationFrame(tick);
+ }, [pauseAllVideos, playAllVideos, updateOverlays]);
+
+ const startLoop = useCallback(() => {
+ followerCheckCounter.current = 0;
+ lastReactUpdateRef.current = 0;
+ rafRef.current = requestAnimationFrame(tick);
+ }, [tick]);
+
+ const stopLoop = useCallback(() => {
+ if (rafRef.current !== null) { cancelAnimationFrame(rafRef.current); rafRef.current = null; }
+ }, []);
+
+ useEffect(() => stopLoop, [stopLoop]);
+
+ // Metadata handler β€” called by video elements via onLoadedMetadata
+ const handleLoadedMetadata = useCallback((e: React.SyntheticEvent<HTMLVideoElement>) => {
+ const el = e.currentTarget;
+ if (el.duration && el.duration !== Infinity) {
+ const d = el.duration;
+ setDuration((prev) => Math.max(prev, d));
+ const frames = Math.floor(d * fpsRef.current);
+ if (totalFramesRef.current === 0 || frames < totalFramesRef.current) {
+ totalFramesRef.current = frames;
+ setTotalFrames(frames);
+ }
+ }
+ el.pause();
+ setVideosReady((prev) => prev + 1);
+ }, []);
+
+ // Playback commands
+ const handlePlayPause = useCallback(() => {
+ if (isPlayingRef.current) {
+ isPlayingRef.current = false;
+ stopLoop();
+ pauseAllVideos();
+ setIsPlaying(false);
+ const leaderId = leaderIdRef.current;
+ const leader = leaderId ? videoRefs.current.get(leaderId) : null;
+ if (leader) {
+ const pauseFrame = Math.floor(leader.currentTime * fpsRef.current);
+ seekAllToFrame(pauseFrame);
+ }
+ } else {
+ if (Math.floor(currentFrameRef.current) >= totalFramesRef.current - 1) {
+ seekAllToFrame(0);
+ }
+ isPlayingRef.current = true;
+ setIsPlaying(true);
+ playAllVideos();
+ startLoop();
+ }
+ }, [seekAllToFrame, startLoop, stopLoop, playAllVideos, pauseAllVideos]);
+
+ const handleSeekDrag = useCallback((frame: number) => {
+ if (!isDraggingRef.current) {
+ isDraggingRef.current = true;
+ wasPlayingBeforeDragRef.current = isPlayingRef.current;
+ if (isPlayingRef.current) {
+ isPlayingRef.current = false;
+ stopLoop();
+ pauseAllVideos();
+ }
+ }
+ const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
+ currentFrameRef.current = clamped;
+ updateOverlays(clamped);
+ setCurrentFrame(clamped);
+ const targetTime = fpsRef.current > 0 ? clamped / fpsRef.current : 0;
+ videoRefs.current.forEach((el) => { el.currentTime = targetTime; });
+ }, [stopLoop, pauseAllVideos, updateOverlays]);
+
+ const handleSeekCommit = useCallback((frame: number) => {
+ const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
+ seekAllToFrame(clamped);
+ if (wasPlayingBeforeDragRef.current) {
+ isPlayingRef.current = true;
+ setIsPlaying(true);
+ playAllVideos();
+ startLoop();
+ }
+ isDraggingRef.current = false;
+ wasPlayingBeforeDragRef.current = false;
+ }, [seekAllToFrame, playAllVideos, startLoop]);
+
+ const handleFrameStep = useCallback((delta: number) => {
+ if (isPlayingRef.current) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); setIsPlaying(false); }
+ seekAllToFrame(Math.floor(currentFrameRef.current) + delta);
+ }, [seekAllToFrame, stopLoop, pauseAllVideos]);
+
+ const handlePlaybackRateChange = useCallback((rate: number) => {
+ playbackRateRef.current = rate;
+ setPlaybackRate(rate);
+ videoRefs.current.forEach((el) => { el.playbackRate = rate; });
+ }, []);
+
+ const handleSeekToStart = useCallback(() => {
+ const wasPlaying = isPlayingRef.current;
+ if (wasPlaying) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); }
+ seekAllToFrame(0);
+ if (wasPlaying) { isPlayingRef.current = true; setIsPlaying(true); playAllVideos(); startLoop(); }
+ }, [seekAllToFrame, stopLoop, startLoop, playAllVideos, pauseAllVideos]);
+
+ const handleSeekToEnd = useCallback(() => {
+ if (isPlayingRef.current) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); setIsPlaying(false); }
+ seekAllToFrame(totalFramesRef.current - 1);
+ }, [seekAllToFrame, stopLoop, pauseAllVideos]);
+
+ const handleToggleLoop = useCallback(() => {
+ setIsLooping((prev) => !prev);
+ }, []);
+
+ // Seek to initialFrame once all videos are ready
+ useEffect(() => {
+ if (allReady && !didSeekInitialRef.current && initialFrame > 0) {
+ didSeekInitialRef.current = true;
+ seekAllToFrame(initialFrame);
+ }
+ }, [allReady, initialFrame, seekAllToFrame]);
+
+ // Keyboard shortcuts
+ useEffect(() => {
+ const handleKeyDown = (e: KeyboardEvent) => {
+ if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return;
+ switch (e.key) {
+ case ' ': if (e.shiftKey) break; e.preventDefault(); handlePlayPause(); break;
+ case 'ArrowLeft': e.preventDefault(); handleFrameStep(e.shiftKey ? -10 : -1); break;
+ case 'ArrowRight': e.preventDefault(); handleFrameStep(e.shiftKey ? 10 : 1); break;
+ case 'Home': e.preventDefault(); handleSeekToStart(); break;
+ case 'End': e.preventDefault(); handleSeekToEnd(); break;
+ case 'l': case 'L': e.preventDefault(); handleToggleLoop(); break;
+ }
+ };
+ window.addEventListener('keydown', handleKeyDown);
+ return () => window.removeEventListener('keydown', handleKeyDown);
+ }, [handlePlayPause, handleFrameStep, handleSeekToStart, handleSeekToEnd, handleToggleLoop]);
+
+ // Ref registration callbacks
+ const setVideoRef = useCallback((videoId: string, el: HTMLVideoElement | null) => {
+ if (el) videoRefs.current.set(videoId, el);
+ else videoRefs.current.delete(videoId);
+ }, []);
+
+ const setFrameOverlayRef = useCallback((videoId: string, el: HTMLElement | null) => {
+ if (el) frameOverlayRefs.current.set(videoId, el);
+ else frameOverlayRefs.current.delete(videoId);
+ }, []);
+
+ const setTimeOverlayRef = useCallback((videoId: string, el: HTMLElement | null) => {
+ if (el) timeOverlayRefs.current.set(videoId, el);
+ else timeOverlayRefs.current.delete(videoId);
+ }, []);
+
+ return {
+ // State
+ isPlaying,
+ currentFrame,
+ totalFrames,
+ duration,
+ playbackRate,
+ fps,
+ currentTime,
+ settings,
+ isLooping,
+ allReady,
+ videosReady,
+
+ // Setters
+ setSettings,
+
+ // Handlers
+ handlePlayPause,
+ handleSeekDrag,
+ handleSeekCommit,
+ handleFrameStep,
+ handlePlaybackRateChange,
+ handleSeekToStart,
+ handleSeekToEnd,
+ handleToggleLoop,
+ handleLoadedMetadata,
+
+ // Ref registration
+ setVideoRef,
+ setFrameOverlayRef,
+ setTimeOverlayRef,
+
+ // Internal refs exposed for SyncedVideoPlayer overlay rendering
+ settingsRef,
+ frameTimestampsRef,
+ fpsRef,
+ currentFrameRef,
+ totalFramesRef,
+ };
+}
+
+export type PlaybackController = ReturnType<typeof usePlaybackController>;
diff --git a/freemocap-ui/src/components/ui-components/PageTabButtons.tsx b/freemocap-ui/src/components/ui-components/PageTabButtons.tsx
index cba20a39..5498a710 100644
--- a/freemocap-ui/src/components/ui-components/PageTabButtons.tsx
+++ b/freemocap-ui/src/components/ui-components/PageTabButtons.tsx
@@ -50,7 +50,7 @@ export const PageTabButtons = () => {
}),
}}
>
- {t('cameras')}
+ Streaming
</Button>
<Button
variant={location.pathname === '/playback' ? 'contained' : 'outlined'}
diff --git a/freemocap-ui/src/constants/server-urls.ts b/freemocap-ui/src/constants/server-urls.ts
index e9a0c83f..30aeec96 100644
--- a/freemocap-ui/src/constants/server-urls.ts
+++ b/freemocap-ui/src/constants/server-urls.ts
@@ -44,27 +44,28 @@ class ServerUrls {
health: `${baseUrl}/health`,
shutdown: `${baseUrl}/shutdown`,
- // Camera endpoints
+ // Camera endpoints (SkellyCam)
detectCameras: `${baseUrl}/skellycam/camera/detect`,
camerasConnectOrUpdate: `${baseUrl}/skellycam/camera/group/apply`,
closeAll: `${baseUrl}/skellycam/camera/group/close/all`,
updateConfigs: `${baseUrl}/skellycam/camera/update`,
pauseUnpauseCameras: `${baseUrl}/skellycam/camera/group/all/pause_unpause`,
detectMicrophones: `${baseUrl}/skellycam/camera/microphone/detect`,
+
// Playback endpoints
- playbackRecordings: `${baseUrl}/skellycam/playback/recordings`,
+ playbackRecordings: `${baseUrl}/freemocap/playback/recordings`,
playbackVideos: (recordingId: string) =>
- `${baseUrl}/skellycam/playback/${encodeURIComponent(recordingId)}/videos`,
+ `${baseUrl}/freemocap/playback/${encodeURIComponent(recordingId)}/videos`,
playbackVideoStream: (recordingId: string, videoId: string) =>
- `${baseUrl}/skellycam/playback/${encodeURIComponent(recordingId)}/videos/${encodeURIComponent(videoId)}`,
+ `${baseUrl}/freemocap/playback/${encodeURIComponent(recordingId)}/videos/${encodeURIComponent(videoId)}`,
playbackAllTimestamps: (recordingId: string) =>
- `${baseUrl}/skellycam/playback/${encodeURIComponent(recordingId)}/timestamps`,
+ `${baseUrl}/freemocap/playback/${encodeURIComponent(recordingId)}/timestamps`,
playbackVideoTimestamps: (recordingId: string, videoId: string) =>
- `${baseUrl}/skellycam/playback/${encodeURIComponent(recordingId)}/videos/${encodeURIComponent(videoId)}/timestamps`,
+ `${baseUrl}/freemocap/playback/${encodeURIComponent(recordingId)}/videos/${encodeURIComponent(videoId)}/timestamps`,
// Recording endpoints
- startRecording: `${baseUrl}/skellycam/camera/group/all/record/start`,
- stopRecording: `${baseUrl}/skellycam/camera/group/all/record/stop`,
+ startRecording: `${baseUrl}/freemocap/camera/group/all/record/start`,
+ stopRecording: `${baseUrl}/freemocap/camera/group/all/record/stop`,
// Realtime pipeline endpoints
realtimeConnectOrUpdate: `${baseUrl}/freemocap/realtime/apply`,
diff --git a/freemocap-ui/src/hooks/useMocap.ts b/freemocap-ui/src/hooks/useMocap.ts
index 60719418..51f54233 100644
--- a/freemocap-ui/src/hooks/useMocap.ts
+++ b/freemocap-ui/src/hooks/useMocap.ts
@@ -164,6 +164,8 @@ export function useMocap() {
isLoading: mocapState.isLoading,
isRecording: mocapState.isRecording,
recordingProgress: mocapState.recordingProgress,
+ processingProgress: mocapState.processingProgress,
+ processingPhase: mocapState.processingPhase,
mocapRecordingPath,
directoryInfo,
isUsingManualPath,
diff --git a/freemocap-ui/src/layout/BasePanelLayout.tsx b/freemocap-ui/src/layout/BasePanelLayout.tsx
index e02b143d..fb2eb74b 100644
--- a/freemocap-ui/src/layout/BasePanelLayout.tsx
+++ b/freemocap-ui/src/layout/BasePanelLayout.tsx
@@ -7,6 +7,7 @@ import {useTheme} from "@mui/material/styles";
import {Box} from "@mui/material";
import {useMenuActions} from "@/hooks/useMenuActions";
import {useKeyboardShortcuts} from "@/hooks/useKeyboardShortcuts";
+import {RecordingCompleteDialog} from "@/components/control-panels/recording-info-panel/RecordingCompleteDialog";
export const BasePanelLayout = ({children}: { children: React.ReactNode }) => {
const theme = useTheme();
@@ -73,6 +74,7 @@ export const BasePanelLayout = ({children}: { children: React.ReactNode }) => {
{/* Main/Central Content Panel */}
<Panel defaultSize={76} minSize={10}>
{children}
+ <RecordingCompleteDialog />
</Panel>
</PanelGroup>
</Panel>
diff --git a/freemocap-ui/src/layout/content/SidePanelContent.tsx b/freemocap-ui/src/layout/content/SidePanelContent.tsx
index 639cc12e..5088d93f 100644
--- a/freemocap-ui/src/layout/content/SidePanelContent.tsx
+++ b/freemocap-ui/src/layout/content/SidePanelContent.tsx
@@ -237,6 +237,7 @@ export const SidePanelContent = () => {
</List>
<ServerConnectionStatus/>
<PageTabButtons/>
+
{/* Sidebar Sections β€” drag-reorderable */}
<DndContext
sensors={sensors}
diff --git a/freemocap-ui/src/pages/PlaybackPage.tsx b/freemocap-ui/src/pages/PlaybackPage.tsx
index 231955b8..d770eb24 100644
--- a/freemocap-ui/src/pages/PlaybackPage.tsx
+++ b/freemocap-ui/src/pages/PlaybackPage.tsx
@@ -1,36 +1,24 @@
import React, {useCallback, useEffect, useState} from 'react';
import {Box, Chip, IconButton, Tooltip, Typography, useTheme} from '@mui/material';
-import ArrowBackIcon from '@mui/icons-material/ArrowBack';
import VideocamIcon from '@mui/icons-material/Videocam';
import StorageIcon from '@mui/icons-material/Storage';
import FolderOpenIcon from '@mui/icons-material/FolderOpen';
+import VideoLibraryIcon from '@mui/icons-material/VideoLibrary';
+import CloseIcon from '@mui/icons-material/Close';
import {Footer} from '@/components/ui-components/Footer';
import ErrorBoundary from '@/components/common/ErrorBoundary';
-import {LoadedVideo, RecordingBrowser} from '@/components/playback/RecordingBrowser';
import {SyncedVideoPlayer} from '@/components/playback/SyncedVideoPlayer';
+import {PlaybackControls} from '@/components/playback/PlaybackControls';
+import {usePlaybackController} from '@/components/playback/usePlaybackController';
+import {usePlaybackContext} from '@/components/playback/PlaybackContext';
+import {RecordingBrowser} from '@/components/playback/RecordingBrowser';
import {useElectronIPC} from '@/services';
-import {serverUrls} from '@/constants/server-urls';
import {useTranslation} from 'react-i18next';
import {useLocation} from 'react-router-dom';
import type {CameraSettings} from '@/pages/ViewportPage';
-import {
- SettingsOverlay
-} from "@/components/ui-components/SettingsOverlay";
-
-// Module-level cache so playback state survives tab switches
-let cachedPlaybackState: {
- loadedVideos: LoadedVideo[];
- recordingPath: string | null;
- recordingFps: number | undefined;
- frameTimestamps: Record<string, number[]> | null;
- currentFrame: number;
-} = {
- loadedVideos: [],
- recordingPath: null,
- recordingFps: undefined,
- frameTimestamps: null,
- currentFrame: 0,
-};
+import {SettingsOverlay} from "@/components/ui-components/SettingsOverlay";
+import {Panel, PanelGroup, PanelResizeHandle} from "react-resizable-panels";
+import {ThreeJsCanvas} from "@/components/viewport3d/ThreeJsCanvas";
const PlaybackPage: React.FC = () => {
const theme = useTheme();
@@ -39,75 +27,37 @@ const PlaybackPage: React.FC = () => {
const location = useLocation();
const isDark = theme.palette.mode === 'dark';
const locationState = location.state as { loadRecordingPath?: string } | null;
- const initialLoadPath = locationState?.loadRecordingPath ?? null;
- // If navigating here with a new recording path, clear cached state so RecordingBrowser shows and auto-loads
- const initState = (initialLoadPath && initialLoadPath !== cachedPlaybackState.recordingPath)
- ? {
- loadedVideos: [] as LoadedVideo[],
- recordingPath: null,
- recordingFps: undefined,
- frameTimestamps: null,
- currentFrame: 0
- }
- : cachedPlaybackState;
+ const ctx = usePlaybackContext();
- const [loadedVideos, setLoadedVideos] = useState<LoadedVideo[]>(initState.loadedVideos);
- const [recordingPath, setRecordingPath] = useState<string | null>(initState.recordingPath);
- const [recordingFps, setRecordingFps] = useState<number | undefined>(initState.recordingFps);
- const [frameTimestamps, setFrameTimestamps] = useState<Record<string, number[]> | null>(initState.frameTimestamps);
- const [manualColumns, setManualColumns] = useState<number | null>(null);
+ // Pass initialLoadPath from route state to the context
+ useEffect(() => {
+ const path = locationState?.loadRecordingPath ?? null;
+ if (path) ctx?.setInitialLoadPath(path);
+ }, [locationState?.loadRecordingPath]);
+
+ const [settings, setSettings] = useState<CameraSettings>({
+ columns: null,
+ show3dView: true,
+ layoutDirection: 'horizontal',
+ });
const [resetKey, setResetKey] = useState<number>(0);
- const handleRecordingLoaded = useCallback((videos: LoadedVideo[], path: string, fps?: number) => {
- setLoadedVideos(videos);
- setRecordingPath(path);
- setRecordingFps(fps);
- setFrameTimestamps(null);
- cachedPlaybackState = {
- loadedVideos: videos,
- recordingPath: path,
- recordingFps: fps,
- frameTimestamps: null,
- currentFrame: 0
- };
- }, []);
+ const [isBrowsing, setIsBrowsing] = useState<boolean>(!ctx?.recordingPath);
- // After a recording is loaded, fetch real timestamps from the server
useEffect(() => {
- if (loadedVideos.length === 0) return;
+ if (!ctx?.recordingPath) {
+ setIsBrowsing(true);
+ }
+ }, [ctx?.recordingPath]);
- const fetchTimestamps = async () => {
- try {
- if (recordingPath) {
- const response = await fetch(serverUrls.endpoints.playbackAllTimestamps(recordingPath!));
- if (!response.ok) return;
- const data = await response.json();
- if (data.timestamps && Object.keys(data.timestamps).length > 0) {
- setFrameTimestamps(data.timestamps);
- cachedPlaybackState.frameTimestamps = data.timestamps;
- }
- }
- } catch {
- // Timestamps not available β€” SyncedVideoPlayer will use approximation
- }
- };
- fetchTimestamps();
- }, [loadedVideos]);
+ const isHorizontal = settings.layoutDirection === 'horizontal';
- const handleBack = useCallback(() => {
- setLoadedVideos([]);
- setRecordingPath(null);
- setRecordingFps(undefined);
- setFrameTimestamps(null);
- cachedPlaybackState = {
- loadedVideos: [],
- recordingPath: null,
- recordingFps: undefined,
- frameTimestamps: null,
- currentFrame: 0
- };
- }, []);
+ const loadedVideos = ctx?.loadedVideos ?? [];
+ const recordingPath = ctx?.recordingPath ?? null;
+ const recordingFps = ctx?.recordingFps;
+ const frameTimestamps = ctx?.frameTimestamps ?? null;
+ const onFrameChange = ctx?.onFrameChange;
const handleOpenFolder = useCallback(async () => {
if (!recordingPath) return;
@@ -115,30 +65,35 @@ const PlaybackPage: React.FC = () => {
await api?.fileSystem.openFolder.mutate({path: recordingPath});
} catch (err) {
console.error('Failed to open recording folder:', err);
- throw err;
}
}, [recordingPath, api]);
const handleSettingsChange = useCallback((partial: Partial<CameraSettings>) => {
- if (partial.columns !== undefined) {
- setManualColumns(partial.columns);
- }
+ setSettings((prev) => ({...prev, ...partial}));
}, []);
const handleResetLayout = useCallback(() => {
setResetKey((v) => v + 1);
}, []);
- const handleFrameChange = useCallback((frame: number) => {
- cachedPlaybackState.currentFrame = frame;
- }, []);
-
- const hasVideos = loadedVideos.length > 0;
const totalSize = loadedVideos.reduce((sum, v) => sum + v.sizeBytes, 0);
const monoFont = '"JetBrains Mono", "Fira Code", "SF Mono", monospace';
+ const recordingName = recordingPath ? recordingPath.split(/[\\/]/).pop() || recordingPath : t('noVideosLoaded');
- // Extract recording name from path
- const recordingName = recordingPath ? recordingPath.split(/[\\/]/).pop() || recordingPath : '';
+ const videoEntries = loadedVideos.map((v) => ({
+ videoId: v.videoId,
+ filename: v.filename,
+ streamUrl: v.streamUrl,
+ }));
+
+ // Playback controller β€” owns all playback state/logic
+ const controller = usePlaybackController({
+ videos: videoEntries,
+ recordingFps,
+ frameTimestamps,
+ initialFrame: ctx?.cachedCurrentFrame ?? 0,
+ onFrameChange,
+ });
return (
<Box
@@ -157,151 +112,253 @@ const PlaybackPage: React.FC = () => {
>
<Box sx={{flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden'}}>
<ErrorBoundary>
- {hasVideos ? (
- <Box sx={{display: 'flex', flexDirection: 'column', height: '100%', position: 'relative'}}>
- {/* Settings overlay for grid columns */}
- <SettingsOverlay
- settings={{columns: manualColumns, show3dView: false, layoutDirection: 'horizontal'}}
- onSettingsChange={handleSettingsChange}
- onResetLayout={handleResetLayout}
- />
+ <Box sx={{display: 'flex', flexDirection: 'column', height: '100%', position: 'relative'}}>
+ {/* Settings overlay for grid columns */}
+ <SettingsOverlay
+ settings={settings}
+ onSettingsChange={handleSettingsChange}
+ onResetLayout={handleResetLayout}
+ />
- {/* Recording header bar */}
- <Box
+ {/* Recording header bar */}
+ <Box
+ sx={{
+ display: 'flex',
+ alignItems: 'center',
+ gap: 1.5,
+ px: 1.5,
+ py: 0.75,
+ borderBottom: `1px solid ${theme.palette.divider}`,
+ backgroundColor: isDark ? 'rgba(255,255,255,0.03)' : 'rgba(0,0,0,0.02)',
+ minHeight: 40,
+ flexWrap: 'wrap',
+ }}
+ >
+ {/* Recording name */}
+ <Typography
+ variant="body2"
sx={{
- display: 'flex',
- alignItems: 'center',
- gap: 1.5,
- px: 1.5,
- py: 0.75,
- borderBottom: `1px solid ${theme.palette.divider}`,
- backgroundColor: isDark ? 'rgba(255,255,255,0.03)' : 'rgba(0,0,0,0.02)',
- minHeight: 40,
- flexWrap: 'wrap',
+ fontFamily: monoFont,
+ fontWeight: 600,
+ color: theme.palette.text.primary,
+ overflow: 'hidden',
+ textOverflow: 'ellipsis',
+ whiteSpace: 'nowrap',
}}
>
- <Tooltip title={t('backToRecordings')}>
- <IconButton size="small" onClick={handleBack}
- sx={{color: isDark ? '#b3b9c6' : undefined}}>
- <ArrowBackIcon fontSize="small"/>
- </IconButton>
- </Tooltip>
+ {recordingName}
+ </Typography>
- {/* Recording name */}
- <Typography
- variant="body2"
+ {/* Browse Recordings button */}
+ <Tooltip title={isBrowsing ? "Close browser" : "Browse recordings"}>
+ <IconButton
+ size="small"
+ onClick={() => setIsBrowsing(!isBrowsing)}
sx={{
+ color: isDark ? '#b3b9c6' : theme.palette.text.secondary,
+ border: `1px solid ${isDark ? 'rgba(255,255,255,0.15)' : theme.palette.divider}`,
+ borderRadius: '6px',
+ px: 1,
+ gap: 0.5,
+ fontSize: '0.75rem',
fontFamily: monoFont,
- fontWeight: 600,
- color: theme.palette.text.primary,
- overflow: 'hidden',
- textOverflow: 'ellipsis',
- whiteSpace: 'nowrap',
+ '&:hover': {
+ backgroundColor: isDark ? 'rgba(255,255,255,0.05)' : 'rgba(0,0,0,0.04)',
+ },
}}
>
- {recordingName}
- </Typography>
+ {isBrowsing ? <CloseIcon sx={{fontSize: 16}}/> : <VideoLibraryIcon sx={{fontSize: 16}}/>}
+ {isBrowsing ? 'Close' : 'Browse'}
+ </IconButton>
+ </Tooltip>
+
+ {/* Open Folder button */}
+ <Tooltip title={t('openFolder')}>
+ <IconButton
+ size="small"
+ onClick={handleOpenFolder}
+ sx={{
+ color: isDark ? '#ffcc80' : theme.palette.warning.dark,
+ border: `1px solid ${isDark ? 'rgba(255,204,128,0.3)' : theme.palette.warning.light}`,
+ borderRadius: '6px',
+ px: 1,
+ gap: 0.5,
+ fontSize: '0.75rem',
+ fontFamily: monoFont,
+ '&:hover': {
+ backgroundColor: isDark ? 'rgba(255,204,128,0.1)' : 'rgba(255,152,0,0.08)',
+ },
+ }}
+ >
+ <FolderOpenIcon sx={{fontSize: 16}}/>
+ </IconButton>
+ </Tooltip>
+
+ {/* Spacer */}
+ <Box sx={{flex: 1}}/>
+
+ {/* Stats chips */}
+ <Tooltip title={t('cameraStreams')}>
+ <Chip
+ icon={<VideocamIcon sx={{fontSize: '14px !important'}}/>}
+ label={t('cameraCount', {count: loadedVideos.length})}
+ size="small"
+ variant="outlined"
+ sx={{
+ fontFamily: monoFont,
+ fontSize: '0.75rem',
+ height: 24,
+ borderColor: isDark ? 'rgba(41,182,246,0.3)' : undefined,
+ color: isDark ? '#29b6f6' : theme.palette.info.main,
+ '& .MuiChip-icon': {color: 'inherit'},
+ }}
+ />
+ </Tooltip>
- {/* Open Folder button */}
- <Tooltip title={t('openFolder')}>
- <IconButton
+ {totalSize > 0 && (
+ <Tooltip title={t('totalRecordingSize')}>
+ <Chip
+ icon={<StorageIcon sx={{fontSize: '14px !important'}}/>}
+ label={formatBytes(totalSize)}
size="small"
- onClick={handleOpenFolder}
+ variant="outlined"
sx={{
- color: isDark ? '#ffcc80' : theme.palette.warning.dark,
- border: `1px solid ${isDark ? 'rgba(255,204,128,0.3)' : theme.palette.warning.light}`,
- borderRadius: '6px',
- px: 1,
- gap: 0.5,
- fontSize: '0.75rem',
fontFamily: monoFont,
- '&:hover': {
- backgroundColor: isDark ? 'rgba(255,204,128,0.1)' : 'rgba(255,152,0,0.08)',
- },
+ fontSize: '0.75rem',
+ height: 24,
+ borderColor: isDark ? 'rgba(255,255,255,0.15)' : undefined,
+ color: isDark ? '#b3b9c6' : theme.palette.text.secondary,
+ '& .MuiChip-icon': {color: 'inherit'},
}}
- >
- <FolderOpenIcon sx={{fontSize: 16}}/>
- </IconButton>
+ />
</Tooltip>
+ )}
- {/* Spacer */}
- <Box sx={{flex: 1}}/>
-
- {/* Stats chips */}
- <Tooltip title={t('cameraStreams')}>
+ {recordingFps != null && recordingFps > 0 && (
+ <Tooltip title={t('recordingCaptureFps')}>
<Chip
- icon={<VideocamIcon sx={{fontSize: '14px !important'}}/>}
- label={t('cameraCount', {count: loadedVideos.length})}
+ label={`rec: ${recordingFps} fps`}
size="small"
variant="outlined"
sx={{
fontFamily: monoFont,
fontSize: '0.75rem',
height: 24,
- borderColor: isDark ? 'rgba(41,182,246,0.3)' : undefined,
- color: isDark ? '#29b6f6' : theme.palette.info.main,
- '& .MuiChip-icon': {color: 'inherit'},
+ borderColor: isDark ? 'rgba(255,204,128,0.3)' : undefined,
+ color: isDark ? '#ffcc80' : theme.palette.warning.dark,
}}
/>
</Tooltip>
+ )}
+ </Box>
- {totalSize > 0 && (
- <Tooltip title={t('totalRecordingSize')}>
- <Chip
- icon={<StorageIcon sx={{fontSize: '14px !important'}}/>}
- label={formatBytes(totalSize)}
- size="small"
- variant="outlined"
- sx={{
- fontFamily: monoFont,
- fontSize: '0.75rem',
- height: 24,
- borderColor: isDark ? 'rgba(255,255,255,0.15)' : undefined,
- color: isDark ? '#b3b9c6' : theme.palette.text.secondary,
- '& .MuiChip-icon': {color: 'inherit'},
- }}
- />
- </Tooltip>
- )}
+ {/* Video + 3D viewport area */}
+ <Box sx={{ flex: 1, minHeight: 0, display: isBrowsing ? 'none' : 'flex', flexDirection: 'column' }}>
+ {settings.show3dView ? (
+ <PanelGroup
+ key={`main-panels-${resetKey}-${settings.layoutDirection}`}
+ direction={settings.layoutDirection}
+ >
+ <Panel defaultSize={60} minSize={20}>
+ <Box sx={{height: '100%', display: 'flex', flexDirection: 'column'}}>
+ <SyncedVideoPlayer
+ videos={videoEntries}
+ manualColumns={settings.columns}
+ resetKey={resetKey}
+ controller={controller}
+ />
+ </Box>
+ </Panel>
- {recordingFps != null && recordingFps > 0 && (
- <Tooltip title={t('recordingCaptureFps')}>
- <Chip
- label={`rec: ${recordingFps} fps`}
- size="small"
- variant="outlined"
+ <PanelResizeHandle>
+ <Box
sx={{
- fontFamily: monoFont,
- fontSize: '0.75rem',
- height: 24,
- borderColor: isDark ? 'rgba(255,204,128,0.3)' : undefined,
- color: isDark ? '#ffcc80' : theme.palette.warning.dark,
+ display: 'flex',
+ alignItems: 'center',
+ justifyContent: 'center',
+ backgroundColor: theme.palette.divider,
+ transition: 'background-color 0.15s ease',
+ cursor: isHorizontal ? 'col-resize' : 'row-resize',
+ ...(isHorizontal
+ ? {width: '6px', height: '100%', flexDirection: 'column'}
+ : {height: '6px', width: '100%', flexDirection: 'row'}
+ ),
+ '&:hover': {
+ backgroundColor: theme.palette.primary.main,
+ },
+ '&:active': {
+ backgroundColor: theme.palette.primary.dark,
+ },
}}
- />
- </Tooltip>
- )}
- </Box>
+ >
+ {[0, 1, 2].map((i) => (
+ <Box
+ key={i}
+ sx={{
+ width: 4,
+ height: 4,
+ borderRadius: '50%',
+ backgroundColor: theme.palette.text.disabled,
+ m: isHorizontal ? '2px 0' : '0 2px',
+ flexShrink: 0,
+ }}
+ />
+ ))}
+ </Box>
+ </PanelResizeHandle>
- {/* Player */}
- <Box sx={{flex: 1, minHeight: 0}}>
+ <Panel defaultSize={40} minSize={10}>
+ <Box sx={{height: '100%'}}>
+ <ThreeJsCanvas/>
+ </Box>
+ </Panel>
+ </PanelGroup>
+ ) : (
<SyncedVideoPlayer
- videos={loadedVideos.map((v) => ({
- videoId: v.videoId,
- filename: v.filename,
- streamUrl: v.streamUrl,
- }))}
- recordingFps={recordingFps}
- frameTimestamps={frameTimestamps}
- manualColumns={manualColumns}
+ videos={videoEntries}
+ manualColumns={settings.columns}
resetKey={resetKey}
- initialFrame={initState.currentFrame}
- onFrameChange={handleFrameChange}
+ controller={controller}
/>
- </Box>
+ )}
</Box>
- ) : (
- <RecordingBrowser onRecordingLoaded={handleRecordingLoaded} initialLoadPath={initialLoadPath}/>
- )}
+
+ {/* Recording Browser Area */}
+ {isBrowsing && (
+ <Box sx={{ flex: 1, minHeight: 0, display: 'flex', flexDirection: 'column' }}>
+ <RecordingBrowser
+ onRecordingLoaded={(videos, recPath, recFps) => {
+ ctx?.onRecordingLoaded(videos, recPath, recFps);
+ setIsBrowsing(false);
+ }}
+ initialLoadPath={ctx?.initialLoadPath}
+ />
+ </Box>
+ )}
+
+ {/* Playback controls β€” full width below video + 3D area */}
+ <PlaybackControls
+ isPlaying={controller.isPlaying}
+ currentTime={controller.currentTime}
+ duration={controller.duration}
+ playbackRate={controller.playbackRate}
+ currentFrame={controller.currentFrame}
+ totalFrames={controller.totalFrames}
+ fps={controller.fps}
+ recordingFps={recordingFps}
+ settings={controller.settings}
+ onSettingsChange={controller.setSettings}
+ onPlayPause={controller.handlePlayPause}
+ onSeekDrag={controller.handleSeekDrag}
+ onSeekCommit={controller.handleSeekCommit}
+ onFrameStep={controller.handleFrameStep}
+ onPlaybackRateChange={controller.handlePlaybackRateChange}
+ onSeekToStart={controller.handleSeekToStart}
+ onSeekToEnd={controller.handleSeekToEnd}
+ isLooping={controller.isLooping}
+ onToggleLoop={controller.handleToggleLoop}
+ />
+ </Box>
</ErrorBoundary>
</Box>
diff --git a/freemocap-ui/src/services/server/ServerContextProvider.tsx b/freemocap-ui/src/services/server/ServerContextProvider.tsx
index 24772053..7d686420 100644
--- a/freemocap-ui/src/services/server/ServerContextProvider.tsx
+++ b/freemocap-ui/src/services/server/ServerContextProvider.tsx
@@ -13,9 +13,12 @@ import {MediapipeObservation} from "@/services/server/server-helpers/image-overl
import {
isFramerateUpdate,
isFrontendPayload,
- isLogRecord
+ isLogRecord,
+ isPosthocProgress,
} from "@/services/server/server-helpers/websocket-message-types";
import {Point3d, RigidBodyPose} from "@/components/viewport3d";
+import {store} from "@/store";
+import {posthocProgressReceived} from "@/store/slices/mocap";
interface ServerContextValue {
isConnected: boolean;
@@ -308,6 +311,13 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childr
for (const cb of rigidBodiesSubscribersRef.current) cb(posesMap);
}
}
+ else if (isPosthocProgress(jsonData)) {
+ store.dispatch(posthocProgressReceived({
+ phase: jsonData.phase,
+ progress_fraction: jsonData.progress_fraction,
+ detail: jsonData.detail,
+ }));
+ }
} catch (error) {
console.error('Error parsing JSON message:', error);
}
diff --git a/freemocap-ui/src/services/server/server-helpers/websocket-message-types.ts b/freemocap-ui/src/services/server/server-helpers/websocket-message-types.ts
index 4505566c..af760189 100644
--- a/freemocap-ui/src/services/server/server-helpers/websocket-message-types.ts
+++ b/freemocap-ui/src/services/server/server-helpers/websocket-message-types.ts
@@ -65,3 +65,19 @@ export function isFrontendPayload(data: any): data is FrontendPayloadMessage {
data.frame_number && typeof data.frame_number === 'number'
);
}
+
+export interface PosthocProgressMessage {
+ message_type: 'posthoc_progress';
+ pipeline_id: string;
+ phase: string;
+ progress_fraction: number;
+ detail: string;
+}
+
+export function isPosthocProgress(data: unknown): data is PosthocProgressMessage {
+ return (
+ typeof data === 'object' &&
+ data !== null &&
+ (data as PosthocProgressMessage).message_type === 'posthoc_progress'
+ );
+}
diff --git a/freemocap-ui/src/store/slices/mocap/mocap-slice.ts b/freemocap-ui/src/store/slices/mocap/mocap-slice.ts
index 79884011..0f14d834 100644
--- a/freemocap-ui/src/store/slices/mocap/mocap-slice.ts
+++ b/freemocap-ui/src/store/slices/mocap/mocap-slice.ts
@@ -144,6 +144,8 @@ export interface MocapState {
directoryInfo: MocapDirectoryInfo | null;
/** User-specified calibration TOML path override. null = use most recent (default). */
calibrationTomlPath: string | null;
+ processingProgress: number;
+ processingPhase: string;
}
// ==================== Initial State ====================
@@ -161,6 +163,8 @@ const initialState: MocapState = {
manualMocapRecordingPath: null,
directoryInfo: null,
calibrationTomlPath: null,
+ processingProgress: 0,
+ processingPhase: '',
};
// ==================== Slice ====================
@@ -217,6 +221,14 @@ export const mocapSlice = createSlice({
state.calibrationTomlPath = null;
},
+ posthocProgressReceived: (state, action: PayloadAction<{phase: string; progress_fraction: number; detail: string}>) => {
+ state.processingPhase = action.payload.phase;
+ state.processingProgress = Math.round(action.payload.progress_fraction * 100);
+ if (action.payload.phase === 'complete' || action.payload.phase === 'failed') {
+ state.isLoading = false;
+ }
+ },
+
resetMocapState: () => initialState,
},
@@ -258,9 +270,12 @@ export const mocapSlice = createSlice({
.addCase(processMocapRecording.pending, (state) => {
state.isLoading = true;
state.error = null;
+ state.processingProgress = 0;
+ state.processingPhase = '';
})
.addCase(processMocapRecording.fulfilled, (state) => {
- state.isLoading = false;
+ // isLoading stays true β€” it will be reset by posthocProgressReceived
+ // when the pipeline emits 'complete' or 'failed' over WebSocket
})
.addCase(processMocapRecording.rejected, (state, action) => {
state.isLoading = false;
@@ -282,6 +297,8 @@ export const selectMocapProgress = (state: RootState) => state.mocap.recordingPr
export const selectMocapError = (state: RootState) => state.mocap.error;
export const selectMocapDirectoryInfo = (state: RootState) => state.mocap.directoryInfo;
export const selectCalibrationTomlPath = (state: RootState) => state.mocap.calibrationTomlPath;
+export const selectProcessingProgress = (state: RootState) => state.mocap.processingProgress;
+export const selectProcessingPhase = (state: RootState) => state.mocap.processingPhase;
export const selectMocapRecordingPath = createSelector(
[
@@ -341,6 +358,7 @@ export const {
mocapDirectoryInfoUpdated,
calibrationTomlPathChanged,
calibrationTomlPathCleared,
+ posthocProgressReceived,
resetMocapState
} = mocapSlice.actions;
diff --git a/freemocap-ui/src/store/slices/recording/recording-slice.ts b/freemocap-ui/src/store/slices/recording/recording-slice.ts
index 9a003c8a..86d7f6e9 100644
--- a/freemocap-ui/src/store/slices/recording/recording-slice.ts
+++ b/freemocap-ui/src/store/slices/recording/recording-slice.ts
@@ -173,11 +173,12 @@ export const recordingSlice = createSlice({
state.startedAt = new Date().toISOString();
state.duration = 0;
})
- .addCase(stopRecording.fulfilled, (state) => {
+ .addCase(stopRecording.fulfilled, (state, action) => {
state.isRecording = false;
state.recordingName = null;
state.startedAt = null;
state.duration = 0;
+ state.completionData = action.payload;
});
},
});
diff --git a/freemocap/api/http/blender/blender_router.py b/freemocap/api/http/blender/blender_router.py
index a91e3e3b..76bcb6b7 100644
--- a/freemocap/api/http/blender/blender_router.py
+++ b/freemocap/api/http/blender/blender_router.py
@@ -6,7 +6,7 @@ from fastapi import APIRouter, HTTPException
from pydantic import BaseModel, ConfigDict, Field
from freemocap.core.blender.export_to_blender import export_to_blender
-from freemocap.core.blender.helpers.freemocap_blender_addon_helpers.install_addon.install_blender_addon import \
+from freemocap.core.blender.helpers.install_blender_addon import \
install_freemocap_blender_addon
from freemocap.core.blender.helpers.get_best_guess_of_blender_path import get_best_guess_of_blender_path
from freemocap.system.default_paths import FREEMOCAP_TEST_DATA_PATH
diff --git a/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/__init__.py b/freemocap/api/http/playback/__init__.py
similarity index 100%
rename from freemocap/core/blender/helpers/freemocap_blender_addon_helpers/__init__.py
rename to freemocap/api/http/playback/__init__.py
diff --git a/freemocap/api/http/playback/playback_router.py b/freemocap/api/http/playback/playback_router.py
new file mode 100644
index 00000000..86e3ea81
--- /dev/null
+++ b/freemocap/api/http/playback/playback_router.py
@@ -0,0 +1,493 @@
+"""
+Playback router: serves pre-recorded video files over HTTP for browser-native
+<video> playback. Supports range requests for efficient seeking.
+
+Endpoints are keyed on {recording_id} (the recording folder name). The full
+recording path is resolved as {BASE_RECORDINGS_DIRECTORY}/{recording_id},
+with an optional `recording_parent_directory` query param to override the base.
+
+Endpoints:
+ GET /playback/recordings β€” list available recordings
+ GET /playback/{recording_id}/videos β€” list videos in a recording
+ GET /playback/{recording_id}/videos/{video_id} β€” stream a video file
+ GET /playback/{recording_id}/timestamps β€” timestamps for all videos
+ GET /playback/{recording_id}/videos/{video_id}/timestamps β€” timestamps for one video
+"""
+import csv
+import logging
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+from freemocap.system.default_paths import get_default_freemocap_recordings_path
+
+_VIEWER_HTML = Path(__file__).parent.parent.parent.parent / "core" / "viz" / "parquet_viewer.html"
+
+logger = logging.getLogger(__name__)
+
+playback_router = APIRouter(prefix="/playback", tags=["Playback"])
+
+VIDEO_EXTENSIONS = {".mp4", ".avi", ".mov", ".mkv", ".webm"}
+TIMESTAMP_EXTENSIONS = {".csv"}
+
+
+# ---------------------------------------------------------------------------
+# Response models
+# ---------------------------------------------------------------------------
+
+class VideoInfo(BaseModel):
+ video_id: str
+ filename: str
+ size_bytes: int
+ stream_url: str
+
+
+class RecordingListEntry(BaseModel):
+ name: str
+ path: str
+ video_count: int
+ total_size_bytes: int = 0
+ created_timestamp: Optional[str] = None
+ total_frames: Optional[int] = None
+ duration_seconds: Optional[float] = None
+ fps: Optional[float] = None
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _resolve_recording_path(
+ recording_id: str,
+ recording_parent_directory: str | None = None,
+) -> Path:
+ """Resolve the full recording path from recording_id + optional parent dir.
+
+ Raises HTTPException(404) if the directory does not exist.
+ Raises HTTPException(400) for path traversal attempts.
+ """
+ parent = (
+ Path(recording_parent_directory)
+ if recording_parent_directory
+ else Path(get_default_freemocap_recordings_path())
+ )
+ parent = parent.expanduser().resolve()
+ recording_path = (parent / recording_id).resolve()
+
+ # Path traversal guard
+ if not str(recording_path).startswith(str(parent)):
+ raise HTTPException(status_code=400, detail="Invalid recording_id")
+
+ if not recording_path.is_dir():
+ raise HTTPException(
+ status_code=404,
+ detail=f"Recording directory not found: {recording_path}",
+ )
+ return recording_path
+
+
+def _discover_videos(folder: Path) -> dict[str, Path]:
+ """Find video files in a folder, keyed by a stable ID derived from the filename stem."""
+ videos: dict[str, Path] = {}
+ if not folder.is_dir():
+ raise FileNotFoundError(f"Not a directory: {folder}")
+
+ for p in sorted(folder.iterdir()):
+ if p.is_file() and p.suffix.lower() in VIDEO_EXTENSIONS:
+ video_id = p.stem
+ videos[video_id] = p
+ return videos
+
+
+def _find_video_folder(recording_path: Path) -> Path:
+ """Resolve the actual folder containing video files.
+
+ Looks for a synchronized_videos/ subfolder first, then falls back to
+ videos directly in the recording root.
+ """
+ synced = recording_path / "synchronized_videos"
+ if synced.is_dir():
+ if any(p.suffix.lower() in VIDEO_EXTENSIONS for p in synced.iterdir() if p.is_file()):
+ return synced
+
+ if any(p.suffix.lower() in VIDEO_EXTENSIONS for p in recording_path.iterdir() if p.is_file()):
+ return recording_path
+
+ raise FileNotFoundError(
+ f"No video files found in {recording_path} or {recording_path}/synchronized_videos/"
+ )
+
+
+def _get_total_size(video_folder: Path) -> int:
+ """Sum of all video file sizes in a folder."""
+ total = 0
+ for p in video_folder.iterdir():
+ if p.is_file() and p.suffix.lower() in VIDEO_EXTENSIONS:
+ try:
+ total += p.stat().st_size
+ except OSError:
+ pass
+ return total
+
+
+def _get_recording_stats(recording_path: Path, video_folder: Path) -> dict:
+ """Try to extract frame count, duration, and fps from timestamp CSV files."""
+ stats: dict = {
+ "total_frames": None,
+ "duration_seconds": None,
+ "fps": None,
+ }
+
+ # Look for timestamp CSV files in various locations
+ timestamp_dirs = [
+ recording_path / "synchronized_videos" / "timestamps" / "camera_timestamps",
+ recording_path / "synchronized_videos" / "timestamps",
+ recording_path / "timestamps",
+ video_folder,
+ ]
+
+ for ts_dir in timestamp_dirs:
+ if not ts_dir.is_dir():
+ continue
+ for ts_file in sorted(ts_dir.iterdir()):
+ if ts_file.suffix.lower() != ".csv":
+ continue
+ try:
+ with open(ts_file, "r", newline="") as f:
+ reader = csv.reader(f)
+ header = next(reader, None)
+ if header is None:
+ continue
+ rows = list(reader)
+ if len(rows) < 2:
+ continue
+
+ frame_count = len(rows)
+ stats["total_frames"] = frame_count
+
+ # Try to get timestamps for duration/fps calculation
+ timestamp_col = None
+ for i, col_name in enumerate(header):
+ col_lower = col_name.strip().lower()
+ if any(kw in col_lower for kw in ["timestamp", "time", "elapsed", "seconds"]):
+ timestamp_col = i
+ break
+
+ if timestamp_col is not None and len(rows) >= 2:
+ try:
+ first_ts = float(rows[0][timestamp_col])
+ last_ts = float(rows[-1][timestamp_col])
+ duration = abs(last_ts - first_ts)
+
+ # If duration seems to be in nanoseconds or milliseconds, convert
+ if duration > 1e15: # nanoseconds
+ duration /= 1e9
+ elif duration > 1e6: # milliseconds
+ duration /= 1e3
+
+ if duration > 0:
+ stats["duration_seconds"] = round(duration, 2)
+ stats["fps"] = round(frame_count / duration, 1)
+ except (ValueError, IndexError):
+ pass
+
+ # Found a timestamp file β€” use it and stop
+ return stats
+ except (OSError, csv.Error):
+ continue
+
+ return stats
+
+
+def _get_created_timestamp(recording_path: Path) -> str | None:
+ """Try to determine the recording creation time from folder name or file metadata."""
+ try:
+ stat = recording_path.stat()
+ from datetime import datetime
+ created = datetime.fromtimestamp(stat.st_mtime)
+ return created.isoformat(timespec="seconds")
+ except OSError:
+ return None
+
+
+def _read_timestamp_values_for_video(recording_path: Path, video_id: str) -> list[float] | None:
+ """Read the timestamp CSV for a video and return the list of float timestamps.
+
+ Returns None if no matching CSV can be found or parsed.
+ """
+ timestamp_dirs = [
+ recording_path / "synchronized_videos" / "timestamps" / "camera_timestamps",
+ recording_path / "synchronized_videos" / "timestamps",
+ recording_path / "timestamps",
+ ]
+
+ for ts_dir in timestamp_dirs:
+ if not ts_dir.is_dir():
+ continue
+ for ts_file in ts_dir.iterdir():
+ if ts_file.suffix.lower() != ".csv" or video_id not in ts_file.stem:
+ continue
+ try:
+ with open(ts_file, "r", newline="") as f:
+ reader = csv.reader(f)
+ header = next(reader, None)
+ if header is None:
+ continue
+ rows = list(reader)
+ if len(rows) < 2:
+ continue
+
+ # Find the timestamp column
+ timestamp_col: int | None = None
+ for i, col_name in enumerate(header):
+ col_lower = col_name.strip().lower()
+ if any(kw in col_lower for kw in ["timestamp", "time", "elapsed", "seconds"]):
+ timestamp_col = i
+ break
+
+ if timestamp_col is None:
+ continue
+
+ values: list[float] = []
+ for row in rows:
+ values.append(float(row[timestamp_col]))
+ return values
+ except (OSError, csv.Error, ValueError, IndexError):
+ continue
+
+ return None
+
+
+# ---------------------------------------------------------------------------
+# Endpoints
+# ---------------------------------------------------------------------------
+
+@playback_router.get("/viewer", summary="Parquet skeleton viewer (HTML)", include_in_schema=False)
+def parquet_viewer() -> FileResponse:
+ if not _VIEWER_HTML.is_file():
+ raise HTTPException(status_code=404, detail=f"Viewer HTML not found: {_VIEWER_HTML}")
+ return FileResponse(str(_VIEWER_HTML), media_type="text/html")
+
+
+@playback_router.get("/parquet", summary="Serve a parquet file by absolute path", include_in_schema=False)
+def serve_parquet(
+ path: str = Query(..., description="Absolute path to the .parquet file"),
+) -> FileResponse:
+ p = Path(path).expanduser().resolve()
+ if not p.is_file() or p.suffix.lower() != ".parquet":
+ raise HTTPException(status_code=404, detail=f"Parquet file not found: {p}")
+ return FileResponse(str(p), media_type="application/octet-stream", filename=p.name)
+
+
+@playback_router.get("/recordings", summary="List available recordings")
+def list_recordings(
+ recording_parent_directory: str | None = Query(
+ default=None,
+ description="Override the default recordings directory",
+ ),
+) -> list[RecordingListEntry]:
+ recordings_dir = (
+ Path(recording_parent_directory).expanduser().resolve()
+ if recording_parent_directory
+ else Path(get_default_freemocap_recordings_path())
+ )
+ if not recordings_dir.is_dir():
+ return []
+
+ entries: list[RecordingListEntry] = []
+ for child in sorted(recordings_dir.iterdir(), reverse=True): # newest first by name
+ if not child.is_dir():
+ continue
+ try:
+ video_folder = _find_video_folder(child)
+ video_count = sum(
+ 1 for p in video_folder.iterdir()
+ if p.is_file() and p.suffix.lower() in VIDEO_EXTENSIONS
+ )
+ if video_count > 0:
+ total_size = _get_total_size(video_folder)
+ created_ts = _get_created_timestamp(child)
+ stats = _get_recording_stats(child, video_folder)
+
+ entries.append(RecordingListEntry(
+ name=child.name,
+ path=str(child),
+ video_count=video_count,
+ total_size_bytes=total_size,
+ created_timestamp=created_ts,
+ total_frames=stats.get("total_frames"),
+ duration_seconds=stats.get("duration_seconds"),
+ fps=stats.get("fps"),
+ ))
+ except (FileNotFoundError, PermissionError):
+ continue
+
+ return entries
+
+
+@playback_router.get(
+ "/{recording_id}/videos",
+ summary="List videos in a recording",
+)
+def list_videos(
+ recording_id: str,
+ recording_parent_directory: str | None = Query(
+ default=None,
+ description="Override the default recordings directory",
+ ),
+) -> list[VideoInfo]:
+ recording_path = _resolve_recording_path(recording_id, recording_parent_directory)
+
+ try:
+ video_folder = _find_video_folder(recording_path)
+ except FileNotFoundError as e:
+ raise HTTPException(status_code=404, detail=str(e))
+
+ videos = _discover_videos(video_folder)
+ if not videos:
+ raise HTTPException(status_code=404, detail=f"No video files found in {video_folder}")
+
+ logger.info(f"Discovered {len(videos)} videos in recording '{recording_id}'")
+ return [
+ VideoInfo(
+ video_id=vid_id,
+ filename=path.name,
+ size_bytes=path.stat().st_size,
+ stream_url=f"/freemocap/playback/{recording_id}/videos/{vid_id}",
+ )
+ for vid_id, path in videos.items()
+ ]
+
+
+@playback_router.get(
+ "/{recording_id}/videos/{video_id}",
+ summary="Stream a video file (supports HTTP range requests for seeking)",
+)
+def stream_video(
+ recording_id: str,
+ video_id: str,
+ recording_parent_directory: str | None = Query(
+ default=None,
+ description="Override the default recordings directory",
+ ),
+) -> FileResponse:
+ recording_path = _resolve_recording_path(recording_id, recording_parent_directory)
+
+ try:
+ video_folder = _find_video_folder(recording_path)
+ except FileNotFoundError as e:
+ raise HTTPException(status_code=404, detail=str(e))
+
+ videos = _discover_videos(video_folder)
+ if video_id not in videos:
+ raise HTTPException(status_code=404, detail=f"Video '{video_id}' not found in recording '{recording_id}'")
+
+ video_path = videos[video_id]
+ if not video_path.is_file():
+ raise HTTPException(status_code=404, detail=f"Video file no longer exists: {video_path}")
+
+ suffix = video_path.suffix.lower()
+ media_types = {
+ ".mp4": "video/mp4",
+ ".webm": "video/webm",
+ ".avi": "video/x-msvideo",
+ ".mov": "video/quicktime",
+ ".mkv": "video/x-matroska",
+ }
+ media_type = media_types.get(suffix, "application/octet-stream")
+
+ return FileResponse(
+ path=str(video_path),
+ media_type=media_type,
+ filename=video_path.name,
+ )
+
+
+@playback_router.get(
+ "/{recording_id}/timestamps",
+ summary="Get timestamps for all videos in a recording",
+)
+def get_all_timestamps(
+ recording_id: str,
+ recording_parent_directory: str | None = Query(
+ default=None,
+ description="Override the default recordings directory",
+ ),
+) -> dict:
+ """Return frame timestamps for every video in the recording.
+
+ Response shape: {"timestamps": {"<video_id>": [t0, t1, ...], ...}, "warnings": [...]}
+ Videos without discoverable timestamp CSVs produce a warning instead of an error.
+ """
+ recording_path = _resolve_recording_path(recording_id, recording_parent_directory)
+
+ try:
+ video_folder = _find_video_folder(recording_path)
+ except FileNotFoundError as e:
+ raise HTTPException(status_code=404, detail=str(e))
+
+ videos = _discover_videos(video_folder)
+ all_timestamps: dict[str, list[float]] = {}
+ warnings: list[str] = []
+
+ for vid_id in videos:
+ ts_values = _read_timestamp_values_for_video(recording_path, video_id=vid_id)
+ if ts_values is not None:
+ all_timestamps[vid_id] = ts_values
+ else:
+ warnings.append(f"No timestamp data found for video '{vid_id}'")
+
+ return {"timestamps": all_timestamps, "warnings": warnings}
+
+
+@playback_router.get(
+ "/{recording_id}/videos/{video_id}/timestamps",
+ summary="Get timestamp data for a specific video in a recording",
+)
+def get_video_timestamps(
+ recording_id: str,
+ video_id: str,
+ recording_parent_directory: str | None = Query(
+ default=None,
+ description="Override the default recordings directory",
+ ),
+) -> dict:
+ """Return timestamp CSV info for a specific video.
+
+ Returns a warning instead of 404 when timestamps are not found,
+ since not all recordings have timestamp data.
+ """
+ recording_path = _resolve_recording_path(recording_id, recording_parent_directory)
+
+ timestamp_dirs = [
+ recording_path / "synchronized_videos" / "timestamps" / "camera_timestamps",
+ recording_path / "synchronized_videos" / "timestamps",
+ recording_path / "timestamps",
+ ]
+
+ for ts_dir in timestamp_dirs:
+ if not ts_dir.is_dir():
+ continue
+ for ts_file in ts_dir.iterdir():
+ if ts_file.suffix.lower() == ".csv" and video_id in ts_file.stem:
+ lines = ts_file.read_text().strip().split("\n")
+ if len(lines) < 2:
+ continue
+ headers = lines[0].split(",")
+ rows = [line.split(",") for line in lines[1:]]
+ return {
+ "video_id": video_id,
+ "headers": headers,
+ "row_count": len(rows),
+ "file": ts_file.name,
+ }
+
+ return {
+ "video_id": video_id,
+ "warning": f"No timestamp data found for video '{video_id}'",
+ "headers": [],
+ "row_count": 0,
+ }
diff --git a/freemocap/api/routers.py b/freemocap/api/routers.py
index 6a95880b..1f312b92 100644
--- a/freemocap/api/routers.py
+++ b/freemocap/api/routers.py
@@ -1,5 +1,5 @@
from skellycam.api.http.cameras.camera_router import camera_router
-from skellycam.api.http.playback.playback_router import playback_router
+from freemocap.api.http.playback.playback_router import playback_router
from freemocap.api.http.app.health import health_router
from freemocap.api.http.app.shutdown import shutdown_router
@@ -13,11 +13,11 @@ APP_ROUTERS = [health_router,
SKELLYCAM_ROUTERS = [
camera_router,
- playback_router
]
FREEMOCAP_ROUTERS = [realtime_router,
calibration_router,
mocap_router,
blender_router,
+ playback_router
]
diff --git a/freemocap/api/websocket/websocket_server.py b/freemocap/api/websocket/websocket_server.py
index a456bd7e..75476737 100644
--- a/freemocap/api/websocket/websocket_server.py
+++ b/freemocap/api/websocket/websocket_server.py
@@ -88,6 +88,10 @@ class WebsocketServer:
self._logs_relay(),
name="WebsocketLogsRelay",
),
+ asyncio.create_task(
+ self._posthoc_progress_relay(),
+ name="WebsocketPosthocProgressRelay",
+ ),
asyncio.create_task(
self._client_message_handler(),
name="WebsocketClientMessageHandler",
@@ -187,6 +191,38 @@ class WebsocketServer:
self._websocket_should_continue = False
raise
+ async def _posthoc_progress_relay(self) -> None:
+ logger.info("Starting posthoc progress relay...")
+ progress_queue = self._app.posthoc_pipeline_manager.shared_progress_queue
+ try:
+ while self.should_continue:
+ if not progress_queue.empty() and self.websocket.client_state == WebSocketState.CONNECTED:
+ try:
+ msg = progress_queue.get_nowait()
+ except Exception:
+ continue
+ payload = {
+ "message_type": "posthoc_progress",
+ "pipeline_id": msg.pipeline_id,
+ "phase": msg.phase,
+ "progress_fraction": msg.progress_fraction,
+ "detail": msg.detail,
+ }
+ async with self._send_lock:
+ await self.websocket.send_json(payload)
+ else:
+ await await_10ms()
+ except asyncio.CancelledError:
+ logger.debug("Posthoc progress relay task cancelled")
+ except WebSocketDisconnect:
+ logger.info("Client disconnected, ending posthoc progress relay task...")
+ except Exception as e:
+ logger.exception(
+ f"Error in posthoc progress relay: {e.__class__.__name__}: {e}"
+ )
+ self._websocket_should_continue = False
+ raise
+
async def _client_message_handler(self):
"""Handle messages from the client, including settings messages."""
logger.info("Starting client message handler...")
diff --git a/freemocap/core/blender/export_to_blender.py b/freemocap/core/blender/export_to_blender.py
index 156d72a9..cce3852b 100644
--- a/freemocap/core/blender/export_to_blender.py
+++ b/freemocap/core/blender/export_to_blender.py
@@ -6,7 +6,7 @@ from typing import Union, List
import freemocap_blender_addon
-from freemocap.core.blender.helpers.freemocap_blender_addon_helpers.run_simple import run_simple
+from freemocap.core.blender.helpers.run_blender_export import run_blender_export
from freemocap.core.blender.helpers.get_best_guess_of_blender_path import get_best_guess_of_blender_path
from freemocap.utilities.open_file import open_file
@@ -66,7 +66,7 @@ def export_to_blender(
site_packages_path = str(addon_package_path.parent.parent)
logger.debug(f"Will inject site-packages path into Blender's sys.path: {site_packages_path}")
- simple_run_script = inspect.getfile(run_simple)
+ simple_run_script = inspect.getfile(run_blender_export)
command_list = [
str(blender_exe_path),
diff --git a/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/install_addon/bpy_install_addon.py b/freemocap/core/blender/helpers/bpy_install_addon.py
similarity index 100%
rename from freemocap/core/blender/helpers/freemocap_blender_addon_helpers/install_addon/bpy_install_addon.py
rename to freemocap/core/blender/helpers/bpy_install_addon.py
diff --git a/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/install_addon/__init__.py b/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/install_addon/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/get_numpy_path.py b/freemocap/core/blender/helpers/get_numpy_path.py
similarity index 100%
rename from freemocap/core/blender/helpers/freemocap_blender_addon_helpers/get_numpy_path.py
rename to freemocap/core/blender/helpers/get_numpy_path.py
diff --git a/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/install_addon/install_blender_addon.py b/freemocap/core/blender/helpers/install_blender_addon.py
similarity index 93%
rename from freemocap/core/blender/helpers/freemocap_blender_addon_helpers/install_addon/install_blender_addon.py
rename to freemocap/core/blender/helpers/install_blender_addon.py
index abcbe7fc..e2cea551 100644
--- a/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/install_addon/install_blender_addon.py
+++ b/freemocap/core/blender/helpers/install_blender_addon.py
@@ -5,7 +5,7 @@ from pathlib import Path
from freemocap_blender_addon.main import ajc27_run_as_main_function
-from freemocap.core.blender.helpers.freemocap_blender_addon_helpers.install_addon.bpy_install_addon import \
+from freemocap.core.blender.helpers.bpy_install_addon import \
INSTALL_ADDON_SCRIPT_PATH
from freemocap.core.blender.helpers.get_best_guess_of_blender_path import get_best_guess_of_blender_path
diff --git a/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/run_simple.py b/freemocap/core/blender/helpers/run_blender_export.py
similarity index 71%
rename from freemocap/core/blender/helpers/freemocap_blender_addon_helpers/run_simple.py
rename to freemocap/core/blender/helpers/run_blender_export.py
index c89c5c04..c3d50ed0 100644
--- a/freemocap/core/blender/helpers/freemocap_blender_addon_helpers/run_simple.py
+++ b/freemocap/core/blender/helpers/run_blender_export.py
@@ -1,7 +1,7 @@
import sys
-def run_simple(site_packages_path: str, recording_path_input: str, blender_file_save_path_input: str):
+def run_blender_export(site_packages_path: str, recording_path_input: str, blender_file_save_path_input: str):
# Inject the freemocap venv's site-packages so freemocap_blender_addon is importable
# without needing to install the addon into Blender
if site_packages_path not in sys.path:
@@ -21,8 +21,8 @@ if __name__ == "__main__":
site_packages_path_input = str(argv[0])
recording_path_input = str(argv[1])
blender_file_save_path_input = str(argv[2])
- run_simple(site_packages_path=site_packages_path_input,
- recording_path_input=recording_path_input,
- blender_file_save_path_input=blender_file_save_path_input)
+ run_blender_export(site_packages_path=site_packages_path_input,
+ recording_path_input=recording_path_input,
+ blender_file_save_path_input=blender_file_save_path_input)
print("\nDone!\n")
diff --git a/freemocap/core/pipeline/posthoc/posthoc_aggregation_node.py b/freemocap/core/pipeline/posthoc/posthoc_aggregation_node.py
index 44cd1637..e90a259e 100644
--- a/freemocap/core/pipeline/posthoc/posthoc_aggregation_node.py
+++ b/freemocap/core/pipeline/posthoc/posthoc_aggregation_node.py
@@ -21,6 +21,7 @@ import logging
import multiprocessing
from collections.abc import Callable
from dataclasses import dataclass
+from typing import Optional
from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry
from skellycam.core.recorders.videos.recording_info import RecordingInfo
@@ -34,6 +35,7 @@ from freemocap.pubsub.pubsub_manager import PubSubTopicManager
from freemocap.pubsub.pubsub_topics import (
VideoNodeOutputMessage,
VideoNodeOutputTopic,
+ PosthocProgressMessage,
)
from freemocap.utilities.wait_functions import wait_1ms
@@ -56,6 +58,7 @@ class PosthocAggregationNode(AggregatorNode):
worker_registry: WorkerRegistry,
ipc: PipelineIPC,
pubsub: PubSubTopicManager,
+ progress_pub: Optional[multiprocessing.Queue] = None,
) -> "PosthocAggregationNode":
shutdown_self_flag, worker = cls._create_worker(
target=cls._run,
@@ -71,6 +74,7 @@ class PosthocAggregationNode(AggregatorNode):
video_node_output_subscription=pubsub.get_subscription(
VideoNodeOutputTopic,
),
+ progress_pub=progress_pub,
),
)
return cls(
@@ -88,7 +92,16 @@ class PosthocAggregationNode(AggregatorNode):
ipc: PipelineIPC,
shutdown_self_flag: multiprocessing.Value,
video_node_output_subscription: TopicSubscriptionQueue,
+ progress_pub: Optional[multiprocessing.Queue] = None,
) -> None:
+ def _emit_progress(phase: str, progress_fraction: float, detail: str = "") -> None:
+ if progress_pub is not None:
+ progress_pub.put(PosthocProgressMessage(
+ pipeline_id=pipeline_id,
+ phase=phase,
+ progress_fraction=progress_fraction,
+ detail=detail,
+ ))
start_frames = set(vm.start_frame for vm in video_metadata.values())
end_frames = set(vm.end_frame for vm in video_metadata.values())
if len(start_frames) != 1 or len(end_frames) != 1:
@@ -107,6 +120,7 @@ class PosthocAggregationNode(AggregatorNode):
f"expecting {len(frame_numbers)} frames Γ— {len(video_ids)} videos "
f"= {total_expected} outputs"
)
+ _emit_progress("collecting_frames", 0.0, f"Collecting {total_expected} observations from {len(video_ids)} videos")
video_outputs_by_frame: dict[FrameNumberInt, dict[VideoIdString, VideoNodeOutputMessage | None]] = {
frame_number: {vid: None for vid in video_ids}
@@ -156,7 +170,7 @@ class PosthocAggregationNode(AggregatorNode):
)
logger.info(f"PosthocAggregationNode [{pipeline_id}] β€” all frames collected")
-
+ _emit_progress("all_frames_collected", 1.0, f"All {total_expected} observations collected")
observations_by_frame: list[dict[VideoIdString, object]] = []
for frame_number in frame_numbers:
@@ -174,15 +188,18 @@ class PosthocAggregationNode(AggregatorNode):
frame_observations=observations_by_frame,
recording_info=recording_info,
video_metadata=video_metadata,
+ report_progress=_emit_progress,
)
logger.info(f"PosthocAggregationNode [{pipeline_id}] β€” task completed")
+ _emit_progress("complete", 1.0, "Pipeline complete")
except Exception as e:
logger.error(
f"Exception in PosthocAggregationNode [{pipeline_id}]: {e}",
exc_info=True,
)
+ _emit_progress("failed", 0.0, str(e))
ipc.shutdown_pipeline()
raise
finally:
diff --git a/freemocap/core/pipeline/posthoc/posthoc_pipeline.py b/freemocap/core/pipeline/posthoc/posthoc_pipeline.py
index 04b5fe72..a3256f3a 100644
--- a/freemocap/core/pipeline/posthoc/posthoc_pipeline.py
+++ b/freemocap/core/pipeline/posthoc/posthoc_pipeline.py
@@ -14,6 +14,7 @@ import multiprocessing
import uuid
from dataclasses import dataclass
from pathlib import Path
+from typing import Optional
from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry
from skellycam.core.recorders.videos.recording_info import RecordingInfo
@@ -69,6 +70,7 @@ class PosthocPipeline(PipelineABC):
worker_registry: WorkerRegistry,
global_kill_flag: multiprocessing.Value,
save_annotated_video: bool = True,
+ progress_pub: Optional[multiprocessing.Queue] = None,
) -> "PosthocPipeline":
"""
Create a posthoc pipeline.
@@ -103,6 +105,8 @@ class PosthocPipeline(PipelineABC):
video_nodes: dict[VideoIdString, VideoNode] = {}
for video_id, video_helper in video_group.videos.items():
+ vm = video_group.video_metadata_by_id[video_id]
+ total_frame_count = vm.end_frame - vm.start_frame
video_nodes[video_id] = VideoNode.create(
video_id=video_id,
video_path=video_helper.video_path,
@@ -112,6 +116,9 @@ class PosthocPipeline(PipelineABC):
pubsub=pubsub,
recording_path=recording_path,
save_annotated_video=save_annotated_video,
+ pipeline_id=pipeline_id,
+ total_frame_count=total_frame_count,
+ progress_pub=progress_pub,
)
aggregation_node = PosthocAggregationNode.create(
@@ -122,6 +129,7 @@ class PosthocPipeline(PipelineABC):
worker_registry=worker_registry,
ipc=ipc,
pubsub=pubsub,
+ progress_pub=progress_pub,
)
video_group.close()
diff --git a/freemocap/core/pipeline/posthoc/posthoc_pipeline_manager.py b/freemocap/core/pipeline/posthoc/posthoc_pipeline_manager.py
index ae051d5f..ee245809 100644
--- a/freemocap/core/pipeline/posthoc/posthoc_pipeline_manager.py
+++ b/freemocap/core/pipeline/posthoc/posthoc_pipeline_manager.py
@@ -41,6 +41,7 @@ class PosthocPipelineManager(PipelineManagerABC):
worker_registry: WorkerRegistry
lock: multiprocessing.Lock = field(default_factory=multiprocessing.Lock)
pipelines: dict[PipelineIdString, PosthocPipeline] = field(default_factory=dict)
+ shared_progress_queue: multiprocessing.Queue = field(default_factory=multiprocessing.Queue)
# ------------------------------------------------------------------
# Lazy cleanup
@@ -95,6 +96,7 @@ class PosthocPipelineManager(PipelineManagerABC):
aggregation_task_fn=calibration_aggregation_task_fn,
worker_registry=self.worker_registry,
global_kill_flag=self.global_kill_flag,
+ progress_pub=self.shared_progress_queue,
)
pipeline.start()
with self.lock:
@@ -123,6 +125,7 @@ class PosthocPipelineManager(PipelineManagerABC):
aggregation_task_fn=mocap_task_fn,
worker_registry=self.worker_registry,
global_kill_flag=self.global_kill_flag,
+ progress_pub=self.shared_progress_queue,
)
if start_pipeline:
pipeline.start()
diff --git a/freemocap/core/pipeline/posthoc/video_node.py b/freemocap/core/pipeline/posthoc/video_node.py
index f9172449..a476983d 100644
--- a/freemocap/core/pipeline/posthoc/video_node.py
+++ b/freemocap/core/pipeline/posthoc/video_node.py
@@ -13,6 +13,7 @@ import logging
import multiprocessing
from dataclasses import dataclass
from pathlib import Path
+from typing import Optional
import cv2
from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry
@@ -21,9 +22,9 @@ from skellytracker.trackers.base_tracker.helpers import create_detector_from_con
from freemocap.core.pipeline.abcs.pipeline_ipc import PipelineIPC
from freemocap.core.pipeline.abcs.source_node_abc import SourceNode
-from freemocap.core.types.type_overloads import VideoIdString, TopicPublicationQueue
+from freemocap.core.types.type_overloads import VideoIdString, TopicPublicationQueue, PipelineIdString
from freemocap.pubsub.pubsub_manager import PubSubTopicManager
-from freemocap.pubsub.pubsub_topics import VideoNodeOutputTopic, VideoNodeOutputMessage
+from freemocap.pubsub.pubsub_topics import VideoNodeOutputTopic, VideoNodeOutputMessage, PosthocProgressMessage
logger = logging.getLogger(__name__)
@@ -47,6 +48,9 @@ class VideoNode(SourceNode):
pubsub: PubSubTopicManager,
recording_path: Path,
save_annotated_video: bool = True,
+ pipeline_id: PipelineIdString | None = None,
+ total_frame_count: int = 0,
+ progress_pub: Optional[multiprocessing.Queue] = None,
) -> "VideoNode":
shutdown_self_flag, worker = cls._create_worker(
target=cls._run,
@@ -63,6 +67,9 @@ class VideoNode(SourceNode):
),
recording_path=recording_path,
save_annotated_video=save_annotated_video,
+ pipeline_id=pipeline_id,
+ total_frame_count=total_frame_count,
+ progress_pub=progress_pub,
),
)
return cls(
@@ -121,6 +128,9 @@ class VideoNode(SourceNode):
shutdown_self_flag: multiprocessing.Value,
recording_path: Path,
save_annotated_video: bool,
+ pipeline_id: PipelineIdString | None = None,
+ total_frame_count: int = 0,
+ progress_pub: Optional[multiprocessing.Queue] = None,
) -> None:
detector = create_detector_from_config(detector_config)
video_reader = cv2.VideoCapture(str(video_path), cv2.CAP_FFMPEG)
@@ -168,6 +178,8 @@ class VideoNode(SourceNode):
f"{' (with annotation)' if save_annotated_video else ''}"
)
frame_number: int = 0
+ _PROGRESS_THRESHOLD = 0.05
+ last_reported_fraction: float = -1.0
try:
success, image = video_reader.read()
while success and not shutdown_self_flag.value and ipc.should_continue:
@@ -183,6 +195,17 @@ class VideoNode(SourceNode):
),
)
+ if progress_pub is not None and pipeline_id is not None and total_frame_count > 0:
+ fraction = frame_number / total_frame_count
+ if fraction - last_reported_fraction >= _PROGRESS_THRESHOLD:
+ progress_pub.put(PosthocProgressMessage(
+ pipeline_id=pipeline_id,
+ phase="detecting_frames",
+ progress_fraction=min(fraction, 1.0),
+ detail=f"{video_path.stem}: frame {frame_number}/{total_frame_count}",
+ ))
+ last_reported_fraction = fraction
+
# Annotate and write frame if enabled
if annotator is not None and video_writer is not None:
# Use previous annotated frame as base if available, else source frame
diff --git a/freemocap/core/tasks/calibration/posthoc_calibration_task.py b/freemocap/core/tasks/calibration/posthoc_calibration_task.py
index 553a26f5..0460fa0e 100644
--- a/freemocap/core/tasks/calibration/posthoc_calibration_task.py
+++ b/freemocap/core/tasks/calibration/posthoc_calibration_task.py
@@ -14,6 +14,7 @@ Pre-bind task_config via functools.partial when creating the pipeline.
import json
import logging
+from collections.abc import Callable
from pathlib import Path
import numpy as np
@@ -221,6 +222,7 @@ def run_posthoc_calibration_task(
recording_info: RecordingInfo,
video_metadata: dict[VideoIdString, VideoMetadata],
task_config: PosthocCalibrationPipelineConfig,
+ report_progress: Callable[[str, float], None] | None = None,
) -> None:
"""Run posthoc calibration on collected charuco observations.
diff --git a/uv.lock b/uv.lock
index f84ddd0a..98562b34 100644
--- a/uv.lock
+++ b/uv.lock
@@ -122,16 +122,16 @@ wheels = [
[[package]]
name = "build"
-version = "1.4.2"
+version = "1.4.3"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "colorama", marker = "(os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },
{ name = "packaging" },
{ name = "pyproject-hooks" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/6c/1d/ab15c8ac57f4ee8778d7633bc6685f808ab414437b8644f555389cdc875e/build-1.4.2.tar.gz", hash = "sha256:35b14e1ee329c186d3f08466003521ed7685ec15ecffc07e68d706090bf161d1", size = 83433, upload-time = "2026-03-25T14:20:27.659Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3f/16/4b272700dea44c1d2e8ca963ebb3c684efe22b3eba8cfa31c5fdb60de707/build-1.4.3.tar.gz", hash = "sha256:5aa4231ae0e807efdf1fd0623e07366eca2ab215921345a2e38acdd5d0fa0a74", size = 89314, upload-time = "2026-04-10T21:25:40.857Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/4a/57/3b7d4dd193ade4641c865bc2b93aeeb71162e81fc348b8dad020215601ed/build-1.4.2-py3-none-any.whl", hash = "sha256:7a4d8651ea877cb2a89458b1b198f2e69f536c95e89129dbf5d448045d60db88", size = 24643, upload-time = "2026-03-25T14:20:26.568Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/30/f169e1d8b2071beaf8b97088787e30662b1d8fb82f8c0941d14678c0cbf1/build-1.4.3-py3-none-any.whl", hash = "sha256:1bc22b19b383303de8f2c8554c9a32894a58d3f185fe3756b0b20d255bee9a38", size = 26171, upload-time = "2026-04-10T21:25:39.671Z" },
]
[[package]]