Cargo.toml

@@ -11,7 +11,7 @@ axum = { version = "0.6.20", features = ["macros"] }
 clap = { version = "4.4.1", features = ["derive"] }
 env_logger = "0.10.0"
 log = "0.4.20"
-mpvipc = "1.3.0"
+mpvipc-async = { git = "https://git.pvv.ntnu.no/oysteikt/mpvipc-async.git", rev = "v0.1.0" }
 serde = { version = "1.0.188", features = ["derive"] }
 serde_json = "1.0.105"
 tokio = { version = "1.32.0", features = ["full"] }

src/api/base.rs

@@ -1,62 +1,61 @@
-use std::sync::Arc;
+use mpvipc_async::{
-
+    LoopProperty, Mpv, MpvExt, NumberChangeOptions, PlaylistAddOptions, PlaylistAddTypeOptions,
-use log::trace;
+    SeekOptions, Switch,
-use mpvipc::{
-    Mpv, NumberChangeOptions, PlaylistAddOptions, PlaylistAddTypeOptions, SeekOptions, Switch,
 };
 use serde_json::{json, Value};
-use tokio::sync::Mutex;
 
 /// Add item to playlist
-pub async fn loadfile(mpv: Arc<Mutex<Mpv>>, path: &str) -> anyhow::Result<()> {
+pub async fn loadfile(mpv: Mpv, path: &str) -> anyhow::Result<()> {
-    trace!("api::loadfile({:?})", path);
+    log::trace!("api::loadfile({:?})", path);
-    mpv.lock().await.playlist_add(
+    mpv.playlist_add(
         path,
         PlaylistAddTypeOptions::File,
         PlaylistAddOptions::Append,
-    )?;
+    )
+    .await?;
 
     Ok(())
 }
 
 /// Check whether the player is paused or playing
-pub async fn play_get(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<Value> {
+pub async fn play_get(mpv: Mpv) -> anyhow::Result<Value> {
-    trace!("api::play_get()");
+    log::trace!("api::play_get()");
-    let paused: bool = mpv.lock().await.get_property("pause")?;
+    let paused: bool = !mpv.is_playing().await?;
     Ok(json!(!paused))
 }
 
 /// Set whether the player is paused or playing
-pub async fn play_set(mpv: Arc<Mutex<Mpv>>, should_play: bool) -> anyhow::Result<()> {
+pub async fn play_set(mpv: Mpv, should_play: bool) -> anyhow::Result<()> {
-    trace!("api::play_set({:?})", should_play);
+    log::trace!("api::play_set({:?})", should_play);
-    mpv.lock()
+    mpv.set_playback(if should_play { Switch::On } else { Switch::Off })
         .await
-        .set_property("pause", !should_play)
         .map_err(|e| e.into())
 }
 
 /// Get the current player volume
-pub async fn volume_get(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<Value> {
+pub async fn volume_get(mpv: Mpv) -> anyhow::Result<Value> {
-    trace!("api::volume_get()");
+    log::trace!("api::volume_get()");
-    let volume: f64 = mpv.lock().await.get_property("volume")?;
+    let volume: f64 = mpv.get_volume().await?;
     Ok(json!(volume))
 }
 
 /// Set the player volume
-pub async fn volume_set(mpv: Arc<Mutex<Mpv>>, value: f64) -> anyhow::Result<()> {
+pub async fn volume_set(mpv: Mpv, value: f64) -> anyhow::Result<()> {
-    trace!("api::volume_set({:?})", value);
+    log::trace!("api::volume_set({:?})", value);
-    mpv.lock()
+    mpv.set_volume(value, NumberChangeOptions::Absolute)
         .await
-        .set_volume(value, NumberChangeOptions::Absolute)
         .map_err(|e| e.into())
 }
 
 /// Get current playback position
-pub async fn time_get(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<Value> {
+pub async fn time_get(mpv: Mpv) -> anyhow::Result<Value> {
-    trace!("api::time_get()");
+    log::trace!("api::time_get()");
-    let current: f64 = mpv.lock().await.get_property("time-pos")?;
+    let current: Option<f64> = mpv.get_time_pos().await?;
-    let remaining: f64 = mpv.lock().await.get_property("time-remaining")?;
+    let remaining: Option<f64> = mpv.get_time_remaining().await?;
-    let total = current + remaining;
+    let total = match (current, remaining) {
+        (Some(c), Some(r)) => Some(c + r),
+        (_, _) => None,
+    };
 
     Ok(json!({
         "current": current,
@@ -66,22 +65,16 @@ pub async fn time_get(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<Value> {
 }
 
 /// Set playback position
-pub async fn time_set(
+pub async fn time_set(mpv: Mpv, pos: Option<f64>, percent: Option<f64>) -> anyhow::Result<()> {
-    mpv: Arc<Mutex<Mpv>>,
+    log::trace!("api::time_set({:?}, {:?})", pos, percent);
-    pos: Option<f64>,
-    percent: Option<f64>,
-) -> anyhow::Result<()> {
-    trace!("api::time_set({:?}, {:?})", pos, percent);
     if pos.is_some() && percent.is_some() {
         anyhow::bail!("pos and percent cannot be provided at the same time");
     }
 
     if let Some(pos) = pos {
-        mpv.lock().await.seek(pos, SeekOptions::Absolute)?;
+        mpv.seek(pos, SeekOptions::Absolute).await?;
     } else if let Some(percent) = percent {
-        mpv.lock()
+        mpv.seek(percent, SeekOptions::AbsolutePercent).await?;
-            .await
-            .seek(percent, SeekOptions::AbsolutePercent)?;
     } else {
         anyhow::bail!("Either pos or percent must be provided");
     };
@@ -90,10 +83,10 @@ pub async fn time_set(
 }
 
 /// Get the current playlist
-pub async fn playlist_get(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<Value> {
+pub async fn playlist_get(mpv: Mpv) -> anyhow::Result<Value> {
-    trace!("api::playlist_get()");
+    log::trace!("api::playlist_get()");
-    let playlist: mpvipc::Playlist = mpv.lock().await.get_playlist()?;
+    let playlist: mpvipc_async::Playlist = mpv.get_playlist().await?;
-    let is_playing: bool = mpv.lock().await.get_property("pause")?;
+    let is_playing: bool = mpv.is_playing().await?;
 
     let items: Vec<Value> = playlist
         .0
@@ -104,7 +97,7 @@ pub async fn playlist_get(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<Value> {
               "index": i,
               "current": item.current,
               "playing": is_playing,
-              "filename": item.filename,
+              "filename": item.title.as_ref().unwrap_or(&item.filename),
               "data": {
                 "fetching": true,
               }
@@ -116,74 +109,64 @@ pub async fn playlist_get(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<Value> {
 }
 
 /// Skip to the next item in the playlist
-pub async fn playlist_next(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
+pub async fn playlist_next(mpv: Mpv) -> anyhow::Result<()> {
-    trace!("api::playlist_next()");
+    log::trace!("api::playlist_next()");
-    mpv.lock().await.next().map_err(|e| e.into())
+    mpv.next().await.map_err(|e| e.into())
 }
 
 /// Go back to the previous item in the playlist
-pub async fn playlist_previous(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
+pub async fn playlist_previous(mpv: Mpv) -> anyhow::Result<()> {
-    trace!("api::playlist_previous()");
+    log::trace!("api::playlist_previous()");
-    mpv.lock().await.prev().map_err(|e| e.into())
+    mpv.prev().await.map_err(|e| e.into())
 }
 
 /// Go chosen item in the playlist
-pub async fn playlist_goto(mpv: Arc<Mutex<Mpv>>, index: usize) -> anyhow::Result<()> {
+pub async fn playlist_goto(mpv: Mpv, index: usize) -> anyhow::Result<()> {
-    trace!("api::playlist_goto({:?})", index);
+    log::trace!("api::playlist_goto({:?})", index);
-    mpv.lock()
+    mpv.playlist_play_id(index).await.map_err(|e| e.into())
-        .await
-        .playlist_play_id(index)
-        .map_err(|e| e.into())
 }
 
 /// Clears the playlist
-pub async fn playlist_clear(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
+pub async fn playlist_clear(mpv: Mpv) -> anyhow::Result<()> {
-    trace!("api::playlist_clear()");
+    log::trace!("api::playlist_clear()");
-    mpv.lock().await.playlist_clear().map_err(|e| e.into())
+    mpv.playlist_clear().await.map_err(|e| e.into())
 }
 
 /// Remove an item from the playlist by index
-pub async fn playlist_remove(mpv: Arc<Mutex<Mpv>>, index: usize) -> anyhow::Result<()> {
+pub async fn playlist_remove(mpv: Mpv, index: usize) -> anyhow::Result<()> {
-    trace!("api::playlist_remove({:?})", index);
+    log::trace!("api::playlist_remove({:?})", index);
-    mpv.lock()
+    mpv.playlist_remove_id(index).await.map_err(|e| e.into())
-        .await
-        .playlist_remove_id(index)
-        .map_err(|e| e.into())
 }
 
 /// Move an item in the playlist from one index to another
-pub async fn playlist_move(mpv: Arc<Mutex<Mpv>>, from: usize, to: usize) -> anyhow::Result<()> {
+pub async fn playlist_move(mpv: Mpv, from: usize, to: usize) -> anyhow::Result<()> {
-    trace!("api::playlist_move({:?}, {:?})", from, to);
+    log::trace!("api::playlist_move({:?}, {:?})", from, to);
-    mpv.lock()
+    mpv.playlist_move_id(from, to).await.map_err(|e| e.into())
-        .await
-        .playlist_move_id(from, to)
-        .map_err(|e| e.into())
 }
 
 /// Shuffle the playlist
-pub async fn shuffle(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
+pub async fn shuffle(mpv: Mpv) -> anyhow::Result<()> {
-    trace!("api::shuffle()");
+    log::trace!("api::shuffle()");
-    mpv.lock().await.playlist_shuffle().map_err(|e| e.into())
+    mpv.playlist_shuffle().await.map_err(|e| e.into())
 }
 
 /// See whether it loops the playlist or not
-pub async fn playlist_get_looping(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<Value> {
+pub async fn playlist_get_looping(mpv: Mpv) -> anyhow::Result<Value> {
-    trace!("api::playlist_get_looping()");
+    log::trace!("api::playlist_get_looping()");
-    let loop_playlist = mpv.lock().await.get_property_string("loop-playlist")? == "inf";
+
-    Ok(json!(loop_playlist))
+    let loop_status = match mpv.playlist_is_looping().await? {
+        LoopProperty::No => false,
+        LoopProperty::Inf => true,
+        LoopProperty::N(_) => true,
+    };
+
+    Ok(json!(loop_status))
 }
 
-pub async fn playlist_set_looping(mpv: Arc<Mutex<Mpv>>, r#loop: bool) -> anyhow::Result<()> {
+pub async fn playlist_set_looping(mpv: Mpv, r#loop: bool) -> anyhow::Result<()> {
-    trace!("api::playlist_set_looping({:?})", r#loop);
+    log::trace!("api::playlist_set_looping({:?})", r#loop);
-    if r#loop {
+
-        mpv.lock()
+    mpv.set_loop_playlist(if r#loop { Switch::On } else { Switch::Off })
         .await
-            .set_loop_playlist(Switch::On)
         .map_err(|e| e.into())
-    } else {
-        mpv.lock()
-            .await
-            .set_loop_playlist(Switch::Off)
-            .map_err(|e| e.into())
-    }
 }

src/api/rest_wrapper_v1.rs

@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use axum::{
     extract::{Query, State},
     http::StatusCode,
@@ -7,13 +5,12 @@ use axum::{
     routing::{delete, get, post},
     Json, Router,
 };
-use mpvipc::Mpv;
+use mpvipc_async::Mpv;
 use serde_json::{json, Value};
-use tokio::sync::Mutex;
 
 use super::base;
 
-pub fn rest_api_routes(mpv: Arc<Mutex<Mpv>>) -> Router {
+pub fn rest_api_routes(mpv: Mpv) -> Router {
     Router::new()
         .route("/load", post(loadfile))
         .route("/play", get(play_get))
@@ -54,7 +51,7 @@ impl IntoResponse for RestResponse {
             Ok(value) => (StatusCode::OK, Json(value)).into_response(),
             Err(err) => (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                Json(json!({ "error": err.to_string(), "success": false })),
+                Json(json!({ "error": err.to_string(), "errortext": err.to_string(), "success": false })),
             )
                 .into_response(),
         }
@@ -72,14 +69,11 @@ struct LoadFileArgs {
     path: String,
 }
 
-async fn loadfile(
+async fn loadfile(State(mpv): State<Mpv>, Query(query): Query<LoadFileArgs>) -> RestResponse {
-    State(mpv): State<Arc<Mutex<Mpv>>>,
-    Query(query): Query<LoadFileArgs>,
-) -> RestResponse {
     base::loadfile(mpv, &query.path).await.into()
 }
 
-async fn play_get(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
+async fn play_get(State(mpv): State<Mpv>) -> RestResponse {
     base::play_get(mpv).await.into()
 }
 
@@ -88,15 +82,12 @@ struct PlaySetArgs {
     play: String,
 }
 
-async fn play_set(
+async fn play_set(State(mpv): State<Mpv>, Query(query): Query<PlaySetArgs>) -> RestResponse {
-    State(mpv): State<Arc<Mutex<Mpv>>>,
-    Query(query): Query<PlaySetArgs>,
-) -> RestResponse {
     let play = query.play.to_lowercase() == "true";
     base::play_set(mpv, play).await.into()
 }
 
-async fn volume_get(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
+async fn volume_get(State(mpv): State<Mpv>) -> RestResponse {
     base::volume_get(mpv).await.into()
 }
 
@@ -105,14 +96,11 @@ struct VolumeSetArgs {
     volume: f64,
 }
 
-async fn volume_set(
+async fn volume_set(State(mpv): State<Mpv>, Query(query): Query<VolumeSetArgs>) -> RestResponse {
-    State(mpv): State<Arc<Mutex<Mpv>>>,
-    Query(query): Query<VolumeSetArgs>,
-) -> RestResponse {
     base::volume_set(mpv, query.volume).await.into()
 }
 
-async fn time_get(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
+async fn time_get(State(mpv): State<Mpv>) -> RestResponse {
     base::time_get(mpv).await.into()
 }
 
@@ -122,22 +110,19 @@ struct TimeSetArgs {
     percent: Option<f64>,
 }
 
-async fn time_set(
+async fn time_set(State(mpv): State<Mpv>, Query(query): Query<TimeSetArgs>) -> RestResponse {
-    State(mpv): State<Arc<Mutex<Mpv>>>,
-    Query(query): Query<TimeSetArgs>,
-) -> RestResponse {
     base::time_set(mpv, query.pos, query.percent).await.into()
 }
 
-async fn playlist_get(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
+async fn playlist_get(State(mpv): State<Mpv>) -> RestResponse {
     base::playlist_get(mpv).await.into()
 }
 
-async fn playlist_next(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
+async fn playlist_next(State(mpv): State<Mpv>) -> RestResponse {
     base::playlist_next(mpv).await.into()
 }
 
-async fn playlist_previous(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
+async fn playlist_previous(State(mpv): State<Mpv>) -> RestResponse {
     base::playlist_previous(mpv).await.into()
 }
 
@@ -147,7 +132,7 @@ struct PlaylistGotoArgs {
 }
 
 async fn playlist_goto(
-    State(mpv): State<Arc<Mutex<Mpv>>>,
+    State(mpv): State<Mpv>,
     Query(query): Query<PlaylistGotoArgs>,
 ) -> RestResponse {
     base::playlist_goto(mpv, query.index).await.into()
@@ -159,7 +144,7 @@ struct PlaylistRemoveOrClearArgs {
 }
 
 async fn playlist_remove_or_clear(
-    State(mpv): State<Arc<Mutex<Mpv>>>,
+    State(mpv): State<Mpv>,
     Query(query): Query<PlaylistRemoveOrClearArgs>,
 ) -> RestResponse {
     match query.index {
@@ -175,7 +160,7 @@ struct PlaylistMoveArgs {
 }
 
 async fn playlist_move(
-    State(mpv): State<Arc<Mutex<Mpv>>>,
+    State(mpv): State<Mpv>,
     Query(query): Query<PlaylistMoveArgs>,
 ) -> RestResponse {
     base::playlist_move(mpv, query.index1, query.index2)
@@ -183,11 +168,11 @@ async fn playlist_move(
         .into()
 }
 
-async fn shuffle(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
+async fn shuffle(State(mpv): State<Mpv>) -> RestResponse {
     base::shuffle(mpv).await.into()
 }
 
-async fn playlist_get_looping(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
+async fn playlist_get_looping(State(mpv): State<Mpv>) -> RestResponse {
     base::playlist_get_looping(mpv).await.into()
 }
 
@@ -197,7 +182,7 @@ struct PlaylistSetLoopingArgs {
 }
 
 async fn playlist_set_looping(
-    State(mpv): State<Arc<Mutex<Mpv>>>,
+    State(mpv): State<Mpv>,
     Query(query): Query<PlaylistSetLoopingArgs>,
 ) -> RestResponse {
     base::playlist_set_looping(mpv, query.r#loop).await.into()

src/main.rs

@@ -1,17 +1,13 @@
 use anyhow::Context;
 use axum::{Router, Server};
 use clap::Parser;
-use mpvipc::Mpv;
+use mpvipc_async::Mpv;
 use std::{
     fs::create_dir_all,
     net::{IpAddr, SocketAddr},
     path::Path,
-    sync::Arc,
-};
-use tokio::{
-    process::{Child, Command},
-    sync::Mutex,
 };
+use tokio::process::{Child, Command};
 
 mod api;
 
@@ -84,9 +80,9 @@ async fn connect_to_mpv(args: &MpvConnectionArgs) -> anyhow::Result<(Mpv, Option
                 .arg(format!("--input-ipc-server={}", &args.socket_path))
                 .arg("--idle")
                 .arg("--force-window")
-                // .arg("--fullscreen")
+                .arg("--fullscreen")
                 // .arg("--no-terminal")
-                // .arg("--load-unsafe-playlists")
+                .arg("--load-unsafe-playlists")
                 .arg("--keep-open") // Keep last frame of video on end of video
                 .spawn()
                 .context("Failed to start mpv")?,
@@ -112,7 +108,7 @@ async fn connect_to_mpv(args: &MpvConnectionArgs) -> anyhow::Result<(Mpv, Option
     }
 
     Ok((
-        Mpv::connect(&args.socket_path).context(format!(
+        Mpv::connect(&args.socket_path).await.context(format!(
             "Failed to connect to mpv socket: {}",
             &args.socket_path
         ))?,
@@ -146,16 +142,17 @@ async fn main() -> anyhow::Result<()> {
     let addr = SocketAddr::new(resolve(&args.host).await?, args.port);
     log::info!("Starting API on {}", addr);
 
-    let mpv = Arc::new(Mutex::new(mpv));
+    let app = Router::new().nest("/api", api::rest_api_routes(mpv.clone()));
-    let app = Router::new().nest("/api", api::rest_api_routes(mpv));
 
     if let Some(mut proc) = proc {
         tokio::select! {
             exit_status = proc.wait() => {
                 log::warn!("mpv process exited with status: {}", exit_status?);
+                mpv.disconnect().await?;
             }
             _ = tokio::signal::ctrl_c() => {
                 log::info!("Received Ctrl-C, exiting");
+                mpv.disconnect().await?;
                 proc.kill().await?;
             }
             result = async {
@@ -165,6 +162,7 @@ async fn main() -> anyhow::Result<()> {
               }
             } => {
               log::info!("API server exited");
+              mpv.disconnect().await?;
               proc.kill().await?;
               result?;
             }
@@ -173,9 +171,11 @@ async fn main() -> anyhow::Result<()> {
         tokio::select! {
             _ = tokio::signal::ctrl_c() => {
                 log::info!("Received Ctrl-C, exiting");
+                mpv.disconnect().await?;
             }
             _ =  Server::bind(&addr.clone()).serve(app.into_make_service()) => {
                 log::info!("API server exited");
+                mpv.disconnect().await?;
             }
         }
     }