Projects/greg-ng
Projects
/
greg-ng
7
0
Fork 0
Code Issues 24 Pull Requests Releases Activity

Use mpvipc-async version 0.1.0

This commit is contained in:
Oystein Kristoffer Tveit 2024-04-18 22:02:39 +02:00
parent 24b0307f0f
commit 894cc4e146
Signed by: oysteikt
GPG Key ID: 9F2F7D8250F35146
5 changed files with 494 additions and 413 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

649
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

2
Cargo.toml
View File

@ -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"] }

165
src/api/base.rs
View File

@ -1,62 +1,61 @@
use std::sync::Arc;
use log::trace;
use mpvipc::{
Mpv, NumberChangeOptions, PlaylistAddOptions, PlaylistAddTypeOptions, SeekOptions, Switch,
use mpvipc_async::{
LoopProperty, Mpv, MpvExt, 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<()> {
trace!("api::loadfile({:?})", path);
mpv.lock().await.playlist_add(
pub async fn loadfile(mpv: Mpv, path: &str) -> anyhow::Result<()> {
log::trace!("api::loadfile({:?})", path);
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> {
trace!("api::play_get()");
let paused: bool = mpv.lock().await.get_property("pause")?;
pub async fn play_get(mpv: Mpv) -> anyhow::Result<Value> {
log::trace!("api::play_get()");
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<()> {
trace!("api::play_set({:?})", should_play);
mpv.lock()
pub async fn play_set(mpv: Mpv, should_play: bool) -> anyhow::Result<()> {
log::trace!("api::play_set({:?})", should_play);
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> {
trace!("api::volume_get()");
let volume: f64 = mpv.lock().await.get_property("volume")?;
pub async fn volume_get(mpv: Mpv) -> anyhow::Result<Value> {
log::trace!("api::volume_get()");
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<()> {
trace!("api::volume_set({:?})", value);
mpv.lock()
pub async fn volume_set(mpv: Mpv, value: f64) -> anyhow::Result<()> {
log::trace!("api::volume_set({:?})", value);
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> {
trace!("api::time_get()");
let current: f64 = mpv.lock().await.get_property("time-pos")?;
let remaining: f64 = mpv.lock().await.get_property("time-remaining")?;
let total = current + remaining;
pub async fn time_get(mpv: Mpv) -> anyhow::Result<Value> {
log::trace!("api::time_get()");
let current: Option<f64> = mpv.get_time_pos().await?;
let remaining: Option<f64> = mpv.get_time_remaining().await?;
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(
mpv: Arc<Mutex<Mpv>>,
pos: Option<f64>,
percent: Option<f64>,
) -> anyhow::Result<()> {
trace!("api::time_set({:?}, {:?})", pos, percent);
pub async fn time_set(mpv: Mpv, pos: Option<f64>, percent: Option<f64>) -> anyhow::Result<()> {
log::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()
.await
.seek(percent, SeekOptions::AbsolutePercent)?;
mpv.seek(percent, SeekOptions::AbsolutePercent).await?;
} 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> {
trace!("api::playlist_get()");
let playlist: mpvipc::Playlist = mpv.lock().await.get_playlist()?;
let is_playing: bool = mpv.lock().await.get_property("pause")?;
pub async fn playlist_get(mpv: Mpv) -> anyhow::Result<Value> {
log::trace!("api::playlist_get()");
let playlist: mpvipc_async::Playlist = mpv.get_playlist().await?;
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<()> {
trace!("api::playlist_next()");
mpv.lock().await.next().map_err(|e| e.into())
pub async fn playlist_next(mpv: Mpv) -> anyhow::Result<()> {
log::trace!("api::playlist_next()");
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<()> {
trace!("api::playlist_previous()");
mpv.lock().await.prev().map_err(|e| e.into())
pub async fn playlist_previous(mpv: Mpv) -> anyhow::Result<()> {
log::trace!("api::playlist_previous()");
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<()> {
trace!("api::playlist_goto({:?})", index);
mpv.lock()
.await
.playlist_play_id(index)
.map_err(|e| e.into())
pub async fn playlist_goto(mpv: Mpv, index: usize) -> anyhow::Result<()> {
log::trace!("api::playlist_goto({:?})", index);
mpv.playlist_play_id(index).await.map_err(|e| e.into())
}
/// Clears the playlist
pub async fn playlist_clear(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
trace!("api::playlist_clear()");
mpv.lock().await.playlist_clear().map_err(|e| e.into())
pub async fn playlist_clear(mpv: Mpv) -> anyhow::Result<()> {
log::trace!("api::playlist_clear()");
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<()> {
trace!("api::playlist_remove({:?})", index);
mpv.lock()
.await
.playlist_remove_id(index)
.map_err(|e| e.into())
pub async fn playlist_remove(mpv: Mpv, index: usize) -> anyhow::Result<()> {
log::trace!("api::playlist_remove({:?})", index);
mpv.playlist_remove_id(index).await.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<()> {
trace!("api::playlist_move({:?}, {:?})", from, to);
mpv.lock()
.await
.playlist_move_id(from, to)
.map_err(|e| e.into())
pub async fn playlist_move(mpv: Mpv, from: usize, to: usize) -> anyhow::Result<()> {
log::trace!("api::playlist_move({:?}, {:?})", from, to);
mpv.playlist_move_id(from, to).await.map_err(|e| e.into())
}
/// Shuffle the playlist
pub async fn shuffle(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
trace!("api::shuffle()");
mpv.lock().await.playlist_shuffle().map_err(|e| e.into())
pub async fn shuffle(mpv: Mpv) -> anyhow::Result<()> {
log::trace!("api::shuffle()");
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> {
trace!("api::playlist_get_looping()");
let loop_playlist = mpv.lock().await.get_property_string("loop-playlist")? == "inf";
Ok(json!(loop_playlist))
pub async fn playlist_get_looping(mpv: Mpv) -> anyhow::Result<Value> {
log::trace!("api::playlist_get_looping()");
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<()> {
trace!("api::playlist_set_looping({:?})", r#loop);
if r#loop {
mpv.lock()
.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())
}
pub async fn playlist_set_looping(mpv: Mpv, r#loop: bool) -> anyhow::Result<()> {
log::trace!("api::playlist_set_looping({:?})", r#loop);
mpv.set_loop_playlist(if r#loop { Switch::On } else { Switch::Off })
.await
.map_err(|e| e.into())
}

53
src/api/rest_wrapper_v1.rs
View File

@ -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(
State(mpv): State<Arc<Mutex<Mpv>>>,
Query(query): Query<LoadFileArgs>,
) -> RestResponse {
async fn loadfile(State(mpv): State<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(
State(mpv): State<Arc<Mutex<Mpv>>>,
Query(query): Query<PlaySetArgs>,
) -> RestResponse {
async fn play_set(State(mpv): State<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(
State(mpv): State<Arc<Mutex<Mpv>>>,
Query(query): Query<VolumeSetArgs>,
) -> RestResponse {
async fn volume_set(State(mpv): State<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(
State(mpv): State<Arc<Mutex<Mpv>>>,
Query(query): Query<TimeSetArgs>,
) -> RestResponse {
async fn time_set(State(mpv): State<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()

38
src/main.rs
View File

@ -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,25 +142,27 @@ 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));
let app = Router::new().nest("/api", api::rest_api_routes(mpv.clone()));
if let Some(mut proc) = proc {
tokio::select! {
exit_status = proc.wait() => {
log::warn!("mpv process exited with status: {}", exit_status?);
}
_ = tokio::signal::ctrl_c() => {
log::info!("Received Ctrl-C, exiting");
proc.kill().await?;
}
result = async {
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 {
match Server::try_bind(&addr.clone()).context("Failed to bind server") {
Ok(server) => server.serve(app.into_make_service()).await.context("Failed to serve app"),
Err(err) => Err(err),
}
} => {
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?;
}
}
}