Fix most clippy errors and warnings, applied rustfmt

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();
@@ -26,16 +25,14 @@ fn main() {
     let (tx, rx) = channel::<()>();
 
     let em = md.event_manager();
-    let _ = em.attach(EventType::MediaStateChanged, move |e, _| {
+    let _ = em.attach(EventType::MediaStateChanged, move |e, _| match e {
-        match e {
         Event::MediaStateChanged(s) => {
             println!("State : {:?}", s);
             if s == State::Ended || s == State::Error {
                 tx.send(()).unwrap();
             }
-            },
-            _ => (),
         }
+        _ => (),
     });
 
     mdp.set_media(&md);
@@ -46,5 +43,3 @@ fn main() {
     // Wait for end state
     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
 

src/audio.rs

@@ -2,16 +2,17 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use vlc_sys as 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>>;
 }
 
@@ -35,25 +36,33 @@ impl MediaPlayerAudioEx for MediaPlayer {
     fn get_volume(&self) -> i32 {
         unsafe { sys::libvlc_audio_get_volume(self.ptr) }
     }
-    fn set_volume(&self, volume: i32) -> Result<(), ()> {
+    fn set_volume(&self, volume: i32) -> Result<(), InternalError> {
         unsafe {
-            if sys::libvlc_audio_set_volume(self.ptr, volume) == 0 { Ok(()) }else{ Err(()) }
+            if sys::libvlc_audio_set_volume(self.ptr, volume) == 0 {
+                Ok(())
+            } else {
+                Err(InternalError)
+            }
         }
     }
     fn get_audio_track_description(&self) -> Option<Vec<TrackDescription>> {
         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,34 +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;
-use std::i32;
-use std::convert::TryInto;
-use libc::{c_void, c_char, c_int};
-use vlc_sys as 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()
+        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()
+        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 {}
@@ -42,14 +57,15 @@ impl Instance {
         let args_c_ptr: Vec<*const c_char>;
         let args_c: Vec<CString>;
         if let Some(argv) = args {
-            args_c = argv.into_iter()
+            args_c = argv
-                .map(|x| CString::new(x).expect("Error: Unexpected null byte")).collect();
+                .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 {
             let p = if args_c_ptr.is_empty() {
                 sys::libvlc_new(0, ptr::null())
@@ -71,23 +87,23 @@ impl Instance {
     }
 
     /// 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{
+        let result = unsafe { sys::libvlc_add_intf(self.ptr, cstr.as_ptr()) };
-            sys::libvlc_add_intf(self.ptr, cstr.as_ptr())
-        };
 
-        if result == 0 { Ok(()) }
+        if result == 0 {
-        else { Err(()) }
+            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(
+            sys::libvlc_set_user_agent(self.ptr, to_cstr(name).as_ptr(), to_cstr(http).as_ptr());
-                self.ptr, to_cstr(name).as_ptr(), to_cstr(http).as_ptr());
         }
     }
 
@@ -100,7 +116,11 @@ impl Instance {
     pub fn set_app_id(&self, id: &str, version: &str, icon: &str) {
         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(),
+            );
         }
     }
 
@@ -108,8 +128,11 @@ impl Instance {
     pub fn audio_filter_list_get(&self) -> Option<ModuleDescriptionList> {
         unsafe {
             let p = sys::libvlc_audio_filter_list_get(self.ptr);
-            if p.is_null() { None }
+            if p.is_null() {
-            else { Some(ModuleDescriptionList{ptr: p}) }
+                None
+            } else {
+                Some(ModuleDescriptionList { ptr: p })
+            }
         }
     }
 
@@ -117,8 +140,11 @@ impl Instance {
     pub fn video_filter_list_get(&self) -> Option<ModuleDescriptionList> {
         unsafe {
             let p = sys::libvlc_video_filter_list_get(self.ptr);
-            if p.is_null() { None }
+            if p.is_null() {
-            else { Some(ModuleDescriptionList{ptr: p}) }
+                None
+            } else {
+                Some(ModuleDescriptionList { ptr: p })
+            }
         }
     }
 
@@ -127,7 +153,10 @@ impl Instance {
         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,
+            }
         }
     }
 
@@ -156,14 +185,22 @@ impl Drop for Instance {
 
 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: *mut sys::__va_list_tag) {
+    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];
 
     sys::vsnprintf(buf.as_mut_ptr(), BUF_SIZE.try_into().unwrap(), fmt, args);
 
-    f((level as u32).into(), 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.
@@ -189,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,
+        }
     }
 }
 
@@ -315,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> {
@@ -324,8 +364,9 @@ pub struct EventManager<'a> {
 }
 
 impl<'a> EventManager<'a> {
-    pub fn attach<F>(&self, event_type: EventType, callback: F) -> Result<(), ()>
+    pub fn attach<F>(&self, event_type: EventType, callback: F) -> Result<(), InternalError>
-        where F: Fn(Event, VLCObject) + Send + 'static
+    where
+        F: Fn(Event, VLCObject) + Send + 'static,
     {
         // Explicit type annotation is needed
         let callback: Box<Box<dyn Fn(Event, VLCObject) + Send + 'static>> =
@@ -333,14 +374,17 @@ impl<'a> EventManager<'a> {
 
         let result = unsafe {
             sys::libvlc_event_attach(
-                self.ptr, event_type as i32, Some(event_manager_callback),
+                self.ptr,
-                Box::into_raw(callback) as *mut c_void)
+                event_type as i32,
+                Some(event_manager_callback),
+                Box::into_raw(callback) as *mut c_void,
+            )
         };
 
         if result == 0 {
             Ok(())
         } else {
-            Err(())
+            Err(InternalError)
         }
     }
 
@@ -361,193 +405,125 @@ fn conv_event(pe: *const sys::libvlc_event_t) -> Event {
     let event_type: EventType = (unsafe { (*pe).type_ } as u32).into();
 
     match event_type {
-        EventType::MediaMetaChanged => {
+        EventType::MediaMetaChanged => unsafe {
-            unsafe{
             Event::MediaMetaChanged((*pe).u.media_meta_changed.meta_type.into())
-            }
         },
-        EventType::MediaSubItemAdded => {
+        EventType::MediaSubItemAdded => Event::MediaSubItemAdded,
-            Event::MediaSubItemAdded
+        EventType::MediaDurationChanged => unsafe {
-        },
-        EventType::MediaDurationChanged => {
-            unsafe{
             Event::MediaDurationChanged((*pe).u.media_duration_changed.new_duration)
-            }
         },
-        EventType::MediaParsedChanged => {
+        EventType::MediaParsedChanged => unsafe {
-            unsafe{
             Event::MediaParsedChanged((*pe).u.media_parsed_changed.new_status)
-            }
         },
-        EventType::MediaFreed => {
+        EventType::MediaFreed => Event::MediaFreed,
-            Event::MediaFreed
+        EventType::MediaStateChanged => unsafe {
-        },
+            let new_state: sys::libvlc_state_t =
-        EventType::MediaStateChanged => {
+                (*pe).u.media_state_changed.new_state.try_into().unwrap();
-            unsafe{
-                let new_state: sys::libvlc_state_t = (*pe).u.media_state_changed.new_state.try_into().unwrap();
             Event::MediaStateChanged(new_state.into())
-            }
         },
-        EventType::MediaSubItemTreeAdded => {
+        EventType::MediaSubItemTreeAdded => Event::MediaSubItemTreeAdded,
-            Event::MediaSubItemTreeAdded
+        EventType::MediaPlayerMediaChanged => Event::MediaPlayerMediaChanged,
-        },
+        EventType::MediaPlayerNothingSpecial => Event::MediaPlayerNothingSpecial,
-        EventType::MediaPlayerMediaChanged => {
+        EventType::MediaPlayerOpening => Event::MediaPlayerOpening,
-            Event::MediaPlayerMediaChanged
+        EventType::MediaPlayerBuffering => unsafe {
-        },
-        EventType::MediaPlayerNothingSpecial => {
-            Event::MediaPlayerNothingSpecial
-        },
-        EventType::MediaPlayerOpening => {
-            Event::MediaPlayerOpening
-        },
-        EventType::MediaPlayerBuffering => {
-            unsafe{
             Event::MediaPlayerBuffering((*pe).u.media_player_buffering.new_cache)
-            }
         },
-        EventType::MediaPlayerPlaying => {
+        EventType::MediaPlayerPlaying => Event::MediaPlayerPlaying,
-            Event::MediaPlayerPlaying
+        EventType::MediaPlayerPaused => Event::MediaPlayerPaused,
-        },
+        EventType::MediaPlayerStopped => Event::MediaPlayerStopped,
-        EventType::MediaPlayerPaused => {
+        EventType::MediaPlayerForward => Event::MediaPlayerForward,
-            Event::MediaPlayerPaused
+        EventType::MediaPlayerBackward => Event::MediaPlayerBackward,
-        },
+        EventType::MediaPlayerEndReached => Event::MediaPlayerEndReached,
-        EventType::MediaPlayerStopped => {
+        EventType::MediaPlayerEncounteredError => Event::MediaPlayerEncounteredError,
-            Event::MediaPlayerStopped
+        EventType::MediaPlayerTimeChanged => Event::MediaPlayerTimeChanged,
-        },
+        EventType::MediaPlayerPositionChanged => unsafe {
-        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::MediaPlayerSeekableChanged => {
+        EventType::MediaPlayerSeekableChanged => Event::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::MediaPlayerPausableChanged => {
+        EventType::VlmMediaRemoved => unsafe {
-            Event::MediaPlayerPausableChanged
+            Event::VlmMediaRemoved(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerTitleChanged => {
+        EventType::VlmMediaChanged => unsafe {
-            Event::MediaPlayerTitleChanged
+            Event::VlmMediaChanged(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerSnapshotTaken => {
+        EventType::VlmMediaInstanceStarted => unsafe {
-            Event::MediaPlayerSnapshotTaken
+            Event::VlmMediaInstanceStarted(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerLengthChanged => {
+        EventType::VlmMediaInstanceStopped => unsafe {
-            Event::MediaPlayerLengthChanged
+            Event::VlmMediaInstanceStopped(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerVout => {
+        EventType::VlmMediaInstanceStatusInit => unsafe {
-            Event::MediaPlayerVout
+            Event::VlmMediaInstanceStatusInit(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaPlayerScrambledChanged => {
+        EventType::VlmMediaInstanceStatusOpening => unsafe {
-            Event::MediaPlayerScrambledChanged
+            Event::VlmMediaInstanceStatusOpening(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaListItemAdded => {
+        EventType::VlmMediaInstanceStatusPlaying => unsafe {
-            Event::MediaListItemAdded
+            Event::VlmMediaInstanceStatusPlaying(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaListWillAddItem => {
+        EventType::VlmMediaInstanceStatusPause => unsafe {
-            Event::MediaListWillAddItem
+            Event::VlmMediaInstanceStatusPause(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaListItemDeleted => {
+        EventType::VlmMediaInstanceStatusEnd => unsafe {
-            Event::MediaListItemDeleted
+            Event::VlmMediaInstanceStatusEnd(
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
+            )
         },
-        EventType::MediaListWillDeleteItem => {
+        EventType::VlmMediaInstanceStatusError => unsafe {
-            Event::MediaListWillDeleteItem
+            Event::VlmMediaInstanceStatusError(
-        },
+                from_cstr((*pe).u.vlm_media_event.psz_instance_name),
-        EventType::MediaListViewItemAdded => {
+                from_cstr((*pe).u.vlm_media_event.psz_media_name),
-            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))
-            }
         },
     }
 }
@@ -564,7 +540,7 @@ impl VLCObject {
 }
 
 pub struct Log {
-    pub(crate) ptr: *const sys::libvlc_log_t
+    pub(crate) ptr: *const sys::libvlc_log_t,
 }
 
 impl Log {
@@ -573,4 +549,3 @@ impl Log {
         self.ptr
     }
 }
-

src/lib.rs

@@ -4,23 +4,23 @@
 
 extern crate libc;
 
-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 vlc_sys as sys;
+use crate::enums::{Meta, State, TrackType};
-use crate::{Instance, EventManager};
+use crate::tools::{from_cstr, path_to_cstr, to_cstr};
-use crate::enums::{State, Meta, TrackType};
+use crate::{EventManager, Instance};
-use crate::tools::{to_cstr, from_cstr, path_to_cstr};
 use std::path::Path;
+use vlc_sys as sys;
 
 pub struct Media {
     pub(crate) ptr: *mut sys::libvlc_media_t,
@@ -33,7 +33,9 @@ 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 {
@@ -70,7 +72,10 @@ impl Media {
         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,
+            }
         }
     }
 
@@ -95,7 +100,7 @@ impl Media {
 
     /// 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.
@@ -105,10 +110,12 @@ impl Media {
 
     /// Get duration (in ms) of media descriptor object item.
     pub fn duration(&self) -> Option<i64> {
-        let time = unsafe{
+        let time = unsafe { sys::libvlc_media_get_duration(self.ptr) };
-            sys::libvlc_media_get_duration(self.ptr)
+        if time != -1 {
-        };
+            Some(time)
-        if time != -1 { Some(time) }else{ None }
+        } else {
+            None
+        }
     }
 
     /// Parse a media.
@@ -123,7 +130,7 @@ impl Media {
 
     /// 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>> {
@@ -146,7 +153,7 @@ impl Media {
                             channels: (*audio).i_channels,
                             rate: (*audio).i_rate,
                         })
-                    },
+                    }
                     TrackType::Video => {
                         let video = (**p).__bindgen_anon_1.video;
                         MediaTrackUnion::Video(VideoTrack {
@@ -157,13 +164,13 @@ impl Media {
                             frame_rate_num: (*video).i_frame_rate_num,
                             frame_rate_den: (*video).i_frame_rate_den,
                         })
-                    },
+                    }
                     TrackType::Text => {
                         let subtitle = (**p).__bindgen_anon_1.subtitle;
                         MediaTrackUnion::Subtitle(SubtitleTrack {
-                            encoding: from_cstr((*subtitle).psz_encoding)
+                            encoding: from_cstr((*subtitle).psz_encoding),
                         })
-                    },
+                    }
                     TrackType::Unknown => MediaTrackUnion::None,
                 };
                 track.push(MediaTrack {
@@ -176,7 +183,7 @@ impl Media {
                     bitrate: (**p).i_bitrate,
                     language: from_cstr((**p).psz_language),
                     description: from_cstr((**p).psz_description),
-                    type_specific_data: type_specific_data,
+                    type_specific_data,
                 });
             }
 
@@ -213,7 +220,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)]
@@ -236,4 +246,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::{Instance, InternalError, MediaList};
 use vlc_sys as sys;
-use crate::{Instance, MediaList};
 
 pub struct MediaLibrary {
     pub(crate) ptr: *mut sys::libvlc_media_library_t,
@@ -14,14 +14,22 @@ impl MediaLibrary {
     pub fn new(instance: &Instance) -> Option<MediaLibrary> {
         unsafe {
             let p = sys::libvlc_media_library_new(instance.ptr);
-            if p.is_null() { None }else{ Some(MediaLibrary{ptr: p}) }
+            if p.is_null() {
+                None
+            } else {
+                Some(MediaLibrary { ptr: p })
+            }
         }
     }
 
     /// Load media library.
-    pub fn load(&self) -> Result<(), ()> {
+    pub fn load(&self) -> Result<(), InternalError> {
         unsafe {
-            if sys::libvlc_media_library_load(self.ptr) == 0 { Ok(()) }else{ Err(()) }
+            if sys::libvlc_media_library_load(self.ptr) == 0 {
+                Ok(())
+            } else {
+                Err(InternalError)
+            }
         }
     }
 
@@ -29,7 +37,11 @@ impl MediaLibrary {
     pub fn media_list(&self) -> Option<MediaList> {
         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 })
+            }
         }
     }
 

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::{EventManager, Instance, InternalError, Media};
 use vlc_sys as sys;
-use crate::{Instance, Media, EventManager};
 
 pub struct MediaList {
     pub(crate) ptr: *mut sys::libvlc_media_list_t,
@@ -14,14 +14,20 @@ impl MediaList {
     pub fn new(instance: &Instance) -> Option<MediaList> {
         unsafe {
             let p = sys::libvlc_media_list_new(instance.ptr);
-            if p.is_null() { None }else{ Some(MediaList{ptr: p}) }
+            if p.is_null() {
+                None
+            } else {
+                Some(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.
@@ -29,31 +35,47 @@ impl MediaList {
     pub fn media(&self) -> Option<Media> {
         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<(), ()> {
+    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(()) }
+            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<(), ()> {
+    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(()) }
+            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<(), ()> {
+    pub fn remove_index(&self, pos: i32) -> Result<(), InternalError> {
         unsafe {
-            if sys::libvlc_media_list_remove_index(self.ptr, pos) == 0 { Ok(()) }else{ Err(()) }
+            if sys::libvlc_media_list_remove_index(self.ptr, pos) == 0 {
+                Ok(())
+            } else {
+                Err(InternalError)
+            }
         }
     }
 
@@ -68,7 +90,11 @@ impl MediaList {
     pub fn item_at_index(&self, pos: i32) -> Option<Media> {
         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 })
+            }
         }
     }
 
@@ -76,24 +102,32 @@ impl MediaList {
     pub fn index_of_item(&self, md: &Media) -> Option<i32> {
         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.
@@ -101,7 +135,10 @@ impl MediaList {
         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,
+            }
         }
     }
 

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 vlc_sys as sys;
+use crate::enums::{Position, State};
-use crate::Instance;
-use crate::Media;
 use crate::EventManager;
-use libc::{c_void, c_uint};
+use crate::Instance;
-use crate::enums::{State, Position};
+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 {
@@ -22,13 +23,13 @@ impl MediaPlayer {
     pub fn new(instance: &Instance) -> Option<MediaPlayer> {
         unsafe {
             let p = sys::libvlc_media_player_new(instance.ptr);
-
             if p.is_null() {
-                return None;
+                None
-            }
+            } else {
                 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) {
@@ -50,25 +51,24 @@ impl MediaPlayer {
         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 {
+        unsafe { sys::libvlc_media_player_is_playing(self.ptr) != 0 }
-            false
-        }else{
-            true
-        }
     }
 
     /// Play
-    pub fn play(&self) -> Result<(), ()> {
+    pub fn play(&self) -> Result<(), InternalError> {
         if unsafe { sys::libvlc_media_player_play(self.ptr) } == 0 {
             Ok(())
         } else {
-            Err(())
+            Err(InternalError)
         }
     }
 
@@ -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>>)
+        drain: Option<Box<dyn Fn() + Send + 'static>>,
-        where F: Fn(*const c_void, u32, i64) + 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,8 +103,11 @@ impl MediaPlayer {
         let flag_drain = drain.is_some();
 
         let data = AudioCallbacksData {
-            play: Box::new(play), pause: pause, resume: resume,
+            play: Box::new(play),
-            flush: flush, drain: drain,
+            pause,
+            resume,
+            flush,
+            drain,
         };
         let data = Box::into_raw(Box::new(data));
 
@@ -111,23 +115,45 @@ impl MediaPlayer {
             sys::libvlc_audio_set_callbacks(
                 self.ptr,
                 Some(audio_cb_play),
-                if flag_pause {Some(audio_cb_pause)} else {None},
+                if flag_pause {
-                if flag_resume {Some(audio_cb_resume)} else {None},
+                    Some(audio_cb_pause)
-                if flag_flush {Some(audio_cb_flush)} else {None},
+                } else {
-                if flag_drain {Some(audio_cb_drain)} else {None},
+                    None
-                data as *mut c_void);
+                },
+                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) }
+        if nso.is_null() {
+            None
+        } else {
+            Some(nso)
+        }
     }
 
     /// Set an X Window System drawable where the media player should render its video output.
@@ -138,59 +164,87 @@ impl MediaPlayer {
     /// 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) }
+        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) }
+        if hwnd.is_null() {
+            None
+        } else {
+            Some(hwnd)
+        }
     }
 
     /// Get the current movie time (in ms).
     pub fn get_time(&self) -> Option<i64> {
         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 {
             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 {
             let c = sys::libvlc_media_player_get_chapter(self.ptr);
-            if c == -1 { None }else{ Some(c) }
+            if c == -1 {
+                None
+            } else {
+                Some(c)
+            }
         }
     }
 
@@ -198,36 +252,47 @@ impl MediaPlayer {
     pub fn chapter_count(&self) -> Option<i32> {
         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{
+        unsafe { sys::libvlc_media_player_will_play(self.ptr) != 0 }
-            let b = sys::libvlc_media_player_will_play(self.ptr);
-            if b == 0 { false }else{ true }
-        }
     }
 
     /// Get title chapter count.
     pub fn chapter_count_for_title(&self, title: i32) -> Option<i32> {
         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 {
             let t = sys::libvlc_media_player_get_title(self.ptr);
-            if t == -1 { None }else{ Some(t) }
+            if t == -1 {
+                None
+            } else {
+                Some(t)
+            }
         }
     }
 
@@ -235,18 +300,26 @@ impl MediaPlayer {
     pub fn title_count(&self) -> Option<i32> {
         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.
@@ -255,10 +328,10 @@ impl MediaPlayer {
     }
 
     /// Set movie play rate.
-    pub fn set_rate(&self, rate: f32) -> Result<(),()> {
+    pub fn set_rate(&self, rate: f32) -> Result<(), InternalError> {
         unsafe {
             if sys::libvlc_media_player_set_rate(self.ptr, rate) == -1 {
-                Err(())
+                Err(InternalError)
             } else {
                 Ok(())
             }
@@ -277,41 +350,38 @@ impl MediaPlayer {
 
     /// Is this media player seekable?
     pub fn is_seekable(&self) -> bool {
-        unsafe{
+        unsafe { sys::libvlc_media_player_is_seekable(self.ptr) != 0 }
-            let b = sys::libvlc_media_player_is_seekable(self.ptr);
-            if b == 0 { false }else{ true }
-        }
     }
 
     /// Can this media player be paused?
     pub fn can_pause(&self) -> bool {
-        unsafe{
+        unsafe { sys::libvlc_media_player_can_pause(self.ptr) != 0 }
-            let b = sys::libvlc_media_player_can_pause(self.ptr);
-            if b == 0 { false }else{ true }
-        }
     }
 
     /// Check if the current program is scrambled.
     pub fn program_scrambled(&self) -> bool {
-        unsafe{
+        unsafe { sys::libvlc_media_player_program_scrambled(self.ptr) != 0 }
-            let b = sys::libvlc_media_player_program_scrambled(self.ptr);
-            if b == 0 { false }else{ true }
-        }
     }
 
     /// 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 as i32, timeout); }
+        unsafe {
+            sys::libvlc_media_player_set_video_title_display(self.ptr, position as i32, timeout);
+        }
     }
 
     /// Returns raw pointer
@@ -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/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.

src/video.rs

@@ -2,12 +2,12 @@
 // This file is part of vlc-rs.
 // Licensed under the MIT license, see the LICENSE file.
 
-use vlc_sys as 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,26 +32,38 @@ 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 {
             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)> {
@@ -59,29 +71,43 @@ impl MediaPlayerVideoEx for MediaPlayer {
             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) }
     }
     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 {
             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 {
             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
         }
     }
@@ -97,12 +123,17 @@ impl MediaPlayerVideoEx for MediaPlayer {
     fn get_video_track_description(&self) -> Option<Vec<TrackDescription>> {
         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);
@@ -113,12 +144,16 @@ impl MediaPlayerVideoEx for MediaPlayer {
         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) }
     }
     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,34 +2,57 @@ use std::ffi::CString;
 use std::os::raw::c_char;
 use std::ptr;
 
-use vlc_sys as sys;
-use crate::Instance;
 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);
@@ -38,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()
+            opts_c = vec
-                .map(|x| CString::new(x).expect("Error: Unexpected null byte")).collect();
+                .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);
@@ -63,86 +117,125 @@ impl Vlm for Instance {
         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();
+                        .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 {
+        let result = unsafe { sys::libvlc_vlm_play_media(self.ptr, name.as_ptr()) };
-            sys::libvlc_vlm_play_media(self.ptr, name.as_ptr())
+        if result == 0 {
-        };
+            Ok(())
-        if result == 0 { Ok(()) } else { Err(()) }
+        } 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 {
+        let result = unsafe { sys::libvlc_vlm_pause_media(self.ptr, name.as_ptr()) };
-            sys::libvlc_vlm_pause_media(self.ptr, name.as_ptr())
+        if result == 0 {
-        };
+            Ok(())
-        if result == 0 { Ok(()) } else { Err(()) }
+        } 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 {
+        let result = unsafe { sys::libvlc_vlm_stop_media(self.ptr, name.as_ptr()) };
-            sys::libvlc_vlm_stop_media(self.ptr, name.as_ptr())
+        if result == 0 {
-        };
+            Ok(())
-        if result == 0 { Ok(()) } else { Err(()) }
+        } 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(()) }
+        // if result != -1f32 { Ok(result) } else { Err(()) }
-    }
+        if (result - -1f32).abs() < f32::EPSILON {
-
+            Err(InternalError)
-    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())
         } 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)
         }
     }
 }