refactor(libmpv2): Move to the `crates` directory

1 files changed, 0 insertions, 620 deletions

diff --git a/libmpv2/src/mpv.rs b/libmpv2/src/mpv.rs
deleted file mode 100644
index 9d554a6..0000000
--- a/libmpv2/src/mpv.rs
+++ /dev/null
@@ -1,620 +0,0 @@
-// yt - A fully featured command line YouTube client
-//
-// Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-// This file is part of Yt.
-//
-// You should have received a copy of the License along with this program.
-// If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.
-
-macro_rules! mpv_cstr_to_str {
-    ($cstr: expr) => {
-        std::ffi::CStr::from_ptr($cstr)
-            .to_str()
-            .map_err(Error::from)
-    };
-}
-
-mod errors;
-
-/// Event handling
-pub mod events;
-/// Custom protocols (`protocol://$url`) for playback
-#[cfg(feature = "protocols")]
-pub mod protocol;
-/// Custom rendering
-#[cfg(feature = "render")]
-pub mod render;
-
-use log::debug;
-
-pub use self::errors::*;
-use self::events::EventContext;
-use super::*;
-
-use std::{
-    ffi::CString,
-    mem::MaybeUninit,
-    ops::Deref,
-    ptr::{self, NonNull},
-    sync::atomic::AtomicBool,
-};
-
-fn mpv_err<T>(ret: T, err: ctype::c_int) -> Result<T> {
-    if err == 0 {
-        Ok(ret)
-    } else {
-        // debug!("Creating a raw error: {}", to_string_mpv_error(err));
-        Err(Error::Raw(err))
-    }
-}
-
-/// This trait describes which types are allowed to be passed to getter mpv APIs.
-pub unsafe trait GetData: Sized {
-    #[doc(hidden)]
-    fn get_from_c_void<T, F: FnMut(*mut ctype::c_void) -> Result<T>>(mut fun: F) -> Result<Self> {
-        let mut val = MaybeUninit::uninit();
-        let _ = fun(val.as_mut_ptr() as *mut _)?;
-        Ok(unsafe { val.assume_init() })
-    }
-    fn get_format() -> Format;
-}
-
-/// This trait describes which types are allowed to be passed to setter mpv APIs.
-pub unsafe trait SetData: Sized {
-    #[doc(hidden)]
-    fn call_as_c_void<T, F: FnMut(*mut ctype::c_void) -> Result<T>>(
-        mut self,
-        mut fun: F,
-    ) -> Result<T> {
-        fun(&mut self as *mut Self as _)
-    }
-    fn get_format() -> Format;
-}
-
-unsafe impl GetData for f64 {
-    fn get_format() -> Format {
-        Format::Double
-    }
-}
-
-unsafe impl SetData for f64 {
-    fn get_format() -> Format {
-        Format::Double
-    }
-}
-
-unsafe impl GetData for i64 {
-    fn get_format() -> Format {
-        Format::Int64
-    }
-}
-
-pub mod mpv_node {
-    use self::sys_node::SysMpvNode;
-    use crate::{Error, Format, GetData, Result};
-    use std::{mem::MaybeUninit, os::raw::c_void, ptr};
-
-    #[derive(Debug, Clone)]
-    pub enum MpvNode {
-        String(String),
-        Flag(bool),
-        Int64(i64),
-        Double(f64),
-        ArrayIter(MpvNodeArrayIter),
-        MapIter(MpvNodeMapIter),
-        None,
-    }
-
-    impl MpvNode {
-        pub fn bool(&self) -> Option<bool> {
-            if let MpvNode::Flag(value) = *self {
-                Some(value)
-            } else {
-                None
-            }
-        }
-        pub fn i64(&self) -> Option<i64> {
-            if let MpvNode::Int64(value) = *self {
-                Some(value)
-            } else {
-                None
-            }
-        }
-        pub fn f64(&self) -> Option<f64> {
-            if let MpvNode::Double(value) = *self {
-                Some(value)
-            } else {
-                None
-            }
-        }
-
-        pub fn str(&self) -> Option<&str> {
-            if let MpvNode::String(value) = self {
-                Some(value)
-            } else {
-                None
-            }
-        }
-
-        pub fn array(self) -> Option<MpvNodeArrayIter> {
-            if let MpvNode::ArrayIter(value) = self {
-                Some(value)
-            } else {
-                None
-            }
-        }
-
-        pub fn map(self) -> Option<MpvNodeMapIter> {
-            if let MpvNode::MapIter(value) = self {
-                Some(value)
-            } else {
-                None
-            }
-        }
-    }
-
-    impl PartialEq for MpvNode {
-        fn eq(&self, other: &Self) -> bool {
-            match (self, other) {
-                (Self::String(l0), Self::String(r0)) => l0 == r0,
-                (Self::Flag(l0), Self::Flag(r0)) => l0 == r0,
-                (Self::Int64(l0), Self::Int64(r0)) => l0 == r0,
-                (Self::Double(l0), Self::Double(r0)) => l0 == r0,
-                (Self::ArrayIter(l0), Self::ArrayIter(r0)) => l0.clone().eq(r0.clone()),
-                (Self::MapIter(l0), Self::MapIter(r0)) => l0.clone().eq(r0.clone()),
-                _ => core::mem::discriminant(self) == core::mem::discriminant(other),
-            }
-        }
-    }
-
-    #[derive(Debug)]
-    struct DropWrapper(libmpv2_sys::mpv_node);
-
-    impl Drop for DropWrapper {
-        fn drop(&mut self) {
-            unsafe {
-                libmpv2_sys::mpv_free_node_contents(&mut self.0 as *mut libmpv2_sys::mpv_node)
-            };
-        }
-    }
-
-    pub mod sys_node {
-        use super::{DropWrapper, MpvNode, MpvNodeArrayIter, MpvNodeMapIter};
-        use crate::{mpv_error, mpv_format, Error, Result};
-        use std::rc::Rc;
-
-        #[derive(Debug, Clone)]
-        pub struct SysMpvNode {
-            // Reference counted pointer to a parent node so it stays alive long enough.
-            //
-            // MPV has one big cleanup function that takes a node so store the parent node
-            // and force it to stay alive until the reference count hits 0.
-            parent: Option<Rc<DropWrapper>>,
-            node: libmpv2_sys::mpv_node,
-        }
-
-        impl SysMpvNode {
-            pub fn new(node: libmpv2_sys::mpv_node, drop: bool) -> Self {
-                Self {
-                    parent: if drop {
-                        Some(Rc::new(DropWrapper(node)))
-                    } else {
-                        None
-                    },
-                    node,
-                }
-            }
-
-            pub fn child(self: Self, node: libmpv2_sys::mpv_node) -> Self {
-                Self {
-                    parent: self.parent,
-                    node,
-                }
-            }
-
-            pub fn value(&self) -> Result<MpvNode> {
-                let node = self.node;
-                Ok(match node.format {
-                    mpv_format::Flag => MpvNode::Flag(unsafe { node.u.flag } == 1),
-                    mpv_format::Int64 => MpvNode::Int64(unsafe { node.u.int64 }),
-                    mpv_format::Double => MpvNode::Double(unsafe { node.u.double_ }),
-                    mpv_format::String => {
-                        let text = unsafe { mpv_cstr_to_str!(node.u.string) }?.to_owned();
-                        MpvNode::String(text)
-                    }
-                    mpv_format::Array => {
-                        let list = unsafe { *node.u.list };
-                        let iter = MpvNodeArrayIter {
-                            node: self.clone(),
-                            start: unsafe { *node.u.list }.values,
-                            end: unsafe { list.values.offset(list.num.try_into().unwrap()) },
-                        };
-                        return Ok(MpvNode::ArrayIter(iter));
-                    }
-
-                    mpv_format::Map => MpvNode::MapIter(MpvNodeMapIter {
-                        list: unsafe { *node.u.list },
-                        curr: 0,
-                        node: self.clone(),
-                    }),
-                    mpv_format::None => MpvNode::None,
-                    _ => return Err(Error::Raw(mpv_error::PropertyError)),
-                })
-            }
-        }
-    }
-
-    #[derive(Debug, Clone)]
-    pub struct MpvNodeArrayIter {
-        // Reference counted pointer to a parent node so it stays alive long enough.
-        //
-        // MPV has one big cleanup function that takes a node so store the parent node
-        // and force it to stay alive until the reference count hits 0.
-        node: SysMpvNode,
-        start: *const libmpv2_sys::mpv_node,
-        end: *const libmpv2_sys::mpv_node,
-    }
-
-    impl Iterator for MpvNodeArrayIter {
-        type Item = MpvNode;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            if self.start == self.end {
-                None
-            } else {
-                unsafe {
-                    let result = ptr::read(self.start);
-                    let node = SysMpvNode::child(self.node.clone(), result);
-                    self.start = self.start.offset(1);
-                    node.value().ok()
-                }
-            }
-        }
-    }
-
-    #[derive(Debug, Clone)]
-    pub struct MpvNodeMapIter {
-        // Reference counted pointer to a parent node so it stays alive long enough.
-        //
-        // MPV has one big cleanup function that takes a node so store the parent node
-        // and force it to stay alive until the reference count hits 0.
-        node: SysMpvNode,
-        list: libmpv2_sys::mpv_node_list,
-        curr: usize,
-    }
-
-    impl Iterator for MpvNodeMapIter {
-        type Item = (String, MpvNode);
-
-        fn next(&mut self) -> Option<Self::Item> {
-            if self.curr >= self.list.num.try_into().unwrap() {
-                None
-            } else {
-                let offset = self.curr.try_into().unwrap();
-                let (key, value) = unsafe {
-                    (
-                        mpv_cstr_to_str!(*self.list.keys.offset(offset)),
-                        *self.list.values.offset(offset),
-                    )
-                };
-                self.curr += 1;
-                let node = SysMpvNode::child(self.node.clone(), value);
-                Some((key.unwrap().to_string(), node.value().unwrap()))
-            }
-        }
-    }
-
-    unsafe impl GetData for MpvNode {
-        fn get_from_c_void<T, F: FnMut(*mut c_void) -> Result<T>>(mut fun: F) -> Result<Self> {
-            let mut val = MaybeUninit::uninit();
-            fun(val.as_mut_ptr() as *mut _)?;
-            let sys_node = unsafe { val.assume_init() };
-            let node = SysMpvNode::new(sys_node, true);
-            node.value()
-        }
-
-        fn get_format() -> Format {
-            Format::Node
-        }
-    }
-}
-
-unsafe impl SetData for i64 {
-    fn get_format() -> Format {
-        Format::Int64
-    }
-}
-
-unsafe impl GetData for bool {
-    fn get_format() -> Format {
-        Format::Flag
-    }
-}
-
-unsafe impl SetData for bool {
-    fn call_as_c_void<T, F: FnMut(*mut ctype::c_void) -> Result<T>>(self, mut fun: F) -> Result<T> {
-        let mut cpy: i64 = if self { 1 } else { 0 };
-        fun(&mut cpy as *mut i64 as *mut _)
-    }
-
-    fn get_format() -> Format {
-        Format::Flag
-    }
-}
-
-unsafe impl GetData for String {
-    fn get_from_c_void<T, F: FnMut(*mut ctype::c_void) -> Result<T>>(mut fun: F) -> Result<String> {
-        let ptr = &mut ptr::null();
-        fun(ptr as *mut *const ctype::c_char as _)?;
-
-        let ret = unsafe { mpv_cstr_to_str!(*ptr) }?.to_owned();
-        unsafe { libmpv2_sys::mpv_free(*ptr as *mut _) };
-        Ok(ret)
-    }
-
-    fn get_format() -> Format {
-        Format::String
-    }
-}
-
-unsafe impl SetData for String {
-    fn call_as_c_void<T, F: FnMut(*mut ctype::c_void) -> Result<T>>(self, mut fun: F) -> Result<T> {
-        let string = CString::new(self)?;
-        fun((&mut string.as_ptr()) as *mut *const ctype::c_char as *mut _)
-    }
-
-    fn get_format() -> Format {
-        Format::String
-    }
-}
-
-/// Wrapper around an `&str` returned by mpv, that properly deallocates it with mpv's allocator.
-#[derive(Debug, Hash, Eq, PartialEq)]
-pub struct MpvStr<'a>(&'a str);
-impl<'a> Deref for MpvStr<'a> {
-    type Target = str;
-
-    fn deref(&self) -> &str {
-        self.0
-    }
-}
-impl<'a> Drop for MpvStr<'a> {
-    fn drop(&mut self) {
-        unsafe { libmpv2_sys::mpv_free(self.0.as_ptr() as *mut u8 as _) };
-    }
-}
-
-unsafe impl<'a> GetData for MpvStr<'a> {
-    fn get_from_c_void<T, F: FnMut(*mut ctype::c_void) -> Result<T>>(
-        mut fun: F,
-    ) -> Result<MpvStr<'a>> {
-        let ptr = &mut ptr::null();
-        let _ = fun(ptr as *mut *const ctype::c_char as _)?;
-
-        Ok(MpvStr(unsafe { mpv_cstr_to_str!(*ptr) }?))
-    }
-
-    fn get_format() -> Format {
-        Format::String
-    }
-}
-
-unsafe impl<'a> SetData for &'a str {
-    fn call_as_c_void<T, F: FnMut(*mut ctype::c_void) -> Result<T>>(self, mut fun: F) -> Result<T> {
-        let string = CString::new(self)?;
-        fun((&mut string.as_ptr()) as *mut *const ctype::c_char as *mut _)
-    }
-
-    fn get_format() -> Format {
-        Format::String
-    }
-}
-
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
-/// Subset of `mpv_format` used by the public API.
-pub enum Format {
-    String,
-    Flag,
-    Int64,
-    Double,
-    Node,
-}
-
-impl Format {
-    fn as_mpv_format(&self) -> MpvFormat {
-        match *self {
-            Format::String => mpv_format::String,
-            Format::Flag => mpv_format::Flag,
-            Format::Int64 => mpv_format::Int64,
-            Format::Double => mpv_format::Double,
-            Format::Node => mpv_format::Node,
-        }
-    }
-}
-
-/// Context passed to the `initializer` of `Mpv::with_initialzer`.
-pub struct MpvInitializer {
-    ctx: *mut libmpv2_sys::mpv_handle,
-}
-
-impl MpvInitializer {
-    /// Set the value of a property.
-    pub fn set_property<T: SetData>(&self, name: &str, data: T) -> Result<()> {
-        let name = CString::new(name)?;
-        let format = T::get_format().as_mpv_format() as _;
-        data.call_as_c_void(|ptr| {
-            mpv_err((), unsafe {
-                libmpv2_sys::mpv_set_property(self.ctx, name.as_ptr(), format, ptr)
-            })
-        })
-    }
-
-    /// Set the value of an option
-    pub fn set_option<T: SetData>(&self, name: &str, data: T) -> Result<()> {
-        let name = CString::new(name)?;
-        let format = T::get_format().as_mpv_format() as _;
-        data.call_as_c_void(|ptr| {
-            mpv_err((), unsafe {
-                libmpv2_sys::mpv_set_option(self.ctx, name.as_ptr(), format, ptr)
-            })
-        })
-    }
-}
-
-/// The central mpv context.
-pub struct Mpv {
-    /// The handle to the mpv core
-    pub ctx: NonNull<libmpv2_sys::mpv_handle>,
-    event_context: EventContext,
-    #[cfg(feature = "protocols")]
-    protocols_guard: AtomicBool,
-}
-
-unsafe impl Send for Mpv {}
-unsafe impl Sync for Mpv {}
-
-impl Drop for Mpv {
-    fn drop(&mut self) {
-        unsafe {
-            libmpv2_sys::mpv_terminate_destroy(self.ctx.as_ptr());
-        }
-    }
-}
-
-impl Mpv {
-    /// Create a new `Mpv`.
-    /// The default settings can be probed by running: `$ mpv --show-profile=libmpv`.
-    pub fn new() -> Result<Mpv> {
-        Mpv::with_initializer(|_| Ok(()))
-    }
-
-    /// Create a new `Mpv`.
-    /// The same as `Mpv::new`, but you can set properties before `Mpv` is initialized.
-    pub fn with_initializer<F: FnOnce(MpvInitializer) -> Result<()>>(
-        initializer: F,
-    ) -> Result<Mpv> {
-        let api_version = unsafe { libmpv2_sys::mpv_client_api_version() };
-        if crate::MPV_CLIENT_API_MAJOR != api_version >> 16 {
-            return Err(Error::VersionMismatch {
-                linked: crate::MPV_CLIENT_API_VERSION,
-                loaded: api_version,
-            });
-        }
-
-        let ctx = unsafe { libmpv2_sys::mpv_create() };
-        if ctx.is_null() {
-            return Err(Error::Null);
-        }
-
-        initializer(MpvInitializer { ctx })?;
-        mpv_err((), unsafe { libmpv2_sys::mpv_initialize(ctx) }).map_err(|err| {
-            unsafe { libmpv2_sys::mpv_terminate_destroy(ctx) };
-            err
-        })?;
-
-        let ctx = unsafe { NonNull::new_unchecked(ctx) };
-
-        Ok(Mpv {
-            ctx,
-            event_context: EventContext::new(ctx),
-            #[cfg(feature = "protocols")]
-            protocols_guard: AtomicBool::new(false),
-        })
-    }
-
-    /// Execute a command
-    pub fn execute(&self, name: &str, args: &[&str]) -> Result<()> {
-        if args.is_empty() {
-            debug!("Running mpv command: '{}'", name);
-        } else {
-            debug!("Running mpv command: '{} {}'", name, args.join(" "));
-        }
-
-        self.command(name, args)?;
-
-        Ok(())
-    }
-
-    /// Load a configuration file. The path has to be absolute, and a file.
-    pub fn load_config(&self, path: &str) -> Result<()> {
-        let file = CString::new(path)?.into_raw();
-        let ret = mpv_err((), unsafe {
-            libmpv2_sys::mpv_load_config_file(self.ctx.as_ptr(), file)
-        });
-        unsafe {
-            drop(CString::from_raw(file));
-        };
-        ret
-    }
-
-    pub fn event_context(&self) -> &EventContext {
-        &self.event_context
-    }
-
-    pub fn event_context_mut(&mut self) -> &mut EventContext {
-        &mut self.event_context
-    }
-
-    /// Send a command to the `Mpv` instance. This uses `mpv_command_string` internally,
-    /// so that the syntax is the same as described in the [manual for the input.conf](https://mpv.io/manual/master/#list-of-input-commands).
-    ///
-    /// Note that you may have to escape strings with `""` when they contain spaces.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use libmpv2::{Mpv};
-    /// # use libmpv2::mpv_node::MpvNode;
-    /// # use std::collections::HashMap;
-    /// mpv.command("loadfile", &["test-data/jellyfish.mp4", "append-play"]).unwrap();
-    /// # let node = mpv.get_property::<MpvNode>("playlist").unwrap();
-    /// # let mut list = node.array().unwrap().collect::<Vec<_>>();
-    /// # let map = list.pop().unwrap().map().unwrap().collect::<HashMap<_, _>>();
-    /// # assert_eq!(map, HashMap::from([(String::from("id"), MpvNode::Int64(1)), (String::from("current"), MpvNode::Flag(true)), (String::from("filename"), MpvNode::String(String::from("test-data/jellyfish.mp4")))]));
-    /// ```
-    pub fn command(&self, name: &str, args: &[&str]) -> Result<()> {
-        let mut cmd = name.to_owned();
-
-        for elem in args {
-            cmd.push(' ');
-            cmd.push_str(elem);
-        }
-
-        let raw = CString::new(cmd)?;
-        mpv_err((), unsafe {
-            libmpv2_sys::mpv_command_string(self.ctx.as_ptr(), raw.as_ptr())
-        })
-    }
-
-    /// Set the value of a property.
-    pub fn set_property<T: SetData>(&self, name: &str, data: T) -> Result<()> {
-        let name = CString::new(name)?;
-        let format = T::get_format().as_mpv_format() as _;
-        data.call_as_c_void(|ptr| {
-            mpv_err((), unsafe {
-                libmpv2_sys::mpv_set_property(self.ctx.as_ptr(), name.as_ptr(), format, ptr)
-            })
-        })
-    }
-
-    /// Get the value of a property.
-    pub fn get_property<T: GetData>(&self, name: &str) -> Result<T> {
-        let name = CString::new(name)?;
-
-        let format = T::get_format().as_mpv_format() as _;
-        T::get_from_c_void(|ptr| {
-            mpv_err((), unsafe {
-                libmpv2_sys::mpv_get_property(self.ctx.as_ptr(), name.as_ptr(), format, ptr)
-            })
-        })
-    }
-
-    /// Internal time in microseconds, this has an arbitrary offset, and will never go backwards.
-    ///
-    /// This can be called at any time, even if it was stated that no API function should be called.
-    pub fn get_internal_time(&self) -> i64 {
-        unsafe { libmpv2_sys::mpv_get_time_us(self.ctx.as_ptr()) }
-    }
-}