pub(crate) enum CommandOptions {
+Show 14 variants
Play {
+ index: Option<usize>,
+ },
+ Pause,
+ Stop,
+ Next,
+ Prev,
+ Seek {
+ seconds: i32,
+ },
+ Move {
+ index1: usize,
+ index2: usize,
+ },
+ Remove {
+ index: Option<usize>,
+ },
+ Clear,
+ List,
+ Add {
+ filenames: Vec<String>,
+ },
+ Replace {
+ filenames: Vec<String>,
+ },
+ Prop {
+ properties: Vec<String>,
+ },
+ Interactive,
+}Play media at the specified index in the playlist
+Pause the currently playing media
+Stop the playback and quit MPV
+Skip to the next item in the playlist
+Skip to the previous item in the playlist
+Seek to a specific position in the currently playing media
+Move an item in the playlist from one index to another
+Remove an item from the playlist
+If invoked while playlist has no entries, or if the only entry +is the active video, then this will exit MPV.
+Clear the entire playlist
+List all the items in the playlist
+Add files to the playlist
+Needs at least one file to be passed.
+Replace the current playlist with new files
+Fetch properties of the current playback or playlist
+Enter interactive mode to send commands to MPV IPC
+ArgMatches to self.ArgMatches to self.Command] so it can instantiate Self via
+[FromArgMatches::from_arg_matches_mut] Read moreCommand] so it can instantiate self via
+[FromArgMatches::update_from_arg_matches_mut] Read moreSelf can parse a specific subcommandSubscriber to this type, returning a
+[WithDispatch] wrapper. Read morepub(crate) struct Cli {
+ pub(crate) debug: bool,
+ pub(crate) command: CommandOptions,
+}debug: bool§command: CommandOptionsArgGroup::id][crate::ArgGroup::id] for this set of argumentsCommand] so it can instantiate Self via
+[FromArgMatches::from_arg_matches_mut] Read moreCommand] so it can instantiate self via
+[FromArgMatches::update_from_arg_matches_mut] Read moreArgMatches to self.ArgMatches to self.Subscriber to this type, returning a
+[WithDispatch] wrapper. Read morepub enum MpvCommand {
+ SetProperty,
+ PlaylistNext,
+ PlaylistPrev,
+ Seek,
+ Quit,
+ PlaylistMove,
+ PlaylistRemove,
+ PlaylistClear,
+ GetProperty,
+ LoadFile,
+}Represents common MPV commands.
+This enum provides variants for frequently used MPV commands, which can be converted to their
+string equivalents using the as_str method.
Returns an error if the connection to the socket fails or the command execution encounters issues.
+Sets a property to a specified value in MPV.
+Moves to the next item in the playlist.
+Moves to the previous item in the playlist.
+Seeks to a specific time in the current media.
+Quits the MPV application.
+Moves an item in the playlist from one index to another.
+Removes an item from the playlist.
+Clears all items from the playlist.
+Retrieves the value of a property in MPV.
+Loads a file into MPV.
+Subscriber to this type, returning a
+[WithDispatch] wrapper. Read morepub async fn get_property(
+ property: &str,
+ socket_path: Option<&str>,
+) -> Result<Option<Value>>Sends the get_property command to retrieve a property value from MPV.
property: The name of the property to retrieve.socket_path: An optional custom socket path.A Result containing the response data.
Returns an error if the connection to the socket fails or the command execution encounters issues.
+pub async fn loadfile(
+ filename: &str,
+ append: bool,
+ socket_path: Option<&str>,
+) -> Result<Option<Value>>Sends the loadfile command to load a file into MPV.
filename: The name of the file to load.append: Whether to append the file to the playlist (true) or replace the current file (false).socket_path: An optional custom socket path.A Result containing the response data.
Returns an error if the connection to the socket fails or the command execution encounters issues.
+pub async fn playlist_move(
+ from_index: usize,
+ to_index: usize,
+ socket_path: Option<&str>,
+) -> Result<Option<Value>>Sends the playlist-move command to move a playlist item from one index to another.
from_index: The index of the item to move.to_index: The index to move the item to.socket_path: An optional custom socket path.A Result containing the response data.
Returns an error if the connection to the socket fails or the command execution encounters issues.
+pub async fn playlist_remove(
+ index: Option<usize>,
+ socket_path: Option<&str>,
+) -> Result<Option<Value>>Sends the playlist-remove command to remove an item from the playlist.
index: The index of the item to remove, or None to remove the current item.socket_path: An optional custom socket path.A Result containing the response data.
Returns an error if the connection to the socket fails or the command execution encounters issues.
+pub async fn seek(
+ seconds: f64,
+ socket_path: Option<&str>,
+) -> Result<Option<Value>>Sends the seek command to seek the media playback by a given number of seconds.
seconds: The number of seconds to seek.socket_path: An optional custom socket path.A Result containing the response data.
Returns an error if the connection to the socket fails or the command execution encounters issues.
+pub async fn send_ipc_command(
+ command: &str,
+ args: &[Value],
+ socket_path: Option<&str>,
+) -> Result<Option<Value>>Sends a generic IPC command to the specified socket and returns the parsed response data.
+command: The name of the command to send to MPV.args: A slice of Value arguments to include in the command.socket_path: An optional custom path to the MPV IPC socket. If None, the default path is used.A Result containing an Option<Value> with the parsed response data if successful.
Returns an error if the connection to the socket fails or if the response cannot be parsed.
+pub async fn set_property(
+ property: &str,
+ value: &Value,
+ socket_path: Option<&str>,
+) -> Result<Option<Value>>Sends the set_property command to MPV to change a property value.
property: The name of the property to set.value: The new value to assign to the property.socket_path: An optional custom socket path.A Result containing the response data.
Returns an error if the connection to the socket fails or the command execution encounters issues.
+MRC +A library for interacting with the MPV media player using its JSON IPC (Inter-Process Communication) protocol.
+This crate provides a set of utilities to communicate with MPV’s IPC socket, enabling you to send commands +and retrieve responses in a structured format.
+set_property, seek, and playlist-nextuse serde_json::json;
+use tokio;
+use mrc::{send_ipc_command, playlist_next, set_property};
+
+#[tokio::main]
+async fn main() {
+ let result = playlist_next(None).await;
+ match result {
+ Ok(response) => println!("Playlist moved to next: {:?}", response),
+ Err(err) => eprintln!("Error: {:?}", err),
+ }
+
+ let property_result = set_property("volume", &json!(50), None).await;
+ match property_result {
+ Ok(response) => println!("Volume set: {:?}", response),
+ Err(err) => eprintln!("Error: {:?}", err),
+ }
+}SOCKET_PATHDefault path for the MPV IPC socket: /tmp/mpvsocket
get_property command to retrieve a property value from MPV.loadfile command to load a file into MPV.playlist-clear command to clear the playlist.playlist-move command to move a playlist item from one index to another.playlist-next command to move to the next playlist item.playlist-prev command to move to the previous playlist item.playlist-remove command to remove an item from the playlist.quit command to terminate MPV.seek command to seek the media playback by a given number of seconds.set_property command to MPV to change a property value.U::from(self).\nCalls U::from(self).\nThe filenames of the files to add\nThe filenames of the files to replace the playlist with\nThe index of the media to play\nThe index of the item to remove (optional)\nThe index of the item to move\nThe index to move the item to\nThe properties to fetch\nThe number of seconds to seek to")
\ No newline at end of file
diff --git a/search.desc/mrc/mrc-desc-0-.js b/search.desc/mrc/mrc-desc-0-.js
new file mode 100644
index 00000000..aebd50c2
--- /dev/null
+++ b/search.desc/mrc/mrc-desc-0-.js
@@ -0,0 +1 @@
+searchState.loadedDescShard("mrc", 0, "MRC A library for interacting with the MPV media player …\nRetrieves the value of a property in MPV.\nLoads a file into MPV.\nRepresents common MPV commands.\nClears all items from the playlist.\nMoves an item in the playlist from one index to another.\nMoves to the next item in the playlist.\nMoves to the previous item in the playlist.\nRemoves an item from the playlist.\nQuits the MPV application.\nSeeks to a specific time in the current media.\nSets a property to a specified value in MPV.\nConverts MPV commands to their string equivalents.\nReturns the argument unchanged.\nSends the get_property command to retrieve a property …\nCalls U::from(self).\nSends the loadfile command to load a file into MPV.\nSends the playlist-clear command to clear the playlist.\nSends the playlist-move command to move a playlist item …\nSends the playlist-next command to move to the next …\nSends the playlist-prev command to move to the previous …\nSends the playlist-remove command to remove an item from …\nSends the quit command to terminate MPV.\nSends the seek command to seek the media playback by a …\nSends a generic IPC command to the specified socket and …\nSends the set_property command to MPV to change a property …")
\ No newline at end of file
diff --git a/search.desc/server/server-desc-0-.js b/search.desc/server/server-desc-0-.js
new file mode 100644
index 00000000..c4a2bfb8
--- /dev/null
+++ b/search.desc/server/server-desc-0-.js
@@ -0,0 +1 @@
+searchState.loadedDescShard("server", 0, "The IP address and port to bind the server to\nReturns the argument unchanged.\nCalls U::from(self).\nPath to MPV IPC socket")
\ No newline at end of file
diff --git a/server/all.html b/server/all.html
new file mode 100644
index 00000000..aff4217d
--- /dev/null
+++ b/server/all.html
@@ -0,0 +1 @@
+pub(crate) struct Config {
+ pub(crate) bind: String,
+ pub(crate) socket: String,
+}bind: StringThe IP address and port to bind the server to
+socket: StringPath to MPV IPC socket
+ArgGroup::id][crate::ArgGroup::id] for this set of argumentsCommand] so it can instantiate Self via
+[FromArgMatches::from_arg_matches_mut] Read moreCommand] so it can instantiate self via
+[FromArgMatches::update_from_arg_matches_mut] Read moreArgMatches to self.ArgMatches to self.Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more1use clap::{Parser, Subcommand};
+2use mrc::set_property;
+3use mrc::SOCKET_PATH;
+4use mrc::{
+5 get_property, loadfile, playlist_clear, playlist_move, playlist_next, playlist_prev,
+6 playlist_remove, quit, seek,
+7};
+8use serde_json::json;
+9use std::io::{self, Write};
+10use std::path::PathBuf;
+11use tracing::{debug, error, info};
+12
+13#[derive(Parser)]
+14#[command(author, version, about)]
+15struct Cli {
+16 #[arg(short, long, global = true)]
+17 debug: bool,
+18
+19 #[command(subcommand)]
+20 command: CommandOptions,
+21}
+22
+23#[derive(Subcommand)]
+24enum CommandOptions {
+25 /// Play media at the specified index in the playlist
+26 Play {
+27 /// The index of the media to play
+28 index: Option<usize>,
+29 },
+30
+31 /// Pause the currently playing media
+32 Pause,
+33
+34 /// Stop the playback and quit MPV
+35 Stop,
+36
+37 /// Skip to the next item in the playlist
+38 Next,
+39
+40 /// Skip to the previous item in the playlist
+41 Prev,
+42
+43 /// Seek to a specific position in the currently playing media
+44 Seek {
+45 /// The number of seconds to seek to
+46 seconds: i32,
+47 },
+48
+49 /// Move an item in the playlist from one index to another
+50 Move {
+51 /// The index of the item to move
+52 index1: usize,
+53
+54 /// The index to move the item to
+55 index2: usize,
+56 },
+57
+58 /// Remove an item from the playlist
+59 ///
+60 /// If invoked while playlist has no entries, or if the only entry
+61 /// is the active video, then this will exit MPV.
+62 Remove {
+63 /// The index of the item to remove (optional)
+64 index: Option<usize>,
+65 },
+66
+67 /// Clear the entire playlist
+68 Clear,
+69
+70 /// List all the items in the playlist
+71 List,
+72
+73 /// Add files to the playlist
+74 ///
+75 /// Needs at least one file to be passed.
+76 Add {
+77 /// The filenames of the files to add
+78 filenames: Vec<String>,
+79 },
+80
+81 /// Replace the current playlist with new files
+82 Replace {
+83 /// The filenames of the files to replace the playlist with
+84 filenames: Vec<String>,
+85 },
+86
+87 /// Fetch properties of the current playback or playlist
+88 Prop {
+89 /// The properties to fetch
+90 properties: Vec<String>,
+91 },
+92
+93 /// Enter interactive mode to send commands to MPV IPC
+94 Interactive,
+95}
+96
+97#[tokio::main]
+98async fn main() -> io::Result<()> {
+99 tracing_subscriber::fmt::init();
+100 let cli = Cli::parse();
+101
+102 if !PathBuf::from(SOCKET_PATH).exists() {
+103 debug!(SOCKET_PATH);
+104 error!("Error: MPV socket not found. Is MPV running?");
+105 return Ok(());
+106 }
+107
+108 match cli.command {
+109 CommandOptions::Play { index } => {
+110 if let Some(idx) = index {
+111 info!("Playing media at index: {}", idx);
+112 set_property("playlist-pos", &json!(idx), None).await?;
+113 }
+114 info!("Unpausing playback");
+115 set_property("pause", &json!(false), None).await?;
+116 }
+117
+118 CommandOptions::Pause => {
+119 info!("Pausing playback");
+120 set_property("pause", &json!(true), None).await?;
+121 }
+122
+123 CommandOptions::Stop => {
+124 info!("Stopping playback and quitting MPV");
+125 quit(None).await?;
+126 }
+127
+128 CommandOptions::Next => {
+129 info!("Skipping to next item in the playlist");
+130 playlist_next(None).await?;
+131 }
+132
+133 CommandOptions::Prev => {
+134 info!("Skipping to previous item in the playlist");
+135 playlist_prev(None).await?;
+136 }
+137
+138 CommandOptions::Seek { seconds } => {
+139 info!("Seeking to {} seconds", seconds);
+140 seek(seconds.into(), None).await?;
+141 }
+142
+143 CommandOptions::Move { index1, index2 } => {
+144 info!("Moving item from index {} to {}", index1, index2);
+145 playlist_move(index1, index2, None).await?;
+146 }
+147
+148 CommandOptions::Remove { index } => {
+149 if let Some(idx) = index {
+150 info!("Removing item at index {}", idx);
+151 playlist_remove(Some(idx), None).await?;
+152 } else {
+153 info!("Removing current item from playlist");
+154 playlist_remove(None, None).await?;
+155 }
+156 }
+157
+158 CommandOptions::Clear => {
+159 info!("Clearing the playlist");
+160 playlist_clear(None).await?;
+161 }
+162
+163 CommandOptions::List => {
+164 info!("Listing playlist items");
+165 if let Some(data) = get_property("playlist", None).await? {
+166 println!("{}", serde_json::to_string_pretty(&data)?);
+167 }
+168 }
+169
+170 CommandOptions::Add { filenames } => {
+171 if filenames.is_empty() {
+172 let e = "No files provided to add to the playlist";
+173 error!("{}", e);
+174 return Err(io::Error::new(io::ErrorKind::InvalidInput, e));
+175 }
+176
+177 info!("Adding {} files to the playlist", filenames.len());
+178 for filename in filenames {
+179 loadfile(&filename, true, None).await?;
+180 }
+181 }
+182
+183 CommandOptions::Replace { filenames } => {
+184 info!("Replacing current playlist with {} files", filenames.len());
+185 if let Some(first_file) = filenames.first() {
+186 loadfile(first_file, false, None).await?;
+187 for filename in &filenames[1..] {
+188 loadfile(filename, true, None).await?;
+189 }
+190 }
+191 }
+192
+193 CommandOptions::Prop { properties } => {
+194 info!("Fetching properties: {:?}", properties);
+195 for property in properties {
+196 if let Some(data) = get_property(&property, None).await? {
+197 println!("{property}: {data}");
+198 }
+199 }
+200 }
+201
+202 CommandOptions::Interactive => {
+203 println!("Entering interactive mode. Type 'exit' to quit.");
+204 let stdin = io::stdin();
+205 let mut stdout = io::stdout();
+206
+207 loop {
+208 print!("mpv> ");
+209 stdout.flush()?;
+210 let mut input = String::new();
+211 stdin.read_line(&mut input)?;
+212 let trimmed = input.trim();
+213
+214 if trimmed.eq_ignore_ascii_case("exit") {
+215 println!("Exiting interactive mode.");
+216 break;
+217 }
+218
+219 // I don't like this either, but it looks cleaner than a multi-line
+220 // print macro just cramped in here.
+221 let commands = vec![
+222 (
+223 "play [index]",
+224 "Play or unpause playback, optionally at the specified index",
+225 ),
+226 ("pause", "Pause playback"),
+227 ("stop", "Stop playback and quit MPV"),
+228 ("next", "Skip to the next item in the playlist"),
+229 ("prev", "Skip to the previous item in the playlist"),
+230 ("seek <seconds>", "Seek to the specified position"),
+231 ("clear", "Clear the playlist"),
+232 ("list", "List all items in the playlist"),
+233 ("add <files>", "Add files to the playlist"),
+234 ("get <property>", "Get the specified property"),
+235 (
+236 "set <property> <value>",
+237 "Set the specified property to a value",
+238 ),
+239 ("exit", "Quit interactive mode"),
+240 ];
+241
+242 if trimmed.eq_ignore_ascii_case("help") {
+243 println!("Valid commands:");
+244 for (command, description) in commands {
+245 println!(" {} - {}", command, description);
+246 }
+247 continue;
+248 }
+249
+250 let parts: Vec<&str> = trimmed.split_whitespace().collect();
+251 match parts.as_slice() {
+252 ["play"] => {
+253 info!("Unpausing playback");
+254 set_property("pause", &json!(false), None).await?;
+255 }
+256
+257 ["play", index] => {
+258 if let Ok(idx) = index.parse::<usize>() {
+259 info!("Playing media at index: {}", idx);
+260 set_property("playlist-pos", &json!(idx), None).await?;
+261 set_property("pause", &json!(false), None).await?;
+262 } else {
+263 println!("Invalid index: {}", index);
+264 }
+265 }
+266
+267 ["pause"] => {
+268 info!("Pausing playback");
+269 set_property("pause", &json!(true), None).await?;
+270 }
+271
+272 ["stop"] => {
+273 info!("Pausing playback");
+274 quit(None).await?;
+275 }
+276
+277 ["next"] => {
+278 info!("Skipping to next item in the playlist");
+279 playlist_next(None).await?;
+280 }
+281
+282 ["prev"] => {
+283 info!("Skipping to previous item in the playlist");
+284 playlist_prev(None).await?;
+285 }
+286
+287 ["seek", seconds] => {
+288 if let Ok(sec) = seconds.parse::<i32>() {
+289 info!("Seeking to {} seconds", sec);
+290 seek(sec.into(), None).await?;
+291 } else {
+292 println!("Invalid seconds: {}", seconds);
+293 }
+294 }
+295
+296 ["clear"] => {
+297 info!("Clearing the playlist");
+298 playlist_clear(None).await?;
+299 }
+300
+301 ["list"] => {
+302 info!("Listing playlist items");
+303 if let Some(data) = get_property("playlist", None).await? {
+304 println!("{}", serde_json::to_string_pretty(&data)?);
+305 }
+306 }
+307
+308 ["add", files @ ..] => {
+309 if files.is_empty() {
+310 println!("No files provided to add to the playlist");
+311 } else {
+312 info!("Adding {} files to the playlist", files.len());
+313 for file in files {
+314 loadfile(file, true, None).await?;
+315 }
+316 }
+317 }
+318
+319 ["get", property] => {
+320 if let Some(data) = get_property(property, None).await? {
+321 println!("{property}: {data}");
+322 }
+323 }
+324
+325 ["set", property, value] => {
+326 let json_value = serde_json::from_str::<serde_json::Value>(value)
+327 .unwrap_or_else(|_| json!(value));
+328 set_property(property, &json_value, None).await?;
+329 println!("Set {property} to {value}");
+330 }
+331
+332 _ => {
+333 println!("Unknown command: {}", trimmed);
+334 println!("Valid commands: play <index>, pause, stop, next, prev, seek <seconds>, clear, list, add <files>, get <property>, set <property> <value>, exit");
+335 }
+336 }
+337 }
+338 }
+339 }
+340
+341 Ok(())
+342}1//! MRC
+2//! A library for interacting with the MPV media player using its JSON IPC (Inter-Process Communication) protocol.
+3//!
+4//! This crate provides a set of utilities to communicate with MPV's IPC socket, enabling you to send commands
+5//! and retrieve responses in a structured format.
+6//!
+7//! ## Features
+8//!
+9//! - Send commands to MPV's IPC socket
+10//! - Retrieve responses in JSON format
+11//! - Supports common MPV commands like `set_property`, `seek`, and `playlist-next`
+12//! - Flexible socket path configuration
+13//!
+14//! ## Example Usage
+15//! ```rust
+16//! use serde_json::json;
+17//! use tokio;
+18//! use mrc::{send_ipc_command, playlist_next, set_property};
+19//!
+20//! #[tokio::main]
+21//! async fn main() {
+22//! let result = playlist_next(None).await;
+23//! match result {
+24//! Ok(response) => println!("Playlist moved to next: {:?}", response),
+25//! Err(err) => eprintln!("Error: {:?}", err),
+26//! }
+27//!
+28//! let property_result = set_property("volume", &json!(50), None).await;
+29//! match property_result {
+30//! Ok(response) => println!("Volume set: {:?}", response),
+31//! Err(err) => eprintln!("Error: {:?}", err),
+32//! }
+33//! }
+34//! ```
+35//!
+36//! ## Constants
+37//!
+38//! ### `SOCKET_PATH`
+39//! Default path for the MPV IPC socket: `/tmp/mpvsocket`
+40//!
+41//! ## Functions
+42
+43use serde_json::{json, Value};
+44use std::io::{self};
+45use tokio::io::{AsyncReadExt, AsyncWriteExt};
+46use tokio::net::UnixStream;
+47use tracing::{debug, error};
+48
+49pub const SOCKET_PATH: &str = "/tmp/mpvsocket";
+50
+51/// Sends a generic IPC command to the specified socket and returns the parsed response data.
+52///
+53/// # Arguments
+54/// - `command`: The name of the command to send to MPV.
+55/// - `args`: A slice of `Value` arguments to include in the command.
+56/// - `socket_path`: An optional custom path to the MPV IPC socket. If `None`, the default path is used.
+57///
+58/// # Returns
+59/// A `Result` containing an `Option<Value>` with the parsed response data if successful.
+60///
+61/// # Errors
+62/// Returns an error if the connection to the socket fails or if the response cannot be parsed.
+63pub async fn send_ipc_command(
+64 command: &str,
+65 args: &[Value],
+66 socket_path: Option<&str>,
+67) -> io::Result<Option<Value>> {
+68 let socket_path = socket_path.unwrap_or(SOCKET_PATH);
+69 debug!(
+70 "Sending IPC command: {} with arguments: {:?}",
+71 command, args
+72 );
+73
+74 match UnixStream::connect(socket_path).await {
+75 Ok(mut socket) => {
+76 debug!("Connected to socket at {}", socket_path);
+77
+78 let mut command_array = vec![json!(command)];
+79 command_array.extend_from_slice(args);
+80 let message = json!({ "command": command_array });
+81 let message_str = format!("{}\n", serde_json::to_string(&message)?);
+82 debug!("Serialized message to send with newline: {}", message_str);
+83
+84 socket.write_all(message_str.as_bytes()).await?;
+85 socket.flush().await?;
+86 debug!("Message sent and flushed");
+87
+88 let mut response = vec![0; 1024];
+89 let n = socket.read(&mut response).await?;
+90 let response_str = String::from_utf8_lossy(&response[..n]);
+91 debug!("Raw response: {}", response_str);
+92
+93 match serde_json::from_str::<Value>(&response_str) {
+94 Ok(json_response) => {
+95 debug!("Parsed IPC response: {:?}", json_response);
+96 Ok(json_response.get("data").cloned())
+97 }
+98
+99 Err(e) => {
+100 error!("Failed to parse response: {}", e);
+101 Ok(None)
+102 }
+103 }
+104 }
+105
+106 Err(e) => {
+107 error!("Failed to connect to MPV socket: {}", e);
+108 Err(e)
+109 }
+110 }
+111}
+112
+113/// Represents common MPV commands.
+114///
+115/// This enum provides variants for frequently used MPV commands, which can be converted to their
+116/// string equivalents using the `as_str` method.
+117///
+118/// # Errors
+119/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+120#[derive(Debug)]
+121pub enum MpvCommand {
+122 /// Sets a property to a specified value in MPV.
+123 SetProperty,
+124 /// Moves to the next item in the playlist.
+125 PlaylistNext,
+126 /// Moves to the previous item in the playlist.
+127 PlaylistPrev,
+128 /// Seeks to a specific time in the current media.
+129 Seek,
+130 /// Quits the MPV application.
+131 Quit,
+132 /// Moves an item in the playlist from one index to another.
+133 PlaylistMove,
+134 /// Removes an item from the playlist.
+135 PlaylistRemove,
+136 /// Clears all items from the playlist.
+137 PlaylistClear,
+138 /// Retrieves the value of a property in MPV.
+139 GetProperty,
+140 /// Loads a file into MPV.
+141 LoadFile,
+142}
+143
+144impl MpvCommand {
+145 /// Converts MPV commands to their string equivalents.
+146 ///
+147 /// # Returns
+148 /// A string slice representing the command.
+149 #[must_use]
+150 pub const fn as_str(&self) -> &str {
+151 match self {
+152 Self::SetProperty => "set_property",
+153 Self::PlaylistNext => "playlist-next",
+154 Self::PlaylistPrev => "playlist-prev",
+155 Self::Seek => "seek",
+156 Self::Quit => "quit",
+157 Self::PlaylistMove => "playlist-move",
+158 Self::PlaylistRemove => "playlist-remove",
+159 Self::PlaylistClear => "playlist-clear",
+160 Self::GetProperty => "get_property",
+161 Self::LoadFile => "loadfile",
+162 }
+163 }
+164}
+165
+166/// Sends the `set_property` command to MPV to change a property value.
+167///
+168/// # Arguments
+169/// - `property`: The name of the property to set.
+170/// - `value`: The new value to assign to the property.
+171/// - `socket_path`: An optional custom socket path.
+172///
+173/// # Returns
+174/// A `Result` containing the response data.
+175///
+176/// # Errors
+177/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+178pub async fn set_property(
+179 property: &str,
+180 value: &Value,
+181 socket_path: Option<&str>,
+182) -> io::Result<Option<Value>> {
+183 send_ipc_command(
+184 MpvCommand::SetProperty.as_str(),
+185 &[json!(property), value.clone()],
+186 socket_path,
+187 )
+188 .await
+189}
+190
+191/// Sends the `playlist-next` command to move to the next playlist item.
+192///
+193/// # Arguments
+194/// - `socket_path`: An optional custom socket path.
+195///
+196/// # Returns
+197/// A `Result` containing the response data.
+198///
+199/// # Errors
+200/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+201pub async fn playlist_next(socket_path: Option<&str>) -> io::Result<Option<Value>> {
+202 send_ipc_command(MpvCommand::PlaylistNext.as_str(), &[], socket_path).await
+203}
+204
+205/// Sends the `playlist-prev` command to move to the previous playlist item.
+206///
+207/// # Arguments
+208/// - `socket_path`: An optional custom socket path.
+209///
+210/// # Returns
+211/// A `Result` containing the response data.
+212///
+213/// # Errors
+214/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+215pub async fn playlist_prev(socket_path: Option<&str>) -> io::Result<Option<Value>> {
+216 send_ipc_command(MpvCommand::PlaylistPrev.as_str(), &[], socket_path).await
+217}
+218
+219/// Sends the `seek` command to seek the media playback by a given number of seconds.
+220///
+221/// # Arguments
+222/// - `seconds`: The number of seconds to seek.
+223/// - `socket_path`: An optional custom socket path.
+224///
+225/// # Returns
+226/// A `Result` containing the response data.
+227///
+228/// # Errors
+229/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+230pub async fn seek(seconds: f64, socket_path: Option<&str>) -> io::Result<Option<Value>> {
+231 send_ipc_command(MpvCommand::Seek.as_str(), &[json!(seconds)], socket_path).await
+232}
+233
+234/// Sends the `quit` command to terminate MPV.
+235///
+236/// # Arguments
+237/// - `socket_path`: An optional custom socket path.
+238///
+239/// # Returns
+240/// A `Result` containing the response data.
+241///
+242/// # Errors
+243/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+244pub async fn quit(socket_path: Option<&str>) -> io::Result<Option<Value>> {
+245 send_ipc_command(MpvCommand::Quit.as_str(), &[], socket_path).await
+246}
+247
+248/// Sends the `playlist-move` command to move a playlist item from one index to another.
+249///
+250/// # Arguments
+251/// - `from_index`: The index of the item to move.
+252/// - `to_index`: The index to move the item to.
+253/// - `socket_path`: An optional custom socket path.
+254///
+255/// # Returns
+256/// A `Result` containing the response data.
+257///
+258/// # Errors
+259/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+260pub async fn playlist_move(
+261 from_index: usize,
+262 to_index: usize,
+263 socket_path: Option<&str>,
+264) -> io::Result<Option<Value>> {
+265 send_ipc_command(
+266 MpvCommand::PlaylistMove.as_str(),
+267 &[json!(from_index), json!(to_index)],
+268 socket_path,
+269 )
+270 .await
+271}
+272
+273/// Sends the `playlist-remove` command to remove an item from the playlist.
+274///
+275/// # Arguments
+276/// - `index`: The index of the item to remove, or `None` to remove the current item.
+277/// - `socket_path`: An optional custom socket path.
+278///
+279/// # Returns
+280/// A `Result` containing the response data.
+281///
+282/// # Errors
+283/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+284pub async fn playlist_remove(
+285 index: Option<usize>,
+286 socket_path: Option<&str>,
+287) -> io::Result<Option<Value>> {
+288 let args = match index {
+289 Some(idx) => vec![json!(idx)],
+290 None => vec![json!("current")],
+291 };
+292 send_ipc_command(MpvCommand::PlaylistRemove.as_str(), &args, socket_path).await
+293}
+294
+295/// Sends the `playlist-clear` command to clear the playlist.
+296///
+297/// # Arguments
+298/// - `socket_path`: An optional custom socket path.
+299///
+300/// # Returns
+301/// A `Result` containing the response data.
+302///
+303/// # Errors
+304/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+305pub async fn playlist_clear(socket_path: Option<&str>) -> io::Result<Option<Value>> {
+306 send_ipc_command(MpvCommand::PlaylistClear.as_str(), &[], socket_path).await
+307}
+308
+309/// Sends the `get_property` command to retrieve a property value from MPV.
+310///
+311/// # Arguments
+312/// - `property`: The name of the property to retrieve.
+313/// - `socket_path`: An optional custom socket path.
+314///
+315/// # Returns
+316/// A `Result` containing the response data.
+317///
+318/// # Errors
+319/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+320pub async fn get_property(property: &str, socket_path: Option<&str>) -> io::Result<Option<Value>> {
+321 send_ipc_command(
+322 MpvCommand::GetProperty.as_str(),
+323 &[json!(property)],
+324 socket_path,
+325 )
+326 .await
+327}
+328
+329/// Sends the `loadfile` command to load a file into MPV.
+330///
+331/// # Arguments
+332/// - `filename`: The name of the file to load.
+333/// - `append`: Whether to append the file to the playlist (`true`) or replace the current file (`false`).
+334/// - `socket_path`: An optional custom socket path.
+335///
+336/// # Returns
+337/// A `Result` containing the response data.
+338///
+339/// # Errors
+340/// Returns an error if the connection to the socket fails or the command execution encounters issues.
+341pub async fn loadfile(
+342 filename: &str,
+343 append: bool,
+344 socket_path: Option<&str>,
+345) -> io::Result<Option<Value>> {
+346 let append_flag = if append {
+347 json!("append-play")
+348 } else {
+349 json!("replace")
+350 };
+351 send_ipc_command(
+352 MpvCommand::LoadFile.as_str(),
+353 &[json!(filename), append_flag],
+354 socket_path,
+355 )
+356 .await
+357}1use std::env;
+2use std::io::Read;
+3use std::sync::Arc;
+4
+5use clap::Parser;
+6use native_tls::{Identity, TlsAcceptor as NativeTlsAcceptor};
+7use serde_json::json;
+8use tokio::io::{AsyncReadExt, AsyncWriteExt};
+9use tokio_native_tls::TlsAcceptor;
+10use tracing::{debug, error, info};
+11
+12use mrc::{get_property, playlist_clear, playlist_next, playlist_prev, quit, seek, set_property};
+13
+14#[derive(Parser)]
+15#[command(author, version, about)]
+16struct Config {
+17 /// The IP address and port to bind the server to
+18 #[arg(short, long, default_value = "127.0.0.1:8080")]
+19 bind: String,
+20
+21 /// Path to MPV IPC socket
+22 #[arg(short, long, default_value = "/tmp/mpvsocket")]
+23 socket: String,
+24}
+25
+26async fn handle_connection(
+27 stream: tokio::net::TcpStream,
+28 acceptor: Arc<TlsAcceptor>,
+29) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+30 let mut stream = acceptor.accept(stream).await?;
+31 let mut buffer = vec![0; 2048];
+32
+33 let n = stream.read(&mut buffer).await?;
+34 let request = String::from_utf8_lossy(&buffer[..n]);
+35
+36 debug!("Received request:\n{}", request);
+37
+38 let headers = request.split("\r\n").collect::<Vec<&str>>();
+39 let token_line = headers
+40 .iter()
+41 .find(|&&line| line.starts_with("Authorization:"));
+42 let token = match token_line {
+43 Some(line) => line.split(" ").nth(1).unwrap_or_default(),
+44 None => "",
+45 };
+46
+47 let auth_token = match env::var("AUTH_TOKEN") {
+48 Ok(token) => token,
+49 Err(_) => {
+50 error!("Authentication token is not set. Connection cannot be accepted.");
+51 stream.write_all(b"Authentication token not set\n").await?;
+52
+53 // You know what? I do not care to panic when the authentication token is
+54 // missing in the environment. Start the goddamned server and hell, even
+55 // accept incoming connections. Authenticated requests will be refused
+56 // when the token is incorrect or not set, so we can simply continue here.
+57 return Ok(());
+58 }
+59 };
+60
+61 if token != auth_token {
+62 stream.write_all(b"Authentication failed\n").await?;
+63 return Ok(());
+64 }
+65
+66 info!("Client authenticated");
+67 stream.write_all(b"Authenticated\n").await?;
+68
+69 let command = request.split("\r\n\r\n").last().unwrap_or("");
+70 info!("Received command: {}", command);
+71
+72 let response = match process_command(command.trim()).await {
+73 Ok(response) => response,
+74 Err(e) => {
+75 error!("Error processing command: {}", e);
+76 format!("Error: {:?}", e)
+77 }
+78 };
+79
+80 let http_response = format!(
+81 "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}",
+82 response.len(),
+83 response
+84 );
+85 stream.write_all(http_response.as_bytes()).await?;
+86
+87 Ok(())
+88}
+89
+90async fn process_command(command: &str) -> Result<String, String> {
+91 match command {
+92 "pause" => {
+93 info!("Pausing playback");
+94 set_property("pause", &json!(true), None)
+95 .await
+96 .map_err(|e| format!("Failed to pause: {:?}", e))?;
+97 Ok("Paused playback\n".to_string())
+98 }
+99
+100 "play" => {
+101 info!("Unpausing playback");
+102 set_property("pause", &json!(false), None)
+103 .await
+104 .map_err(|e| format!("Failed to play: {:?}", e))?;
+105 Ok("Resumed playback\n".to_string())
+106 }
+107
+108 "stop" => {
+109 info!("Stopping playback and quitting MPV");
+110 quit(None)
+111 .await
+112 .map_err(|e| format!("Failed to stop: {:?}", e))?;
+113 Ok("Stopped playback\n".to_string())
+114 }
+115
+116 "next" => {
+117 info!("Skipping to next item in the playlist");
+118 playlist_next(None)
+119 .await
+120 .map_err(|e| format!("Failed to skip to next: {:?}", e))?;
+121 Ok("Skipped to next item\n".to_string())
+122 }
+123
+124 "prev" => {
+125 info!("Skipping to previous item in the playlist");
+126 playlist_prev(None)
+127 .await
+128 .map_err(|e| format!("Failed to skip to previous: {:?}", e))?;
+129 Ok("Skipped to previous item\n".to_string())
+130 }
+131
+132 "seek" => {
+133 let parts: Vec<&str> = command.split_whitespace().collect();
+134 if let Some(seconds) = parts.get(1) {
+135 if let Ok(sec) = seconds.parse::<i32>() {
+136 info!("Seeking to {} seconds", sec);
+137 seek(sec.into(), None)
+138 .await
+139 .map_err(|e| format!("Failed to seek: {:?}", e))?;
+140 return Ok(format!("Seeking to {} seconds\n", sec));
+141 }
+142 }
+143 Err("Invalid seek command".to_string())
+144 }
+145
+146 "clear" => {
+147 info!("Clearing the playlist");
+148 playlist_clear(None)
+149 .await
+150 .map_err(|e| format!("Failed to clear playlist: {:?}", e))?;
+151 Ok("Cleared playlist\n".to_string())
+152 }
+153
+154 "list" => {
+155 info!("Listing playlist items");
+156 match get_property("playlist", None).await {
+157 Ok(Some(data)) => Ok(format!(
+158 "Playlist: {}",
+159 serde_json::to_string_pretty(&data).unwrap()
+160 )),
+161 Ok(None) => Err("No playlist data available".to_string()),
+162 Err(e) => Err(format!("Failed to fetch playlist: {:?}", e)),
+163 }
+164 }
+165 _ => Err("Unknown command".to_string()),
+166 }
+167}
+168
+169fn create_tls_acceptor() -> Result<TlsAcceptor, Box<dyn std::error::Error + Send + Sync>> {
+170 let pfx_path = env::var("TLS_PFX_PATH")
+171 .map_err(|_| std::io::Error::new(std::io::ErrorKind::NotFound, "TLS_PFX_PATH not set"))?;
+172 let password = env::var("TLS_PASSWORD")
+173 .map_err(|_| std::io::Error::new(std::io::ErrorKind::NotFound, "TLS_PASSWORD not set"))?;
+174
+175 let mut file = std::fs::File::open(&pfx_path)?;
+176 let mut identity = vec![];
+177 file.read_to_end(&mut identity)?;
+178
+179 let identity = Identity::from_pkcs12(&identity, &password)?;
+180 let native_acceptor = NativeTlsAcceptor::new(identity)?;
+181 Ok(TlsAcceptor::from(native_acceptor))
+182}
+183
+184#[tokio::main]
+185async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+186 tracing_subscriber::fmt::init();
+187 let config = Config::parse();
+188
+189 if !std::path::Path::new(&config.socket).exists() {
+190 error!(
+191 "Error: MPV socket not found at '{}'. Is MPV running?",
+192 config.socket
+193 );
+194 }
+195
+196 info!("Server is starting...");
+197 match create_tls_acceptor() {
+198 Ok(acceptor) => {
+199 let acceptor = Arc::new(acceptor);
+200 let listener = tokio::net::TcpListener::bind(&config.bind).await?;
+201 info!("Server is listening on {}", config.bind);
+202
+203 loop {
+204 let (stream, _) = listener.accept().await?;
+205 info!("New connection accepted.");
+206
+207 let acceptor = Arc::clone(&acceptor);
+208 tokio::spawn(handle_connection(stream, acceptor));
+209 }
+210 }
+211
+212 Err(e) => {
+213 error!("Failed to initialize TLS: {}", e);
+214 return Err(e);
+215 }
+216 }
+217}fn:) to \
+ restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \
+ enum, trait, type, macro, \
+ and const.","Search functions by type signature (e.g., vec -> usize or \
+ -> vec or String, enum:Cow -> bool)","You can look for items with an exact name by putting double quotes around \
+ your request: \"string\"",`Look for functions that accept or return \
+ slices and \
+ arrays by writing square \
+ brackets (e.g., -> [u8] or [] -> Option)`,"Look for items inside another one by searching for a path: vec::Vec",].map(x=>""+x+"
").join("");const div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="${value.replaceAll(" ", " ")}`}else{error[index]=value}});output+=`