Compare commits
1 Commits
main
...
openapi-do
| Author | SHA1 | Date |
|---|---|---|
 Oystein Kristoffer Tveit
|
9838d8e8f0
|
|
|
@ -1,2 +1 @@
|
|||
/target
|
||||
result
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
31
Cargo.toml
31
Cargo.toml
|
|
@ -2,33 +2,30 @@
|
|||
name = "greg-ng"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "MIT"
|
||||
authors = ["oysteikt@pvv.ntnu.no"]
|
||||
readme = "README.md"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
aide = { version = "0.13.3", features = [
|
||||
"axum",
|
||||
"axum-extra",
|
||||
"axum-extra-query",
|
||||
"axum-ws",
|
||||
"macros",
|
||||
"scalar",
|
||||
] }
|
||||
anyhow = "1.0.82"
|
||||
axum = { version = "0.7.7", features = ["macros"] }
|
||||
axum = { version = "0.6.20", features = ["macros", "ws"] }
|
||||
axum-jsonschema = { version = "0.8.0", features = ["aide"] }
|
||||
axum-macros = "0.4.1"
|
||||
clap = { version = "4.4.1", features = ["derive"] }
|
||||
clap-verbosity-flag = "2.2.2"
|
||||
env_logger = "0.10.0"
|
||||
log = "0.4.20"
|
||||
mpvipc-async = { git = "https://git.pvv.ntnu.no/oysteikt/mpvipc-async.git", rev = "v0.1.0" }
|
||||
sd-notify = "0.4.3"
|
||||
mpvipc = "1.3.0"
|
||||
schemars = "0.8.16"
|
||||
serde = { version = "1.0.188", features = ["derive"] }
|
||||
serde_json = "1.0.105"
|
||||
systemd-journal-logger = "2.2.0"
|
||||
tempfile = "3.11.0"
|
||||
serde_urlencoded = "0.7.1"
|
||||
tokio = { version = "1.32.0", features = ["full"] }
|
||||
tower = { version = "0.4.13", features = ["full"] }
|
||||
tower-http = { version = "0.4.3", features = ["full"] }
|
||||
utoipa = { version = "5.1.3", features = ["axum_extras"] }
|
||||
utoipa-axum = "0.1.2"
|
||||
utoipa-swagger-ui = { version = "8.0.3", features = ["axum", "vendored"] }
|
||||
|
||||
[profile.release]
|
||||
strip = true
|
||||
lto = true
|
||||
codegen-units = 1
|
||||
|
|
|
|||
35
README.md
35
README.md
|
|
@ -2,20 +2,23 @@
|
|||
|
||||
New implementation of https://github.com/Programvareverkstedet/grzegorz
|
||||
|
||||
## Test it out
|
||||
## Feature wishlist
|
||||
|
||||
```sh
|
||||
# NixOS
|
||||
nix run "git+https://git.pvv.ntnu.no/Projects/greg-ng#" -- --mpv-socket-path /tmp/mpv.sock
|
||||
|
||||
# Other (after git clone and rust toolchain has been set up)
|
||||
cargo run -- --mpv-socket-path /tmp/mpv.sock
|
||||
```
|
||||
|
||||
See also https://git.pvv.ntnu.no/Projects/grzegorz-clients for frontend alternatives
|
||||
|
||||
## Debugging
|
||||
|
||||
```sh
|
||||
RUST_LOG=greg_ng=trace,mpvipc=trace cargo run -- --mpv-socket-path /tmp/mpv.sock
|
||||
```
|
||||
- [ ] Feature parity with old grzegorz
|
||||
- [X] Rest API
|
||||
- [ ] Rest API docs
|
||||
- [ ] Metadata fetcher
|
||||
- [ ] Init mpv with image of grzegorz
|
||||
- [ ] Save playlists to machine
|
||||
- [ ] Cache playlist contents to disk
|
||||
- [ ] Expose service through mpd protocol
|
||||
- [ ] Users with playlists and songs (and auth?)
|
||||
- [ ] Some kind of fair scheduling for each user
|
||||
- [ ] Max time to avoid playlist songs
|
||||
- [ ] Expose video/media stream so others can listen at home
|
||||
- [ ] Syncope support >:)
|
||||
- [ ] Jitsi support >:)))
|
||||
- [ ] Show other media while playing music, like grafana or bustimes
|
||||
- [ ] Soft shuffle
|
||||
- [ ] Libre.fm integration
|
||||
- [ ] Karaoke mode lmao
|
||||
|
|
|
|||
|
|
@ -1,3 +0,0 @@
|
|||
[youtube]
|
||||
profile-cond=path:find('youtu%.?be')
|
||||
--ytdl-format="bestvideo[height<=?720][vcodec!~='vp0?9']+bestaudio/best"
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 157 KiB |
52
default.nix
52
default.nix
|
|
@ -1,52 +0,0 @@
|
|||
{
|
||||
lib
|
||||
, fetchFromGitHub
|
||||
, rustPlatform
|
||||
, makeWrapper
|
||||
, mpv
|
||||
, wrapped ? false
|
||||
}:
|
||||
|
||||
rustPlatform.buildRustPackage rec {
|
||||
pname = "greg-ng";
|
||||
version = "0.1.0";
|
||||
src = builtins.filterSource (path: type: let
|
||||
baseName = baseNameOf (toString path);
|
||||
in !(lib.any (b: b) [
|
||||
(!(lib.cleanSourceFilter path type))
|
||||
(type == "directory" && lib.elem baseName [
|
||||
".direnv"
|
||||
".git"
|
||||
"target"
|
||||
"result"
|
||||
])
|
||||
(type == "regular" && lib.elem baseName [
|
||||
"flake.nix"
|
||||
"flake.lock"
|
||||
"default.nix"
|
||||
"module.nix"
|
||||
".envrc"
|
||||
])
|
||||
])) ./.;
|
||||
|
||||
nativeBuildInputs = [ makeWrapper ];
|
||||
|
||||
cargoLock = {
|
||||
lockFile = ./Cargo.lock;
|
||||
outputHashes = {
|
||||
"mpvipc-async-0.1.0" = "sha256-2TQ2d4q9/DTxTZe9kOAoKBhsmegRZw32x3G2hbluS6U=";
|
||||
};
|
||||
};
|
||||
|
||||
postInstall = lib.optionalString wrapped ''
|
||||
wrapProgram $out/bin/greg-ng \
|
||||
--prefix PATH : '${lib.makeBinPath [ mpv ]}'
|
||||
'';
|
||||
|
||||
meta = with lib; {
|
||||
license = licenses.mit;
|
||||
maintainers = with maintainers; [ h7x4 ];
|
||||
platforms = platforms.linux ++ platforms.darwin;
|
||||
mainProgram = "greg-ng";
|
||||
};
|
||||
}
|
||||
48
flake.lock
48
flake.lock
|
|
@ -1,48 +0,0 @@
|
|||
{
|
||||
"nodes": {
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1729256560,
|
||||
"narHash": "sha256-/uilDXvCIEs3C9l73JTACm4quuHUsIHcns1c+cHUJwA=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "4c2fcb090b1f3e5b47eaa7bd33913b574a11e0a0",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "NixOS",
|
||||
"ref": "nixos-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"root": {
|
||||
"inputs": {
|
||||
"nixpkgs": "nixpkgs",
|
||||
"rust-overlay": "rust-overlay"
|
||||
}
|
||||
},
|
||||
"rust-overlay": {
|
||||
"inputs": {
|
||||
"nixpkgs": [
|
||||
"nixpkgs"
|
||||
]
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1729391507,
|
||||
"narHash": "sha256-as0I9xieJUHf7kiK2a9znDsVZQTFWhM1pLivII43Gi0=",
|
||||
"owner": "oxalica",
|
||||
"repo": "rust-overlay",
|
||||
"rev": "784981a9feeba406de38c1c9a3decf966d853cca",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "oxalica",
|
||||
"repo": "rust-overlay",
|
||||
"type": "github"
|
||||
}
|
||||
}
|
||||
},
|
||||
"root": "root",
|
||||
"version": 7
|
||||
}
|
||||
75
flake.nix
75
flake.nix
|
|
@ -1,75 +0,0 @@
|
|||
{
|
||||
inputs = {
|
||||
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
|
||||
|
||||
rust-overlay.url = "github:oxalica/rust-overlay";
|
||||
rust-overlay.inputs.nixpkgs.follows = "nixpkgs";
|
||||
};
|
||||
|
||||
outputs = { self, nixpkgs, rust-overlay }:
|
||||
let
|
||||
inherit (nixpkgs) lib;
|
||||
|
||||
systems = [
|
||||
"x86_64-linux"
|
||||
"aarch64-linux"
|
||||
"x86_64-darwin"
|
||||
"aarch64-darwin"
|
||||
"armv7l-linux"
|
||||
];
|
||||
|
||||
forAllSystems = f: lib.genAttrs systems (system: let
|
||||
pkgs = import nixpkgs {
|
||||
inherit system;
|
||||
overlays = [
|
||||
(import rust-overlay)
|
||||
];
|
||||
};
|
||||
|
||||
rust-bin = rust-overlay.lib.mkRustBin { } pkgs.buildPackages;
|
||||
toolchain = rust-bin.stable.latest.default.override {
|
||||
extensions = [ "rust-src" "rust-analyzer" "rust-std" ];
|
||||
};
|
||||
in f system pkgs toolchain);
|
||||
in {
|
||||
apps = forAllSystems (system: pkgs: _: {
|
||||
default = self.apps.${system}.greg-ng;
|
||||
greg-ng = let
|
||||
package = self.packages.${system}.greg-ng-wrapped;
|
||||
in {
|
||||
type = "app";
|
||||
program = toString (pkgs.writeShellScript "greg-ng" ''
|
||||
${lib.getExe package} --mpv-socket-path /tmp/greg-ng-mpv.sock -vvvv
|
||||
'');
|
||||
};
|
||||
});
|
||||
|
||||
devShells = forAllSystems (system: pkgs: toolchain: {
|
||||
default = pkgs.mkShell {
|
||||
nativeBuildInputs = [
|
||||
toolchain
|
||||
pkgs.mpv
|
||||
];
|
||||
|
||||
RUST_SRC_PATH = "${toolchain}/lib/rustlib/src/rust/library";
|
||||
};
|
||||
});
|
||||
|
||||
overlays = {
|
||||
default = self.overlays.greg-ng;
|
||||
greg-ng = final: prev: {
|
||||
inherit (self.packages.${prev.system}) greg-ng;
|
||||
};
|
||||
};
|
||||
|
||||
packages = forAllSystems (system: pkgs: _: {
|
||||
default = self.packages.${system}.greg-ng;
|
||||
greg-ng = pkgs.callPackage ./default.nix { };
|
||||
greg-ng-wrapped = pkgs.callPackage ./default.nix {
|
||||
wrapped = true;
|
||||
};
|
||||
});
|
||||
} // {
|
||||
nixosModules.default = ./module.nix;
|
||||
};
|
||||
}
|
||||
197
module.nix
197
module.nix
|
|
@ -1,197 +0,0 @@
|
|||
{ config, pkgs, lib, ... }:
|
||||
let
|
||||
cfg = config.services.greg-ng;
|
||||
in
|
||||
{
|
||||
options.services.greg-ng = {
|
||||
enable = lib.mkEnableOption "greg-ng, an mpv based media player";
|
||||
|
||||
package = lib.mkPackageOption pkgs "greg-ng" { };
|
||||
|
||||
mpvPackage = lib.mkPackageOption pkgs "mpv" { };
|
||||
|
||||
enableSway = lib.mkEnableOption "sway as the main window manager";
|
||||
|
||||
enablePipewire = lib.mkEnableOption "pipewire" // { default = true; };
|
||||
|
||||
logLevel = lib.mkOption {
|
||||
type = lib.types.enum [ "quiet" "error" "warn" "info" "debug" "trace" ];
|
||||
default = "debug";
|
||||
description = "Log level.";
|
||||
apply = level: {
|
||||
"quiet" = "-q";
|
||||
"error" = "";
|
||||
"warn" = "-v";
|
||||
"info" = "-vv";
|
||||
"debug" = "-vvv";
|
||||
"trace" = "-vvvv";
|
||||
}.${level};
|
||||
};
|
||||
|
||||
# TODO: create some better descriptions
|
||||
settings = {
|
||||
host = lib.mkOption {
|
||||
type = lib.types.str;
|
||||
default = "localhost";
|
||||
example = "0.0.0.0";
|
||||
description = ''
|
||||
Which host to bind to.
|
||||
'';
|
||||
};
|
||||
|
||||
port = lib.mkOption {
|
||||
type = lib.types.port;
|
||||
default = 8008;
|
||||
example = 10008;
|
||||
description = ''
|
||||
Which port to bind to.
|
||||
'';
|
||||
};
|
||||
|
||||
mpv-socket-path = lib.mkOption {
|
||||
type = lib.types.str;
|
||||
default = "%t/greg-ng-mpv.sock";
|
||||
description = ''
|
||||
Path to the mpv socket.
|
||||
'';
|
||||
};
|
||||
|
||||
mpv-executable-path = lib.mkOption {
|
||||
type = lib.types.str;
|
||||
default = lib.getExe cfg.mpvPackage;
|
||||
defaultText = lib.literalExpression ''
|
||||
lib.getExe config.services.greg-ng.mpvPackage
|
||||
'';
|
||||
description = ''
|
||||
Path to the mpv executable.
|
||||
'';
|
||||
};
|
||||
|
||||
mpv-config-file = lib.mkOption {
|
||||
type = with lib.types; nullOr str;
|
||||
default = null;
|
||||
description = ''
|
||||
Path to the mpv config file.
|
||||
'';
|
||||
};
|
||||
|
||||
auto-start-mpv = lib.mkOption {
|
||||
type = lib.types.bool;
|
||||
default = true;
|
||||
description = ''
|
||||
Whether to automatically start mpv.
|
||||
'';
|
||||
};
|
||||
|
||||
force-auto-start = lib.mkOption {
|
||||
type = lib.types.bool;
|
||||
default = true;
|
||||
description = ''
|
||||
Whether to force auto starting mpv.
|
||||
'';
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
config = lib.mkMerge [
|
||||
(lib.mkIf cfg.enable {
|
||||
systemd.user.services.greg-ng = {
|
||||
description = "greg-ng, an mpv based media player";
|
||||
wantedBy = [ "graphical-session.target" ];
|
||||
partOf = [ "graphical-session.target" ];
|
||||
serviceConfig = {
|
||||
Type = "notify";
|
||||
ExecStart = let
|
||||
args = lib.cli.toGNUCommandLineShell { } (cfg.settings // {
|
||||
systemd = true;
|
||||
});
|
||||
in "${lib.getExe cfg.package} ${cfg.logLevel} ${args}";
|
||||
|
||||
Restart = "always";
|
||||
RestartSec = 3;
|
||||
WatchdogSec = lib.mkDefault 15;
|
||||
TimeoutStartSec = lib.mkDefault 30;
|
||||
|
||||
RestrictAddressFamilies = [ "AF_UNIX" "AF_INET" "AF_INET6" ];
|
||||
AmbientCapabilities = [ "" ];
|
||||
CapabilityBoundingSet = [ "" ];
|
||||
DeviceAllow = [ "" ];
|
||||
LockPersonality = true;
|
||||
# Might work, but wouldn't bet on it with embedded lua in mpv
|
||||
MemoryDenyWriteExecute = false;
|
||||
NoNewPrivileges = true;
|
||||
# MPV and mesa tries to talk directly to the GPU.
|
||||
PrivateDevices = false;
|
||||
PrivateMounts = true;
|
||||
PrivateTmp = true;
|
||||
PrivateUsers = true;
|
||||
ProcSubset = "pid";
|
||||
ProtectClock = true;
|
||||
ProtectControlGroups = true;
|
||||
# MPV wants ~/.cache
|
||||
ProtectHome = false;
|
||||
ProtectHostname = true;
|
||||
ProtectKernelLogs = true;
|
||||
ProtectKernelModules = true;
|
||||
ProtectKernelTunables = true;
|
||||
ProtectProc = "invisible";
|
||||
# I'll figure it out sometime
|
||||
# ProtectSystem = "full";
|
||||
RemoveIPC = true;
|
||||
UMask = "0077";
|
||||
RestrictNamespaces = true;
|
||||
RestrictRealtime = true;
|
||||
RestrictSUIDSGID = true;
|
||||
SystemCallArchitectures = "native";
|
||||
# Something brokey
|
||||
# SystemCallFilter = [
|
||||
# "@system-service"
|
||||
# "~@privileged"
|
||||
# "~@resources"
|
||||
# ];
|
||||
};
|
||||
};
|
||||
})
|
||||
(lib.mkIf (cfg.enable && cfg.enablePipewire) {
|
||||
services.pipewire = {
|
||||
enable = true;
|
||||
alsa.enable = true;
|
||||
alsa.support32Bit = true;
|
||||
pulse.enable = true;
|
||||
};
|
||||
})
|
||||
(lib.mkIf (cfg.enable && cfg.enableSway) {
|
||||
programs.sway = {
|
||||
enable = true;
|
||||
wrapperFeatures.gtk = true;
|
||||
};
|
||||
|
||||
xdg.portal = {
|
||||
enable = true;
|
||||
wlr.enable = true;
|
||||
extraPortals = [ pkgs.xdg-desktop-portal-gtk ];
|
||||
};
|
||||
|
||||
users = {
|
||||
users.greg = {
|
||||
isNormalUser = true;
|
||||
group = "greg";
|
||||
uid = 2000;
|
||||
description = "loud gym bro";
|
||||
};
|
||||
groups.greg.gid = 2000;
|
||||
};
|
||||
|
||||
services.greetd = {
|
||||
enable = true;
|
||||
settings = rec {
|
||||
initial_session = {
|
||||
command = "${pkgs.sway}/bin/sway";
|
||||
user = "greg";
|
||||
};
|
||||
default_session = initial_session;
|
||||
};
|
||||
};
|
||||
})
|
||||
];
|
||||
}
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
mod base;
|
||||
mod rest_wrapper_v1;
|
||||
|
||||
pub use rest_wrapper_v1::{rest_api_routes, rest_api_docs};
|
||||
pub use rest_wrapper_v1::rest_api_routes;
|
||||
|
|
|
|||
165
src/api/base.rs
165
src/api/base.rs
|
|
@ -1,61 +1,62 @@
|
|||
use mpvipc_async::{
|
||||
LoopProperty, Mpv, MpvExt, NumberChangeOptions, PlaylistAddOptions, PlaylistAddTypeOptions,
|
||||
SeekOptions, Switch,
|
||||
use std::sync::Arc;
|
||||
|
||||
use log::trace;
|
||||
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: Mpv, path: &str) -> anyhow::Result<()> {
|
||||
log::trace!("api::loadfile({:?})", path);
|
||||
mpv.playlist_add(
|
||||
pub async fn loadfile(mpv: Arc<Mutex<Mpv>>, path: &str) -> anyhow::Result<()> {
|
||||
trace!("api::loadfile({:?})", path);
|
||||
mpv.lock().await.playlist_add(
|
||||
path,
|
||||
PlaylistAddTypeOptions::File,
|
||||
PlaylistAddOptions::Append,
|
||||
)
|
||||
.await?;
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Check whether the player is paused or playing
|
||||
pub async fn play_get(mpv: Mpv) -> anyhow::Result<Value> {
|
||||
log::trace!("api::play_get()");
|
||||
let paused: bool = !mpv.is_playing().await?;
|
||||
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")?;
|
||||
Ok(json!(!paused))
|
||||
}
|
||||
|
||||
/// Set whether the player is paused or playing
|
||||
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 })
|
||||
pub async fn play_set(mpv: Arc<Mutex<Mpv>>, should_play: bool) -> anyhow::Result<()> {
|
||||
trace!("api::play_set({:?})", should_play);
|
||||
mpv.lock()
|
||||
.await
|
||||
.set_property("pause", !should_play)
|
||||
.map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// Get the current player volume
|
||||
pub async fn volume_get(mpv: Mpv) -> anyhow::Result<Value> {
|
||||
log::trace!("api::volume_get()");
|
||||
let volume: f64 = mpv.get_volume().await?;
|
||||
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")?;
|
||||
Ok(json!(volume))
|
||||
}
|
||||
|
||||
/// Set the player volume
|
||||
pub async fn volume_set(mpv: Mpv, value: f64) -> anyhow::Result<()> {
|
||||
log::trace!("api::volume_set({:?})", value);
|
||||
mpv.set_volume(value, NumberChangeOptions::Absolute)
|
||||
pub async fn volume_set(mpv: Arc<Mutex<Mpv>>, value: f64) -> anyhow::Result<()> {
|
||||
trace!("api::volume_set({:?})", value);
|
||||
mpv.lock()
|
||||
.await
|
||||
.set_volume(value, NumberChangeOptions::Absolute)
|
||||
.map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// Get current playback position
|
||||
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,
|
||||
};
|
||||
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;
|
||||
|
||||
Ok(json!({
|
||||
"current": current,
|
||||
|
|
@ -65,16 +66,22 @@ pub async fn time_get(mpv: Mpv) -> anyhow::Result<Value> {
|
|||
}
|
||||
|
||||
/// Set playback position
|
||||
pub async fn time_set(mpv: Mpv, pos: Option<f64>, percent: Option<f64>) -> anyhow::Result<()> {
|
||||
log::trace!("api::time_set({:?}, {:?})", pos, percent);
|
||||
pub async fn time_set(
|
||||
mpv: Arc<Mutex<Mpv>>,
|
||||
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.seek(pos, SeekOptions::Absolute).await?;
|
||||
mpv.lock().await.seek(pos, SeekOptions::Absolute)?;
|
||||
} else if let Some(percent) = percent {
|
||||
mpv.seek(percent, SeekOptions::AbsolutePercent).await?;
|
||||
mpv.lock()
|
||||
.await
|
||||
.seek(percent, SeekOptions::AbsolutePercent)?;
|
||||
} else {
|
||||
anyhow::bail!("Either pos or percent must be provided");
|
||||
};
|
||||
|
|
@ -83,10 +90,10 @@ pub async fn time_set(mpv: Mpv, pos: Option<f64>, percent: Option<f64>) -> anyho
|
|||
}
|
||||
|
||||
/// Get the current playlist
|
||||
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?;
|
||||
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")?;
|
||||
|
||||
let items: Vec<Value> = playlist
|
||||
.0
|
||||
|
|
@ -97,7 +104,7 @@ pub async fn playlist_get(mpv: Mpv) -> anyhow::Result<Value> {
|
|||
"index": i,
|
||||
"current": item.current,
|
||||
"playing": is_playing,
|
||||
"filename": item.title.as_ref().unwrap_or(&item.filename),
|
||||
"filename": item.filename,
|
||||
"data": {
|
||||
"fetching": true,
|
||||
}
|
||||
|
|
@ -109,64 +116,74 @@ pub async fn playlist_get(mpv: Mpv) -> anyhow::Result<Value> {
|
|||
}
|
||||
|
||||
/// Skip to the next item in the playlist
|
||||
pub async fn playlist_next(mpv: Mpv) -> anyhow::Result<()> {
|
||||
log::trace!("api::playlist_next()");
|
||||
mpv.next().await.map_err(|e| e.into())
|
||||
pub async fn playlist_next(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
|
||||
trace!("api::playlist_next()");
|
||||
mpv.lock().await.next().map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// Go back to the previous item in the playlist
|
||||
pub async fn playlist_previous(mpv: Mpv) -> anyhow::Result<()> {
|
||||
log::trace!("api::playlist_previous()");
|
||||
mpv.prev().await.map_err(|e| e.into())
|
||||
pub async fn playlist_previous(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
|
||||
trace!("api::playlist_previous()");
|
||||
mpv.lock().await.prev().map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// Go chosen item in the playlist
|
||||
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())
|
||||
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())
|
||||
}
|
||||
|
||||
/// Clears the playlist
|
||||
pub async fn playlist_clear(mpv: Mpv) -> anyhow::Result<()> {
|
||||
log::trace!("api::playlist_clear()");
|
||||
mpv.playlist_clear().await.map_err(|e| e.into())
|
||||
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())
|
||||
}
|
||||
|
||||
/// Remove an item from the playlist by index
|
||||
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())
|
||||
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())
|
||||
}
|
||||
|
||||
/// Move an item in the playlist from one index to another
|
||||
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())
|
||||
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())
|
||||
}
|
||||
|
||||
/// Shuffle the playlist
|
||||
pub async fn shuffle(mpv: Mpv) -> anyhow::Result<()> {
|
||||
log::trace!("api::shuffle()");
|
||||
mpv.playlist_shuffle().await.map_err(|e| e.into())
|
||||
pub async fn shuffle(mpv: Arc<Mutex<Mpv>>) -> anyhow::Result<()> {
|
||||
trace!("api::shuffle()");
|
||||
mpv.lock().await.playlist_shuffle().map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// See whether it loops the playlist or not
|
||||
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_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_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())
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,103 +1,26 @@
|
|||
use axum::{
|
||||
extract::{Query, State},
|
||||
http::StatusCode,
|
||||
response::{IntoResponse, Response},
|
||||
routing::{delete, get, post},
|
||||
Json, Router,
|
||||
};
|
||||
use mpvipc_async::Mpv;
|
||||
use serde_json::{json, Value};
|
||||
use std::{ops::Deref, sync::Arc};
|
||||
|
||||
use utoipa::OpenApi;
|
||||
use utoipa_axum::{router::OpenApiRouter, routes};
|
||||
use utoipa_swagger_ui::SwaggerUi;
|
||||
use aide::{axum::IntoApiResponse, operation::OperationIo, OperationOutput};
|
||||
use axum_jsonschema::JsonSchemaRejection;
|
||||
|
||||
use axum::{
|
||||
async_trait, extract::{rejection::{FailedToDeserializeQueryString, QueryRejection}, FromRequest, FromRequestParts, State}, http::{request::Parts, StatusCode}, response::{IntoResponse, Response}, routing::{delete, get, post}, Json, Router
|
||||
};
|
||||
use mpvipc::Mpv;
|
||||
use schemars::JsonSchema;
|
||||
use serde::{de::DeserializeOwned, Serialize};
|
||||
use serde_json::{json, Value};
|
||||
use tokio::sync::Mutex;
|
||||
|
||||
use super::base;
|
||||
|
||||
pub fn rest_api_routes(mpv: Mpv) -> Router {
|
||||
Router::new()
|
||||
.route("/load", post(loadfile))
|
||||
.route("/play", get(play_get))
|
||||
.route("/play", post(play_set))
|
||||
.route("/volume", get(volume_get))
|
||||
.route("/volume", post(volume_set))
|
||||
.route("/time", get(time_get))
|
||||
.route("/time", post(time_set))
|
||||
.route("/playlist", get(playlist_get))
|
||||
.route("/playlist/next", post(playlist_next))
|
||||
.route("/playlist/previous", post(playlist_previous))
|
||||
.route("/playlist/goto", post(playlist_goto))
|
||||
.route("/playlist", delete(playlist_remove_or_clear))
|
||||
.route("/playlist/move", post(playlist_move))
|
||||
.route("/playlist/shuffle", post(shuffle))
|
||||
.route("/playlist/loop", get(playlist_get_looping))
|
||||
.route("/playlist/loop", post(playlist_set_looping))
|
||||
.with_state(mpv)
|
||||
}
|
||||
|
||||
pub fn rest_api_docs(mpv: Mpv) -> Router {
|
||||
let (router, api) = OpenApiRouter::with_openapi(ApiDoc::openapi())
|
||||
.routes(routes!(loadfile))
|
||||
.routes(routes!(play_get, play_set))
|
||||
.routes(routes!(volume_get, volume_set))
|
||||
.routes(routes!(time_get, time_set))
|
||||
.routes(routes!(
|
||||
playlist_get,
|
||||
playlist_remove_or_clear
|
||||
))
|
||||
.routes(routes!(playlist_next))
|
||||
.routes(routes!(playlist_previous))
|
||||
.routes(routes!(playlist_goto))
|
||||
.routes(routes!(playlist_move))
|
||||
.routes(routes!(playlist_get_looping, playlist_set_looping))
|
||||
.routes(routes!(shuffle))
|
||||
.with_state(mpv)
|
||||
.split_for_parts();
|
||||
|
||||
router.merge(SwaggerUi::new("/docs").url("/docs/openapi.json", api))
|
||||
}
|
||||
|
||||
// NOTE: the openapi stuff is very heavily duplicated and introduces
|
||||
// a lot of maintenance overhead and boilerplate. It should theoretically
|
||||
// be possible to infer a lot of this from axum, but I haven't found a
|
||||
// good library that does this and works properly yet (I have tried some
|
||||
// but they all had issues). Feel free to replace this with a better solution.
|
||||
|
||||
#[derive(OpenApi)]
|
||||
#[openapi(
|
||||
info(
|
||||
description = "The legacy Grzegorz Brzeczyszczykiewicz API, used to control a running mpv instance",
|
||||
version = "1.0.0",
|
||||
),
|
||||
)]
|
||||
struct ApiDoc;
|
||||
|
||||
#[derive(serde::Serialize, utoipa::ToSchema)]
|
||||
struct EmptySuccessResponse {
|
||||
success: bool,
|
||||
error: bool,
|
||||
}
|
||||
|
||||
#[derive(serde::Serialize, utoipa::ToSchema)]
|
||||
struct SuccessResponse {
|
||||
#[schema(example = true)]
|
||||
success: bool,
|
||||
#[schema(example = false)]
|
||||
error: bool,
|
||||
#[schema(example = json!({ some: "arbitrary json value" }))]
|
||||
value: Value,
|
||||
}
|
||||
|
||||
#[derive(serde::Serialize, utoipa::ToSchema)]
|
||||
struct ErrorResponse {
|
||||
#[schema(example = "error....")]
|
||||
error: String,
|
||||
#[schema(example = "error....")]
|
||||
errortext: String,
|
||||
#[schema(example = false)]
|
||||
success: bool,
|
||||
}
|
||||
|
||||
// #[derive(FromRequest, OperationIo)]
|
||||
// #[from_request(via(axum_jsonschema::Json), rejection(RestResponse))]
|
||||
// #[aide(
|
||||
// input_with = "axum_jsonschema::Json<T>",
|
||||
// output_with = "axum_jsonschema::Json<T>",
|
||||
// json_schema
|
||||
// )]
|
||||
pub struct RestResponse(anyhow::Result<Value>);
|
||||
|
||||
impl From<anyhow::Result<Value>> for RestResponse {
|
||||
|
|
@ -118,215 +41,203 @@ impl IntoResponse for RestResponse {
|
|||
Ok(value) => (StatusCode::OK, Json(value)).into_response(),
|
||||
Err(err) => (
|
||||
StatusCode::INTERNAL_SERVER_ERROR,
|
||||
Json(json!({ "error": err.to_string(), "errortext": err.to_string(), "success": false })),
|
||||
Json(json!({ "error": err.to_string(), "success": false })),
|
||||
)
|
||||
.into_response(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl aide::OperationOutput for RestResponse {
|
||||
type Inner = anyhow::Result<Value>;
|
||||
}
|
||||
|
||||
/// -------
|
||||
|
||||
// impl<T> aide::OperationInput for Query<T> {}
|
||||
|
||||
// #[derive(FromRequest, OperationIo)]
|
||||
// #[from_request(via(axum_jsonschema::Json), rejection(RestResponse))]
|
||||
// #[aide(
|
||||
// input_with = "axum_jsonschema::Json<T>",
|
||||
// output_with = "axum_jsonschema::Json<T>",
|
||||
// json_schema
|
||||
// )]
|
||||
// pub struct Json<T>(pub T);
|
||||
|
||||
// impl<T> IntoResponse for Json<T>
|
||||
// where
|
||||
// T: Serialize,
|
||||
// {
|
||||
// fn into_response(self) -> axum::response::Response {
|
||||
// axum::Json(self.0).into_response()
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(OperationIo)]
|
||||
#[aide(json_schema)]
|
||||
pub struct Query<T>(pub T);
|
||||
|
||||
#[async_trait]
|
||||
impl <T, S> FromRequestParts<S> for Query<T>
|
||||
where
|
||||
T: JsonSchema + DeserializeOwned,
|
||||
S: Send + Sync,
|
||||
{
|
||||
type Rejection = QueryRejection;
|
||||
|
||||
async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
|
||||
let axum::extract::Query(query) = axum::extract::Query::try_from_uri(&parts.uri)?;
|
||||
Ok(Query(query))
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Deref for Query<T> {
|
||||
type Target = T;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
pub fn rest_api_route_docs(mpv: Arc<Mutex<Mpv>>) -> Router {
|
||||
use aide::axum::ApiRouter;
|
||||
use aide::axum::routing::{delete, get, post};
|
||||
|
||||
let mut api = aide::openapi::OpenApi::default();
|
||||
|
||||
let x = ApiRouter::new()
|
||||
// .api_route("/load", get(loadfile))
|
||||
.api_route("/play", get(play_get))
|
||||
.finish_api(&mut api);
|
||||
// .with_state(mpv);
|
||||
|
||||
todo!()
|
||||
}
|
||||
|
||||
// ----------
|
||||
|
||||
pub fn rest_api_routes(mpv: Arc<Mutex<Mpv>>) -> Router {
|
||||
Router::new()
|
||||
.route("/load", post(loadfile))
|
||||
.route("/play", get(play_get))
|
||||
.route("/play", post(play_set))
|
||||
.route("/volume", get(volume_get))
|
||||
.route("/volume", post(volume_set))
|
||||
.route("/time", get(time_get))
|
||||
.route("/time", post(time_set))
|
||||
.route("/playlist", get(playlist_get))
|
||||
.route("/playlist/next", post(playlist_next))
|
||||
.route("/playlist/previous", post(playlist_previous))
|
||||
.route("/playlist/goto", post(playlist_goto))
|
||||
.route("/playlist", delete(playlist_remove_or_clear))
|
||||
.route("/playlist/move", post(playlist_move))
|
||||
.route("/playlist/shuffle", post(shuffle))
|
||||
.route("/playlist/loop", get(playlist_get_looping))
|
||||
.route("/playlist/loop", post(playlist_set_looping))
|
||||
.with_state(mpv)
|
||||
}
|
||||
|
||||
// -------------------//
|
||||
// Boilerplate galore //
|
||||
// -------------------//
|
||||
|
||||
// TODO: These could possibly be generated with a proc macro
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize, JsonSchema)]
|
||||
struct LoadFileArgs {
|
||||
path: String,
|
||||
}
|
||||
|
||||
|
||||
/// Add item to playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/load",
|
||||
params(LoadFileArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn loadfile(State(mpv): State<Mpv>, Query(query): Query<LoadFileArgs>) -> RestResponse {
|
||||
#[axum::debug_handler]
|
||||
async fn loadfile(
|
||||
State(mpv): State<Arc<Mutex<Mpv>>>,
|
||||
Query(query): Query<LoadFileArgs>,
|
||||
) -> RestResponse {
|
||||
base::loadfile(mpv, &query.path).await.into()
|
||||
}
|
||||
|
||||
/// Check whether the player is paused or playing
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/play",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn play_get(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::play_get(mpv).await.into()
|
||||
async fn play_get(State(mpv): State<Arc<Mutex<Mpv>>>) -> impl IntoApiResponse {
|
||||
RestResponse::from(base::play_get(mpv).await)
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize, JsonSchema)]
|
||||
struct PlaySetArgs {
|
||||
play: String,
|
||||
}
|
||||
|
||||
/// Set whether the player is paused or playing
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/play",
|
||||
params(PlaySetArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn play_set(State(mpv): State<Mpv>, Query(query): Query<PlaySetArgs>) -> RestResponse {
|
||||
async fn play_set(
|
||||
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()
|
||||
}
|
||||
|
||||
/// Get the current player volume
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/volume",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn volume_get(State(mpv): State<Mpv>) -> RestResponse {
|
||||
async fn volume_get(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
|
||||
base::volume_get(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize, JsonSchema)]
|
||||
struct VolumeSetArgs {
|
||||
volume: f64,
|
||||
}
|
||||
|
||||
/// Set the player volume
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/volume",
|
||||
params(VolumeSetArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn volume_set(State(mpv): State<Mpv>, Query(query): Query<VolumeSetArgs>) -> RestResponse {
|
||||
async fn volume_set(
|
||||
State(mpv): State<Arc<Mutex<Mpv>>>,
|
||||
Query(query): Query<VolumeSetArgs>,
|
||||
) -> RestResponse {
|
||||
base::volume_set(mpv, query.volume).await.into()
|
||||
}
|
||||
|
||||
/// Get current playback position
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/time",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn time_get(State(mpv): State<Mpv>) -> RestResponse {
|
||||
async fn time_get(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
|
||||
base::time_get(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize, JsonSchema)]
|
||||
struct TimeSetArgs {
|
||||
pos: Option<f64>,
|
||||
percent: Option<f64>,
|
||||
}
|
||||
|
||||
/// Set playback position
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/time",
|
||||
params(TimeSetArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn time_set(State(mpv): State<Mpv>, Query(query): Query<TimeSetArgs>) -> RestResponse {
|
||||
async fn time_set(
|
||||
State(mpv): State<Arc<Mutex<Mpv>>>,
|
||||
Query(query): Query<TimeSetArgs>,
|
||||
) -> RestResponse {
|
||||
base::time_set(mpv, query.pos, query.percent).await.into()
|
||||
}
|
||||
|
||||
/// Get the current playlist
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/playlist",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_get(State(mpv): State<Mpv>) -> RestResponse {
|
||||
async fn playlist_get(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
|
||||
base::playlist_get(mpv).await.into()
|
||||
}
|
||||
|
||||
/// Go to the next item in the playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/next",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_next(State(mpv): State<Mpv>) -> RestResponse {
|
||||
async fn playlist_next(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
|
||||
base::playlist_next(mpv).await.into()
|
||||
}
|
||||
|
||||
/// Go back to the previous item in the playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/previous",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_previous(State(mpv): State<Mpv>) -> RestResponse {
|
||||
async fn playlist_previous(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
|
||||
base::playlist_previous(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize, JsonSchema)]
|
||||
struct PlaylistGotoArgs {
|
||||
index: usize,
|
||||
}
|
||||
|
||||
/// Go to a specific item in the playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/goto",
|
||||
params(PlaylistGotoArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_goto(
|
||||
State(mpv): State<Mpv>,
|
||||
State(mpv): State<Arc<Mutex<Mpv>>>,
|
||||
Query(query): Query<PlaylistGotoArgs>,
|
||||
) -> RestResponse {
|
||||
base::playlist_goto(mpv, query.index).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize, JsonSchema)]
|
||||
struct PlaylistRemoveOrClearArgs {
|
||||
index: Option<usize>,
|
||||
}
|
||||
|
||||
/// Clears a single item or the entire playlist
|
||||
#[utoipa::path(
|
||||
delete,
|
||||
path = "/playlist",
|
||||
params(PlaylistRemoveOrClearArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_remove_or_clear(
|
||||
State(mpv): State<Mpv>,
|
||||
State(mpv): State<Arc<Mutex<Mpv>>>,
|
||||
Query(query): Query<PlaylistRemoveOrClearArgs>,
|
||||
) -> RestResponse {
|
||||
match query.index {
|
||||
|
|
@ -335,24 +246,14 @@ async fn playlist_remove_or_clear(
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize, JsonSchema)]
|
||||
struct PlaylistMoveArgs {
|
||||
index1: usize,
|
||||
index2: usize,
|
||||
}
|
||||
|
||||
/// Move a playlist item to a different position
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/move",
|
||||
params(PlaylistMoveArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_move(
|
||||
State(mpv): State<Mpv>,
|
||||
State(mpv): State<Arc<Mutex<Mpv>>>,
|
||||
Query(query): Query<PlaylistMoveArgs>,
|
||||
) -> RestResponse {
|
||||
base::playlist_move(mpv, query.index1, query.index2)
|
||||
|
|
@ -360,49 +261,21 @@ async fn playlist_move(
|
|||
.into()
|
||||
}
|
||||
|
||||
/// Shuffle the playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/shuffle",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn shuffle(State(mpv): State<Mpv>) -> RestResponse {
|
||||
async fn shuffle(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
|
||||
base::shuffle(mpv).await.into()
|
||||
}
|
||||
|
||||
/// Check whether the playlist is looping
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/playlist/loop",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_get_looping(State(mpv): State<Mpv>) -> RestResponse {
|
||||
async fn playlist_get_looping(State(mpv): State<Arc<Mutex<Mpv>>>) -> RestResponse {
|
||||
base::playlist_get_looping(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize, JsonSchema)]
|
||||
struct PlaylistSetLoopingArgs {
|
||||
r#loop: bool,
|
||||
}
|
||||
|
||||
/// Set whether the playlist should loop
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/loop",
|
||||
params(PlaylistSetLoopingArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_set_looping(
|
||||
State(mpv): State<Mpv>,
|
||||
State(mpv): State<Arc<Mutex<Mpv>>>,
|
||||
Query(query): Query<PlaylistSetLoopingArgs>,
|
||||
) -> RestResponse {
|
||||
base::playlist_set_looping(mpv, query.r#loop).await.into()
|
||||
|
|
|
|||
266
src/main.rs
266
src/main.rs
|
|
@ -1,15 +1,20 @@
|
|||
use anyhow::Context;
|
||||
use axum::Router;
|
||||
use axum::{Router, Server};
|
||||
use clap::Parser;
|
||||
use clap_verbosity_flag::Verbosity;
|
||||
use mpv_setup::{connect_to_mpv, create_mpv_config_file, show_grzegorz_image};
|
||||
use mpvipc_async::Mpv;
|
||||
use std::net::{IpAddr, SocketAddr};
|
||||
use systemd_journal_logger::JournalLog;
|
||||
use tempfile::NamedTempFile;
|
||||
use mpvipc::Mpv;
|
||||
use std::{
|
||||
fs::create_dir_all,
|
||||
net::{IpAddr, SocketAddr},
|
||||
path::Path,
|
||||
sync::Arc,
|
||||
};
|
||||
use tokio::{
|
||||
process::{Child, Command},
|
||||
sync::Mutex,
|
||||
};
|
||||
|
||||
mod api;
|
||||
mod mpv_setup;
|
||||
mod mpv_broker;
|
||||
|
||||
#[derive(Parser)]
|
||||
struct Args {
|
||||
|
|
@ -19,21 +24,12 @@ struct Args {
|
|||
#[clap(short, long, default_value = "8008")]
|
||||
port: u16,
|
||||
|
||||
#[command(flatten)]
|
||||
verbose: Verbosity,
|
||||
|
||||
#[clap(long)]
|
||||
systemd: bool,
|
||||
|
||||
#[clap(long, value_name = "PATH", default_value = "/run/mpv/mpv.sock")]
|
||||
mpv_socket_path: String,
|
||||
|
||||
#[clap(long, value_name = "PATH")]
|
||||
mpv_executable_path: Option<String>,
|
||||
|
||||
#[clap(long, value_name = "PATH")]
|
||||
mpv_config_file: Option<String>,
|
||||
|
||||
#[clap(long, default_value = "true")]
|
||||
auto_start_mpv: bool,
|
||||
|
||||
|
|
@ -41,16 +37,90 @@ struct Args {
|
|||
force_auto_start: bool,
|
||||
}
|
||||
|
||||
struct MpvConnectionArgs<'a> {
|
||||
struct MpvConnectionArgs {
|
||||
socket_path: String,
|
||||
executable_path: Option<String>,
|
||||
config_file: &'a NamedTempFile,
|
||||
auto_start: bool,
|
||||
force_auto_start: bool,
|
||||
}
|
||||
|
||||
/// Helper function to resolve a hostname to an IP address.
|
||||
/// Why is this not in the standard library? >:(
|
||||
async fn connect_to_mpv(args: &MpvConnectionArgs) -> anyhow::Result<(Mpv, Option<Child>)> {
|
||||
log::debug!("Connecting to mpv");
|
||||
|
||||
debug_assert!(
|
||||
!args.force_auto_start || args.auto_start,
|
||||
"force_auto_start requires auto_start"
|
||||
);
|
||||
|
||||
let socket_path = Path::new(&args.socket_path);
|
||||
|
||||
if !socket_path.exists() {
|
||||
log::debug!("Mpv socket not found at {}", &args.socket_path);
|
||||
if !args.auto_start {
|
||||
panic!("Mpv socket not found at {}", &args.socket_path);
|
||||
}
|
||||
|
||||
log::debug!("Ensuring parent dir of mpv socket exists");
|
||||
let parent_dir = Path::new(&args.socket_path)
|
||||
.parent()
|
||||
.context("Failed to get parent dir of mpv socket")?;
|
||||
|
||||
if !parent_dir.is_dir() {
|
||||
create_dir_all(parent_dir).context("Failed to create parent dir of mpv socket")?;
|
||||
}
|
||||
} else {
|
||||
log::debug!("Existing mpv socket found at {}", &args.socket_path);
|
||||
if args.force_auto_start {
|
||||
log::debug!("Removing mpv socket");
|
||||
std::fs::remove_file(&args.socket_path)?;
|
||||
}
|
||||
}
|
||||
|
||||
let process_handle = if args.auto_start {
|
||||
log::info!("Starting mpv with socket at {}", &args.socket_path);
|
||||
|
||||
// TODO: try to fetch mpv from PATH
|
||||
Some(
|
||||
Command::new(args.executable_path.as_deref().unwrap_or("mpv"))
|
||||
.arg(format!("--input-ipc-server={}", &args.socket_path))
|
||||
.arg("--idle")
|
||||
.arg("--force-window")
|
||||
// .arg("--fullscreen")
|
||||
// .arg("--no-terminal")
|
||||
// .arg("--load-unsafe-playlists")
|
||||
.arg("--keep-open") // Keep last frame of video on end of video
|
||||
.spawn()
|
||||
.context("Failed to start mpv")?,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
// Wait for mpv to create the socket
|
||||
if tokio::time::timeout(tokio::time::Duration::from_millis(500), async {
|
||||
while !&socket_path.exists() {
|
||||
log::debug!("Waiting for mpv socket at {}", &args.socket_path);
|
||||
tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
return Err(anyhow::anyhow!(
|
||||
"Failed to connect to mpv socket: {}",
|
||||
&args.socket_path
|
||||
));
|
||||
}
|
||||
|
||||
Ok((
|
||||
Mpv::connect(&args.socket_path).context(format!(
|
||||
"Failed to connect to mpv socket: {}",
|
||||
&args.socket_path
|
||||
))?,
|
||||
process_handle,
|
||||
))
|
||||
}
|
||||
|
||||
async fn resolve(host: &str) -> anyhow::Result<IpAddr> {
|
||||
let addr = format!("{}:0", host);
|
||||
let addresses = tokio::net::lookup_host(addr).await?;
|
||||
|
|
@ -61,147 +131,42 @@ async fn resolve(host: &str) -> anyhow::Result<IpAddr> {
|
|||
.ok_or_else(|| anyhow::anyhow!("Failed to resolve address"))
|
||||
}
|
||||
|
||||
/// Helper function that spawns a tokio thread that
|
||||
/// continuously sends a ping to systemd watchdog, if enabled.
|
||||
async fn setup_systemd_watchdog_thread() -> anyhow::Result<()> {
|
||||
let mut watchdog_microsecs: u64 = 0;
|
||||
if sd_notify::watchdog_enabled(true, &mut watchdog_microsecs) {
|
||||
watchdog_microsecs = watchdog_microsecs.div_ceil(2);
|
||||
tokio::spawn(async move {
|
||||
log::debug!(
|
||||
"Starting systemd watchdog thread with {} millisecond interval",
|
||||
watchdog_microsecs.div_ceil(1000)
|
||||
);
|
||||
loop {
|
||||
tokio::time::sleep(tokio::time::Duration::from_micros(watchdog_microsecs)).await;
|
||||
if let Err(err) = sd_notify::notify(false, &[sd_notify::NotifyState::Watchdog]) {
|
||||
log::warn!("Failed to notify systemd watchdog: {}", err);
|
||||
} else {
|
||||
log::trace!("Ping sent to systemd watchdog");
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
log::info!("Watchdog not enabled, skipping");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn shutdown(mpv: Mpv, proc: Option<tokio::process::Child>) {
|
||||
log::info!("Shutting down");
|
||||
sd_notify::notify(false, &[sd_notify::NotifyState::Stopping]).unwrap_or_else(|e| {
|
||||
log::warn!(
|
||||
"Failed to notify systemd that the service is stopping: {}",
|
||||
e
|
||||
)
|
||||
});
|
||||
|
||||
mpv.disconnect()
|
||||
.await
|
||||
.unwrap_or_else(|e| log::warn!("Failed to disconnect from mpv: {}", e));
|
||||
if let Some(mut proc) = proc {
|
||||
proc.kill()
|
||||
.await
|
||||
.unwrap_or_else(|e| log::warn!("Failed to kill mpv process: {}", e));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
env_logger::init();
|
||||
let args = Args::parse();
|
||||
|
||||
let systemd_mode = args.systemd && sd_notify::booted().unwrap_or(false);
|
||||
if systemd_mode {
|
||||
JournalLog::new()
|
||||
.context("Failed to initialize journald logging")?
|
||||
.install()
|
||||
.context("Failed to install journald logger")?;
|
||||
|
||||
log::set_max_level(args.verbose.log_level_filter());
|
||||
|
||||
log::debug!("Running with systemd integration");
|
||||
|
||||
setup_systemd_watchdog_thread().await?;
|
||||
} else {
|
||||
env_logger::Builder::new()
|
||||
.filter_level(args.verbose.log_level_filter())
|
||||
.init();
|
||||
|
||||
log::info!("Running without systemd integration");
|
||||
}
|
||||
|
||||
let mpv_config_file = create_mpv_config_file(args.mpv_config_file)?;
|
||||
|
||||
let (mpv, proc) = connect_to_mpv(&MpvConnectionArgs {
|
||||
socket_path: args.mpv_socket_path,
|
||||
executable_path: args.mpv_executable_path,
|
||||
config_file: &mpv_config_file,
|
||||
auto_start: args.auto_start_mpv,
|
||||
force_auto_start: args.force_auto_start,
|
||||
})
|
||||
.await
|
||||
.context("Failed to connect to mpv")?;
|
||||
.await?;
|
||||
|
||||
if let Err(e) = show_grzegorz_image(mpv.clone()).await {
|
||||
log::warn!("Could not show Grzegorz image: {}", e);
|
||||
}
|
||||
let addr = SocketAddr::new(resolve(&args.host).await?, args.port);
|
||||
log::info!("Starting API on {}", addr);
|
||||
|
||||
let addr = match resolve(&args.host)
|
||||
.await
|
||||
.context(format!("Failed to resolve address: {}", &args.host))
|
||||
{
|
||||
Ok(addr) => addr,
|
||||
Err(e) => {
|
||||
log::error!("{}", e);
|
||||
shutdown(mpv, proc).await;
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
let socket_addr = SocketAddr::new(addr, args.port);
|
||||
log::info!("Starting API on {}", socket_addr);
|
||||
|
||||
let app = Router::new()
|
||||
.nest("/api", api::rest_api_routes(mpv.clone()))
|
||||
.merge(api::rest_api_docs(mpv.clone()));
|
||||
|
||||
let listener = match tokio::net::TcpListener::bind(&socket_addr)
|
||||
.await
|
||||
.context(format!("Failed to bind API server to '{}'", &socket_addr))
|
||||
{
|
||||
Ok(listener) => listener,
|
||||
Err(e) => {
|
||||
log::error!("{}", e);
|
||||
shutdown(mpv, proc).await;
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
|
||||
if systemd_mode {
|
||||
match sd_notify::notify(false, &[sd_notify::NotifyState::Ready])
|
||||
.context("Failed to notify systemd that the service is ready")
|
||||
{
|
||||
Ok(_) => log::trace!("Notified systemd that the service is ready"),
|
||||
Err(e) => {
|
||||
log::error!("{}", e);
|
||||
shutdown(mpv, proc).await;
|
||||
return Err(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mpv = Arc::new(Mutex::new(mpv));
|
||||
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?);
|
||||
shutdown(mpv, Some(proc)).await;
|
||||
}
|
||||
_ = tokio::signal::ctrl_c() => {
|
||||
log::info!("Received Ctrl-C, exiting");
|
||||
shutdown(mpv, Some(proc)).await;
|
||||
}
|
||||
result = axum::serve(listener, app.into_make_service()) => {
|
||||
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 {
|
||||
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");
|
||||
shutdown(mpv, Some(proc)).await;
|
||||
proc.kill().await?;
|
||||
result?;
|
||||
}
|
||||
}
|
||||
|
|
@ -209,17 +174,12 @@ async fn main() -> anyhow::Result<()> {
|
|||
tokio::select! {
|
||||
_ = tokio::signal::ctrl_c() => {
|
||||
log::info!("Received Ctrl-C, exiting");
|
||||
shutdown(mpv.clone(), None).await;
|
||||
}
|
||||
result = axum::serve(listener, app.into_make_service()) => {
|
||||
log::info!("API server exited");
|
||||
shutdown(mpv.clone(), None).await;
|
||||
result?;
|
||||
_ = Server::bind(&addr.clone()).serve(app.into_make_service()) => {
|
||||
log::info!("API server exited");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::mem::drop(mpv_config_file);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
|
|
|||
135
src/mpv_setup.rs
135
src/mpv_setup.rs
|
|
@ -1,135 +0,0 @@
|
|||
use std::{fs::create_dir_all, io::Write, path::Path};
|
||||
|
||||
use anyhow::Context;
|
||||
use mpvipc_async::{Mpv, MpvExt};
|
||||
use tempfile::NamedTempFile;
|
||||
use tokio::process::{Child, Command};
|
||||
|
||||
use crate::MpvConnectionArgs;
|
||||
|
||||
const DEFAULT_MPV_CONFIG_CONTENT: &str = include_str!("../assets/default-mpv.conf");
|
||||
|
||||
const THE_MAN_PNG: &[u8] = include_bytes!("../assets/the_man.png");
|
||||
|
||||
pub fn create_mpv_config_file(args_config_file: Option<String>) -> anyhow::Result<NamedTempFile> {
|
||||
let file_content = if let Some(path) = args_config_file {
|
||||
if !Path::new(&path).exists() {
|
||||
anyhow::bail!("Mpv config file not found at {}", &path);
|
||||
}
|
||||
|
||||
std::fs::read_to_string(&path).context("Failed to read mpv config file")?
|
||||
} else {
|
||||
DEFAULT_MPV_CONFIG_CONTENT.to_string()
|
||||
};
|
||||
|
||||
let tmpfile = tempfile::Builder::new()
|
||||
.prefix("mpv-")
|
||||
.rand_bytes(8)
|
||||
.suffix(".conf")
|
||||
.tempfile()?;
|
||||
|
||||
tmpfile.reopen()?.write_all(file_content.as_bytes())?;
|
||||
|
||||
Ok(tmpfile)
|
||||
}
|
||||
|
||||
pub async fn connect_to_mpv<'a>(
|
||||
args: &MpvConnectionArgs<'a>,
|
||||
) -> anyhow::Result<(Mpv, Option<Child>)> {
|
||||
log::debug!("Connecting to mpv");
|
||||
|
||||
debug_assert!(
|
||||
!args.force_auto_start || args.auto_start,
|
||||
"force_auto_start requires auto_start"
|
||||
);
|
||||
|
||||
let socket_path = Path::new(&args.socket_path);
|
||||
|
||||
if !socket_path.exists() {
|
||||
log::debug!("Mpv socket not found at {}", &args.socket_path);
|
||||
if !args.auto_start {
|
||||
panic!("Mpv socket not found at {}", &args.socket_path);
|
||||
}
|
||||
|
||||
log::debug!("Ensuring parent dir of mpv socket exists");
|
||||
let parent_dir = Path::new(&args.socket_path)
|
||||
.parent()
|
||||
.context("Failed to get parent dir of mpv socket")?;
|
||||
|
||||
if !parent_dir.is_dir() {
|
||||
create_dir_all(parent_dir).context("Failed to create parent dir of mpv socket")?;
|
||||
}
|
||||
} else {
|
||||
log::debug!("Existing mpv socket found at {}", &args.socket_path);
|
||||
if args.force_auto_start {
|
||||
log::debug!("Removing mpv socket");
|
||||
std::fs::remove_file(&args.socket_path)?;
|
||||
}
|
||||
}
|
||||
|
||||
let process_handle = if args.auto_start {
|
||||
log::info!("Starting mpv with socket at {}", &args.socket_path);
|
||||
|
||||
// TODO: try to fetch mpv from PATH
|
||||
Some(
|
||||
Command::new(args.executable_path.as_deref().unwrap_or("mpv"))
|
||||
.arg(format!("--input-ipc-server={}", &args.socket_path))
|
||||
.arg("--idle")
|
||||
.arg("--force-window")
|
||||
.arg("--fullscreen")
|
||||
.arg("--no-config")
|
||||
.arg(format!(
|
||||
"--include={}",
|
||||
&args.config_file.path().to_string_lossy()
|
||||
))
|
||||
// .arg("--no-terminal")
|
||||
.arg("--load-unsafe-playlists")
|
||||
.arg("--keep-open") // Keep last frame of video on end of video
|
||||
.spawn()
|
||||
.context("Failed to start mpv")?,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
// Wait for mpv to create the socket
|
||||
if tokio::time::timeout(tokio::time::Duration::from_millis(500), async {
|
||||
while !&socket_path.exists() {
|
||||
log::debug!("Waiting for mpv socket at {}", &args.socket_path);
|
||||
tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
return Err(anyhow::anyhow!(
|
||||
"Failed to connect to mpv socket: {}",
|
||||
&args.socket_path
|
||||
));
|
||||
}
|
||||
|
||||
Ok((
|
||||
Mpv::connect(&args.socket_path).await.context(format!(
|
||||
"Failed to connect to mpv socket: {}",
|
||||
&args.socket_path
|
||||
))?,
|
||||
process_handle,
|
||||
))
|
||||
}
|
||||
|
||||
pub async fn show_grzegorz_image(mpv: Mpv) -> anyhow::Result<()> {
|
||||
let path = std::env::temp_dir().join("the_man.png");
|
||||
std::fs::write(path.as_path(), THE_MAN_PNG)?;
|
||||
|
||||
mpv.playlist_clear().await?;
|
||||
mpv.playlist_add(
|
||||
path.to_string_lossy().as_ref(),
|
||||
mpvipc_async::PlaylistAddTypeOptions::File,
|
||||
mpvipc_async::PlaylistAddOptions::Append,
|
||||
)
|
||||
.await?;
|
||||
mpv.next().await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue