Merge branch '4-clippy_fmt' into 'master'

Draft: Resolve "Fix clippy warnings"

Closes #4

See merge request videolan/vlc-rs!7

.gitignore

@@ -12,4 +12,5 @@
 
 # Generated by Cargo
 /target/
+/libvlc-sys/target
 Cargo.lock

Cargo.toml

@@ -4,7 +4,9 @@ version = "0.3.0"
 authors = ["T. Okubo <t.okubo.rx78+github@gmail.com>"]
 
 description = "Rust bindings for libVLC media framework."
-keywords = ["libVLC", "bindings"]
+keywords = ["libVLC", "bindings", "multimedia"]
+categories = ["external-ffi-bindings", "multimedia"]
+documentation = "https://docs.rs/vlc-rs"
 repository = "https://code.videolan.org/videolan/vlc-rs"
 homepage = "https://code.videolan.org/videolan/vlc-rs"
 license = "MIT"
@@ -17,6 +19,7 @@ crate-type = ["rlib"]
 
 [dependencies]
 libc = "0.2"
+libvlc-sys = "0.2"
 
 [target.'cfg(target_os = "windows")'.build-dependencies]
-vswhom = "0.1.0"
+vswhom = "0.1.0"

examples/cli_player.rs

@@ -1,4 +1,3 @@
-
 // This file is an example for vlc-rs, licensed under CC0.
 // https://creativecommons.org/publicdomain/zero/1.0/deed
 
@@ -6,7 +5,7 @@ extern crate vlc;
 
 use std::sync::mpsc::channel;
 
-use vlc::{Instance, Media, MediaPlayer, Event, EventType, State};
+use vlc::{Event, EventType, Instance, Media, MediaPlayer, State};
 
 fn main() {
     let args: Vec<String> = std::env::args().collect();
@@ -19,32 +18,28 @@ fn main() {
         }
     };
     let instance = Instance::new().unwrap();
-    
-    let md = Media::new_path(&instance, path).unwrap();    
+
+    let md = Media::new_path(&instance, path).unwrap();
     let mdp = MediaPlayer::new(&instance).unwrap();
-    
+
     let (tx, rx) = channel::<()>();
-    
+
     let em = md.event_manager();
-    let _ = em.attach(EventType::MediaStateChanged, move |e, _| {
-        match e {
-            Event::MediaStateChanged(s) => {
-                println!("State : {:?}", s);
-                if s == State::Ended || s == State::Error {
-                    tx.send(()).unwrap();
-                }
-            },
-            _ => (),
+    let _ = em.attach(EventType::MediaStateChanged, move |e, _| match e {
+        Event::MediaStateChanged(s) => {
+            println!("State : {:?}", s);
+            if s == State::Ended || s == State::Error {
+                tx.send(()).unwrap();
+            }
         }
+        _ => (),
     });
-    
+
     mdp.set_media(&md);
-    
+
     // Start playing
     mdp.play().unwrap();
-    
+
     // Wait for end state
-    rx.recv().unwrap();    
+    rx.recv().unwrap();
 }
-
-

examples/print_version.rs

@@ -1,4 +1,3 @@
-
 // This file is an example for vlc-rs, licensed under CC0.
 // https://creativecommons.org/publicdomain/zero/1.0/deed
 

libvlc-sys/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "libvlc-sys"
+version = "0.2.0"
+authors = ["T. Okubo <t.okubo.rx78+devel@gmail.com>"]
+
+description = "libVLC C API"
+keywords = ["libVLC", "bindings"]
+categories = ["external-ffi-bindings", "multimedia"]
+documentation = "https://docs.rs/vlc-rs"
+repository = "https://code.videolan.org/videolan/vlc-rs"
+homepage = "https://code.videolan.org/videolan/vlc-rs"
+license = "MIT"
+edition = "2018"
+build = "build.rs"
+
+[lib]
+name = "vlc_sys"
+crate-type = ["rlib"]
+
+[dependencies]
+libc = "0.2"
+
+[build-dependencies]
+bindgen = "0.59"
+pkg-config = "0.3"

libvlc-sys/build.rs

@@ -0,0 +1,34 @@
+use bindgen;
+
+use std::env;
+use std::path::PathBuf;
+
+fn main() {
+    println!("cargo:rerun-if-changed=wrapper.h");
+
+    let mut bindings = bindgen::Builder::default()
+        .header("wrapper.h")
+        // For no_std
+        .use_core()
+        // Use libc
+        .ctypes_prefix("libc")
+        // Whitelist
+        .whitelist_type(".*vlc.*")
+        .whitelist_function(".*vlc.*")
+        .whitelist_var(".*vlc.*")
+        .whitelist_function("vsnprintf")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks));
+
+    // Set header include paths
+    let pkg_config_library = pkg_config::Config::new().probe("libvlc").unwrap();
+    for include_path in &pkg_config_library.include_paths {
+        bindings = bindings.clang_arg(format!("-I{}", include_path.display()));
+    }
+
+    let bindings = bindings.generate().expect("Unable to generate bindings");
+
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}

libvlc-sys/src/lib.rs

@@ -0,0 +1,6 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![no_std]
+
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

libvlc-sys/wrapper.h

@@ -0,0 +1 @@
+#include <vlc/vlc.h>

src/audio.rs

@@ -2,58 +2,68 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use crate::sys;
+use crate::tools::from_cstr;
+use crate::InternalError;
 use crate::MediaPlayer;
 use crate::TrackDescription;
