Merge branch 'main' of https://github.com/CapSoftware/Cap

Author: richiemcilroy

crates/editor/src/editor_instance.rs

@@ -1,5 +1,5 @@
 use crate::editor;
-use crate::playback::{self, PlaybackHandle};
+use crate::playback::{self, PlaybackHandle, PlaybackStartError};
 use cap_audio::AudioData;
 use cap_project::StudioRecordingMeta;
 use cap_project::{CursorEvents, ProjectConfiguration, RecordingMeta, RecordingMetaInner, XY};
@@ -10,7 +10,7 @@ use cap_rendering::{
 use std::ops::Deref;
 use std::{path::PathBuf, sync::Arc};
 use tokio::sync::{Mutex, watch};
-use tracing::trace;
+use tracing::{trace, warn};
 
 pub struct EditorInstance {
     pub project_path: PathBuf,
@@ -145,15 +145,22 @@ impl EditorInstance {
 
             let start_frame_number = state.playhead_position;
 
-            let playback_handle = playback::Playback {
+            let playback_handle = match (playback::Playback {
                 segments: self.segments.clone(),
                 renderer: self.renderer.clone(),
                 render_constants: self.render_constants.clone(),
                 start_frame_number,
                 project: self.project_config.0.subscribe(),
-            }
+            })
             .start(fps, resolution_base)
-            .await;
+            .await
+            {
+                Ok(handle) => handle,
+                Err(PlaybackStartError::InvalidFps) => {
+                    warn!(fps, "Skipping playback start due to invalid FPS");
+                    return;
+                }
+            };
 
             let prev = state.playback_task.replace(playback_handle.clone());
 

crates/editor/src/playback.rs

@@ -20,6 +20,11 @@ use crate::{
     segments::get_audio_segments,
 };
 
+#[derive(Debug)]
+pub enum PlaybackStartError {
+    InvalidFps,
+}
+
 pub struct Playback {
     pub renderer: Arc<editor::RendererHandle>,
     pub render_constants: Arc<RenderVideoConstants>,
@@ -42,7 +47,18 @@ pub struct PlaybackHandle {
 }
 
 impl Playback {
-    pub async fn start(self, fps: u32, resolution_base: XY<u32>) -> PlaybackHandle {
+    pub async fn start(
+        self,
+        fps: u32,
+        resolution_base: XY<u32>,
+    ) -> Result<PlaybackHandle, PlaybackStartError> {
+        let fps_f64 = fps as f64;
+
+        if !(fps_f64.is_finite() && fps_f64 > 0.0) {
+            warn!(fps, "Invalid FPS provided for playback start");
+            return Err(PlaybackStartError::InvalidFps);
+        }
+
         let (stop_tx, mut stop_rx) = watch::channel(false);
         stop_rx.borrow_and_update();
 
@@ -72,60 +88,83 @@ impl Playback {
             }
             .spawn();
 
-            loop {
-                let time =
-                    (self.start_frame_number as f64 / fps as f64) + start.elapsed().as_secs_f64();
-                let frame_number = (time * fps as f64).floor() as u32;
+            let frame_duration = Duration::from_secs_f64(1.0 / fps_f64);
+            let mut frame_number = self.start_frame_number;
+
+            'playback: loop {
+                let frame_offset = frame_number.saturating_sub(self.start_frame_number) as f64;
+                let next_deadline = start + frame_duration.mul_f64(frame_offset);
 
-                if frame_number as f64 >= fps as f64 * duration {
+                tokio::select! {
+                    _ = stop_rx.changed() => break 'playback,
+                    _ = tokio::time::sleep_until(next_deadline) => {}
+                }
+
+                if *stop_rx.borrow() {
                     break;
-                };
+                }
+
+                let playback_time = frame_number as f64 / fps_f64;
+                if playback_time >= duration {
+                    break;
+                }
 
                 let project = self.project.borrow().clone();
 
-                if let Some((segment_time, segment_i)) = project.get_segment_time(time) {
-                    let segment = &self.segments[segment_i as usize];
-                    let clip_config = project.clips.iter().find(|v| v.index == segment_i);
-                    let clip_offsets = clip_config.map(|v| v.offsets).unwrap_or_default();
+                let Some((segment_time, segment_i)) = project.get_segment_time(playback_time)
+                else {
+                    break;
+                };
 
-                    let data = tokio::select! {
-                        _ = stop_rx.changed() => { break; },
-                        data = segment.decoders.get_frames(segment_time as f32, !project.camera.hide, clip_offsets) => { data }
-                    };
+                let segment = &self.segments[segment_i as usize];
+                let clip_offsets = project
+                    .clips
+                    .iter()
+                    .find(|v| v.index == segment_i)
+                    .map(|v| v.offsets)
+                    .unwrap_or_default();
+
+                let data = tokio::select! {
+                    _ = stop_rx.changed() => break 'playback,
+                    data = segment
+                        .decoders
+                        .get_frames(segment_time as f32, !project.camera.hide, clip_offsets) => data,
+                };
 
-                    if let Some(segment_frames) = data {
-                        let uniforms = ProjectUniforms::new(
-                            &self.render_constants,
-                            &project,
-                            frame_number,
-                            fps,
-                            resolution_base,
-                            &segment.cursor,
-                            &segment_frames,
-                        );
-
-                        self.renderer
-                            .render_frame(segment_frames, uniforms, segment.cursor.clone())
-                            .await;
-                    }
-                }
+                if let Some(segment_frames) = data {
+                    let uniforms = ProjectUniforms::new(
+                        &self.render_constants,
+                        &project,
+                        frame_number,
+                        fps,
+                        resolution_base,
+                        &segment.cursor,
+                        &segment_frames,
+                    );
 
-                tokio::time::sleep_until(
-                    start
-                        + (frame_number - self.start_frame_number)
-                            * Duration::from_secs_f32(1.0 / fps as f32),
-                )
-                .await;
+                    self.renderer
+                        .render_frame(segment_frames, uniforms, segment.cursor.clone())
+                        .await;
+                }
 
                 event_tx.send(PlaybackEvent::Frame(frame_number)).ok();
+
+                frame_number = frame_number.saturating_add(1);
+
+                let expected_frame = self.start_frame_number
+                    + (start.elapsed().as_secs_f64() * fps_f64).floor() as u32;
+
+                if frame_number < expected_frame {
+                    frame_number = expected_frame;
+                }
             }
 
             stop_tx.send(true).ok();
 
             event_tx.send(PlaybackEvent::Stop).ok();
         });
 
-        handle
+        Ok(handle)
     }
 }