Correlate video readiness with mpv loads

Author: kKaskak

src/stremio_app/stremio_player/player.rs

@@ -4,8 +4,9 @@ use flume::{Receiver, Sender};
 use libmpv2::{events::Event, Format, Mpv, SetData};
 use native_windows_gui::{self as nwg, PartialUi};
 use std::{
-    collections::VecDeque,
-    mem, ptr,
+    ffi::{CStr, CString},
+    mem::{self, MaybeUninit},
+    ptr,
     sync::{
         atomic::{AtomicBool, Ordering},
         Arc, Mutex,
@@ -44,32 +45,39 @@ struct ObserveProperty {
 struct VideoReadyState {
     next_load_id: u64,
     current_load_id: Option<u64>,
-    pending_load_ids: VecDeque<u64>,
-    active_load_id: Option<u64>,
+    current_playlist_entry_id: Option<i64>,
+    active_playlist_entry_id: Option<i64>,
     file_loaded_id: Option<u64>,
     ready_sent_id: Option<u64>,
 }
 
 impl VideoReadyState {
-    fn begin_transition(&mut self, loads_file: bool) -> u64 {
+    fn begin_transition(&mut self) -> u64 {
         self.next_load_id += 1;
         self.current_load_id = Some(self.next_load_id);
+        self.current_playlist_entry_id = None;
+        self.active_playlist_entry_id = None;
         self.file_loaded_id = None;
         self.ready_sent_id = None;
-        if loads_file {
-            self.pending_load_ids.push_back(self.next_load_id);
-        }
         self.next_load_id
     }
 
-    fn start_file(&mut self) {
-        self.active_load_id = self.pending_load_ids.pop_front();
+    fn bind_playlist_entry(&mut self, load_id: u64, playlist_entry_id: i64) {
+        if self.current_load_id == Some(load_id) {
+            self.current_playlist_entry_id = Some(playlist_entry_id);
+        }
+    }
+
+    fn start_file(&mut self, playlist_entry_id: i64) {
+        self.active_playlist_entry_id = Some(playlist_entry_id);
         self.file_loaded_id = None;
     }
 
     fn file_loaded(&mut self) {
-        if self.active_load_id == self.current_load_id {
-            self.file_loaded_id = self.active_load_id;
+        if self.current_playlist_entry_id.is_some()
+            && self.active_playlist_entry_id == self.current_playlist_entry_id
+        {
+            self.file_loaded_id = self.current_load_id;
         }
     }
 
@@ -189,11 +197,18 @@ impl PartialUi for Player {
         let mpv_event_client = mpv
             .create_client(None)
             .expect("cannot create MPV event client");
+        let video_ready_event_client = mpv
+            .create_client(Some("video-ready"))
+            .expect("cannot create MPV video readiness client");
 
         let _event_thread = create_event_thread(
             mpv_event_client,
             observe_property_receiver,
             rpc_response_sender.clone(),
+        );
+        let _video_ready_event_thread = create_video_ready_event_thread(
+            video_ready_event_client,
+            rpc_response_sender.clone(),
             Arc::clone(&video_ready_state),
         );
         let gpu_video_processing = Arc::new(AtomicBool::new(false));
@@ -264,6 +279,69 @@ fn create_mpv(window_handle: HWND) -> Mpv {
     mpv.expect("cannot build MPV")
 }
 
+fn playlist_entry_id_from_node(node: &libmpv2_sys::mpv_node) -> Option<i64> {
+    if node.format != libmpv2_sys::mpv_format_MPV_FORMAT_NODE_MAP {
+        return None;
+    }
+
+    let list = unsafe { node.u.list.as_ref()? };
+    if list.num <= 0 || list.keys.is_null() || list.values.is_null() {
+        return None;
+    }
+
+    for index in 0..list.num as usize {
+        let key = unsafe { *list.keys.add(index) };
+        if key.is_null() || unsafe { CStr::from_ptr(key) }.to_bytes() != b"playlist_entry_id" {
+            continue;
+        }
+
+        let value = unsafe { &*list.values.add(index) };
+        if value.format == libmpv2_sys::mpv_format_MPV_FORMAT_INT64 {
+            return Some(unsafe { value.u.int64 });
+        }
+    }
+
+    None
+}
+
+fn mpv_error(error: i32) -> String {
+    let message = unsafe { libmpv2_sys::mpv_error_string(error) };
+    if message.is_null() {
+        return format!("mpv error {error}");
+    }
+    unsafe { CStr::from_ptr(message) }
+        .to_string_lossy()
+        .into_owned()
+}
+
+fn command_loadfile(mpv: &Mpv, args: &[&str]) -> Result<i64, String> {
+    let strings = std::iter::once("loadfile")
+        .chain(args.iter().copied())
+        .map(CString::new)
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|_| "loadfile argument contains a null byte".to_string())?;
+    let mut command = strings
+        .iter()
+        .map(|arg| arg.as_ptr())
+        .chain(std::iter::once(ptr::null()))
+        .collect::<Vec<_>>();
+    let mut result = MaybeUninit::<libmpv2_sys::mpv_node>::zeroed();
+
+    let status = unsafe {
+        libmpv2_sys::mpv_command_ret(mpv.ctx.as_ptr(), command.as_mut_ptr(), result.as_mut_ptr())
+    };
+    if status < 0 {
+        return Err(mpv_error(status));
+    }
+
+    let mut result = unsafe { result.assume_init() };
+    let playlist_entry_id = playlist_entry_id_from_node(&result);
+    unsafe {
+        libmpv2_sys::mpv_free_node_contents(&mut result);
+    }
+    playlist_entry_id.ok_or_else(|| "loadfile did not return playlist_entry_id".to_string())
+}
+
 fn create_display_output_thread(
     mpv: Arc<Mpv>,
     window_handle: isize,
@@ -479,12 +557,20 @@ fn create_event_thread(
     mut mpv_event_client: Mpv,
     observe_property_receiver: Receiver<ObserveProperty>,
     rpc_response_sender: Sender<String>,
-    video_ready_state: SharedVideoReadyState,
 ) -> JoinHandle<()> {
     thread::spawn(move || {
         mpv_event_client
             .disable_deprecated_events()
             .expect("failed to disable deprecated MPV events");
+        for event in [
+            libmpv2_sys::mpv_event_id_MPV_EVENT_START_FILE,
+            libmpv2_sys::mpv_event_id_MPV_EVENT_FILE_LOADED,
+            libmpv2_sys::mpv_event_id_MPV_EVENT_PLAYBACK_RESTART,
+        ] {
+            mpv_event_client
+                .disable_event(event)
+                .expect("failed to disable video readiness event");
+        }
 
         // -- Event handler loop --
 
@@ -505,33 +591,6 @@ fn create_event_thread(
                 None => continue,
             };
 
-            if matches!(&event, Event::StartFile) {
-                video_ready_state
-                    .lock()
-                    .expect("cannot lock video readiness state")
-                    .start_file();
-                continue;
-            }
-
-            if matches!(&event, Event::FileLoaded) {
-                video_ready_state
-                    .lock()
-                    .expect("cannot lock video readiness state")
-                    .file_loaded();
-                continue;
-            }
-
-            if matches!(&event, Event::PlaybackRestart) {
-                let load_id = video_ready_state
-                    .lock()
-                    .expect("cannot lock video readiness state")
-                    .playback_restarted();
-                if let Some(load_id) = load_id {
-                    send_video_ready(&rpc_response_sender, load_id, true);
-                }
-                continue;
-            }
-
             // even if you don't do anything with the events, it is still necessary to empty the event loop
             let player_response = match event {
                 Event::PropertyChange { name, change, .. } => PlayerResponse(
@@ -561,6 +620,65 @@ fn create_event_thread(
     })
 }
 
+fn create_video_ready_event_thread(
+    mpv_event_client: Mpv,
+    rpc_response_sender: Sender<String>,
+    video_ready_state: SharedVideoReadyState,
+) -> JoinHandle<()> {
+    thread::spawn(move || {
+        mpv_event_client
+            .disable_all_events()
+            .expect("failed to disable MPV events");
+        for event in [
+            libmpv2_sys::mpv_event_id_MPV_EVENT_START_FILE,
+            libmpv2_sys::mpv_event_id_MPV_EVENT_FILE_LOADED,
+            libmpv2_sys::mpv_event_id_MPV_EVENT_PLAYBACK_RESTART,
+        ] {
+            mpv_event_client
+                .enable_event(event)
+                .expect("failed to enable video readiness event");
+        }
+
+        loop {
+            let event = unsafe { libmpv2_sys::mpv_wait_event(mpv_event_client.ctx.as_ptr(), 0.1) };
+            let Some(event) = (unsafe { event.as_ref() }) else {
+                continue;
+            };
+
+            match event.event_id {
+                libmpv2_sys::mpv_event_id_MPV_EVENT_START_FILE => {
+                    let Some(start_file) = (unsafe {
+                        (event.data as *const libmpv2_sys::mpv_event_start_file).as_ref()
+                    }) else {
+                        continue;
+                    };
+                    video_ready_state
+                        .lock()
+                        .expect("cannot lock video readiness state")
+                        .start_file(start_file.playlist_entry_id);
+                }
+                libmpv2_sys::mpv_event_id_MPV_EVENT_FILE_LOADED => {
+                    video_ready_state
+                        .lock()
+                        .expect("cannot lock video readiness state")
+                        .file_loaded();
+                }
+                libmpv2_sys::mpv_event_id_MPV_EVENT_PLAYBACK_RESTART => {
+                    let load_id = video_ready_state
+                        .lock()
+                        .expect("cannot lock video readiness state")
+                        .playback_restarted();
+                    if let Some(load_id) = load_id {
+                        send_video_ready(&rpc_response_sender, load_id, true);
+                    }
+                }
+                libmpv2_sys::mpv_event_id_MPV_EVENT_SHUTDOWN => break,
+                _ => {}
+            }
+        }
+    })
+}
+
 fn create_message_thread(
     mpv: Arc<Mpv>,
     window_handle: isize,
@@ -582,16 +700,32 @@ fn create_message_thread(
         let send_command = |cmd: CmdVal| {
             let parts: Vec<String> = cmd.into();
             if let Some((name, args)) = parts.split_first() {
-                if name == "loadfile" || name == "stop" {
+                let load_id = if name == "loadfile" || name == "stop" {
                     let load_id = video_ready_state
                         .lock()
                         .expect("cannot lock video readiness state")
-                        .begin_transition(name == "loadfile");
+                        .begin_transition();
                     send_video_ready(&rpc_response_sender, load_id, false);
-                }
+                    Some(load_id)
+                } else {
+                    None
+                };
                 let args = args.iter().map(String::as_str).collect::<Vec<_>>();
-                if let Err(error) = mpv.command(name, &args) {
-                    eprintln!("failed to execute MPV command: '{error:#}'")
+                if name == "loadfile" {
+                    let load_id = load_id.expect("loadfile transition has no load ID");
+                    let mut state = video_ready_state
+                        .lock()
+                        .expect("cannot lock video readiness state");
+                    match command_loadfile(&mpv, &args) {
+                        Ok(playlist_entry_id) => {
+                            state.bind_playlist_entry(load_id, playlist_entry_id);
+                        }
+                        Err(error) => {
+                            eprintln!("failed to execute MPV command: '{error}'");
+                        }
+                    }
+                } else if let Err(error) = mpv.command(name, &args) {
+                    eprintln!("failed to execute MPV command: '{error:#}'");
                 }
             }
         };
@@ -675,8 +809,9 @@ mod tests {
     #[test]
     fn ready_follows_file_loaded_restart_once() {
         let mut state = VideoReadyState::default();
-        let load_id = state.begin_transition(true);
-        state.start_file();
+        let load_id = state.begin_transition();
+        state.bind_playlist_entry(load_id, 10);
+        state.start_file(10);
         assert_eq!(state.playback_restarted(), None);
         state.file_loaded();
         assert_eq!(state.playback_restarted(), Some(load_id));
@@ -686,22 +821,54 @@ mod tests {
     #[test]
     fn new_transition_ignores_previous_file_events() {
         let mut state = VideoReadyState::default();
-        state.begin_transition(true);
-        state.start_file();
+        let previous_load = state.begin_transition();
+        state.bind_playlist_entry(previous_load, 10);
+        state.start_file(10);
 
-        let current_load = state.begin_transition(true);
+        let current_load = state.begin_transition();
+        state.bind_playlist_entry(current_load, 20);
         state.file_loaded();
         assert_eq!(state.playback_restarted(), None);
 
-        state.start_file();
+        state.start_file(20);
+        state.file_loaded();
+        assert_eq!(state.playback_restarted(), Some(current_load));
+    }
+
+    #[test]
+    fn back_to_back_loads_ignore_superseded_entry() {
+        let mut state = VideoReadyState::default();
+        let previous_load = state.begin_transition();
+        state.bind_playlist_entry(previous_load, 10);
+
+        let current_load = state.begin_transition();
+        state.bind_playlist_entry(current_load, 20);
+
+        state.start_file(10);
+        state.file_loaded();
+        assert_eq!(state.playback_restarted(), None);
+
+        state.start_file(20);
+        state.file_loaded();
+        assert_eq!(state.playback_restarted(), Some(current_load));
+    }
+
+    #[test]
+    fn load_without_start_file_does_not_desynchronize_next_load() {
+        let mut state = VideoReadyState::default();
+        state.begin_transition();
+
+        let current_load = state.begin_transition();
+        state.bind_playlist_entry(current_load, 20);
+        state.start_file(20);
         state.file_loaded();
         assert_eq!(state.playback_restarted(), Some(current_load));
     }
 
     #[test]
     fn stop_never_becomes_ready() {
         let mut state = VideoReadyState::default();
-        state.begin_transition(false);
+        state.begin_transition();
         state.file_loaded();
         assert_eq!(state.playback_restarted(), None);
     }