fix diferent fps video

bea4dev · bea4dev · commit d81d1c554054 · 2026-02-23T22:19:53.000+09:00
diff --git a/backend/src/decoder.rs b/backend/src/decoder.rs
@@ -622,6 +622,28 @@ async fn complete_pending_with_fallback(inner: Arc<Inner>) {
                 continue;
             }
 
+            let previous_frame = {
+                let frames = inner.frames.read().unwrap();
+                let mut probe = frame_index;
+                let mut found: Option<(u32, Arc<Vec<u8>>)> = None;
+                while let Some(prev) = probe.checked_sub(1) {
+                    probe = prev;
+                    let Some(prev_future) = frames.get(&probe) else {
+                        continue;
+                    };
+                    if let Some(prev_frame) = prev_future.get_now() {
+                        found = Some((probe, prev_frame));
+                        break;
+                    }
+                }
+                found
+            };
+            if let Some((_, previous_frame)) = previous_frame {
+                ENTIRE_CACHE_SIZE.fetch_add(previous_frame.len(), Ordering::Relaxed);
+                future.complete(previous_frame).await;
+                continue;
+            }
+
             let frame = hw_decoder::extract_frame_hw_rgba(
                 &inner.path,
                 frame_index as _,
diff --git a/backend/src/ffmpeg.rs b/backend/src/ffmpeg.rs
@@ -16,6 +16,7 @@ struct FfprobeStream {
     duration: Option<String>,
     avg_frame_rate: Option<String>,
     r_frame_rate: Option<String>,
+    nb_read_frames: Option<String>,
     nb_frames: Option<String>,
     width: Option<u32>,
     height: Option<u32>,
@@ -27,7 +28,12 @@ struct FfprobeOutput {
     streams: Option<Vec<FfprobeStream>>,
 }
 
-fn run_ffprobe(path: &str, select_streams: Option<&str>, entries: &str) -> Result<FfprobeOutput, String> {
+fn run_ffprobe(
+    path: &str,
+    select_streams: Option<&str>,
+    entries: &str,
+    count_frames: bool,
+) -> Result<FfprobeOutput, String> {
     let ffprobe = bin::ffprobe_path()?;
     let mut cmd = Command::new(ffprobe);
     cmd.arg("-v")
@@ -36,6 +42,9 @@ fn run_ffprobe(path: &str, select_streams: Option<&str>, entries: &str) -> Resul
         .arg("json")
         .arg("-show_entries")
         .arg(entries);
+    if count_frames {
+        cmd.arg("-count_frames");
+    }
     if let Some(select_streams) = select_streams {
         cmd.arg("-select_streams").arg(select_streams);
     }
@@ -95,7 +104,7 @@ fn parse_ratio(value: Option<&str>) -> Option<f64> {
 
 /// Return video duration in milliseconds using ffprobe metadata.
 pub fn probe_video_duration_ms(path: &str) -> Result<u64, String> {
-    let output = run_ffprobe(path, Some("v:0"), "format=duration:stream=duration")?;
+    let output = run_ffprobe(path, Some("v:0"), "format=duration:stream=duration", false)?;
     let stream_duration = output
         .streams
         .as_ref()
@@ -111,13 +120,28 @@ pub fn probe_video_duration_ms(path: &str) -> Result<u64, String> {
 }
 
 pub fn probe_video_frames(path: &str) -> Result<u64, String> {
-    let output = run_ffprobe(path, Some("v:0"), "stream=nb_frames,duration,avg_frame_rate")?;
+    let output = run_ffprobe(
+        path,
+        Some("v:0"),
+        "stream=nb_read_frames,nb_frames,duration,avg_frame_rate",
+        true,
+    )?;
     let stream = output
         .streams
         .as_ref()
         .and_then(|streams| streams.first())
         .ok_or_else(|| "failed to read frames".to_string())?;
 
+    if let Some(frames) = stream
+        .nb_read_frames
+        .as_deref()
+        .and_then(|value| value.parse::<u64>().ok())
+    {
+        if frames > 0 {
+            return Ok(frames);
+        }
+    }
+
     if let Some(frames) = stream.nb_frames.as_deref().and_then(|value| value.parse::<u64>().ok()) {
         if frames > 0 {
             return Ok(frames);
@@ -134,7 +158,7 @@ pub fn probe_video_frames(path: &str) -> Result<u64, String> {
 }
 
 pub fn probe_video_fps(path: &str) -> Result<f64, String> {
-    let output = run_ffprobe(path, Some("v:0"), "stream=avg_frame_rate,r_frame_rate")?;
+    let output = run_ffprobe(path, Some("v:0"), "stream=avg_frame_rate,r_frame_rate", false)?;
     let stream = output
         .streams
         .as_ref()
@@ -149,7 +173,7 @@ pub fn probe_video_fps(path: &str) -> Result<f64, String> {
 }
 
 pub fn probe_video_dimensions(path: &str) -> Result<(u32, u32), String> {
-    let output = run_ffprobe(path, Some("v:0"), "stream=width,height")?;
+    let output = run_ffprobe(path, Some("v:0"), "stream=width,height", false)?;
     let stream = output
         .streams
         .as_ref()
@@ -170,7 +194,7 @@ pub fn probe_audio_duration_ms(path: &str) -> Result<u64, String> {
     // Some containers report bogus global duration; prefer audio stream duration when available.
     const MAX_REASONABLE_DURATION_MS: u64 = 1000 * 60 * 60 * 24 * 7; // 7 days
 
-    let output = run_ffprobe(path, Some("a:0"), "format=duration:stream=duration")?;
+    let output = run_ffprobe(path, Some("a:0"), "format=duration:stream=duration", false)?;
     let stream_duration = output
         .streams
         .as_ref()
diff --git a/backend/src/main.rs b/backend/src/main.rs
@@ -3,7 +3,12 @@ pub mod ffmpeg;
 pub mod future;
 pub mod util;
 
-use std::{net::SocketAddr, ops::Bound, sync::atomic::AtomicBool, time::{SystemTime, UNIX_EPOCH}};
+use std::{
+    net::SocketAddr,
+    ops::Bound,
+    sync::atomic::AtomicBool,
+    time::{SystemTime, UNIX_EPOCH},
+};
 
 use axum::{
     Router,
@@ -28,7 +33,10 @@ use tracing::{error, info};
 
 use crate::{
     decoder::{DECODER, DecoderKey, set_max_cache_size},
-    ffmpeg::{probe_audio_duration_ms, probe_video_dimensions, probe_video_duration_ms, probe_video_fps},
+    ffmpeg::{
+        probe_audio_duration_ms, probe_video_dimensions, probe_video_duration_ms, probe_video_fps,
+        probe_video_frames,
+    },
     util::resolve_path_to_string,
 };
 
@@ -463,6 +471,7 @@ async fn healthz_handler() -> impl IntoResponse {
 struct VideoMetadataResponse {
     duration_ms: u64,
     fps: f64,
+    frame_count: u64,
     width: u32,
     height: u32,
 }
@@ -476,10 +485,18 @@ async fn video_meta_handler(
         probe_video_duration_ms(&resolved_path).map_err(|_| StatusCode::BAD_REQUEST)?;
 
     let fps = probe_video_fps(&resolved_path).map_err(|_| StatusCode::BAD_REQUEST)?;
+    let frame_count = probe_video_frames(&resolved_path).unwrap_or(0);
     let (width, height) =
         probe_video_dimensions(&resolved_path).map_err(|_| StatusCode::BAD_REQUEST)?;
 
-    let mut resp = Json(VideoMetadataResponse { duration_ms, fps, width, height }).into_response();
+    let mut resp = Json(VideoMetadataResponse {
+        duration_ms,
+        fps,
+        frame_count,
+        width,
+        height,
+    })
+    .into_response();
     apply_cors(resp.headers_mut());
     Ok(resp)
 }
diff --git a/src/lib/video/video-render.tsx b/src/lib/video/video-render.tsx
@@ -4,7 +4,14 @@ import { PROJECT_SETTINGS } from "../../../project/project";
 import { useCurrentFrame } from "../frame";
 import { useClipActive, useClipStart, useProvideClipDuration } from "../clip";
 import { createManualPromise, type ManualPromise } from "../../util/promise";
-import { normalizeVideo, video_fps, video_length, type Video, type VideoResolvedTrimProps } from "./video";
+import {
+  normalizeVideo,
+  video_fps,
+  video_frame_count,
+  video_length,
+  type Video,
+  type VideoResolvedTrimProps,
+} from "./video";
 
 // Track pending frame draws so headless callers can await completion.
 const pendingFramePromises = new Set<Promise<void>>();
@@ -60,6 +67,7 @@ export const VideoCanvasRender = ({ video, style, trimStartFrames = 0, trimEndFr
   const reconnectTimerRef = useRef<number | null>(null);
   const resolved = useMemo(() => normalizeVideo(video), [video]);
   const fps = useMemo(() => video_fps(resolved), [resolved]);
+  const sourceFrameCount = useMemo(() => video_frame_count(resolved), [resolved]);
   const rawDurationFrames = useMemo(() => video_length(resolved), [resolved]);
   const durationFrames = Math.max(0, rawDurationFrames - trimStartFrames - trimEndFrames);
   useProvideClipDuration(durationFrames);
@@ -81,6 +89,10 @@ export const VideoCanvasRender = ({ video, style, trimStartFrames = 0, trimEndFr
 
     const resize = () => {
       const rect = canvas.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) {
+        // Hidden clips report 0x0; keep previous size to avoid requesting 1x1 frames.
+        return;
+      }
       const dpr = window.devicePixelRatio || 1;
       const nextWidth = Math.max(1, Math.round(rect.width * dpr));
       const nextHeight = Math.max(1, Math.round(rect.height * dpr));
@@ -139,8 +151,8 @@ export const VideoCanvasRender = ({ video, style, trimStartFrames = 0, trimEndFr
 
     const req = {
       video: resolved.path,
-      width: canvasSizeRef.current.width,
-      height: canvasSizeRef.current.height,
+      width: canvasSizeRef.current.width > 1 ? canvasSizeRef.current.width : PROJECT_SETTINGS.width,
+      height: canvasSizeRef.current.height > 1 ? canvasSizeRef.current.height : PROJECT_SETTINGS.height,
       frame: playbackFrame,
     };
 
@@ -154,15 +166,27 @@ export const VideoCanvasRender = ({ video, style, trimStartFrames = 0, trimEndFr
       const clampedFrame =
         maxFrame !== undefined ? Math.min(Math.max(frame, 0), maxFrame) : Math.max(frame, 0);
 
-      const sourceStart = trimStartFrames;
-      const sourceEnd = Math.max(sourceStart, rawDurationFrames - trimEndFrames - 1);
+      const sourceStart =
+        fps > 0
+          ? Math.floor((trimStartFrames * fps) / PROJECT_SETTINGS.fps)
+          : trimStartFrames;
+      const sourceTrimEnd =
+        fps > 0
+          ? Math.floor((trimEndFrames * fps) / PROJECT_SETTINGS.fps)
+          : trimEndFrames;
+      const estimatedSourceFrames =
+        fps > 0
+          ? Math.max(0, Math.round((rawDurationFrames * fps) / PROJECT_SETTINGS.fps))
+          : rawDurationFrames;
+      const sourceTotalFrames = sourceFrameCount > 0 ? sourceFrameCount : estimatedSourceFrames;
+      const sourceEnd = Math.max(sourceStart, sourceTotalFrames - sourceTrimEnd - 1);
 
       requestedFrameRef.current = clampedFrame;
 
       const playbackFrameRaw =
         fps > 0
-          ? Math.round(((clampedFrame + sourceStart) * fps) / PROJECT_SETTINGS.fps)
-          : clampedFrame + sourceStart;
+          ? Math.floor(((clampedFrame + trimStartFrames) * fps) / PROJECT_SETTINGS.fps)
+          : clampedFrame + trimStartFrames;
       const playbackFrame = Math.min(Math.max(playbackFrameRaw, sourceStart), sourceEnd);
 
       const alreadyDrawn =
@@ -182,7 +206,15 @@ export const VideoCanvasRender = ({ video, style, trimStartFrames = 0, trimEndFr
 
       sendPlaybackFrameRequest(playbackFrame);
     },
-    [durationFrames, fps, rawDurationFrames, sendPlaybackFrameRequest, trimEndFrames, trimStartFrames],
+    [
+      durationFrames,
+      fps,
+      rawDurationFrames,
+      sendPlaybackFrameRequest,
+      sourceFrameCount,
+      trimEndFrames,
+      trimStartFrames,
+    ],
   );
 
   useEffect(() => {
@@ -271,10 +303,8 @@ export const VideoCanvasRender = ({ video, style, trimStartFrames = 0, trimEndFr
           pending?.projectFrame ??
           Math.max(
             0,
-            Math.round(
-              ((frameIndex - trimStartFrames) * PROJECT_SETTINGS.fps) /
-              Math.max(1, fps || PROJECT_SETTINGS.fps),
-            ),
+            Math.round((frameIndex * PROJECT_SETTINGS.fps) / Math.max(1, fps || PROJECT_SETTINGS.fps)) -
+              trimStartFrames,
           );
 
         if (pending) {
@@ -310,6 +340,13 @@ export const VideoCanvasRender = ({ video, style, trimStartFrames = 0, trimEndFr
     };
   }, [rejectPendingRequests, resolveWaiters, sendFrameRequest, sendPlaybackFrameRequest, visible]);
 
+  useEffect(() => {
+    if (visible) return;
+    // Re-entering a clip must not reuse stale last-drawn markers.
+    lastDrawnFrameRef.current = null;
+    requestedFrameRef.current = null;
+  }, [visible]);
+
   useEffect(() => {
     if (!visible) return;
     sendFrameRequest(currentFrame);
@@ -323,11 +360,15 @@ export const VideoCanvasRender = ({ video, style, trimStartFrames = 0, trimEndFr
       }
       const startOffset = clipStart ?? 0
       const relativeFrame = frame - startOffset
-      if (relativeFrame < 0 || durationFrames <= 0) return
+      if (relativeFrame < 0 || durationFrames <= 0) {
+        return
+      }
       const maxFrame = Math.max(0, durationFrames - 1)
       const clampedFrame = Math.min(Math.max(relativeFrame, 0), maxFrame)
       const lastDrawn = lastDrawnFrameRef.current
-      if (lastDrawn != null && lastDrawn >= clampedFrame) return
+      if (lastDrawn != null && lastDrawn >= clampedFrame) {
+        return
+      }
       await createOrGetFramePromise(clampedFrame).promise
     }
 
diff --git a/src/lib/video/video.tsx b/src/lib/video/video.tsx
@@ -70,6 +70,7 @@ const buildMetaUrl = (video: Video) => {
 type VideoMeta = {
   duration_ms: number
   fps: number
+  frame_count: number
   width: number
   height: number
 }
@@ -81,7 +82,7 @@ const fetchVideoMetaSync = (video: Video): VideoMeta => {
     return videoMetaCache.get(video.path)!
   }
 
-  const fallback: VideoMeta = { duration_ms: 0, fps: 0, width: 0, height: 0 }
+  const fallback: VideoMeta = { duration_ms: 0, fps: 0, frame_count: 0, width: 0, height: 0 }
 
   try {
     const xhr = new XMLHttpRequest()
@@ -93,6 +94,8 @@ const fetchVideoMetaSync = (video: Video): VideoMeta => {
       const meta: VideoMeta = {
         duration_ms: typeof payload.duration_ms === "number" ? Math.max(0, payload.duration_ms) : 0,
         fps: typeof payload.fps === "number" ? payload.fps : 0,
+        frame_count:
+          typeof payload.frame_count === "number" ? Math.max(0, Math.round(payload.frame_count)) : 0,
         width: typeof payload.width === "number" ? Math.max(0, Math.round(payload.width)) : 0,
         height: typeof payload.height === "number" ? Math.max(0, Math.round(payload.height)) : 0,
       }
@@ -120,6 +123,9 @@ const fetchVideoMetaSync = (video: Video): VideoMeta => {
 export const video_length = (video: Video | string): number => {
   const resolved = normalizeVideo(video)
   const meta = fetchVideoMetaSync(resolved)
+  if (meta.frame_count > 0 && meta.fps > 0) {
+    return Math.round((meta.frame_count * PROJECT_SETTINGS.fps) / meta.fps)
+  }
   const seconds = meta.duration_ms > 0 ? meta.duration_ms / 1000 : 0
   return Math.round(seconds * PROJECT_SETTINGS.fps)
 }
@@ -140,6 +146,12 @@ export const video_fps = (video: Video | string): number => {
   return meta.fps
 }
 
+export const video_frame_count = (video: Video | string): number => {
+  const resolved = normalizeVideo(video)
+  const meta = fetchVideoMetaSync(resolved)
+  return meta.frame_count
+}
+
 export type VideoDimensions = {
   width: number
   height: number