-use crate::tools::from_cstr;
+use vlc_sys as sys;
 
 pub trait MediaPlayerAudioEx {
     fn get_mute(&self) -> Option<bool>;
     fn set_mute(&self, muted: bool);
     fn get_volume(&self) -> i32;
-    fn set_volume(&self, volume: i32) -> Result<(), ()>;
+    fn set_volume(&self, volume: i32) -> Result<(), InternalError>;
     fn get_audio_track_description(&self) -> Option<Vec<TrackDescription>>;
 }
 
 impl MediaPlayerAudioEx for MediaPlayer {
     fn get_mute(&self) -> Option<bool> {
-        let r = unsafe{ sys::libvlc_audio_get_mute(self.ptr) };
+        let r = unsafe { sys::libvlc_audio_get_mute(self.ptr) };
 
         if r == 0 {
             Some(false)
-        }else if r == -1 {
+        } else if r == -1 {
             None
-        }else{
+        } else {
             Some(true)
         }
     }
 
     fn set_mute(&self, status: bool) {
-        unsafe{ sys::libvlc_audio_set_mute(self.ptr, if status { 1 }else{ 0 }) };
+        unsafe { sys::libvlc_audio_set_mute(self.ptr, if status { 1 } else { 0 }) };
     }
 
     fn get_volume(&self) -> i32 {
-        unsafe{ sys::libvlc_audio_get_volume(self.ptr) }
+        unsafe { sys::libvlc_audio_get_volume(self.ptr) }
     }
-    fn set_volume(&self, volume: i32) -> Result<(), ()> {
-        unsafe{
-            if sys::libvlc_audio_set_volume(self.ptr, volume) == 0 { Ok(()) }else{ Err(()) }
+    fn set_volume(&self, volume: i32) -> Result<(), InternalError> {
+        unsafe {
+            if sys::libvlc_audio_set_volume(self.ptr, volume) == 0 {
+                Ok(())
+            } else {
+                Err(InternalError)
+            }
         }
     }
+
     fn get_audio_track_description(&self) -> Option<Vec<TrackDescription>> {
-        unsafe{
+        unsafe {
             let p0 = sys::libvlc_audio_get_track_description(self.ptr);
-            if p0.is_null() { return None; }
+            if p0.is_null() {
+                return None;
+            }
             let mut td = Vec::new();
             let mut p = p0;
 
             while !(*p).p_next.is_null() {
-                td.push(TrackDescription{ id: (*p).i_id, name: from_cstr((*p).psz_name) });
+                td.push(TrackDescription {
+                    id: (*p).i_id,
+                    name: from_cstr((*p).psz_name),
+                });
                 p = (*p).p_next;
             }
             sys::libvlc_track_description_list_release(p0);
             Some(td)
         }
     }
-
 }

src/core.rs

@@ -2,33 +2,49 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use std::ptr;
-use std::borrow::Cow;
-use std::marker::PhantomData;
-use std::ffi::{CString, CStr};
-use std::i32;
-use libc::{c_void, c_char, c_int};
-use crate::sys;
-use crate::tools::{to_cstr, from_cstr, from_cstr_ref};
 use crate::enums::*;
+use crate::tools::{from_cstr, from_cstr_ref, to_cstr};
+use libc::{c_char, c_int, c_void};
+use std::borrow::Cow;
+use std::convert::TryInto;
+use std::ffi::CString;
+use std::fmt;
+use std::i32;
+use std::marker::PhantomData;
+use std::ptr;
+use vlc_sys as sys;
+
+#[derive(Debug)]
+pub struct InternalError;
+
+impl fmt::Display for InternalError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "libvlc internal error")
+    }
+}
+
+impl std::error::Error for InternalError {}
 
 /// Retrieve libvlc version.
 pub fn version() -> String {
-    unsafe{
-        from_cstr_ref(sys::libvlc_get_version()).unwrap().into_owned()
+    unsafe {
+        from_cstr_ref(sys::libvlc_get_version())
+            .unwrap()
+            .into_owned()
     }
 }
 
 /// Retrieve libvlc compiler version.
 pub fn compiler() -> String {
-    unsafe{
-        from_cstr_ref(sys::libvlc_get_compiler()).unwrap().into_owned()
+    unsafe {
+        from_cstr_ref(sys::libvlc_get_compiler())
+            .unwrap()
+            .into_owned()
     }
 }
 
 pub struct Instance {
     pub(crate) ptr: *mut sys::libvlc_instance_t,
-
 }
 
 unsafe impl Send for Instance {}
@@ -37,19 +53,20 @@ impl Instance {
     /// Create and initialize a libvlc instance with specified args.
     /// Note: args.len() has to be less or equal to i32::MAX
     /// Note: libvlc discourages using arguments as these are not guaranteed to be stable between different versions of libvlc
-    pub fn with_args(args: Option<Vec<String>>) -> Option<Instance> {
-        let args_c_ptr: Vec<*const c_char> ;
+    pub fn with_args(args: Option<Vec<String>>) -> Result<Instance, InternalError> {
+        let args_c_ptr: Vec<*const c_char>;
         let args_c: Vec<CString>;
         if let Some(argv) = args {
-            args_c = argv.into_iter()
-                .map(|x| CString::new(x).expect("Error: Unexpected null byte")).collect();
+            args_c = argv
+                .into_iter()
+                .map(|x| CString::new(x).expect("Error: Unexpected null byte"))
+                .collect();
             args_c_ptr = args_c.iter().map(|x| x.as_ptr()).collect();
         } else {
             args_c_ptr = Vec::new();
         }
 
-
-        unsafe{
+        unsafe {
             let p = if args_c_ptr.is_empty() {
                 sys::libvlc_new(0, ptr::null())
             } else {
@@ -57,76 +74,89 @@ impl Instance {
             };
 
             if p.is_null() {
-                return None;
+                Err(InternalError)
+            } else {
+                Ok(Instance { ptr: p })
             }
-
-            Some(Instance{ptr: p})
         }
     }
 
     /// Create and initialize a libvlc instance.
-    pub fn new() -> Option<Instance> {
+    pub fn new() -> Result<Instance, InternalError> {
         Instance::with_args(None)
     }
 
     /// Try to start a user interface for the libvlc instance.
-    pub fn add_intf(&self, name: &str) -> Result<(), ()> {
+    pub fn add_intf(&self, name: &str) -> Result<(), InternalError> {
         let cstr = to_cstr(name);
 
-        let result = unsafe{
-            sys::libvlc_add_intf(self.ptr, cstr.as_ptr())
-        };
+        let result = unsafe { sys::libvlc_add_intf(self.ptr, cstr.as_ptr()) };
 
-        if result == 0 { Ok(()) }
-        else { Err(()) }
+        if result == 0 {
+            Ok(())
+        } else {
+            Err(InternalError)
+        }
     }
 
     /// Sets the application name.
     /// LibVLC passes this as the user agent string when a protocol requires it.
     pub fn set_user_agent(&self, name: &str, http: &str) {
-        unsafe{
-            sys::libvlc_set_user_agent(
-                self.ptr, to_cstr(name).as_ptr(), to_cstr(http).as_ptr());
+        unsafe {
+            sys::libvlc_set_user_agent(self.ptr, to_cstr(name).as_ptr(), to_cstr(http).as_ptr());
         }
     }
 
     /// Waits until an interface causes the instance to exit.
     pub fn wait(&self) {
-        unsafe{ sys::libvlc_wait(self.ptr) };
+        unsafe { sys::libvlc_wait(self.ptr) };
     }
 
     /// Sets some meta-information about the application.
     pub fn set_app_id(&self, id: &str, version: &str, icon: &str) {
-        unsafe{
+        unsafe {
             sys::libvlc_set_app_id(
-                self.ptr, to_cstr(id).as_ptr(), to_cstr(version).as_ptr(), to_cstr(icon).as_ptr());
+                self.ptr,
+                to_cstr(id).as_ptr(),
+                to_cstr(version).as_ptr(),
+                to_cstr(icon).as_ptr(),
+            );
         }
     }
 
     /// Returns a list of audio filters that are available.
-    pub fn audio_filter_list_get(&self) -> Option<ModuleDescriptionList> {
-        unsafe{
+    pub fn audio_filter_list_get(&self) -> Result<ModuleDescriptionList, InternalError> {
+        unsafe {
             let p = sys::libvlc_audio_filter_list_get(self.ptr);
-            if p.is_null() { None }
-            else { Some(ModuleDescriptionList{ptr: p}) }
+            if p.is_null() {
+                Err(InternalError)
+            } else {
+                Ok(ModuleDescriptionList { ptr: p })
+            }
         }
     }
 
     /// Returns a list of video filters that are available.
-    pub fn video_filter_list_get(&self) -> Option<ModuleDescriptionList> {
-        unsafe{
+    pub fn video_filter_list_get(&self) -> Result<ModuleDescriptionList, InternalError> {
+        unsafe {
             let p = sys::libvlc_video_filter_list_get(self.ptr);
-            if p.is_null() { None }
-            else { Some(ModuleDescriptionList{ptr: p}) }
+            if p.is_null() {
+                Err(InternalError)
+            } else {
+                Ok(ModuleDescriptionList { ptr: p })
+            }
         }
     }
 
     /// Returns the VLM event manager
     pub fn vlm_event_manager<'a>(&'a self) -> EventManager<'a> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_vlm_get_event_manager(self.ptr);
             assert!(!p.is_null());
-            EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData}
+            EventManager {
+                ptr: p,
+                _phantomdata: ::std::marker::PhantomData,
+            }
         }
     }
 
@@ -134,8 +164,8 @@ impl Instance {
     pub fn set_log<F: Fn(LogLevel, Log, Cow<str>) + Send + 'static>(&self, f: F) {
         let cb: Box<Box<dyn Fn(LogLevel, Log, Cow<str>) + Send + 'static>> = Box::new(Box::new(f));
 
-        unsafe{
-            sys::libvlc_log_set(self.ptr, logging_cb, Box::into_raw(cb) as *mut _);
+        unsafe {
+            sys::libvlc_log_set(self.ptr, Some(logging_cb), Box::into_raw(cb) as *mut _);
         }
     }
 
@@ -147,25 +177,30 @@ impl Instance {
 
 impl Drop for Instance {
     fn drop(&mut self) {
-        unsafe{
+        unsafe {
             sys::libvlc_release(self.ptr);
         }
     }
 }
 
-extern "C" {
-    fn vsnprintf(s: *mut c_char, n: usize, fmt: *const c_char, arg: sys::va_list);
-}
 const BUF_SIZE: usize = 1024; // Write log message to the buffer by vsnprintf.
 unsafe extern "C" fn logging_cb(
-    data: *mut c_void, level: c_int, ctx: *const sys::libvlc_log_t, fmt: *const c_char, args: sys::va_list) {
-
+    data: *mut c_void,
+    level: c_int,
+    ctx: *const sys::libvlc_log_t,
+    fmt: *const c_char,
+    args: *mut sys::__va_list_tag,
+) {
     let f: &Box<dyn Fn(LogLevel, Log, Cow<str>) + Send + 'static> = ::std::mem::transmute(data);
     let mut buf: [c_char; BUF_SIZE] = [0; BUF_SIZE];
 
-    vsnprintf(buf.as_mut_ptr(), BUF_SIZE, fmt, args);
+    sys::vsnprintf(buf.as_mut_ptr(), BUF_SIZE.try_into().unwrap(), fmt, args);
 
-    f(::std::mem::transmute(level), Log{ptr: ctx}, from_cstr_ref(buf.as_ptr()).unwrap());
+    f(
+        (level as u32).into(),
+        Log { ptr: ctx },
+        from_cstr_ref(buf.as_ptr()).unwrap(),
+    );
 }
 
 /// List of module description.
@@ -182,7 +217,7 @@ impl ModuleDescriptionList {
 
 impl Drop for ModuleDescriptionList {
     fn drop(&mut self) {
-        unsafe{ sys::libvlc_module_description_list_release(self.ptr) };
+        unsafe { sys::libvlc_module_description_list_release(self.ptr) };
     }
 }
 
@@ -191,7 +226,10 @@ impl<'a> IntoIterator for &'a ModuleDescriptionList {
     type IntoIter = ModuleDescriptionListIter<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
-        ModuleDescriptionListIter{ptr: self.ptr, _phantomdata: PhantomData}
+        ModuleDescriptionListIter {
+            ptr: self.ptr,
+            _phantomdata: PhantomData,
+        }
     }
 }
 
@@ -204,36 +242,36 @@ pub struct ModuleDescriptionListIter<'a> {
 /// The strings are owned.
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct ModuleDescription {
-    pub name:      Option<String>,
+    pub name: Option<String>,
     pub shortname: Option<String>,
-    pub longname:  Option<String>,
-    pub help:      Option<String>,
+    pub longname: Option<String>,
+    pub help: Option<String>,
 }
 
 /// Description of a module.
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct ModuleDescriptionRef<'a> {
-    pub name:      Option<Cow<'a, str>>,
+    pub name: Option<Cow<'a, str>>,
     pub shortname: Option<Cow<'a, str>>,
-    pub longname:  Option<Cow<'a, str>>,
-    pub help:      Option<Cow<'a, str>>,
+    pub longname: Option<Cow<'a, str>>,
+    pub help: Option<Cow<'a, str>>,
 }
 
 impl<'a> Iterator for ModuleDescriptionListIter<'a> {
     type Item = ModuleDescriptionRef<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        unsafe{
+        unsafe {
             if self.ptr.is_null() {
                 return None;
             }
             let p = self.ptr;
             self.ptr = (*p).p_next;
-            Some(ModuleDescriptionRef{
-                name:      from_cstr_ref((*p).psz_name),
+            Some(ModuleDescriptionRef {
+                name: from_cstr_ref((*p).psz_name),
                 shortname: from_cstr_ref((*p).psz_shortname),
-                longname:  from_cstr_ref((*p).psz_longname),
-                help:      from_cstr_ref((*p).psz_help),
+                longname: from_cstr_ref((*p).psz_longname),
+                help: from_cstr_ref((*p).psz_help),
             })
         }
     }
@@ -243,20 +281,20 @@ impl<'a> ModuleDescriptionRef<'a> {
     /// Convert to owned strings.
     pub fn into_owned(&'a self) -> ModuleDescription {
         ModuleDescription {
-            name:      self.name     .as_ref().map(|s| s.clone().into_owned()),
+            name: self.name.as_ref().map(|s| s.clone().into_owned()),
             shortname: self.shortname.as_ref().map(|s| s.clone().into_owned()),
-            longname:  self.name     .as_ref().map(|s| s.clone().into_owned()),
-            help:      self.shortname.as_ref().map(|s| s.clone().into_owned()),
+            longname: self.name.as_ref().map(|s| s.clone().into_owned()),
+            help: self.shortname.as_ref().map(|s| s.clone().into_owned()),
         }
     }
 }
 
 pub fn errmsg() -> Option<String> {
-    unsafe{ from_cstr(sys::libvlc_errmsg()) }
+    unsafe { from_cstr(sys::libvlc_errmsg()) }
 }
 
 pub fn clearerr() {
-    unsafe{ sys::libvlc_clearerr() };
+    unsafe { sys::libvlc_clearerr() };
 }
 
 #[derive(Clone, Debug)]
@@ -317,7 +355,7 @@ pub enum Event {
     VlmMediaInstanceStatusPlaying(Option<String>, Option<String>),
     VlmMediaInstanceStatusPause(Option<String>, Option<String>),
     VlmMediaInstanceStatusEnd(Option<String>, Option<String>),
-    VlmMediaInstanceStatusError(Option<String>, Option<String>)
+    VlmMediaInstanceStatusError(Option<String>, Option<String>),
 }
 
 pub struct EventManager<'a> {
@@ -326,23 +364,44 @@ pub struct EventManager<'a> {
 }
 
 impl<'a> EventManager<'a> {
-    pub fn attach<F>(&self, event_type: EventType, callback: F) -> Result<(), ()>
-        where F: Fn(Event, VLCObject) + Send + 'static
+    pub fn detach(&self, event_type: EventType, registered_callback: *mut c_void) {
+        unsafe {
+            sys::libvlc_event_detach(
+                self.ptr,
+                event_type as i32,
+                Some(event_manager_callback),
+                registered_callback
+            )
+        }
+    }
+
+    pub fn attach<F>(
+        &self,
+        event_type: EventType,
+        callback: F,
+    ) -> Result<*mut c_void, InternalError>
+    where
+        F: Fn(Event, VLCObject) + Send + 'static,
     {
         // Explicit type annotation is needed
         let callback: Box<Box<dyn Fn(Event, VLCObject) + Send + 'static>> =
             Box::new(Box::new(callback));
 
-        let result = unsafe{
+        let raw = Box::into_raw(callback) as *mut c_void;
+
+        let result = unsafe {
             sys::libvlc_event_attach(
-                self.ptr, event_type as i32, event_manager_callback,
-                Box::into_raw(callback) as *mut c_void)
+                self.ptr,
+                event_type as i32,
+                Some(event_manager_callback),
+                raw,
+            )
         };
 
         if result == 0 {
-            Ok(())
-        }else{
-            Err(())
+            Ok(raw)
+        } else {
+            Err(InternalError)
         }
     }
 
@@ -355,200 +414,133 @@ impl<'a> EventManager<'a> {
 unsafe extern "C" fn event_manager_callback(pe: *const sys::libvlc_event_t, data: *mut c_void) {
     let f: &Box<dyn Fn(Event, VLCObject) + Send + 'static> = ::std::mem::transmute(data);
 
-    f(conv_event(pe), VLCObject{ ptr: (*pe).p_obj });
+    f(conv_event(pe), VLCObject { ptr: (*pe).p_obj });
 }
 
 // Convert c-style libvlc_event_t to Event
 fn conv_event(pe: *const sys::libvlc_event_t) -> Event {
-    let event_type: EventType = unsafe{ ::std::mem::transmute((*pe)._type) };
+    let event_type: EventType = (unsafe { (*pe).type_ } as u32).into();
 
     match event_type {
-        EventType::MediaMetaChanged => {
-            unsafe{
-                Event::MediaMetaChanged((*pe).u.media_meta_changed.meta_type)
-            }
+        EventType::MediaMetaChanged => unsafe {
+            Event::MediaMetaChanged((*pe).u.media_meta_changed.meta_type.into())
         },
-        EventType::MediaSubItemAdded => {
-            Event::MediaSubItemAdded
+        EventType::MediaSubItemAdded => Event::MediaSubItemAdded,
+        EventType::MediaDurationChanged => unsafe {
+            Event::MediaDurationChanged((*pe).u.media_duration_changed.new_duration)
         },
-        EventType::MediaDurationChanged => {
-            unsafe{
-                Event::MediaDurationChanged((*pe).u.media_duration_changed.new_duration)
-            }
+        EventType::MediaParsedChanged => unsafe {
+            Event::MediaParsedChanged((*pe).u.media_parsed_changed.new_status)
         },
-        EventType::MediaParsedChanged => {
-            unsafe{
-                Event::MediaParsedChanged((*pe).u.media_parsed_changed.new_status)
-            }
+        EventType::MediaFreed => Event::MediaFreed,
+        EventType::MediaStateChanged => unsafe {
+            let new_state: sys::libvlc_state_t =
+                (*pe).u.media_state_changed.new_state.try_into().unwrap();
+            Event::MediaStateChanged(new_state.into())
         },
-        EventType::MediaFreed => {
-            Event::MediaFreed
+        EventType::MediaSubItemTreeAdded => Event::MediaSubItemTreeAdded,
+        EventType::MediaPlayerMediaChanged => Event::MediaPlayerMediaChanged,
+        EventType::MediaPlayerNothingSpecial => Event::MediaPlayerNothingSpecial,
+        EventType::MediaPlayerOpening => Event::MediaPlayerOpening,
+        EventType::MediaPlayerBuffering => unsafe {
+            Event::MediaPlayerBuffering((*pe).u.media_player_buffering.new_cache)
         },
-        EventType::MediaStateChanged => {
-            unsafe{
-                Event::MediaStateChanged((*pe).u.media_state_changed.new_state)
-            }
+        EventType::MediaPlayerPlaying => Event::MediaPlayerPlaying,
+        EventType::MediaPlayerPaused => Event::MediaPlayerPaused,
+        EventType::MediaPlayerStopped => Event::MediaPlayerStopped,
+        EventType::MediaPlayerForward => Event::MediaPlayerForward,
+        EventType::MediaPlayerBackward => Event::MediaPlayerBackward,
+        EventType::MediaPlayerEndReached => Event::MediaPlayerEndReached,
+        EventType::MediaPlayerEncounteredError => Event::MediaPlayerEncounteredError,
+        EventType::MediaPlayerTimeChanged => Event::MediaPlayerTimeChanged,
+        EventType::MediaPlayerPositionChanged => unsafe {
+            Event::MediaPlayerPositionChanged((*pe).u.media_player_position_changed.new_position)
         },
-        EventType::MediaSubItemTreeAdded => {
-            Event::MediaSubItemTreeAdded
+        EventType::MediaPlayerSeekableChanged => Event::MediaPlayerSeekableChanged,
+        EventType::MediaPlayerPausableChanged => Event::MediaPlayerPausableChanged,
+        EventType::MediaPlayerTitleChanged => Event::MediaPlayerTitleChanged,
+        EventType::MediaPlayerSnapshotTaken => Event::MediaPlayerSnapshotTaken,
+        EventType::MediaPlayerLengthChanged => Event::MediaPlayerLengthChanged,
+        EventType::MediaPlayerVout => Event::MediaPlayerVout,
+        EventType::MediaPlayerScrambledChanged => Event::MediaPlayerScrambledChanged,
+        EventType::MediaListItemAdded => Event::MediaListItemAdded,
+        EventType::MediaListWillAddItem => Event::MediaListWillAddItem,
+        EventType::MediaListItemDeleted => Event::MediaListItemDeleted,
+        EventType::MediaListWillDeleteItem => Event::MediaListWillDeleteItem,
+        EventType::MediaListViewItemAdded => Event::MediaListViewItemAdded,
+        EventType::MediaListViewWillAddItem => Event::MediaListViewWillAddItem,
+        EventType::MediaListViewItemDeleted => Event::MediaListViewItemDeleted,
+        EventType::MediaListViewWillDeleteItem => Event::MediaListViewWillDeleteItem,
+        EventType::MediaListPlayerPlayed => Event::MediaListPlayerPlayed,
+        EventType::MediaListPlayerNextItemSet => Event::MediaListPlayerNextItemSet,
+        EventType::MediaListPlayerStopped => Event::MediaListPlayerStopped,
+        EventType::MediaDiscovererStarted => Event::MediaDiscovererStarted,
+        EventType::MediaDiscovererEnded => Event::MediaDiscovererEnded,
+        EventType::VlmMediaAdded => unsafe {
+            Event::VlmMediaAdded(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerMediaChanged => {
-            Event::MediaPlayerMediaChanged
+        EventType::VlmMediaRemoved => unsafe {
+            Event::VlmMediaRemoved(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerNothingSpecial => {
-            Event::MediaPlayerNothingSpecial
+        EventType::VlmMediaChanged => unsafe {
+            Event::VlmMediaChanged(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerOpening => {
-            Event::MediaPlayerOpening
+        EventType::VlmMediaInstanceStarted => unsafe {
+            Event::VlmMediaInstanceStarted(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerBuffering => {
-            unsafe{
-                Event::MediaPlayerBuffering((*pe).u.media_player_buffering.new_cache)
-            }
+        EventType::VlmMediaInstanceStopped => unsafe {
+            Event::VlmMediaInstanceStopped(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerPlaying => {
-            Event::MediaPlayerPlaying
+        EventType::VlmMediaInstanceStatusInit => unsafe {
+            Event::VlmMediaInstanceStatusInit(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerPaused => {
-            Event::MediaPlayerPaused
+        EventType::VlmMediaInstanceStatusOpening => unsafe {
+            Event::VlmMediaInstanceStatusOpening(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerStopped => {
-            Event::MediaPlayerStopped
+        EventType::VlmMediaInstanceStatusPlaying => unsafe {
+            Event::VlmMediaInstanceStatusPlaying(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerForward => {
-            Event::MediaPlayerForward
+        EventType::VlmMediaInstanceStatusPause => unsafe {
+            Event::VlmMediaInstanceStatusPause(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerBackward => {
-            Event::MediaPlayerBackward
+        EventType::VlmMediaInstanceStatusEnd => unsafe {
+            Event::VlmMediaInstanceStatusEnd(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerEndReached => {
-            Event::MediaPlayerEndReached
-        },
-        EventType::MediaPlayerEncounteredError => {
-            Event::MediaPlayerEncounteredError
-        },
-        EventType::MediaPlayerTimeChanged => {
-            Event::MediaPlayerTimeChanged
-        },
-        EventType::MediaPlayerPositionChanged => {
-            unsafe{
-                Event::MediaPlayerPositionChanged((*pe).u.media_player_position_changed.new_position)
-            }
-        },
-        EventType::MediaPlayerSeekableChanged => {
-            Event::MediaPlayerSeekableChanged
-        },
-        EventType::MediaPlayerPausableChanged => {
-            Event::MediaPlayerPausableChanged
-        },
-        EventType::MediaPlayerTitleChanged => {
-            Event::MediaPlayerTitleChanged
-        },
-        EventType::MediaPlayerSnapshotTaken => {
-            Event::MediaPlayerSnapshotTaken
-        },
-        EventType::MediaPlayerLengthChanged => {
-            Event::MediaPlayerLengthChanged
-        },
-        EventType::MediaPlayerVout => {
-            Event::MediaPlayerVout
-        },
-        EventType::MediaPlayerScrambledChanged => {
-            Event::MediaPlayerScrambledChanged
-        },
-        EventType::MediaListItemAdded => {
-            Event::MediaListItemAdded
-        },
-        EventType::MediaListWillAddItem => {
-            Event::MediaListWillAddItem
-        },
-        EventType::MediaListItemDeleted => {
-            Event::MediaListItemDeleted
-        },
-        EventType::MediaListWillDeleteItem => {
-            Event::MediaListWillDeleteItem
-        },
-        EventType::MediaListViewItemAdded => {
-            Event::MediaListViewItemAdded
-        },
-        EventType::MediaListViewWillAddItem => {
-            Event::MediaListViewWillAddItem
-        },
-        EventType::MediaListViewItemDeleted => {
-            Event::MediaListViewItemDeleted
-        },
-        EventType::MediaListViewWillDeleteItem => {
-            Event::MediaListViewWillDeleteItem
-        },
-        EventType::MediaListPlayerPlayed => {
-            Event::MediaListPlayerPlayed
-        },
-        EventType::MediaListPlayerNextItemSet => {
-            Event::MediaListPlayerNextItemSet
-        },
-        EventType::MediaListPlayerStopped => {
-            Event::MediaListPlayerStopped
-        },
-        EventType::MediaDiscovererStarted => {
-            Event::MediaDiscovererStarted
-        },
-        EventType::MediaDiscovererEnded => {
-            Event::MediaDiscovererEnded
-        },
-        EventType::VlmMediaAdded => {
-            unsafe {
-                Event::VlmMediaAdded(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaRemoved => {
-            unsafe {
-                Event::VlmMediaRemoved(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaChanged => {
-            unsafe {
-                Event::VlmMediaChanged(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaInstanceStarted => {
-            unsafe {
-                Event::VlmMediaInstanceStarted(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaInstanceStopped => {
-            unsafe {
-                Event::VlmMediaInstanceStopped(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaInstanceStatusInit => {
-            unsafe {
-                Event::VlmMediaInstanceStatusInit(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaInstanceStatusOpening => {
-            unsafe {
-                Event::VlmMediaInstanceStatusOpening(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaInstanceStatusPlaying => {
-            unsafe {
-                Event::VlmMediaInstanceStatusPlaying(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaInstanceStatusPause => {
-            unsafe {
-                Event::VlmMediaInstanceStatusPause(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaInstanceStatusEnd => {
-            unsafe {
-                Event::VlmMediaInstanceStatusEnd(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
-        },
-        EventType::VlmMediaInstanceStatusError => {
-            unsafe {
-                Event::VlmMediaInstanceStatusError(from_cstr((*pe).u.vlm_media_event.psz_instance_name), from_cstr((*pe).u.vlm_media_event.psz_media_name))
-            }
+        EventType::VlmMediaInstanceStatusError => unsafe {
+            Event::VlmMediaInstanceStatusError(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
     }
 }
@@ -565,7 +557,7 @@ impl VLCObject {
 }
 
 pub struct Log {
-    pub(crate) ptr: *const sys::libvlc_log_t
+    pub(crate) ptr: *const sys::libvlc_log_t,
 }
 
 impl Log {
@@ -574,4 +566,3 @@ impl Log {
         self.ptr
     }
 }
-

src/enums.rs

@@ -2,158 +2,171 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-#[repr(C)]
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub enum LogLevel {
-    Debug = 0,
-    Notice = 2,
-    Warning = 3,
-    Error = 4,
+use vlc_sys as sys;
+
+macro_rules! define_enum {
+    ($enum_name:ident, $original_type:ident; $($value:ident = $c_value:ident,)*) => {
+        #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+        #[repr(C)]
+        pub enum $enum_name {
+            $(
+                $value = sys::$c_value as isize,
+            )*
+        }
+
+        impl From<sys::$original_type> for $enum_name {
+            fn from(a: sys::$original_type) -> Self {
+                match a {
+                    $(
+                        sys::$c_value => Self::$value,
+                    )*
+                    _ => unreachable!(),
+                }
+            }
+        }
+    }
 }
 
-#[repr(C)]
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub enum Meta {
-    Title,
-    Artist,
-    Genre,
-    Copyright,
-    Album,
-    TrackNumber,
-    Description,
-    Rating,
-    Date,
-    Setting,
-    URL,
-    Language,
-    NowPlaying,
-    Publisher,
-    EncodedBy,
-    ArtworkURL,
-    TrackID,
-    TrackTotal,
-    Director,
-    Season,
-    Episode,
-    ShowName,
-    Actors
-}
+define_enum!(
+    LogLevel, libvlc_log_level;
+    Debug = libvlc_log_level_LIBVLC_DEBUG,
+    Dotice = libvlc_log_level_LIBVLC_NOTICE,
+    Warning = libvlc_log_level_LIBVLC_WARNING,
+    Error = libvlc_log_level_LIBVLC_ERROR,
+);
 
-#[repr(C)]
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub enum State {
-    NothingSpecial = 0,
-    Opening,
-    Buffering,
-    Playing,
-    Paused,
-    Stopped,
-    Ended,
-    Error
-}
+define_enum!(
+    Meta, libvlc_meta_t;
+    Title = libvlc_meta_t_libvlc_meta_Title,
+    Artist = libvlc_meta_t_libvlc_meta_Artist,
+    Genre = libvlc_meta_t_libvlc_meta_Genre,
+    Copyright = libvlc_meta_t_libvlc_meta_Copyright,
+    Album = libvlc_meta_t_libvlc_meta_Album,
+    TrackNumber = libvlc_meta_t_libvlc_meta_TrackNumber,
+    Description = libvlc_meta_t_libvlc_meta_Description,
+    Rating = libvlc_meta_t_libvlc_meta_Rating,
+    Date = libvlc_meta_t_libvlc_meta_Date,
+    Setting = libvlc_meta_t_libvlc_meta_Setting,
+    URL = libvlc_meta_t_libvlc_meta_URL,
+    Language = libvlc_meta_t_libvlc_meta_Language,
+    NowPlaying = libvlc_meta_t_libvlc_meta_NowPlaying,
+    Publisher = libvlc_meta_t_libvlc_meta_Publisher,
+    EncodedBy = libvlc_meta_t_libvlc_meta_EncodedBy,
+    ArtworkURL = libvlc_meta_t_libvlc_meta_ArtworkURL,
+    TrackID = libvlc_meta_t_libvlc_meta_TrackID,
+    TrackTotal = libvlc_meta_t_libvlc_meta_TrackTotal,
+    Director = libvlc_meta_t_libvlc_meta_Director,
+    Season = libvlc_meta_t_libvlc_meta_Season,
+    Episode = libvlc_meta_t_libvlc_meta_Episode,
+    ShowName = libvlc_meta_t_libvlc_meta_ShowName,
+    Actors = libvlc_meta_t_libvlc_meta_Actors,
+);
 
-#[repr(C)]
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub enum TrackType {
-    Unknown = -1,
-    Audio   = 0,
-    Video   = 1,
-    Text    = 2
-}
+define_enum!(
+    State, libvlc_state_t;
+    NothingSpecial = libvlc_state_t_libvlc_NothingSpecial,
+    Opening = libvlc_state_t_libvlc_Opening,
+    Buffering = libvlc_state_t_libvlc_Buffering,
+    Playing = libvlc_state_t_libvlc_Playing,
+    Paused = libvlc_state_t_libvlc_Paused,
+    Stopped = libvlc_state_t_libvlc_Stopped,
+    Ended = libvlc_state_t_libvlc_Ended,
+    Error = libvlc_state_t_libvlc_Error,
+);
 
-#[repr(C)]
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub enum Position {
-    Disable = -1,
-    Center,
-    Left,
-    Right,
-    Top,
-    TopLeft,
-    TopRight,
-    Bottom,
-    BottomLeft,
-    BottomRight,
-}
+define_enum!(
+    TrackType, libvlc_track_type_t;
+    Unknown = libvlc_track_type_t_libvlc_track_unknown,
+    Audio = libvlc_track_type_t_libvlc_track_audio,
+    Video = libvlc_track_type_t_libvlc_track_video,
+    Text = libvlc_track_type_t_libvlc_track_text,
+);
 
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub enum VideoAdjustOption {
-    Enable = 0,
-    Contrast,
-    Brightness,
-    Hue,
-    Saturation,
-    Gamma
-}
+define_enum!(
+    Position, libvlc_position_t;
+    Disable = libvlc_position_t_libvlc_position_disable,
+    Center = libvlc_position_t_libvlc_position_center,
+    Left = libvlc_position_t_libvlc_position_left,
+    Right = libvlc_position_t_libvlc_position_right,
+    Top = libvlc_position_t_libvlc_position_top,
+    TopLeft = libvlc_position_t_libvlc_position_top_left,
+    TopRight = libvlc_position_t_libvlc_position_top_right,
+    Bottom = libvlc_position_t_libvlc_position_bottom,
+    BottomLeft = libvlc_position_t_libvlc_position_bottom_left,
+    BottomRight = libvlc_position_t_libvlc_position_bottom_right,
+);
 
-// #[repr(C)]
-// #[derive(Clone, Copy, PartialEq, Eq, Debug)]
-// pub enum ParseFlag {
-//     ParseLocal,
-//     ParseNetwork,
-//     FetchLocal,
-//     FetchNetwork,
-// }
+define_enum!(
+    VideoAdjustOption, libvlc_video_adjust_option_t;
+    Enable = libvlc_video_adjust_option_t_libvlc_adjust_Enable,
+    Contrast = libvlc_video_adjust_option_t_libvlc_adjust_Contrast,
+    Brightness = libvlc_video_adjust_option_t_libvlc_adjust_Brightness,
+    Hue = libvlc_video_adjust_option_t_libvlc_adjust_Hue,
+    Saturation = libvlc_video_adjust_option_t_libvlc_adjust_Saturation,
+    Gamma = libvlc_video_adjust_option_t_libvlc_adjust_Gamma,
+);
 
-#[repr(C)]
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub enum EventType {
-    MediaMetaChanged = 0,
-    MediaSubItemAdded,
-    MediaDurationChanged,
-    MediaParsedChanged,
-    MediaFreed,
-    MediaStateChanged,
-    MediaSubItemTreeAdded,
+// libvlc 3.0
+// define_enum!(
+//     ParseFlag, libvlc_media_parse_flag_t;
+//     DoInteract = libvlc_media_parse_flag_t_libvlc_media_do_interact,
+//     FetchLocal = libvlc_media_parse_flag_t_libvlc_media_fetch_local,
+//     FetchNetwork = libvlc_media_parse_flag_t_libvlc_media_fetch_network,
+//     ParseLocal = libvlc_media_parse_flag_t_libvlc_media_parse_local,
+//     ParseNetwork = libvlc_media_parse_flag_t_libvlc_media_parse_network,
+// );
 
-    MediaPlayerMediaChanged = 0x100,
-    MediaPlayerNothingSpecial,
-    MediaPlayerOpening,
-    MediaPlayerBuffering,
-    MediaPlayerPlaying,
-    MediaPlayerPaused,
-    MediaPlayerStopped,
-    MediaPlayerForward,
-    MediaPlayerBackward,
-    MediaPlayerEndReached,
-    MediaPlayerEncounteredError,
-    MediaPlayerTimeChanged,
-    MediaPlayerPositionChanged,
-    MediaPlayerSeekableChanged,
-    MediaPlayerPausableChanged,
-    MediaPlayerTitleChanged,
-    MediaPlayerSnapshotTaken,
-    MediaPlayerLengthChanged,
-    MediaPlayerVout,
-    MediaPlayerScrambledChanged,
-
-    MediaListItemAdded = 0x200,
-    MediaListWillAddItem,
-    MediaListItemDeleted,
-    MediaListWillDeleteItem,
-
-    MediaListViewItemAdded = 0x300,
-    MediaListViewWillAddItem,
-    MediaListViewItemDeleted,
-    MediaListViewWillDeleteItem,
-
-    MediaListPlayerPlayed = 0x400,
-    MediaListPlayerNextItemSet,
-    MediaListPlayerStopped,
-
-    MediaDiscovererStarted = 0x500,
-    MediaDiscovererEnded,
-
-    VlmMediaAdded = 0x600,
-    VlmMediaRemoved,
-    VlmMediaChanged,
-    VlmMediaInstanceStarted,
-    VlmMediaInstanceStopped,
-    VlmMediaInstanceStatusInit,
-    VlmMediaInstanceStatusOpening,
-    VlmMediaInstanceStatusPlaying,
-    VlmMediaInstanceStatusPause,
-    VlmMediaInstanceStatusEnd,
-    VlmMediaInstanceStatusError
-}
+define_enum!(
+    EventType, libvlc_event_e;
+    MediaMetaChanged = libvlc_event_e_libvlc_MediaMetaChanged,
+    MediaSubItemAdded = libvlc_event_e_libvlc_MediaSubItemAdded,
+    MediaDurationChanged = libvlc_event_e_libvlc_MediaDurationChanged,
+    MediaParsedChanged = libvlc_event_e_libvlc_MediaParsedChanged,
+    MediaFreed = libvlc_event_e_libvlc_MediaFreed,
+    MediaStateChanged = libvlc_event_e_libvlc_MediaStateChanged,
+    MediaSubItemTreeAdded = libvlc_event_e_libvlc_MediaSubItemTreeAdded,
+    MediaPlayerMediaChanged = libvlc_event_e_libvlc_MediaPlayerMediaChanged,
+    MediaPlayerNothingSpecial = libvlc_event_e_libvlc_MediaPlayerNothingSpecial,
+    MediaPlayerOpening = libvlc_event_e_libvlc_MediaPlayerOpening,
+    MediaPlayerBuffering = libvlc_event_e_libvlc_MediaPlayerBuffering,
+    MediaPlayerPlaying = libvlc_event_e_libvlc_MediaPlayerPlaying,
+    MediaPlayerPaused = libvlc_event_e_libvlc_MediaPlayerPaused,
+    MediaPlayerStopped = libvlc_event_e_libvlc_MediaPlayerStopped,
+    MediaPlayerForward = libvlc_event_e_libvlc_MediaPlayerForward,
+    MediaPlayerBackward = libvlc_event_e_libvlc_MediaPlayerBackward,
+    MediaPlayerEndReached = libvlc_event_e_libvlc_MediaPlayerEndReached,
+    MediaPlayerEncounteredError = libvlc_event_e_libvlc_MediaPlayerEncounteredError,
+    MediaPlayerTimeChanged = libvlc_event_e_libvlc_MediaPlayerTimeChanged,
+    MediaPlayerPositionChanged = libvlc_event_e_libvlc_MediaPlayerPositionChanged,
+    MediaPlayerSeekableChanged = libvlc_event_e_libvlc_MediaPlayerSeekableChanged,
+    MediaPlayerPausableChanged = libvlc_event_e_libvlc_MediaPlayerPausableChanged,
+    MediaPlayerTitleChanged = libvlc_event_e_libvlc_MediaPlayerTitleChanged,
+    MediaPlayerSnapshotTaken = libvlc_event_e_libvlc_MediaPlayerSnapshotTaken,
+    MediaPlayerLengthChanged = libvlc_event_e_libvlc_MediaPlayerLengthChanged,
+    MediaPlayerVout = libvlc_event_e_libvlc_MediaPlayerVout,
+    MediaPlayerScrambledChanged = libvlc_event_e_libvlc_MediaPlayerScrambledChanged,
+    MediaListItemAdded = libvlc_event_e_libvlc_MediaListItemAdded,
+    MediaListWillAddItem = libvlc_event_e_libvlc_MediaListWillAddItem,
+    MediaListItemDeleted = libvlc_event_e_libvlc_MediaListItemDeleted,
+    MediaListWillDeleteItem = libvlc_event_e_libvlc_MediaListWillDeleteItem,
+    MediaListViewItemAdded = libvlc_event_e_libvlc_MediaListViewItemAdded,
+    MediaListViewWillAddItem = libvlc_event_e_libvlc_MediaListViewWillAddItem,
+    MediaListViewItemDeleted = libvlc_event_e_libvlc_MediaListViewItemDeleted,
+    MediaListViewWillDeleteItem = libvlc_event_e_libvlc_MediaListViewWillDeleteItem,
+    MediaListPlayerPlayed = libvlc_event_e_libvlc_MediaListPlayerPlayed,
+    MediaListPlayerNextItemSet = libvlc_event_e_libvlc_MediaListPlayerNextItemSet,
+    MediaListPlayerStopped = libvlc_event_e_libvlc_MediaListPlayerStopped,
+    MediaDiscovererStarted = libvlc_event_e_libvlc_MediaDiscovererStarted,
+    MediaDiscovererEnded = libvlc_event_e_libvlc_MediaDiscovererEnded,
+    VlmMediaAdded = libvlc_event_e_libvlc_VlmMediaAdded,
+    VlmMediaRemoved = libvlc_event_e_libvlc_VlmMediaRemoved,
+    VlmMediaChanged = libvlc_event_e_libvlc_VlmMediaChanged,
+    VlmMediaInstanceStarted = libvlc_event_e_libvlc_VlmMediaInstanceStarted,
+    VlmMediaInstanceStopped = libvlc_event_e_libvlc_VlmMediaInstanceStopped,
+    VlmMediaInstanceStatusInit = libvlc_event_e_libvlc_VlmMediaInstanceStatusInit,
+    VlmMediaInstanceStatusOpening = libvlc_event_e_libvlc_VlmMediaInstanceStatusOpening,
+    VlmMediaInstanceStatusPlaying = libvlc_event_e_libvlc_VlmMediaInstanceStatusPlaying,
+    VlmMediaInstanceStatusPause = libvlc_event_e_libvlc_VlmMediaInstanceStatusPause,
+    VlmMediaInstanceStatusEnd = libvlc_event_e_libvlc_VlmMediaInstanceStatusEnd,
+    VlmMediaInstanceStatusError = libvlc_event_e_libvlc_VlmMediaInstanceStatusError,
+);

src/lib.rs

@@ -4,25 +4,23 @@
 
 extern crate libc;
 
-pub mod sys;
-
-mod tools;
-mod core;
-mod media;
-mod media_player;
-mod media_list;
-mod media_library;
-mod enums;
-mod video;
 mod audio;
+mod core;
+mod enums;
+mod media;
+mod media_library;
+mod media_list;
+mod media_player;
+mod tools;
+mod video;
 mod vlm;
 
-pub use crate::enums::*;
-pub use crate::core::*;
-pub use crate::media::*;
-pub use crate::media_player::*;
-pub use crate::media_list::*;
-pub use crate::media_library::*;
-pub use crate::video::*;
 pub use crate::audio::*;
+pub use crate::core::*;
+pub use crate::enums::*;
+pub use crate::media::*;
+pub use crate::media_library::*;
+pub use crate::media_list::*;
+pub use crate::media_player::*;
+pub use crate::video::*;
 pub use crate::vlm::*;

src/media.rs

@@ -2,11 +2,11 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use crate::sys;
-use crate::{Instance, EventManager};
-use crate::enums::{State, Meta, TrackType};
-use crate::tools::{to_cstr, from_cstr, path_to_cstr};
+use crate::enums::{Meta, State, TrackType};
+use crate::tools::{from_cstr, path_to_cstr, to_cstr};
+use crate::{EventManager, Instance};
 use std::path::Path;
+use vlc_sys as sys;
 
 pub struct Media {
     pub(crate) ptr: *mut sys::libvlc_media_t,
@@ -19,13 +19,13 @@ impl Media {
     pub fn new_location(instance: &Instance, mrl: &str) -> Option<Media> {
         let cstr = to_cstr(mrl);
 
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_new_location(instance.ptr, cstr.as_ptr());
             if p.is_null() {
                 return None;
             }
 
-            Some(Media{ptr: p})
+            Some(Media { ptr: p })
         }
     }
 
@@ -33,32 +33,34 @@ impl Media {
     pub fn new_path<T: AsRef<Path>>(instance: &Instance, path: T) -> Option<Media> {
         let cstr = match path_to_cstr(path.as_ref()) {
             Ok(s) => s,
-            Err(_) => { return None; },
+            Err(_) => {
+                return None;
+            }
         };
 
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_new_path(instance.ptr, cstr.as_ptr());
             if p.is_null() {
                 return None;
             }
 
-            Some(Media{ptr: p})
+            Some(Media { ptr: p })
         }
     }
 
     pub fn new_fd(instance: &Instance, fd: i32) -> Option<Media> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_new_fd(instance.ptr, fd);
             if p.is_null() {
                 return None;
             }
 
-            Some(Media{ptr: p})
+            Some(Media { ptr: p })
         }
     }
 
     pub fn mrl(&self) -> Option<String> {
-        unsafe{
+        unsafe {
             let p_str = sys::libvlc_media_get_mrl(self.ptr);
             let s = from_cstr(p_str);
             sys::libvlc_free(p_str as *mut ::libc::c_void);
@@ -67,18 +69,21 @@ impl Media {
     }
 
     pub fn event_manager<'a>(&'a self) -> EventManager<'a> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_event_manager(self.ptr);
             assert!(!p.is_null());
-            EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData}
+            EventManager {
+                ptr: p,
+                _phantomdata: ::std::marker::PhantomData,
+            }
         }
     }
 
     /// Read the meta of the media.
     /// If the media has not yet been parsed this will return None.
     pub fn get_meta(&self, meta: Meta) -> Option<String> {
-        unsafe{
-            let p_str = sys::libvlc_media_get_meta(self.ptr, meta);
+        unsafe {
+            let p_str = sys::libvlc_media_get_meta(self.ptr, meta as u32);
             let s = from_cstr(p_str);
             sys::libvlc_free(p_str as *mut ::libc::c_void);
             s
@@ -94,46 +99,48 @@ impl Media {
     /// Set the meta of the media.
     /// (This function will not save the meta, call save_meta in order to save the meta)
     pub fn set_meta(&self, meta: Meta, value: &str) {
-        unsafe{
-            sys::libvlc_media_set_meta(self.ptr, meta, to_cstr(value).as_ptr());
+        unsafe {
+            sys::libvlc_media_set_meta(self.ptr, meta as u32, to_cstr(value).as_ptr());
         }
     }
 
     /// Save the meta previously set.
     pub fn save_meta(&self) -> bool {
-        if unsafe{ sys::libvlc_media_save_meta(self.ptr) } == 0 { false }else{ true }
+        (unsafe { sys::libvlc_media_save_meta(self.ptr) } != 0)
     }
 
     /// Get current state of media descriptor object.
     pub fn state(&self) -> State {
-        unsafe{ sys::libvlc_media_get_state(self.ptr) }
+        unsafe { sys::libvlc_media_get_state(self.ptr).into() }
     }
 
     /// Get duration (in ms) of media descriptor object item.
     pub fn duration(&self) -> Option<i64> {
-        let time = unsafe{
-            sys::libvlc_media_get_duration(self.ptr)
-        };
-        if time != -1 { Some(time) }else{ None }
+        let time = unsafe { sys::libvlc_media_get_duration(self.ptr) };
+        if time != -1 {
+            Some(time)
+        } else {
+            None
+        }
     }
 
     /// Parse a media.
     pub fn parse(&self) {
-        unsafe{ sys::libvlc_media_parse(self.ptr) };
+        unsafe { sys::libvlc_media_parse(self.ptr) };
     }
 
     /// Parse a media.
     pub fn parse_async(&self) {
-        unsafe{ sys::libvlc_media_parse_async(self.ptr) };
+        unsafe { sys::libvlc_media_parse_async(self.ptr) };
     }
 
     /// Get Parsed status for media descriptor object.
     pub fn is_parsed(&self) -> bool {
-        if unsafe{ sys::libvlc_media_is_parsed(self.ptr) } == 0 { false }else{ true }
+        (unsafe { sys::libvlc_media_is_parsed(self.ptr) } != 0)
     }
 
     pub fn tracks(&self) -> Option<Vec<MediaTrack>> {
-        unsafe{
+        unsafe {
             let mut p_track: *mut *mut sys::libvlc_media_track_t = ::std::ptr::null_mut();
             let n = sys::libvlc_media_tracks_get(self.ptr, &mut p_track);
             if n == 0 {
@@ -144,44 +151,45 @@ impl Media {
 
             for i in 0..n {
                 let p = p_track.offset(i as isize);
-                let type_specific_data = match (**p).i_type {
+                let i_type: TrackType = (**p).i_type.into();
+                let type_specific_data = match i_type {
                     TrackType::Audio => {
-                        let audio = (**p).audio();
-                        MediaTrackUnion::Audio(AudioTrack{
+                        let audio = (**p).__bindgen_anon_1.audio;
+                        MediaTrackUnion::Audio(AudioTrack {
                             channels: (*audio).i_channels,
-                            rate:     (*audio).i_rate,
+                            rate: (*audio).i_rate,
                         })
-                    },
+                    }
                     TrackType::Video => {
-                        let video = (**p).video();
-                        MediaTrackUnion::Video(VideoTrack{
-                            height:         (*video).i_height,
-                            width:          (*video).i_width,
-                            sar_num:        (*video).i_sar_num,
-                            sar_den:        (*video).i_sar_den,
+                        let video = (**p).__bindgen_anon_1.video;
+                        MediaTrackUnion::Video(VideoTrack {
+                            height: (*video).i_height,
+                            width: (*video).i_width,
+                            sar_num: (*video).i_sar_num,
+                            sar_den: (*video).i_sar_den,
                             frame_rate_num: (*video).i_frame_rate_num,
                             frame_rate_den: (*video).i_frame_rate_den,
                         })
-                    },
+                    }
                     TrackType::Text => {
-                        let subtitle = (**p).subtitle();
-                        MediaTrackUnion::Subtitle(SubtitleTrack{
-                            encoding: from_cstr((*subtitle).psz_encoding)
+                        let subtitle = (**p).__bindgen_anon_1.subtitle;
+                        MediaTrackUnion::Subtitle(SubtitleTrack {
+                            encoding: from_cstr((*subtitle).psz_encoding),
                         })
-                    },
+                    }
                     TrackType::Unknown => MediaTrackUnion::None,
                 };
-                track.push(MediaTrack{
-                    codec:              (**p).i_codec,
-                    original_fourcc:    (**p).i_original_fourcc,
-                    id:                 (**p).i_id,
-                    track_type:         (**p).i_type,
-                    profile:            (**p).i_profile,
-                    level:              (**p).i_level,
-                    bitrate:            (**p).i_bitrate,
-                    language:           from_cstr((**p).psz_language),
-                    description:        from_cstr((**p).psz_description),
-                    type_specific_data: type_specific_data,
+                track.push(MediaTrack {
+                    codec: (**p).i_codec,
+                    original_fourcc: (**p).i_original_fourcc,
+                    id: (**p).i_id,
+                    track_type: (**p).i_type.into(),
+                    profile: (**p).i_profile,
+                    level: (**p).i_level,
+                    bitrate: (**p).i_bitrate,
+                    language: from_cstr((**p).psz_language),
+                    description: from_cstr((**p).psz_description),
+                    type_specific_data,
                 });
             }
 
@@ -198,7 +206,7 @@ impl Media {
 
 impl Drop for Media {
     fn drop(&mut self) {
-        unsafe{ sys::libvlc_media_release(self.ptr) };
+        unsafe { sys::libvlc_media_release(self.ptr) };
     }
 }
 
@@ -218,7 +226,10 @@ pub struct MediaTrack {
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub enum MediaTrackUnion {
-    Audio(AudioTrack), Video(VideoTrack), Subtitle(SubtitleTrack), None,
+    Audio(AudioTrack),
+    Video(VideoTrack),
+    Subtitle(SubtitleTrack),
+    None,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
@@ -241,4 +252,3 @@ pub struct VideoTrack {
 pub struct SubtitleTrack {
     pub encoding: Option<String>,
 }
-

src/media_library.rs

@@ -2,8 +2,8 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use crate::sys;
-use crate::{Instance, MediaList};
+use crate::{Instance, InternalError, MediaList};
+use vlc_sys as sys;
 
 pub struct MediaLibrary {
     pub(crate) ptr: *mut sys::libvlc_media_library_t,
@@ -11,25 +11,37 @@ pub struct MediaLibrary {
 
 impl MediaLibrary {
     /// Create an new Media Library object.
-    pub fn new(instance: &Instance) -> Option<MediaLibrary> {
-        unsafe{
+    pub fn new(instance: &Instance) -> Result<MediaLibrary, InternalError> {
+        unsafe {
             let p = sys::libvlc_media_library_new(instance.ptr);
-            if p.is_null() { None }else{ Some(MediaLibrary{ptr: p}) }
+            if p.is_null() {
+                Err(InternalError)
+            } else {
+                Ok(MediaLibrary { ptr: p })
+            }
         }
     }
 
     /// Load media library.
-    pub fn load(&self) -> Result<(), ()> {
-        unsafe{
-            if sys::libvlc_media_library_load(self.ptr) == 0 { Ok(()) }else{ Err(()) }
+    pub fn load(&self) -> Result<(), InternalError> {
+        unsafe {
+            if sys::libvlc_media_library_load(self.ptr) == 0 {
+                Ok(())
+            } else {
+                Err(InternalError)
+            }
         }
     }
 
     /// Get media library subitems.
     pub fn media_list(&self) -> Option<MediaList> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_library_media_list(self.ptr);
-            if p.is_null() { None }else{ Some(MediaList{ptr: p}) }
+            if p.is_null() {
+                None
+            } else {
+                Some(MediaList { ptr: p })
+            }
         }
     }
 
@@ -41,6 +53,6 @@ impl MediaLibrary {
 
 impl Drop for MediaLibrary {
     fn drop(&mut self) {
-        unsafe{ sys::libvlc_media_library_release(self.ptr) };
+        unsafe { sys::libvlc_media_library_release(self.ptr) };
     }
 }

src/media_list.rs

@@ -2,8 +2,8 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use crate::sys;
-use crate::{Instance, Media, EventManager};
+use crate::{EventManager, Instance, InternalError, Media};
+use vlc_sys as sys;
 
 pub struct MediaList {
     pub(crate) ptr: *mut sys::libvlc_media_list_t,
@@ -11,97 +11,135 @@ pub struct MediaList {
 
 impl MediaList {
     /// Create an empty media list.
-    pub fn new(instance: &Instance) -> Option<MediaList> {
-        unsafe{
+    pub fn new(instance: &Instance) -> Result<MediaList, InternalError> {
+        unsafe {
             let p = sys::libvlc_media_list_new(instance.ptr);
-            if p.is_null() { None }else{ Some(MediaList{ptr: p}) }
+            if p.is_null() {
+                Err(InternalError)
+            } else {
+                Ok(MediaList { ptr: p })
+            }
         }
     }
 
     /// Associate media instance with this media list instance.
     /// If another media instance was present it will be released. The libvlc_media_list_lock should NOT be held upon entering this function.
     pub fn set_media(&self, md: &Media) {
-        unsafe{ sys::libvlc_media_list_set_media(self.ptr, md.ptr); }
+        unsafe {
+            sys::libvlc_media_list_set_media(self.ptr, md.ptr);
+        }
     }
 
     /// Get media instance from this media list instance.
     /// The MediaList::lock should NOT be held upon entering this function.
     pub fn media(&self) -> Option<Media> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_list_media(self.ptr);
-            if p.is_null() { None }else{ Some(Media{ptr: p}) }
+            if p.is_null() {
+                None
+            } else {
+                Some(Media { ptr: p })
+            }
         }
     }
 
     /// Add media instance to media list.
     /// The MediaList::lock should be held upon entering this function.
-    pub fn add_media(&self, md: &Media) -> Result<(), ()> {
-        unsafe{
-            if sys::libvlc_media_list_add_media(self.ptr, md.ptr) == 0 { Ok(()) }else{ Err(()) }
+    // TODO: use specific error type since documentation says "-1 if the media list is read-only"
+    pub fn add_media(&self, md: &Media) -> Result<(), InternalError> {
+        unsafe {
+            if sys::libvlc_media_list_add_media(self.ptr, md.ptr) == 0 {
+                Ok(())
+            } else {
+                Err(InternalError)
+            }
         }
     }
 
     /// Insert media instance in media list on a position.
     /// The MediaList::lock should be held upon entering this function.
-    pub fn insert_media(&self, md: &Media, pos: i32) -> Result<(), ()> {
-        unsafe{
-            if sys::libvlc_media_list_insert_media(self.ptr, md.ptr, pos) == 0 { Ok(()) }else{ Err(()) }
+    pub fn insert_media(&self, md: &Media, pos: i32) -> Result<(), InternalError> {
+        unsafe {
+            if sys::libvlc_media_list_insert_media(self.ptr, md.ptr, pos) == 0 {
+                Ok(())
+            } else {
+                Err(InternalError)
+            }
         }
     }
 
     /// Remove media instance from media list on a position.
     /// The MediaList::lock should be held upon entering this function.
-    pub fn remove_index(&self, pos: i32) -> Result<(), ()> {
-        unsafe{
-            if sys::libvlc_media_list_remove_index(self.ptr, pos) == 0 { Ok(()) }else{ Err(()) }
+    pub fn remove_index(&self, pos: i32) -> Result<(), InternalError> {
+        unsafe {
+            if sys::libvlc_media_list_remove_index(self.ptr, pos) == 0 {
+                Ok(())
+            } else {
+                Err(InternalError)
+            }
         }
     }
 
     /// Get count on media list items.
     /// The MediaList::lock should be held upon entering this function.
     pub fn count(&self) -> i32 {
-        unsafe{ sys::libvlc_media_list_count(self.ptr) }
+        unsafe { sys::libvlc_media_list_count(self.ptr) }
     }
 
     /// List media instance in media list at a position.
     /// The MediaList::lock should be held upon entering this function.
     pub fn item_at_index(&self, pos: i32) -> Option<Media> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_list_item_at_index(self.ptr, pos);
-            if p.is_null() { None }else{ Some(Media{ptr: p}) }
+            if p.is_null() {
+                None
+            } else {
+                Some(Media { ptr: p })
+            }
         }
     }
 
     /// Find index position of List media instance in media list.
     pub fn index_of_item(&self, md: &Media) -> Option<i32> {
-        unsafe{
+        unsafe {
             let i = sys::libvlc_media_list_index_of_item(self.ptr, md.ptr);
-            if i == -1 { None }else{ Some(i) }
+            if i == -1 {
+                None
+            } else {
+                Some(i)
+            }
         }
     }
 
     /// This indicates if this media list is read-only from a user point of view.
     pub fn is_readonly(&self) -> bool {
-        unsafe{ if sys::libvlc_media_list_is_readonly(self.ptr) == 0 { false }else{ true } }
+        unsafe { sys::libvlc_media_list_is_readonly(self.ptr) != 0 }
     }
 
     /// Get lock on media list items
     pub fn lock(&self) {
-        unsafe{ sys::libvlc_media_list_lock(self.ptr); }
+        unsafe {
+            sys::libvlc_media_list_lock(self.ptr);
+        }
     }
 
     /// Release lock on media list items
     /// The libvlc_media_list_lock should be held upon entering this function.
     pub fn unlock(&self) {
-        unsafe{ sys::libvlc_media_list_unlock(self.ptr); }
+        unsafe {
+            sys::libvlc_media_list_unlock(self.ptr);
+        }
     }
 
     /// Get EventManager from this media list instance.
     pub fn event_manager<'a>(&'a self) -> EventManager<'a> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_list_event_manager(self.ptr);
             assert!(!p.is_null());
-            EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData}
+            EventManager {
+                ptr: p,
+                _phantomdata: ::std::marker::PhantomData,
+            }
         }
     }
 
@@ -113,6 +151,6 @@ impl MediaList {
 
 impl Drop for MediaList {
     fn drop(&mut self) {
-        unsafe{ sys::libvlc_media_list_release(self.ptr) };
+        unsafe { sys::libvlc_media_list_release(self.ptr) };
     }
 }

src/media_player.rs

@@ -2,13 +2,14 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use crate::sys;
-use crate::Instance;
-use crate::Media;
+use crate::enums::{Position, State};
 use crate::EventManager;
-use libc::{c_void, c_uint};
-use crate::enums::{State, Position};
+use crate::Instance;
+use crate::InternalError;
+use crate::Media;
+use libc::{c_uint, c_void};
 use std::mem::transmute;
+use vlc_sys as sys;
 
 /// A LibVLC media player plays one media (usually in a custom drawable).
 pub struct MediaPlayer {
@@ -20,71 +21,70 @@ unsafe impl Send for MediaPlayer {}
 impl MediaPlayer {
     /// Create an empty Media Player object
     pub fn new(instance: &Instance) -> Option<MediaPlayer> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_player_new(instance.ptr);
-
             if p.is_null() {
-                return None;
+                None
+            } else {
+                Some(MediaPlayer { ptr: p })
             }
-            Some(MediaPlayer{ptr: p})
         }
     }
 
     /// Set the media that will be used by the media_player. If any, previous md will be released.
     pub fn set_media(&self, md: &Media) {
-        unsafe{ sys::libvlc_media_player_set_media(self.ptr, md.ptr) };
+        unsafe { sys::libvlc_media_player_set_media(self.ptr, md.ptr) };
     }
 
     /// Get the media used by the media_player.
     pub fn get_media(&self) -> Option<Media> {
-        let p = unsafe{ sys::libvlc_media_player_get_media(self.ptr) };
+        let p = unsafe { sys::libvlc_media_player_get_media(self.ptr) };
         if p.is_null() {
             None
-        }else{
-            Some(Media{ptr: p})
+        } else {
+            Some(Media { ptr: p })
         }
     }
 
     /// Get the Event Manager from which the media player send event.
     pub fn event_manager<'a>(&'a self) -> EventManager<'a> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_media_player_event_manager(self.ptr);
             assert!(!p.is_null());
-            EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData}
+            EventManager {
+                ptr: p,
+                _phantomdata: ::std::marker::PhantomData,
+            }
         }
     }
 
     /// is_playing
     pub fn is_playing(&self) -> bool {
-        if unsafe{ sys::libvlc_media_player_is_playing(self.ptr) } == 0 {
-            false
-        }else{
-            true
-        }
+        unsafe { sys::libvlc_media_player_is_playing(self.ptr) != 0 }
     }
 
     /// Play
-    pub fn play(&self) -> Result<(), ()> {
-        if unsafe{ sys::libvlc_media_player_play(self.ptr) } == 0 {
+    pub fn play(&self) -> Result<(), InternalError> {
+        if unsafe { sys::libvlc_media_player_play(self.ptr) } == 0 {
             Ok(())
-        }else{
-            Err(())
+        } else {
+            Err(InternalError)
         }
     }
 
     /// Pause or resume (no effect if there is no media)
     pub fn set_pause(&self, do_pause: bool) {
-        unsafe{ sys::libvlc_media_player_set_pause(self.ptr, if do_pause {1} else {0}) };
+        unsafe { sys::libvlc_media_player_set_pause(self.ptr, if do_pause { 1 } else { 0 }) };
     }
 
     /// Toggle pause (no effect if there is no media)
     pub fn pause(&self) {
-        unsafe{ sys::libvlc_media_player_pause(self.ptr) };
+        unsafe { sys::libvlc_media_player_pause(self.ptr) };
     }
 
     /// Stop (no effect if there is no media)
     pub fn stop(&self) {
-        unsafe{ sys::libvlc_media_player_stop(self.ptr) };
+        unsafe { sys::libvlc_media_player_stop(self.ptr) };
     }
 
     pub fn set_callbacks<F>(
@@ -93,8 +93,9 @@ impl MediaPlayer {
         pause: Option<Box<dyn Fn(i64) + Send + 'static>>,
         resume: Option<Box<dyn Fn(i64) + Send + 'static>>,
         flush: Option<Box<dyn Fn(i64) + Send + 'static>>,
-        drain: Option<Box<dyn Fn() + Send + 'static>>)
-        where F: Fn(*const c_void, u32, i64) + Send + 'static,
+        drain: Option<Box<dyn Fn() + Send + 'static>>,
+    ) where
+        F: Fn(*const c_void, u32, i64) + Send + 'static,
     {
         let flag_pause = pause.is_some();
         let flag_resume = resume.is_some();
@@ -102,164 +103,236 @@ impl MediaPlayer {
         let flag_drain = drain.is_some();
 
         let data = AudioCallbacksData {
-            play: Box::new(play), pause: pause, resume: resume,
-            flush: flush, drain: drain,
+            play: Box::new(play),
+            pause,
+            resume,
+            flush,
+            drain,
         };
         let data = Box::into_raw(Box::new(data));
 
-        unsafe{
+        unsafe {
             sys::libvlc_audio_set_callbacks(
                 self.ptr,
                 Some(audio_cb_play),
-                if flag_pause {Some(audio_cb_pause)} else {None},
-                if flag_resume {Some(audio_cb_resume)} else {None},
-                if flag_flush {Some(audio_cb_flush)} else {None},
-                if flag_drain {Some(audio_cb_drain)} else {None},
-                data as *mut c_void);
+                if flag_pause {
+                    Some(audio_cb_pause)
+                } else {
+                    None
+                },
+                if flag_resume {
+                    Some(audio_cb_resume)
+                } else {
+                    None
+                },
+                if flag_flush {
+                    Some(audio_cb_flush)
+                } else {
+                    None
+                },
+                if flag_drain {
+                    Some(audio_cb_drain)
+                } else {
+                    None
+                },
+                data as *mut c_void,
+            );
         }
     }
 
     /// Set the NSView handler where the media player should render its video output.
     pub fn set_nsobject(&self, drawable: *mut c_void) {
-        unsafe{ sys::libvlc_media_player_set_nsobject(self.ptr, drawable) };
+        let d = drawable;
+        unsafe { sys::libvlc_media_player_set_nsobject(self.ptr, d) };
     }
 
     /// Get the NSView handler previously set with set_nsobject().
     pub fn get_nsobject(&self) -> Option<*mut c_void> {
-        let nso = unsafe{ sys::libvlc_media_player_get_nsobject(self.ptr) };
-        if nso.is_null() { None }else{ Some(nso) }
+        let nso = unsafe { sys::libvlc_media_player_get_nsobject(self.ptr) };
+        if nso.is_null() {
+            None
+        } else {
+            Some(nso)
+        }
     }
 
     /// Set an X Window System drawable where the media player should render its video output.
     pub fn set_xwindow(&self, drawable: u32) {
-        unsafe{ sys::libvlc_media_player_set_xwindow(self.ptr, drawable) };
+        unsafe { sys::libvlc_media_player_set_xwindow(self.ptr, drawable) };
     }
 
     /// Get the X Window System window identifier previously set with set_xwindow().
     pub fn get_xwindow(&self) -> Option<u32> {
-        let id = unsafe{ sys::libvlc_media_player_get_xwindow(self.ptr) };
-        if id == 0 { None }else{ Some(id) }
+        let id = unsafe { sys::libvlc_media_player_get_xwindow(self.ptr) };
+        if id == 0 {
+            None
+        } else {
+            Some(id)
+        }
     }
 
     /// Set a Win32/Win64 API window handle (HWND) where the media player should render its video output.
     /// If LibVLC was built without Win32/Win64 API output support, then this has no effects.
     pub fn set_hwnd(&self, drawable: *mut c_void) {
-        unsafe{ sys::libvlc_media_player_set_hwnd(self.ptr, drawable) };
+        let d = drawable;
+        unsafe { sys::libvlc_media_player_set_hwnd(self.ptr, d) };
     }
 
     /// Get the Windows API window handle (HWND) previously set with set_hwnd().
     pub fn get_hwnd(&self) -> Option<*mut c_void> {
-        let hwnd = unsafe{ sys::libvlc_media_player_get_hwnd(self.ptr) };
-        if hwnd.is_null() { None }else{ Some(hwnd) }
+        let hwnd = unsafe { sys::libvlc_media_player_get_hwnd(self.ptr) };
+        if hwnd.is_null() {
+            None
+        } else {
+            Some(hwnd)
+        }
     }
 
     /// Get the current movie time (in ms).
     pub fn get_time(&self) -> Option<i64> {
-        unsafe{
+        unsafe {
             let t = sys::libvlc_media_player_get_time(self.ptr);
-            if t == -1 { None }else{ Some(t) }
+            if t == -1 {
+                None
+            } else {
+                Some(t)
+            }
         }
     }
 
     /// Set the movie time (in ms).
     /// This has no effect if no media is being played. Not all formats and protocols support this.
     pub fn set_time(&self, time: i64) {
-        unsafe{ sys::libvlc_media_player_set_time(self.ptr, time); }
+        unsafe {
+            sys::libvlc_media_player_set_time(self.ptr, time);
+        }
     }
 
     /// Get movie position as percentage between 0.0 and 1.0.
     pub fn get_position(&self) -> Option<f32> {
-        unsafe{
+        unsafe {
             let pos = sys::libvlc_media_player_get_position(self.ptr);
-            if pos == -1f32 { None }else{ Some(pos) }
+            // if pos == -1f32 { None }else{ Some(pos) }
+            if (pos - -1f32).abs() < f32::EPSILON {
+                None
+            } else {
+                Some(pos)
+            }
         }
     }
 
     /// Set movie position as percentage between 0.0 and 1.0.
     /// This has no effect if playback is not enabled. This might not work depending on the underlying input format and protocol.
     pub fn set_position(&self, pos: f32) {
-        unsafe{ sys::libvlc_media_player_set_position(self.ptr, pos); }
+        unsafe {
+            sys::libvlc_media_player_set_position(self.ptr, pos);
+        }
     }
 
     /// Set movie chapter (if applicable).
     pub fn set_chapter(&self, chapter: i32) {
-        unsafe{ sys::libvlc_media_player_set_chapter(self.ptr, chapter); }
+        unsafe {
+            sys::libvlc_media_player_set_chapter(self.ptr, chapter);
+        }
     }
 
     /// Get movie chapter.
     pub fn get_chapter(&self) -> Option<i32> {
-        unsafe{
+        unsafe {
             let c = sys::libvlc_media_player_get_chapter(self.ptr);
-            if c == -1 { None }else{ Some(c) }
+            if c == -1 {
+                None
+            } else {
+                Some(c)
+            }
         }
     }
 
     /// Get movie chapter count.
     pub fn chapter_count(&self) -> Option<i32> {
-        unsafe{
+        unsafe {
             let c = sys::libvlc_media_player_get_chapter_count(self.ptr);
-            if c == -1 { None }else{ Some(c) }
+            if c == -1 {
+                None
+            } else {
+                Some(c)
+            }
         }
     }
 
     /// Is the player able to play.
     pub fn will_play(&self) -> bool {
-        unsafe{
-            let b = sys::libvlc_media_player_will_play(self.ptr);
-            if b == 0 { false }else{ true }
-        }
+        unsafe { sys::libvlc_media_player_will_play(self.ptr) != 0 }
     }
 
     /// Get title chapter count.
     pub fn chapter_count_for_title(&self, title: i32) -> Option<i32> {
-        unsafe{
+        unsafe {
             let c = sys::libvlc_media_player_get_chapter_count_for_title(self.ptr, title);
-            if c == -1 { None }else{ Some(c) }
+            if c == -1 {
+                None
+            } else {
+                Some(c)
+            }
         }
     }
 
     /// Set movie title.
     pub fn set_title(&self, title: i32) {
-        unsafe{ sys::libvlc_media_player_set_title(self.ptr, title); }
+        unsafe {
+            sys::libvlc_media_player_set_title(self.ptr, title);
+        }
     }
 
     /// Get movie title.
     pub fn get_title(&self) -> Option<i32> {
-        unsafe{
+        unsafe {
             let t = sys::libvlc_media_player_get_title(self.ptr);
-            if t == -1 { None }else{ Some(t) }
+            if t == -1 {
+                None
+            } else {
+                Some(t)
+            }
         }
     }
 
     /// Get movie title count.
     pub fn title_count(&self) -> Option<i32> {
-        unsafe{
+        unsafe {
             let t = sys::libvlc_media_player_get_title_count(self.ptr);
-            if t == -1 { Some(t) } else { None }
+            if t == -1 {
+                Some(t)
+            } else {
+                None
+            }
         }
     }
 
     /// Set previous chapter (if applicable)
     pub fn previous_chapter(&self) {
-        unsafe{ sys::libvlc_media_player_previous_chapter(self.ptr); }
+        unsafe {
+            sys::libvlc_media_player_previous_chapter(self.ptr);
+        }
     }
 
     /// Set next chapter (if applicable)
     pub fn next_chapter(&self) {
-        unsafe{ sys::libvlc_media_player_next_chapter(self.ptr); }
+        unsafe {
+            sys::libvlc_media_player_next_chapter(self.ptr);
+        }
     }
 
     /// Get the requested movie play rate.
     pub fn get_rate(&self) -> f32 {
-        unsafe{ sys::libvlc_media_player_get_rate(self.ptr) }
+        unsafe { sys::libvlc_media_player_get_rate(self.ptr) }
     }
 
     /// Set movie play rate.
-    pub fn set_rate(&self, rate: f32) -> Result<(),()> {
-        unsafe{
+    pub fn set_rate(&self, rate: f32) -> Result<(), InternalError> {
+        unsafe {
             if sys::libvlc_media_player_set_rate(self.ptr, rate) == -1 {
-                Err(())
-            }else{
+                Err(InternalError)
+            } else {
                 Ok(())
             }
         }
@@ -267,51 +340,48 @@ impl MediaPlayer {
 
     /// Get current movie state.
     pub fn state(&self) -> State {
-        unsafe{ sys::libvlc_media_player_get_state(self.ptr) }
+        unsafe { sys::libvlc_media_player_get_state(self.ptr) }.into()
     }
 
     /// How many video outputs does this media player have?
     pub fn has_vout(&self) -> u32 {
-        unsafe{ sys::libvlc_media_player_has_vout(self.ptr) }
+        unsafe { sys::libvlc_media_player_has_vout(self.ptr) }
     }
 
     /// Is this media player seekable?
     pub fn is_seekable(&self) -> bool {
-        unsafe{
-            let b = sys::libvlc_media_player_is_seekable(self.ptr);
-            if b == 0 { false }else{ true }
-        }
+        unsafe { sys::libvlc_media_player_is_seekable(self.ptr) != 0 }
     }
 
     /// Can this media player be paused?
     pub fn can_pause(&self) -> bool {
-        unsafe{
-            let b = sys::libvlc_media_player_can_pause(self.ptr);
-            if b == 0 { false }else{ true }
-        }
+        unsafe { sys::libvlc_media_player_can_pause(self.ptr) != 0 }
     }
 
     /// Check if the current program is scrambled.
     pub fn program_scrambled(&self) -> bool {
-        unsafe{
-            let b = sys::libvlc_media_player_program_scrambled(self.ptr);
-            if b == 0 { false }else{ true }
-        }
+        unsafe { sys::libvlc_media_player_program_scrambled(self.ptr) != 0 }
     }
 
     /// Display the next frame (if supported)
     pub fn next_frame(&self) {
-        unsafe{ sys::libvlc_media_player_next_frame(self.ptr); }
+        unsafe {
+            sys::libvlc_media_player_next_frame(self.ptr);
+        }
     }
 
     /// Navigate through DVD Menu.
     pub fn navigate(&self, navigate: u32) {
-        unsafe{ sys::libvlc_media_player_navigate(self.ptr, navigate); }
+        unsafe {
+            sys::libvlc_media_player_navigate(self.ptr, navigate);
+        }
     }
 
     /// Set if, and how, the video title will be shown when media is played.
     pub fn set_video_title_display(&self, position: Position, timeout: u32) {
-        unsafe{ sys::libvlc_media_player_set_video_title_display(self.ptr, position, timeout); }
+        unsafe {
+            sys::libvlc_media_player_set_video_title_display(self.ptr, position as i32, timeout);
+        }
     }
 
     /// Returns raw pointer
@@ -322,7 +392,7 @@ impl MediaPlayer {
 
 impl Drop for MediaPlayer {
     fn drop(&mut self) {
-        unsafe{ sys::libvlc_media_player_release(self.ptr) };
+        unsafe { sys::libvlc_media_player_release(self.ptr) };
     }
 }
 
@@ -336,10 +406,13 @@ struct AudioCallbacksData {
 }
 
 unsafe extern "C" fn audio_cb_play(
-    data: *mut c_void, samples: *const c_void, count: c_uint, pts: i64) {
+    data: *mut c_void,
+    samples: *const c_void,
+    count: c_uint,
+    pts: i64,
+) {
     let data: &AudioCallbacksData = transmute(data as *mut AudioCallbacksData);
     (data.play)(samples, count, pts);
-
 }
 
 unsafe extern "C" fn audio_cb_pause(data: *mut c_void, pts: i64) {
@@ -367,4 +440,3 @@ pub struct TrackDescription {
     pub id: i32,
     pub name: Option<String>,
 }
-

src/sys.rs

@@ -1,853 +0,0 @@
-// Copyright (c) 2015 T. Okubo
-// This file is part of vlc-rs.
-// Licensed under the MIT license, see the LICENSE file.
-
-#![allow(non_camel_case_types, non_upper_case_globals)]
-
-#[link(name = "vlc")]
-extern "C" {}
-
-use libc::{c_void, c_int, c_uint, c_char, c_float, uintptr_t, FILE};
-
-pub type c_bool = u8;
-
-pub type libvlc_event_type_t = c_int;
-
-// From libvlc_structures.h
-pub enum libvlc_instance_t {}
-pub enum libvlc_log_iterator_t {}
-
-pub type libvlc_time_t = i64;
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_log_message_t {
-    pub i_severity: c_int,
-    pub psz_type: *const c_char,
-    pub psz_name: *const c_char,
-    pub psz_header: *const c_char,
-    pub psz_message: *const c_char,
-}
-
-// From libvlc.h
-pub enum libvlc_event_manager_t {}
-pub enum libvlc_log_t {}
-pub enum vlc_log_t {}
-
-pub type libvlc_callback_t = unsafe extern "C" fn(*const libvlc_event_t, *mut c_void);
-pub type va_list = *mut c_void;
-pub type libvlc_log_cb = unsafe extern "C" fn(*mut c_void, c_int, *const libvlc_log_t, *const c_char, va_list);
-
-pub use crate::enums::LogLevel as libvlc_log_level;
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_module_description_t
-{
-    pub psz_name: *const c_char,
-    pub psz_shortname: *const c_char,
-    pub psz_longname: *const c_char,
-    pub psz_help: *const c_char,
-    pub p_next: *mut libvlc_module_description_t,
-}
-
-extern "C" {
-    pub fn libvlc_errmsg() -> *const c_char;
-    pub fn libvlc_clearerr();
-    pub fn libvlc_new(argc: c_int, argv: *const *const c_char) -> *mut libvlc_instance_t;
-    pub fn libvlc_release(p_instance: *mut libvlc_instance_t);
-    pub fn libvlc_retain(p_instance: *mut libvlc_instance_t);
-    pub fn libvlc_add_intf(p_instance: *mut libvlc_instance_t, name: *const c_char) -> c_int;
-    pub fn libvlc_set_exit_handler(
-        p_instance: *mut libvlc_instance_t,
-        cb: extern "C" fn(*mut c_void), opaque: *mut c_void);
-    pub fn libvlc_wait(p_instance: *mut libvlc_instance_t);
-    pub fn libvlc_set_user_agent(
-        p_instance: *mut libvlc_instance_t, name: *const c_char, http: *const c_char);
-    pub fn libvlc_set_app_id(
-        p_instance: *mut libvlc_instance_t, id: *const c_char, version: *const c_char,
-        icon: *const c_char);
-    pub fn libvlc_get_version() -> *const c_char;
-    pub fn libvlc_get_compiler() -> *const c_char;
-    pub fn libvlc_get_changeset() -> *const c_char;
-    pub fn libvlc_free(ptr: *mut c_void);
-    pub fn libvlc_event_attach(
-        p_event_manager: *mut libvlc_event_manager_t, i_event_type: libvlc_event_type_t,
-        f_callback: libvlc_callback_t, user_data: *mut c_void) -> c_int;
-    pub fn libvlc_event_type_name(event_type: libvlc_event_type_t) -> *const c_char;
-    pub fn libvlc_log_get_context(
-        ctx: *const libvlc_log_t, module: *const *const c_char, file: *const *const c_char,
-        line: *mut c_uint);
-    pub fn libvlc_log_get_object(
-        ctx: *const libvlc_log_t, name: *const *const c_char,
-        header: *const *const c_char, id: *mut uintptr_t);
-    pub fn libvlc_log_unset(_: *mut libvlc_instance_t);
-    pub fn libvlc_log_set(instance: *mut libvlc_instance_t, cb: libvlc_log_cb, data: *mut c_void);
-    pub fn libvlc_log_set_file(_: *mut libvlc_instance_t, stream: *mut FILE);
-    pub fn libvlc_module_description_list_release(p_list: *mut libvlc_module_description_t);
-    pub fn libvlc_audio_filter_list_get(
-        p_instance: *mut libvlc_instance_t) -> *mut libvlc_module_description_t;
-    pub fn libvlc_video_filter_list_get(
-        p_instance: *mut libvlc_instance_t) -> *mut libvlc_module_description_t;
-    pub fn libvlc_clock() -> i64;
-}
-
-pub unsafe fn libvlc_delay(pts: i64) -> i64 {
-    pts - libvlc_clock()
-}
-
-// From libvlc_media.h
-pub enum libvlc_media_t {}
-
-pub use crate::enums::Meta as libvlc_meta_t;
-pub use crate::enums::State as libvlc_state_t;
-
-pub const libvlc_media_option_trusted: u32 = 0x2;
-pub const libvlc_media_option_unique: u32 = 0x100;
-
-pub use crate::enums::TrackType as libvlc_track_type_t;
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_media_stats_t {
-    /* Input */
-    pub i_read_bytes: c_int,
-    pub f_input_bitrate: c_float,
-    /* Demux */
-    pub i_demux_read_bytes: c_int,
-    pub f_demux_bitrate: c_float,
-    pub i_demux_corrupted: c_int,
-    pub i_demux_discontinuity: c_int,
-    /* Decoders */
-    pub i_decoded_video: c_int,
-    pub i_decoded_audio: c_int,
-    /* Video Output */
-    pub i_displayed_pictures: c_int,
-    pub i_lost_pictures: c_int,
-    /* Audio output */
-    pub i_played_abuffers: c_int,
-    pub i_lost_abuffers: c_int,
-    /* Stream output */
-    pub i_sent_packets: c_int,
-    pub i_sent_bytes: c_int,
-    pub f_send_bitrate: c_float,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_media_track_info_t {
-    /* Codec fourcc */
-    pub i_codec: u32,
-    pub i_id: c_int,
-    pub i_type: libvlc_track_type_t,
-    /* Codec specific */
-    pub i_profile: c_int,
-    pub i_level: c_int,
-    
-    pub u: libvlc_media_track_info_t_types::u,
-}
-
-pub mod libvlc_media_track_info_t_types {
-    use libc::c_uint;
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub union u {
-        pub audio: audio,
-        pub video: video,
-    }
-
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct audio {
-        pub i_channels: c_uint,
-        pub i_rate: c_uint,
-    }
-
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct video {
-        pub i_height: c_uint,
-        pub i_width: c_uint,
-    }
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_audio_track_t
-{
-    pub i_channels: c_uint,
-    pub i_rate: c_uint,
-}
-
-#[derive(Clone, Copy)]
-#[repr(C)]
-pub struct libvlc_video_track_t
-{
-    pub i_height: c_uint,
-    pub i_width: c_uint,
-    pub i_sar_num: c_uint,
-    pub i_sar_den: c_uint,
-    pub i_frame_rate_num: c_uint,
-    pub i_frame_rate_den: c_uint,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_subtitle_track_t {
-    pub psz_encoding: *const c_char,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_media_track_t {
-    pub i_codec: u32,
-    pub i_original_fourcc: u32,
-    pub i_id: c_int,
-    pub i_type: libvlc_track_type_t,
-    pub i_profile: c_int,
-    pub i_level: c_int,
-    pub u: libvlc_media_track_t_types::u,
-    pub i_bitrate: c_uint,
-    pub psz_language: *mut c_char,
-    pub psz_description: *mut c_char,
-}
-
-pub mod libvlc_media_track_t_types {
-    use super::*;
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub union u {
-        pub audio: *mut libvlc_audio_track_t,
-        pub video: *mut libvlc_video_track_t,
-        pub subtitle: *mut libvlc_subtitle_track_t,
-    }
-}
-
-impl libvlc_media_track_t {
-    pub unsafe fn audio(&self) -> *mut libvlc_audio_track_t {
-        self.u.audio
-    }
-    pub unsafe fn video(&self) -> *mut libvlc_video_track_t {
-        self.u.video
-    }
-    pub unsafe fn subtitle(&self) -> *mut libvlc_subtitle_track_t {
-        self.u.subtitle
-    }
-}
-
-extern "C" {
-    pub fn libvlc_media_new_location(p_instance: *mut libvlc_instance_t, psz_mrl: *const c_char)
-                                     -> *mut libvlc_media_t;
-    pub fn libvlc_media_new_path(p_instance: *mut libvlc_instance_t, path: *const c_char)
-                                 -> *mut libvlc_media_t;
-    pub fn libvlc_media_new_fd(p_instance: *mut libvlc_instance_t, fd: c_int)
-                               -> *mut libvlc_media_t;
-    pub fn libvlc_media_as_node(p_instance: *mut libvlc_instance_t, psz_name: *const c_char)
-                                -> *mut libvlc_media_t;
-    pub fn libvlc_media_add_option(p_md: *mut libvlc_media_t, psz_options: *const c_char);
-    pub fn libvlc_media_add_option_flag(
-        p_md: *mut libvlc_media_t, psz_options: *const c_char, i_flags: c_uint);
-    pub fn libvlc_media_retain(p_md: *mut libvlc_media_t);
-    pub fn libvlc_media_release(p_md: *mut libvlc_media_t);
-    pub fn libvlc_media_get_mrl(p_md: *mut libvlc_media_t) -> *mut c_char;
-    pub fn libvlc_media_duplicate(p_md: *mut libvlc_media_t) -> *mut libvlc_media_t;
-    pub fn libvlc_media_get_meta(p_md: *mut libvlc_media_t, e_meta: libvlc_meta_t) -> *mut c_char;
-    pub fn libvlc_media_set_meta(p_md: *mut libvlc_media_t, e_meta: libvlc_meta_t,
-                                 psz_value: *const c_char);
-    pub fn libvlc_media_save_meta(p_md: *mut libvlc_media_t) -> c_int;
-    pub fn libvlc_media_get_state(p_md: *mut libvlc_media_t) -> libvlc_state_t;
-    pub fn libvlc_media_get_stats(p_md: *mut libvlc_media_t, p_stats: *mut libvlc_media_stats_t)
-                                  -> c_int;
-    pub fn libvlc_media_subitems(p_md: *mut libvlc_media_t)
-                                 -> *mut libvlc_media_list_t;
-    pub fn libvlc_media_event_manager(p_md: *mut libvlc_media_t)
-                                      -> *mut libvlc_event_manager_t;
-    pub fn libvlc_media_get_duration(p_md: *mut libvlc_media_t)
-                                     -> libvlc_time_t;
-    pub fn libvlc_media_parse(p_md: *mut libvlc_media_t);
-    pub fn libvlc_media_parse_async(p_md: *mut libvlc_media_t);
-    pub fn libvlc_media_is_parsed(p_md: *mut libvlc_media_t) -> c_int;
-    pub fn libvlc_media_set_user_data(p_md: *mut libvlc_media_t,
-                                      p_new_user_data: *mut c_void);
-    pub fn libvlc_media_get_user_data(p_md: *mut libvlc_media_t) -> *mut c_void;
-    pub fn libvlc_media_tracks_get(p_md: *mut libvlc_media_t,
-                                   tracks: *mut *mut *mut libvlc_media_track_t) -> c_uint;
-    pub fn libvlc_media_tracks_release(p_tracks: *mut *mut libvlc_media_track_t, i_count: c_uint);
-}
-
-// From libvlc_media_player.h
-
-pub enum libvlc_media_player_t {}
-pub enum libvlc_equalizer_t {}
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub struct libvlc_track_description_t {
-    pub i_id: c_int,
-    pub psz_name: *mut c_char,
-    pub p_next: *mut libvlc_track_description_t,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_audio_output_t {
-    pub psz_name: *mut c_char,
-    pub psz_description: *mut c_char,
-    pub p_next: *mut libvlc_audio_output_t,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_audio_output_device_t {
-    pub p_next: *mut libvlc_audio_output_device_t,
-    pub psz_device: *mut c_char,
-    pub psz_description: *mut c_char,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub struct libvlc_rectangle_t {
-    pub top: c_int, pub left: c_int, pub bottom: c_int, pub right: c_int,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub enum libvlc_video_marquee_option_t {
-    libvlc_marquee_Enable = 0,
-    libvlc_marquee_Text,
-    libvlc_marquee_Color,
-    libvlc_marquee_Opacity,
-    libvlc_marquee_Position,
-    libvlc_marquee_Refresh,
-    libvlc_marquee_Size,
-    libvlc_marquee_Timeout,
-    libvlc_marquee_X,
-    libvlc_marquee_Y,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub enum libvlc_navigate_mode_t {
-    libvlc_navigate_activate = 0,
-    libvlc_navigate_up,
-    libvlc_navigate_down,
-    libvlc_navigate_left,
-    libvlc_navigate_right,
-}
-
-pub use crate::enums::Position as libvlc_position_t;
-pub use crate::enums::VideoAdjustOption as libvlc_video_adjust_option;
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub enum libvlc_video_logo_option_t {
-    libvlc_logo_enable,
-    libvlc_logo_file,
-    libvlc_logo_x,
-    libvlc_logo_y,
-    libvlc_logo_delay,
-    libvlc_logo_repeat,
-    libvlc_logo_opacity,
-    libvlc_logo_position
-}
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub enum libvlc_audio_output_device_types_t {
-    libvlc_AudioOutputDevice_Error  = -1,
-    libvlc_AudioOutputDevice_Mono   =  1,
-    libvlc_AudioOutputDevice_Stereo =  2,
-    libvlc_AudioOutputDevice_2F2R   =  4,
-    libvlc_AudioOutputDevice_3F2R   =  5,
-    libvlc_AudioOutputDevice_5_1    =  6,
-    libvlc_AudioOutputDevice_6_1    =  7,
-    libvlc_AudioOutputDevice_7_1    =  8,
-    libvlc_AudioOutputDevice_SPDIF  = 10
-}
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub enum libvlc_audio_output_channel_t {
-    libvlc_AudioChannel_Error   = -1,
-    libvlc_AudioChannel_Stereo  =  1,
-    libvlc_AudioChannel_RStereo =  2,
-    libvlc_AudioChannel_Left    =  3,
-    libvlc_AudioChannel_Right   =  4,
-    libvlc_AudioChannel_Dolbys  =  5
-}
-
-pub type libvlc_video_lock_cb = Option<unsafe extern "C" fn(*mut c_void, *mut c_void) -> *mut c_void>;
-pub type libvlc_video_unlock_cb = Option<unsafe extern "C" fn(
-    *mut c_void, *mut c_void, *const *mut c_void)>;
-pub type libvlc_video_display_cb = Option<unsafe extern "C" fn(*mut c_void, *mut c_void)>;
-pub type libvlc_video_format_cb = Option<unsafe extern "C" fn(
-    *mut *mut c_void, *mut c_char, *mut c_uint, *mut c_uint, *mut c_uint, *mut c_uint)>;
-pub type libvlc_video_cleanup_cb = Option<unsafe extern "C" fn(*mut c_void)>;
-pub type libvlc_audio_play_cb = Option<unsafe extern "C" fn(*mut c_void, *const c_void, c_uint, i64)>;
-pub type libvlc_audio_pause_cb = Option<unsafe extern "C" fn(*mut c_void, i64)>;
-pub type libvlc_audio_resume_cb = Option<unsafe extern "C" fn(*mut c_void, i64)>;
-pub type libvlc_audio_flush_cb = Option<unsafe extern "C" fn(*mut c_void, i64)>;
-pub type libvlc_audio_drain_cb = Option<unsafe extern "C" fn(*mut c_void)>;
-pub type libvlc_audio_set_volume_cb = Option<unsafe extern "C" fn(*mut c_void, c_float, c_bool)>;
-pub type libvlc_audio_setup_cb = Option<unsafe extern "C" fn(
-    *mut *mut c_void, *mut c_char, *mut c_uint, *mut c_uint)>;
-pub type libvlc_audio_cleanup_cb = Option<unsafe extern "C" fn(*mut c_void)>;
-
-extern "C" {
-    pub fn libvlc_media_player_new(p_libvlc_instance: *mut libvlc_instance_t)
-                                   -> *mut libvlc_media_player_t;
-    pub fn libvlc_media_player_new_from_media(p_md: *mut libvlc_media_t)
-                                              -> *mut libvlc_media_player_t;
-    pub fn libvlc_media_player_release(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_media_player_retain(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_media_player_set_media(p_mi: *mut libvlc_media_player_t,
-                                         p_md: *mut libvlc_media_t);
-    pub fn libvlc_media_player_get_media(p_mi: *mut libvlc_media_player_t) -> *mut libvlc_media_t;
-    pub fn libvlc_media_player_event_manager(p_mi: *mut libvlc_media_player_t)
-                                             -> *mut libvlc_event_manager_t;
-    pub fn libvlc_media_player_is_playing(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_play(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_set_pause(mp: *mut libvlc_media_player_t, do_pause: c_int);
-    pub fn libvlc_media_player_pause(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_media_player_stop(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_video_set_callbacks(
-        mp: *mut libvlc_media_player_t, lock: libvlc_video_lock_cb,
-        unlock: libvlc_video_unlock_cb, display: libvlc_video_display_cb,
-        opaque: *mut c_void);
-    pub fn libvlc_video_set_format(
-        mp: *mut libvlc_media_player_t, chroma: *const c_char, width: c_uint, height: c_uint,
-        pitch: c_uint);
-    pub fn libvlc_video_set_format_callbacks(
-        mp: *mut libvlc_media_player_t, setup: libvlc_video_format_cb,
-        cleanup: libvlc_video_cleanup_cb);
-    pub fn libvlc_media_player_set_nsobject(
-        p_mi: *mut libvlc_media_player_t, drawable: *mut c_void);
-    pub fn libvlc_media_player_get_nsobject(p_mi: *mut libvlc_media_player_t) -> *mut c_void;
-    pub fn libvlc_media_player_set_xwindow(
-        p_mi: *mut libvlc_media_player_t, drawable: u32);
-    pub fn libvlc_media_player_get_xwindow(p_mi: *mut libvlc_media_player_t) -> u32;
-    pub fn libvlc_media_player_set_hwnd(
-        p_mi: *mut libvlc_media_player_t, drawable: *mut c_void);
-    pub fn libvlc_media_player_get_hwnd(p_mi: *mut libvlc_media_player_t) -> *mut c_void;
-    pub fn libvlc_audio_set_callbacks(
-        mp: *mut libvlc_media_player_t, play: libvlc_audio_play_cb, pause: libvlc_audio_pause_cb,
-        resume: libvlc_audio_resume_cb, flush: libvlc_audio_flush_cb,
-        drain: libvlc_audio_drain_cb, opaque: *mut c_void);
-    pub fn libvlc_audio_set_volume_callback(
-        mp: *mut libvlc_media_player_t, set_volume: libvlc_audio_set_volume_cb);
-    pub fn libvlc_audio_set_format_callbacks(
-        mp: *mut libvlc_media_player_t, setup: libvlc_audio_setup_cb,
-        cleanup: libvlc_audio_cleanup_cb);
-    pub fn libvlc_audio_set_format(
-        mp: *mut libvlc_media_player_t, format: *const c_char, rate: c_uint, channels: c_uint);
-    pub fn libvlc_media_player_get_length(p_mi: *mut libvlc_media_player_t) -> libvlc_time_t;
-    pub fn libvlc_media_player_get_time(p_mi: *mut libvlc_media_player_t) -> libvlc_time_t;
-    pub fn libvlc_media_player_set_time(
-        p_mi: *mut libvlc_media_player_t, i_time: libvlc_time_t);
-    pub fn libvlc_media_player_get_position(p_mi: *mut libvlc_media_player_t) -> c_float;
-    pub fn libvlc_media_player_set_position(p_mi: *mut libvlc_media_player_t, f_pos: c_float);
-    pub fn libvlc_media_player_set_chapter(p_mi: *mut libvlc_media_player_t, i_chapter: c_int);
-    pub fn libvlc_media_player_get_chapter(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_get_chapter_count(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_will_play(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_set_title(p_mi: *mut libvlc_media_player_t, i_title: c_int);
-    pub fn libvlc_media_player_get_chapter_count_for_title(
-        p_mi: *mut libvlc_media_player_t, i_title: c_int) -> c_int;
-    pub fn libvlc_media_player_get_title(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_get_title_count(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_previous_chapter(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_media_player_next_chapter(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_media_player_get_rate(p_mi: *mut libvlc_media_player_t) -> c_float;
-    pub fn libvlc_media_player_set_rate(p_mi: *mut libvlc_media_player_t, rate: c_float) -> c_int;
-    pub fn libvlc_media_player_get_state(p_mi: *mut libvlc_media_player_t) -> libvlc_state_t;
-    pub fn libvlc_media_player_get_fps(p_mi: *mut libvlc_media_player_t) -> c_float;
-    pub fn libvlc_media_player_has_vout(p_mi: *mut libvlc_media_player_t) -> c_uint;
-    pub fn libvlc_media_player_is_seekable(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_can_pause(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_program_scrambled(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_media_player_next_frame(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_media_player_navigate(p_mi: *mut libvlc_media_player_t, navigate: c_uint);
-    pub fn libvlc_media_player_set_video_title_display(
-        p_mi: *mut libvlc_media_player_t, position: libvlc_position_t, timeout: c_uint);
-    pub fn libvlc_track_description_list_release(p_track_description: *mut libvlc_track_description_t);
-    pub fn libvlc_toggle_fullscreen(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_set_fullscreen(p_mi: *mut libvlc_media_player_t, b_fullscreen: c_int);
-    pub fn libvlc_get_fullscreen(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_video_set_key_input(p_mi: *mut libvlc_media_player_t, on: c_uint);
-    pub fn libvlc_video_set_mouse_input(p_mi: *mut libvlc_media_player_t, on: c_uint);
-    pub fn libvlc_video_get_size(
-        p_mi: *mut libvlc_media_player_t, num: c_uint, px: *mut c_uint, py: *mut c_uint) -> c_int;
-    pub fn libvlc_video_get_cursor(
-        p_mi: *mut libvlc_media_player_t, num: c_uint, px: *mut c_int, py: *mut c_int) -> c_int;
-    pub fn libvlc_video_get_scale(p_mi: *mut libvlc_media_player_t) -> c_float;
-    pub fn libvlc_video_set_scale(p_mi: *mut libvlc_media_player_t, f_factor: c_float);
-    pub fn libvlc_video_get_aspect_ratio(p_mi: *mut libvlc_media_player_t) -> *mut c_char;
-    pub fn libvlc_video_set_aspect_ratio(p_mi: *mut libvlc_media_player_t, psz_aspect: *const c_char);
-    pub fn libvlc_video_get_spu(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_video_get_spu_count(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_video_get_spu_description(p_mi: *mut libvlc_media_player_t)
-     -> *mut libvlc_track_description_t;
-    pub fn libvlc_video_set_spu(p_mi: *mut libvlc_media_player_t, i_spu: c_int) -> c_int;
-    pub fn libvlc_video_set_subtitle_file(
-        p_mi: *mut libvlc_media_player_t, psz_subtitle: *const c_char) -> c_int;
-    pub fn libvlc_video_get_spu_delay(p_mi: *mut libvlc_media_player_t) -> i64;
-    pub fn libvlc_video_set_spu_delay(
-        p_mi: *mut libvlc_media_player_t, i_delay: i64) -> c_int;
-    pub fn libvlc_video_get_title_description(
-        p_mi: *mut libvlc_media_player_t) -> *mut libvlc_track_description_t;
-    pub fn libvlc_video_get_chapter_description(
-        p_mi: *mut libvlc_media_player_t, i_title: c_int) -> *mut libvlc_track_description_t;
-    pub fn libvlc_video_get_crop_geometry(p_mi: *mut libvlc_media_player_t) -> *mut c_char;
-    pub fn libvlc_video_set_crop_geometry(
-        p_mi: *mut libvlc_media_player_t, psz_geometry: *const c_char);
-    pub fn libvlc_video_get_teletext(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_video_set_teletext(p_mi: *mut libvlc_media_player_t, i_page: c_int);
-    pub fn libvlc_toggle_teletext(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_video_get_track_count(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_video_get_track_description(
-        p_mi: *mut libvlc_media_player_t) -> *mut libvlc_track_description_t;
-    pub fn libvlc_video_get_track(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_video_set_track(p_mi: *mut libvlc_media_player_t, i_track: c_int) -> c_int;
-    pub fn libvlc_video_take_snapshot(
-        p_mi: *mut libvlc_media_player_t, num: c_uint, psz_filepath: *const c_char,
-        i_width: c_uint, i_height: c_uint) -> c_int;
-    pub fn libvlc_video_set_deinterlace(p_mi: *mut libvlc_media_player_t, psz_mode: *const c_char);
-    pub fn libvlc_video_get_marquee_int(p_mi: *mut libvlc_media_player_t, option: c_uint) -> c_int;
-    pub fn libvlc_video_get_marquee_string(
-        p_mi: *mut libvlc_media_player_t, option: c_uint) -> *mut c_char;
-    pub fn libvlc_video_set_marquee_int(
-        p_mi: *mut libvlc_media_player_t, option: c_uint, i_val: c_int);
-    pub fn libvlc_video_set_marquee_string(
-        p_mi: *mut libvlc_media_player_t, option: c_uint, psz_text: *const c_char);
-    pub fn libvlc_video_get_logo_int(p_mi: *mut libvlc_media_player_t, option: c_uint) -> c_int;
-    pub fn libvlc_video_set_logo_int(p_mi: *mut libvlc_media_player_t, option: c_uint, value: c_int);
-    pub fn libvlc_video_set_logo_string(
-        p_mi: *mut libvlc_media_player_t, option: c_uint, psz_value: *const c_char);
-    pub fn libvlc_video_get_adjust_int(
-        p_mi: *mut libvlc_media_player_t, option: c_uint) -> c_int;
-    pub fn libvlc_video_set_adjust_int(
-        p_mi: *mut libvlc_media_player_t, option: c_uint, value: c_int);
-    pub fn libvlc_video_get_adjust_float(
-        p_mi: *mut libvlc_media_player_t, option: c_uint) -> c_float;
-    pub fn libvlc_video_set_adjust_float(
-        p_mi: *mut libvlc_media_player_t, option: c_uint, value: c_float);
-    pub fn libvlc_audio_output_list_get(p_instance: *mut libvlc_instance_t)
-     -> *mut libvlc_audio_output_t;
-    pub fn libvlc_audio_output_list_release(p_list: *mut libvlc_audio_output_t);
-    pub fn libvlc_audio_output_set(p_mi: *mut libvlc_media_player_t, psz_name: *const c_char) -> c_int;
-    pub fn libvlc_audio_output_device_enum(
-        mp: *mut libvlc_media_player_t) -> *mut libvlc_audio_output_device_t;
-    pub fn libvlc_audio_output_device_list_get(
-        p_instance: *mut libvlc_instance_t, aout: *const c_char) -> *mut libvlc_audio_output_device_t;
-    pub fn libvlc_audio_output_device_list_release(p_list: *mut libvlc_audio_output_device_t);
-    pub fn libvlc_audio_output_device_set(
-        mp: *mut libvlc_media_player_t, module: *const c_char, device_id: *const c_char);
-    pub fn libvlc_audio_toggle_mute(p_mi: *mut libvlc_media_player_t);
-    pub fn libvlc_audio_get_mute(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_audio_set_mute(p_mi: *mut libvlc_media_player_t, status: c_int);
-    pub fn libvlc_audio_get_volume(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_audio_set_volume(p_mi: *mut libvlc_media_player_t, i_volume: c_int) -> c_int;
-    pub fn libvlc_audio_get_track_count(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_audio_get_track_description(
-        p_mi: *mut libvlc_media_player_t) -> *mut libvlc_track_description_t;
-    pub fn libvlc_audio_get_track(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_audio_set_track(p_mi: *mut libvlc_media_player_t, i_track: c_int) -> c_int;
-    pub fn libvlc_audio_get_channel(p_mi: *mut libvlc_media_player_t) -> c_int;
-    pub fn libvlc_audio_set_channel(p_mi: *mut libvlc_media_player_t, channel: c_int) -> c_int;
-    pub fn libvlc_audio_get_delay(p_mi: *mut libvlc_media_player_t) -> i64;
-    pub fn libvlc_audio_set_delay(p_mi: *mut libvlc_media_player_t, i_delay: i64) -> c_int;
-    pub fn libvlc_audio_equalizer_get_preset_count() -> c_uint;
-    pub fn libvlc_audio_equalizer_get_preset_name(u_index: c_uint) -> *const c_char;
-    pub fn libvlc_audio_equalizer_get_band_count() -> c_uint;
-    pub fn libvlc_audio_equalizer_get_band_frequency(u_index: c_uint) -> c_float;
-    pub fn libvlc_audio_equalizer_new() -> *mut libvlc_equalizer_t;
-    pub fn libvlc_audio_equalizer_new_from_preset(u_index: c_uint) -> *mut libvlc_equalizer_t;
-    pub fn libvlc_audio_equalizer_release(p_equalizer: *mut libvlc_equalizer_t);
-    pub fn libvlc_audio_equalizer_set_preamp(
-        p_equalizer: *mut libvlc_equalizer_t, f_preamp: c_float) -> c_int;
-    pub fn libvlc_audio_equalizer_get_preamp(p_equalizer: *mut libvlc_equalizer_t) -> c_float;
-    pub fn libvlc_audio_equalizer_set_amp_at_index(
-        p_equalizer: *mut libvlc_equalizer_t, f_amp: c_float, u_band: c_uint) -> c_int;
-    pub fn libvlc_audio_equalizer_get_amp_at_index(
-        p_equalizer: *mut libvlc_equalizer_t, u_band: c_uint) -> c_float;
-    pub fn libvlc_media_player_set_equalizer(
-        p_mi: *mut libvlc_media_player_t, p_equalizer: *mut libvlc_equalizer_t) -> c_int;
-}
-
-// From libvlc_events.h
-pub use crate::enums::EventType as libvlc_event_e;
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct libvlc_event_t {
-    pub _type: c_int,
-    pub p_obj: *mut c_void,
-    pub u: libvlc_event_t_types::u,
-}
-
-pub mod libvlc_event_t_types {
-    use super::*;
-    use libc::{c_int, c_char, c_float};
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub union u {
-        pub media_meta_changed: media_meta_changed,
-        pub media_subitem_added: media_subitem_added,
-        pub media_duration_changed: media_duration_changed,
-        pub media_parsed_changed: media_parsed_changed,
-        pub media_freed: media_freed,
-        pub media_state_changed: media_state_changed,
-        pub media_subitemtree_added: media_subitemtree_added,
-        pub media_player_buffering: media_player_buffering,
-        pub media_player_position_changed: media_player_position_changed,
-        pub media_player_time_changed: media_player_time_changed,
-        pub media_player_title_changed: media_player_title_changed,
-        pub media_player_seekable_changed: media_player_seekable_changed,
-        pub media_player_pausable_changed: media_player_pausable_changed,
-        pub media_player_scrambled_changed: media_player_scrambled_changed,
-        pub media_player_vout: media_player_vout,
-        pub media_list_item_added: media_list_item_added,
-        pub media_list_will_add_item: media_list_will_add_item,
-        pub media_list_item_deleted: media_list_item_deleted,
-        pub media_list_will_delete_item: media_list_will_delete_item,
-        pub media_list_player_next_item_set: media_list_player_next_item_set,
-        pub media_player_snapshot_taken: media_player_snapshot_taken,
-        pub media_player_length_changed: media_player_length_changed,
-        pub vlm_media_event: vlm_media_event,
-        pub media_player_media_changed: media_player_media_changed,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_meta_changed {
-        pub meta_type: libvlc_meta_t,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_subitem_added {
-        pub new_child: *mut libvlc_media_t,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_duration_changed {
-        pub new_duration: i64,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_parsed_changed {
-        pub new_status: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_freed {
-        pub md: *mut libvlc_media_t,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_state_changed {
-        pub new_state: libvlc_state_t,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_subitemtree_added {
-        pub item: *mut libvlc_media_t,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_buffering {
-        pub new_cache: c_float,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_position_changed {
-        pub new_position: c_float,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_time_changed {
-        pub new_time: libvlc_time_t,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_title_changed {
-        pub new_titie: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_seekable_changed {
-        pub new_seekable: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_pausable_changed {
-        pub new_pausable: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_scrambled_changed {
-        pub new_scrambled: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_vout {
-        pub new_count: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_list_item_added {
-        pub item: *mut libvlc_media_t,
-        pub index: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_list_will_add_item {
-        pub item: *mut libvlc_media_t,
-        pub index: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_list_item_deleted {
-        pub item: *mut libvlc_media_t,
-        pub index: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_list_will_delete_item {
-        pub item: *mut libvlc_media_t,
-        pub index: c_int,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_list_player_next_item_set {
-        pub item: *mut libvlc_media_t,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_snapshot_taken {
-        pub psz_filename: *mut c_char,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_length_changed {
-        pub new_length: libvlc_time_t,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct vlm_media_event {
-        pub psz_media_name: *mut c_char,
-        pub psz_instance_name: *mut c_char,
-    }
-    #[repr(C)]
-    #[derive(Clone, Copy)]
-    pub struct media_player_media_changed {
-        pub new_media: *mut libvlc_media_t,
-    }
-}
-
-// From libvlc_media_list.h
-
-pub enum libvlc_media_list_t {}
-
-extern "C" {
-    pub fn libvlc_media_list_new(p_instance: *mut libvlc_instance_t) -> *mut libvlc_media_list_t;
-    pub fn libvlc_media_list_release(p_ml: *mut libvlc_media_list_t);
-    pub fn libvlc_media_list_retain(p_ml: *mut libvlc_media_list_t);
-    pub fn libvlc_media_list_set_media(p_ml: *mut libvlc_media_list_t, p_md: *mut libvlc_media_t);
-    pub fn libvlc_media_list_media(p_ml: *mut libvlc_media_list_t) -> *mut libvlc_media_t;
-    pub fn libvlc_media_list_add_media(
-        p_ml: *mut libvlc_media_list_t, p_md: *mut libvlc_media_t) -> c_int;
-    pub fn libvlc_media_list_insert_media(
-        p_ml: *mut libvlc_media_list_t, p_md: *mut libvlc_media_t, i_pos: c_int) -> c_int;
-    pub fn libvlc_media_list_remove_index(p_ml: *mut libvlc_media_list_t, i_pos: c_int) -> c_int;
-    pub fn libvlc_media_list_count(p_ml: *mut libvlc_media_list_t) -> c_int;
-    pub fn libvlc_media_list_item_at_index(
-        p_ml: *mut libvlc_media_list_t, i_pos: c_int) -> *mut libvlc_media_t;
-    pub fn libvlc_media_list_index_of_item(
-        p_ml: *mut libvlc_media_list_t, p_md: *mut libvlc_media_t) -> c_int;
-    pub fn libvlc_media_list_is_readonly(p_ml: *mut libvlc_media_list_t) -> c_int;
-    pub fn libvlc_media_list_lock(p_ml: *mut libvlc_media_list_t);
-    pub fn libvlc_media_list_unlock(p_ml: *mut libvlc_media_list_t);
-    pub fn libvlc_media_list_event_manager(
-        p_ml: *mut libvlc_media_list_t) -> *mut libvlc_event_manager_t;
-}
-
-// From libvlc_media_library.h
-
-pub enum libvlc_media_library_t {}
-
-extern "C" {
-    pub fn libvlc_media_library_new(p_instance: *mut libvlc_instance_t) -> *mut libvlc_media_library_t;
-    pub fn libvlc_media_library_release(p_mlib: *mut libvlc_media_library_t);
-    pub fn libvlc_media_library_retain(p_mlib: *mut libvlc_media_library_t);
-    pub fn libvlc_media_library_load(p_mlib: *mut libvlc_media_library_t) -> c_int;
-    pub fn libvlc_media_library_media_list(
-        p_mlib: *mut libvlc_media_library_t) -> *mut libvlc_media_list_t;
-}
-
-// From libvlc_media_discoverer.h
-
-pub enum libvlc_media_discoverer_t {}
-
-extern "C" {
-    pub fn libvlc_media_discoverer_new_from_name(
-        p_inst: *mut libvlc_instance_t, psz_name: *const c_char) -> *mut libvlc_media_discoverer_t;
-    pub fn libvlc_media_discoverer_release(p_mdis: *mut libvlc_media_discoverer_t);
-    pub fn libvlc_media_discoverer_localized_name(
-        p_mdis: *mut libvlc_media_discoverer_t) -> *mut c_char;
-    pub fn libvlc_media_discoverer_media_list(
-        p_mdis: *mut libvlc_media_discoverer_t) -> *mut libvlc_media_list_t;
-    pub fn libvlc_media_discoverer_event_manager(
-        p_mdis: *mut libvlc_media_discoverer_t) -> *mut libvlc_event_manager_t;
-    pub fn libvlc_media_discoverer_is_running(p_mdis: *mut libvlc_media_discoverer_t) -> c_int;
-}
-
-// From libvlc_vlm.h
-
-extern "C" {
-    pub fn libvlc_vlm_release(p_instance: *mut libvlc_instance_t);
-    pub fn libvlc_vlm_add_broadcast(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, psz_input: *const c_char,
-        psz_output: *const c_char, i_options: c_int, ppsz_options: *const *const c_char,
-        b_enabled: c_int, b_loop: c_int) -> c_int;
-    pub fn libvlc_vlm_add_vod(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, psz_input: *const c_char,
-        i_options: c_int, ppsz_options: *const *const c_char, b_enabled: c_int,
-        psz_mux: *const c_char) -> c_int;
-    pub fn libvlc_vlm_del_media(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char) -> c_int;
-    pub fn libvlc_vlm_set_enabled(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, b_enabled: c_int) -> c_int;
-    pub fn libvlc_vlm_set_output(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, psz_output: *const c_char) -> c_int;
-    pub fn libvlc_vlm_set_input(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, psz_input: *const c_char) -> c_int;
-    pub fn libvlc_vlm_add_input(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, psz_input: *const c_char) -> c_int;
-    pub fn libvlc_vlm_set_loop(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, b_loop: c_int) -> c_int;
-    pub fn libvlc_vlm_set_mux(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, psz_mux: *const c_char) -> c_int;
-    pub fn libvlc_vlm_change_media(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, psz_input: *const c_char,
-        psz_output: *const c_char, i_options: c_int, ppsz_options: *const *const c_char,
-        b_enabled: c_int, b_loop: c_int) -> c_int;
-    pub fn libvlc_vlm_play_media(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char) -> c_int;
-    pub fn libvlc_vlm_stop_media(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char) -> c_int;
-    pub fn libvlc_vlm_pause_media(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char) -> c_int;
-    pub fn libvlc_vlm_seek_media(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, f_percentage: c_float) -> c_int;
-    pub fn libvlc_vlm_show_media(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char) -> *const c_char;
-    pub fn libvlc_vlm_get_media_instance_position(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, i_instance: c_int) -> c_float;
-    pub fn libvlc_vlm_get_media_instance_time(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, i_instance: c_int) -> c_int;
-    pub fn libvlc_vlm_get_media_instance_length(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, i_instance: c_int) -> c_int;
-    pub fn libvlc_vlm_get_media_instance_rate(
-        p_instance: *mut libvlc_instance_t, psz_name: *const c_char, i_instance: c_int) -> c_int;
-    pub fn libvlc_vlm_get_event_manager(
-        p_instance: *mut libvlc_instance_t) -> *mut libvlc_event_manager_t;
-}

src/tools.rs

@@ -2,10 +2,10 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use std::ffi::{CString, CStr, NulError};
-use std::path::Path;
-use std::borrow::Cow;
 use libc::c_char;
+use std::borrow::Cow;
+use std::ffi::{CStr, CString, NulError};
+use std::path::Path;
 
 // Convert String to CString.
 // Panic if the string includes null bytes.
@@ -16,8 +16,8 @@ pub fn to_cstr(s: &str) -> CString {
 // Convert *const c_char to String
 pub unsafe fn from_cstr(p: *const c_char) -> Option<String> {
     if p.is_null() {
-            None
-    }else{
+        None
+    } else {
         let cstr = CStr::from_ptr(p);
 
         Some(cstr.to_string_lossy().into_owned())
@@ -27,8 +27,8 @@ pub unsafe fn from_cstr(p: *const c_char) -> Option<String> {
 // Convert *const c_char to &str
 pub unsafe fn from_cstr_ref<'a>(p: *const c_char) -> Option<Cow<'a, str>> {
     if p.is_null() {
-            None
-    }else{
+        None
+    } else {
         let cstr = CStr::from_ptr(p);
 
         Some(cstr.to_string_lossy())

src/video.rs

@@ -2,12 +2,12 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use crate::sys;
+use crate::enums::VideoAdjustOption;
+use crate::tools::{from_cstr, to_cstr};
 use crate::MediaPlayer;
 use crate::TrackDescription;
-use crate::enums::VideoAdjustOption;
-use crate::tools::{to_cstr, from_cstr};
 use libc::c_void;
+use vlc_sys as sys;
 
 pub trait MediaPlayerVideoEx {
     fn toggle_fullscreen(&self);
@@ -32,77 +32,108 @@ pub trait MediaPlayerVideoEx {
 
 impl MediaPlayerVideoEx for MediaPlayer {
     fn toggle_fullscreen(&self) {
-        unsafe{ sys::libvlc_toggle_fullscreen(self.ptr); }
+        unsafe {
+            sys::libvlc_toggle_fullscreen(self.ptr);
+        }
     }
     fn set_fullscreen(&self, fullscreen: bool) {
-        unsafe{ sys::libvlc_set_fullscreen(self.ptr, if fullscreen { 1 }else{ 0 }); }
+        unsafe {
+            sys::libvlc_set_fullscreen(self.ptr, if fullscreen { 1 } else { 0 });
+        }
     }
     fn get_fullscreen(&self) -> bool {
-        unsafe{ if sys::libvlc_get_fullscreen(self.ptr) == 0 { false }else{ true } }
+        unsafe { sys::libvlc_get_fullscreen(self.ptr) != 0 }
     }
     fn set_key_input(&self, on: bool) {
-        unsafe{ sys::libvlc_video_set_key_input(self.ptr, if on { 1 }else{ 0 }); }
+        unsafe {
+            sys::libvlc_video_set_key_input(self.ptr, if on { 1 } else { 0 });
+        }
     }
     fn set_mouse_input(&self, on: bool) {
-        unsafe{ sys::libvlc_video_set_mouse_input(self.ptr, if on { 1 }else{ 0 }); }
+        unsafe {
+            sys::libvlc_video_set_mouse_input(self.ptr, if on { 1 } else { 0 });
+        }
     }
     fn get_size(&self, num: u32) -> Option<(u32, u32)> {
-        unsafe{
+        unsafe {
             let mut x = 0;
             let mut y = 0;
             let res = sys::libvlc_video_get_size(self.ptr, num, &mut x, &mut y);
-            if res == -1 { None }else{ Some((x, y)) }
+            if res == -1 {
+                None
+            } else {
+                Some((x, y))
+            }
         }
     }
     fn get_cursor(&self, num: u32) -> Option<(i32, i32)> {
-        unsafe{
+        unsafe {
             let mut x = 0;
             let mut y = 0;
             let res = sys::libvlc_video_get_cursor(self.ptr, num, &mut x, &mut y);
-            if res == -1 { None }else{ Some((x, y)) }
+            if res == -1 {
+                None
+            } else {
+                Some((x, y))
+            }
         }
     }
     fn get_scale(&self) -> f32 {
-        unsafe{ sys::libvlc_video_get_scale(self.ptr) }
+        unsafe { sys::libvlc_video_get_scale(self.ptr) }
     }
     fn set_scale(&self, factor: f32) {
-        unsafe{ sys::libvlc_video_set_scale(self.ptr, factor); }
+        unsafe {
+            sys::libvlc_video_set_scale(self.ptr, factor);
+        }
     }
     fn get_video_track(&self) -> Option<i32> {
-        unsafe{
+        unsafe {
             let track = sys::libvlc_video_get_track(self.ptr);
-            if track == -1 { None }else{ Some(track) }
+            if track == -1 {
+                None
+            } else {
+                Some(track)
+            }
         }
     }
     fn set_video_track(&self, track: i32) {
-        unsafe{ sys::libvlc_video_set_track(self.ptr, track); }
+        unsafe {
+            sys::libvlc_video_set_track(self.ptr, track);
+        }
     }
     fn get_aspect_ratio(&self) -> Option<String> {
-        unsafe{
+        unsafe {
             let p = sys::libvlc_video_get_aspect_ratio(self.ptr);
             let s = from_cstr(p);
-            if !p.is_null() { sys::libvlc_free(p as *mut c_void); }
+            if !p.is_null() {
+                sys::libvlc_free(p as *mut c_void);
+            }
             s
         }
     }
     fn set_aspect_ratio(&self, aspect: Option<&str>) {
-        unsafe{
+        unsafe {
             if let Some(a) = aspect {
                 sys::libvlc_video_set_aspect_ratio(self.ptr, to_cstr(a).as_ptr());
-            }else{
+            } else {
                 sys::libvlc_video_set_aspect_ratio(self.ptr, ::std::ptr::null());
             }
         }
     }
     fn get_video_track_description(&self) -> Option<Vec<TrackDescription>> {
-        unsafe{
+        unsafe {
             let p0 = sys::libvlc_video_get_track_description(self.ptr);
-            if p0.is_null() { return None; }
+            if p0.is_null() {
+                return None;
+            }
             let mut td = Vec::new();
             let mut p = p0;
 
             while !(*p).p_next.is_null() {
-                td.push(TrackDescription{ id: (*p).i_id, name: from_cstr((*p).psz_name) });
+                td.push(TrackDescription {
+                    id: (*p).i_id,
+                    name: from_cstr((*p).psz_name),
+                });
                 p = (*p).p_next;
             }
             sys::libvlc_track_description_list_release(p0);
@@ -110,15 +141,19 @@ impl MediaPlayerVideoEx for MediaPlayer {
         }
     }
     fn get_adjust_int(&self, option: VideoAdjustOption) -> i32 {
-        unsafe{ sys::libvlc_video_get_adjust_int(self.ptr, option as u32) }
+        unsafe { sys::libvlc_video_get_adjust_int(self.ptr, option as u32) }
     }
     fn set_adjust_int(&self, option: VideoAdjustOption, value: i32) {
-        unsafe{ sys::libvlc_video_set_adjust_int(self.ptr, option as u32, value); }
+        unsafe {
+            sys::libvlc_video_set_adjust_int(self.ptr, option as u32, value);
+        }
     }
     fn get_adjust_float(&self, option: VideoAdjustOption) -> f32 {
-        unsafe{ sys::libvlc_video_get_adjust_float(self.ptr, option as u32) }
+        unsafe { sys::libvlc_video_get_adjust_float(self.ptr, option as u32) }
     }
     fn set_adjust_float(&self, option: VideoAdjustOption, value: f32) {
-        unsafe{ sys::libvlc_video_set_adjust_float(self.ptr, option as u32, value); }
+        unsafe {
+            sys::libvlc_video_set_adjust_float(self.ptr, option as u32, value);
+        }
     }
 }

src/vlm.rs

@@ -2,33 +2,57 @@ use std::ffi::CString;
 use std::os::raw::c_char;
 use std::ptr;
 
-use crate::{Instance, sys};
 use crate::tools::{from_cstr, to_cstr};
+use crate::{Instance, InternalError};
+use vlc_sys as sys;
 
 pub trait Vlm {
-    fn add_broadcast(&self, name: &str, input: &str, output: &str, options: Option<Vec<String>>, enabled: bool, loop_broadcast: bool, ) -> Result<(), ()>;
+    fn add_broadcast(
+        &self,
+        name: &str,
+        input: &str,
+        output: &str,
+        options: Option<Vec<String>>,
+        enabled: bool,
+        loop_broadcast: bool,
+    ) -> Result<(), InternalError>;
 
-    fn add_vod(&self, name: &str, input: &str, mux: &str, options: Option<Vec<String>>, enabled: bool) -> Result<(), ()>;
+    fn add_vod(
+        &self,
+        name: &str,
+        input: &str,
+        mux: &str,
+        options: Option<Vec<String>>,
+        enabled: bool,
+    ) -> Result<(), InternalError>;
 
-    fn play_media(&self, name: &str) -> Result<(), ()>;
+    fn play_media(&self, name: &str) -> Result<(), InternalError>;
 
-    fn pause_media(&self, name: &str) -> Result<(), ()>;
+    fn pause_media(&self, name: &str) -> Result<(), InternalError>;
 
-    fn stop_media(&self, name: &str) -> Result<(), ()>;
+    fn stop_media(&self, name: &str) -> Result<(), InternalError>;
 
-    fn get_media_instance_position(&self, name: &str, instance: i32) -> Result<f32, ()>;
+    fn get_media_instance_position(&self, name: &str, instance: i32) -> Result<f32, InternalError>;
 
-    fn get_media_instance_length(&self, name: &str, instance: i32) -> Result<i32, ()>;
+    fn get_media_instance_length(&self, name: &str, instance: i32) -> Result<i32, InternalError>;
 
-    fn get_media_instance_time(&self, name: &str, instance: i32) -> Result<i32, ()>;
+    fn get_media_instance_time(&self, name: &str, instance: i32) -> Result<i32, InternalError>;
 
-    fn get_media_instance_rate(&self, name: &str, instance: i32) -> Result<i32, ()>;
+    fn get_media_instance_rate(&self, name: &str, instance: i32) -> Result<i32, InternalError>;
 
-    fn show_media(&self, name: &str) -> Result<String, ()>;
+    fn show_media(&self, name: &str) -> Result<String, InternalError>;
 }
 
 impl Vlm for Instance {
-    fn add_broadcast(&self, name: &str, input: &str, output: &str, options: Option<Vec<String>>, enabled: bool, loop_broadcast: bool, ) -> Result<(), ()> {
+    fn add_broadcast(
+        &self,
+        name: &str,
+        input: &str,
+        output: &str,
+        options: Option<Vec<String>>,
+        enabled: bool,
+        loop_broadcast: bool,
+    ) -> Result<(), InternalError> {
         let name = to_cstr(name);
         let input = to_cstr(input);
         let output = to_cstr(output);
@@ -37,23 +61,54 @@ impl Vlm for Instance {
         let enabled = if enabled { 1 } else { 0 };
         let loop_broadcast = if loop_broadcast { 1 } else { 0 };
         if let Some(vec) = options {
-            opts_c = vec.into_iter()
-                .map(|x| CString::new(x).expect("Error: Unexpected null byte")).collect();
+            opts_c = vec
+                .into_iter()
+                .map(|x| CString::new(x).expect("Error: Unexpected null byte"))
+                .collect();
             opts_c_ptr = opts_c.iter().map(|x| x.as_ptr()).collect();
         } else {
             opts_c_ptr = Vec::new();
         }
         let result = unsafe {
             if opts_c_ptr.is_empty() {
-                sys::libvlc_vlm_add_broadcast(self.ptr, name.as_ptr(), input.as_ptr(), output.as_ptr(), 0, ptr::null(), enabled, loop_broadcast)
+                sys::libvlc_vlm_add_broadcast(
+                    self.ptr,
+                    name.as_ptr(),
+                    input.as_ptr(),
+                    output.as_ptr(),
+                    0,
+                    ptr::null(),
+                    enabled,
+                    loop_broadcast,
+                )
             } else {
-                sys::libvlc_vlm_add_broadcast(self.ptr, name.as_ptr(), input.as_ptr(), output.as_ptr(), opts_c_ptr.len() as i32, opts_c_ptr.as_ptr(), enabled, loop_broadcast)
+                sys::libvlc_vlm_add_broadcast(
+                    self.ptr,
+                    name.as_ptr(),
+                    input.as_ptr(),
+                    output.as_ptr(),
+                    opts_c_ptr.len() as i32,
+                    opts_c_ptr.as_ptr(),
+                    enabled,
+                    loop_broadcast,
+                )
             }
         };
-        if result == 0 { Ok(()) } else { Err(()) }
+        if result == 0 {
+            Ok(())
+        } else {
+            Err(InternalError)
+        }
     }
 
-    fn add_vod(&self, name: &str, input: &str, mux: &str, options: Option<Vec<String>>, enabled: bool) -> Result<(), ()> {
+    fn add_vod(
+        &self,
+        name: &str,
+        input: &str,
+        mux: &str,
+        options: Option<Vec<String>>,
+        enabled: bool,
+    ) -> Result<(), InternalError> {
         let name = to_cstr(name);
         let input = to_cstr(input);
         let mux = to_cstr(mux);
@@ -61,87 +116,127 @@ impl Vlm for Instance {
         let opts_c: Vec<CString>;
         let enabled = if enabled { 1 } else { 0 };
         if let Some(vec) = options {
-            opts_c = vec.into_iter()
-                .map(|x| CString::new(x).expect("Error: Unexpected null byte")).collect();
+            opts_c = vec
+                .into_iter()
+                .map(|x| CString::new(x).expect("Error: Unexpected null byte"))
+                .collect();
             opts_c_ptr = opts_c.iter().map(|x| x.as_ptr()).collect();
         } else {
             opts_c_ptr = Vec::new();
         }
         let result = unsafe {
             if opts_c_ptr.is_empty() {
-                sys::libvlc_vlm_add_vod(self.ptr, name.as_ptr(), input.as_ptr(), 0, ptr::null(), enabled, mux.as_ptr())
+                sys::libvlc_vlm_add_vod(
+                    self.ptr,
+                    name.as_ptr(),
+                    input.as_ptr(),
+                    0,
+                    ptr::null(),
+                    enabled,
+                    mux.as_ptr(),
+                )
             } else {
-                sys::libvlc_vlm_add_vod(self.ptr, name.as_ptr(), input.as_ptr(), opts_c_ptr.len() as i32, opts_c_ptr.as_ptr(), enabled, mux.as_ptr())
+                sys::libvlc_vlm_add_vod(
+                    self.ptr,
+                    name.as_ptr(),
+                    input.as_ptr(),
+                    opts_c_ptr.len() as i32,
+                    opts_c_ptr.as_ptr(),
+                    enabled,
+                    mux.as_ptr(),
+                )
             }
         };
-        if result == 0 { Ok(()) } else { Err(()) }
+        if result == 0 {
+            Ok(())
+        } else {
+            Err(InternalError)
+        }
     }
 
-    fn play_media(&self, name: &str) -> Result<(), ()> {
+    fn play_media(&self, name: &str) -> Result<(), InternalError> {
         let name = to_cstr(name);
-        let result = unsafe {
-            sys::libvlc_vlm_play_media(self.ptr, name.as_ptr())
-        };
-        if result == 0 { Ok(()) } else { Err(()) }
+        let result = unsafe { sys::libvlc_vlm_play_media(self.ptr, name.as_ptr()) };
+        if result == 0 {
+            Ok(())
+        } else {
+            Err(InternalError)
+        }
     }
 
-    fn pause_media(&self, name: &str) -> Result<(), ()> {
+    fn pause_media(&self, name: &str) -> Result<(), InternalError> {
         let name = to_cstr(name);
-        let result = unsafe {
-            sys::libvlc_vlm_pause_media(self.ptr, name.as_ptr())
-        };
-        if result == 0 { Ok(()) } else { Err(()) }
+        let result = unsafe { sys::libvlc_vlm_pause_media(self.ptr, name.as_ptr()) };
+        if result == 0 {
+            Ok(())
+        } else {
+            Err(InternalError)
+        }
     }
 
-    fn stop_media(&self, name: &str) -> Result<(), ()> {
+    fn stop_media(&self, name: &str) -> Result<(), InternalError> {
         let name = to_cstr(name);
-        let result = unsafe {
-            sys::libvlc_vlm_stop_media(self.ptr, name.as_ptr())
-        };
-        if result == 0 { Ok(()) } else { Err(()) }
+        let result = unsafe { sys::libvlc_vlm_stop_media(self.ptr, name.as_ptr()) };
+        if result == 0 {
+            Ok(())
+        } else {
+            Err(InternalError)
+        }
     }
 
-    fn get_media_instance_position(&self, name: &str, instance: i32) -> Result<f32, ()> {
+    fn get_media_instance_position(&self, name: &str, instance: i32) -> Result<f32, InternalError> {
         let name = to_cstr(name);
         let result = unsafe {
             sys::libvlc_vlm_get_media_instance_position(self.ptr, name.as_ptr(), instance)
         };
-        if result != -1f32 { Ok(result) } else { Err(()) }
-    }
-
-    fn get_media_instance_length(&self, name: &str, instance: i32) -> Result<i32, ()> {
-        let name = to_cstr(name);
-        let result = unsafe {
-            sys::libvlc_vlm_get_media_instance_length(self.ptr, name.as_ptr(), instance)
-        };
-        if result != -1 { Ok(result) } else { Err(()) }
-    }
-
-    fn get_media_instance_time(&self, name: &str, instance: i32) -> Result<i32, ()> {
-        let name = to_cstr(name);
-        let result = unsafe {
-            sys::libvlc_vlm_get_media_instance_time(self.ptr, name.as_ptr(), instance)
-        };
-        if result != -1 { Ok(result) } else { Err(()) }
-    }
-
-    fn get_media_instance_rate(&self, name: &str, instance: i32) -> Result<i32, ()> {
-        let name = to_cstr(name);
-        let result = unsafe {
-            sys::libvlc_vlm_get_media_instance_rate(self.ptr, name.as_ptr(), instance)
-        };
-        if result != -1 { Ok(result) } else { Err(()) }
-    }
-
-    fn show_media(&self, name: &str) -> Result<String, ()> {
-        let name = to_cstr(name);
-        let result = unsafe {
-            from_cstr(sys::libvlc_vlm_show_media(self.ptr, name.as_ptr()))
-        };
-        if let Some(data) = result {
-            Ok(data.to_string())
+        // if result != -1f32 { Ok(result) } else { Err(()) }
+        if (result - -1f32).abs() < f32::EPSILON {
+            Err(InternalError)
         } else {
-            Err(())
+            Ok(result)
+        }
+    }
+
+    fn get_media_instance_length(&self, name: &str, instance: i32) -> Result<i32, InternalError> {
+        let name = to_cstr(name);
+        let result =
+            unsafe { sys::libvlc_vlm_get_media_instance_length(self.ptr, name.as_ptr(), instance) };
+        if result != -1 {
+            Ok(result)
+        } else {
+            Err(InternalError)
+        }
+    }
+
+    fn get_media_instance_time(&self, name: &str, instance: i32) -> Result<i32, InternalError> {
+        let name = to_cstr(name);
+        let result =
+            unsafe { sys::libvlc_vlm_get_media_instance_time(self.ptr, name.as_ptr(), instance) };
+        if result != -1 {
+            Ok(result)
+        } else {
+            Err(InternalError)
+        }
+    }
+
+    fn get_media_instance_rate(&self, name: &str, instance: i32) -> Result<i32, InternalError> {
+        let name = to_cstr(name);
+        let result =
+            unsafe { sys::libvlc_vlm_get_media_instance_rate(self.ptr, name.as_ptr(), instance) };
+        if result != -1 {
+            Ok(result)
+        } else {
+            Err(InternalError)
+        }
+    }
+
+    fn show_media(&self, name: &str) -> Result<String, InternalError> {
+        let name = to_cstr(name);
+        let result = unsafe { from_cstr(sys::libvlc_vlm_show_media(self.ptr, name.as_ptr())) };
+        if let Some(data) = result {
+            Ok(data)
+        } else {
+            Err(InternalError)
         }
     }
 }