kirbylife
/
vlc-rs
mirror of https://code.videolan.org/videolan/vlc-rs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename ffi module to sys

merge-requests/7/merge
T. Okubo 2018-02-27 22:52:21 +09:00
parent c4f08bb2cb
commit 3d029b0c37
9 changed files with 149 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/audio.rs
View File

@ -2,7 +2,7 @@
// This file is part of vlc-rs. // This file is part of vlc-rs.
// Licensed under the MIT license, see the LICENSE file. // Licensed under the MIT license, see the LICENSE file.
use ffi; use sys;
use ::MediaPlayer; use ::MediaPlayer;
use ::TrackDescription; use ::TrackDescription;
use ::tools::from_cstr; use ::tools::from_cstr;
@ -17,7 +17,7 @@ pub trait MediaPlayerAudioEx {
impl MediaPlayerAudioEx for MediaPlayer { impl MediaPlayerAudioEx for MediaPlayer {
fn get_mute(&self) -> Option<bool> { fn get_mute(&self) -> Option<bool> {
let r = unsafe{ ffi::libvlc_audio_get_mute(self.ptr) }; let r = unsafe{ sys::libvlc_audio_get_mute(self.ptr) };
if r == 0 { if r == 0 {
Some(false) Some(false)
@ -29,20 +29,20 @@ impl MediaPlayerAudioEx for MediaPlayer {
} }
fn set_mute(&self, status: bool) { fn set_mute(&self, status: bool) {
unsafe{ ffi::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 { fn get_volume(&self) -> i32 {
unsafe{ ffi::libvlc_audio_get_volume(self.ptr) } unsafe{ sys::libvlc_audio_get_volume(self.ptr) }
} }
fn set_volume(&self, volume: i32) -> Result<(), ()> { fn set_volume(&self, volume: i32) -> Result<(), ()> {
unsafe{ unsafe{
if ffi::libvlc_audio_set_volume(self.ptr, volume) == 0 { Ok(()) }else{ Err(()) } if sys::libvlc_audio_set_volume(self.ptr, volume) == 0 { Ok(()) }else{ Err(()) }
} }
} }
fn get_audio_track_description(&self) -> Option<Vec<TrackDescription>> { fn get_audio_track_description(&self) -> Option<Vec<TrackDescription>> {
unsafe{ unsafe{
let p0 = ffi::libvlc_audio_get_track_description(self.ptr); 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 td = Vec::new();
let mut p = p0; let mut p = p0;
@ -51,7 +51,7 @@ impl MediaPlayerAudioEx for MediaPlayer {
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; p = (*p).p_next;
} }
ffi::libvlc_track_description_list_release(p0); sys::libvlc_track_description_list_release(p0);
Some(td) Some(td)
} }
} }

66
src/core.rs
View File

@ -5,7 +5,7 @@
use std::ptr::null; use std::ptr::null;
use std::borrow::Cow; use std::borrow::Cow;
use std::marker::PhantomData; use std::marker::PhantomData;
use ffi; use sys;
use ::tools::{to_cstr, from_cstr, from_cstr_ref}; use ::tools::{to_cstr, from_cstr, from_cstr_ref};
use ::libc::{c_void, c_char, c_int}; use ::libc::{c_void, c_char, c_int};
use ::enums::*; use ::enums::*;
@ -13,26 +13,26 @@ use ::enums::*;
/// Retrieve libvlc version. /// Retrieve libvlc version.
pub fn version() -> Cow<'static, str> { pub fn version() -> Cow<'static, str> {
unsafe{ unsafe{
from_cstr_ref(ffi::libvlc_get_version()).unwrap() from_cstr_ref(sys::libvlc_get_version()).unwrap()
} }
} }
/// Retrieve libvlc compiler version. /// Retrieve libvlc compiler version.
pub fn compiler() -> Cow<'static, str> { pub fn compiler() -> Cow<'static, str> {
unsafe{ unsafe{
from_cstr_ref(ffi::libvlc_get_compiler()).unwrap() from_cstr_ref(sys::libvlc_get_compiler()).unwrap()
} }
} }
pub struct Instance { pub struct Instance {
pub ptr: *mut ffi::libvlc_instance_t, pub ptr: *mut sys::libvlc_instance_t,
} }
impl Instance { impl Instance {
/// Create and initialize a libvlc instance. /// Create and initialize a libvlc instance.
pub fn new() -> Option<Instance> { pub fn new() -> Option<Instance> {
unsafe{ unsafe{
let p = ffi::libvlc_new(0, null()); let p = sys::libvlc_new(0, null());
if p.is_null() { if p.is_null() {
return None; return None;
@ -47,7 +47,7 @@ impl Instance {
let cstr = to_cstr(name); let cstr = to_cstr(name);
let result = unsafe{ let result = unsafe{
ffi::libvlc_add_intf(self.ptr, cstr.as_ptr()) sys::libvlc_add_intf(self.ptr, cstr.as_ptr())
}; };
if result == 0 { Ok(()) } if result == 0 { Ok(()) }
@ -58,20 +58,20 @@ impl Instance {
/// LibVLC passes this as the user agent string when a protocol requires it. /// LibVLC passes this as the user agent string when a protocol requires it.
pub fn set_user_agent(&self, name: &str, http: &str) { pub fn set_user_agent(&self, name: &str, http: &str) {
unsafe{ unsafe{
ffi::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());
} }
} }
/// Waits until an interface causes the instance to exit. /// Waits until an interface causes the instance to exit.
pub fn wait(&self) { pub fn wait(&self) {
unsafe{ ffi::libvlc_wait(self.ptr) }; unsafe{ sys::libvlc_wait(self.ptr) };
} }
/// Sets some meta-information about the application. /// Sets some meta-information about the application.
pub fn set_app_id(&self, id: &str, version: &str, icon: &str) { pub fn set_app_id(&self, id: &str, version: &str, icon: &str) {
unsafe{ unsafe{
ffi::libvlc_set_app_id( 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());
} }
} }
@ -79,7 +79,7 @@ impl Instance {
/// Returns a list of audio filters that are available. /// Returns a list of audio filters that are available.
pub fn audio_filter_list_get(&self) -> Option<ModuleDescriptionList> { pub fn audio_filter_list_get(&self) -> Option<ModuleDescriptionList> {
unsafe{ unsafe{
let p = ffi::libvlc_audio_filter_list_get(self.ptr); let p = sys::libvlc_audio_filter_list_get(self.ptr);
if p.is_null() { None } if p.is_null() { None }
else { Some(ModuleDescriptionList{ptr: p}) } else { Some(ModuleDescriptionList{ptr: p}) }
} }
@ -88,7 +88,7 @@ impl Instance {
/// Returns a list of video filters that are available. /// Returns a list of video filters that are available.
pub fn video_filter_list_get(&self) -> Option<ModuleDescriptionList> { pub fn video_filter_list_get(&self) -> Option<ModuleDescriptionList> {
unsafe{ unsafe{
let p = ffi::libvlc_video_filter_list_get(self.ptr); let p = sys::libvlc_video_filter_list_get(self.ptr);
if p.is_null() { None } if p.is_null() { None }
else { Some(ModuleDescriptionList{ptr: p}) } else { Some(ModuleDescriptionList{ptr: p}) }
} }
@ -99,7 +99,7 @@ impl Instance {
let cb: Box<Box<Fn(LogLevel, Log, Cow<str>) + Send + 'static>> = Box::new(Box::new(f)); let cb: Box<Box<Fn(LogLevel, Log, Cow<str>) + Send + 'static>> = Box::new(Box::new(f));
unsafe{ unsafe{
ffi::libvlc_log_set(self.ptr, logging_cb, Box::into_raw(cb) as *mut _); sys::libvlc_log_set(self.ptr, logging_cb, Box::into_raw(cb) as *mut _);
} }
} }
} }
@ -107,17 +107,17 @@ impl Instance {
impl Drop for Instance { impl Drop for Instance {
fn drop(&mut self) { fn drop(&mut self) {
unsafe{ unsafe{
ffi::libvlc_release(self.ptr); sys::libvlc_release(self.ptr);
} }
} }
} }
extern "C" { extern "C" {
fn vsnprintf(s: *mut c_char, n: usize, fmt: *const c_char, arg: ffi::va_list); 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. const BUF_SIZE: usize = 1024; // Write log message to the buffer by vsnprintf.
unsafe extern "C" fn logging_cb( unsafe extern "C" fn logging_cb(
data: *mut c_void, level: c_int, ctx: *const ffi::libvlc_log_t, fmt: *const c_char, args: ffi::va_list) { data: *mut c_void, level: c_int, ctx: *const sys::libvlc_log_t, fmt: *const c_char, args: sys::va_list) {
let f: &Box<Fn(LogLevel, Log, Cow<str>) + Send + 'static> = ::std::mem::transmute(data); let f: &Box<Fn(LogLevel, Log, Cow<str>) + Send + 'static> = ::std::mem::transmute(data);
let mut buf: [c_char; BUF_SIZE] = [0; BUF_SIZE]; let mut buf: [c_char; BUF_SIZE] = [0; BUF_SIZE];
@ -129,12 +129,12 @@ unsafe extern "C" fn logging_cb(
/// List of module description. /// List of module description.
pub struct ModuleDescriptionList { pub struct ModuleDescriptionList {
ptr: *mut ffi::libvlc_module_description_t, ptr: *mut sys::libvlc_module_description_t,
} }
impl Drop for ModuleDescriptionList { impl Drop for ModuleDescriptionList {
fn drop(&mut self) { fn drop(&mut self) {
unsafe{ ffi::libvlc_module_description_list_release(self.ptr) }; unsafe{ sys::libvlc_module_description_list_release(self.ptr) };
} }
} }
@ -148,8 +148,8 @@ impl<'a> IntoIterator for &'a ModuleDescriptionList {
} }
pub struct ModuleDescriptionListIter<'a> { pub struct ModuleDescriptionListIter<'a> {
ptr: *mut ffi::libvlc_module_description_t, ptr: *mut sys::libvlc_module_description_t,
_phantomdata: PhantomData<&'a ffi::libvlc_module_description_t>, _phantomdata: PhantomData<&'a sys::libvlc_module_description_t>,
} }
/// Description of a module. /// Description of a module.
@ -204,11 +204,11 @@ impl<'a> ModuleDescriptionRef<'a> {
} }
pub fn errmsg() -> Option<String> { pub fn errmsg() -> Option<String> {
unsafe{ from_cstr(ffi::libvlc_errmsg()) } unsafe{ from_cstr(sys::libvlc_errmsg()) }
} }
pub fn clearerr() { pub fn clearerr() {
unsafe{ ffi::libvlc_clearerr() }; unsafe{ sys::libvlc_clearerr() };
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -273,8 +273,8 @@ pub enum Event {
} }
pub struct EventManager<'a> { pub struct EventManager<'a> {
pub ptr: *mut ffi::libvlc_event_manager_t, pub ptr: *mut sys::libvlc_event_manager_t,
pub _phantomdata: ::std::marker::PhantomData<&'a ffi::libvlc_event_manager_t>, pub _phantomdata: ::std::marker::PhantomData<&'a sys::libvlc_event_manager_t>,
} }
impl<'a> EventManager<'a> { impl<'a> EventManager<'a> {
@ -286,7 +286,7 @@ impl<'a> EventManager<'a> {
Box::new(Box::new(callback)); Box::new(Box::new(callback));
let result = unsafe{ let result = unsafe{
ffi::libvlc_event_attach( sys::libvlc_event_attach(
self.ptr, event_type as i32, event_manager_callback, self.ptr, event_type as i32, event_manager_callback,
Box::into_raw(callback) as *mut c_void) Box::into_raw(callback) as *mut c_void)
}; };
@ -299,20 +299,20 @@ impl<'a> EventManager<'a> {
} }
} }
unsafe extern "C" fn event_manager_callback(pe: *const ffi::libvlc_event_t, data: *mut c_void) { unsafe extern "C" fn event_manager_callback(pe: *const sys::libvlc_event_t, data: *mut c_void) {
let f: &Box<Fn(Event, VLCObject) + Send + 'static> = ::std::mem::transmute(data); let f: &Box<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 // Convert c-style libvlc_event_t to Event
fn conv_event(pe: *const ffi::libvlc_event_t) -> 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{ ::std::mem::transmute((*pe)._type) };
match event_type { match event_type {
EventType::MediaMetaChanged => { EventType::MediaMetaChanged => {
unsafe{ unsafe{
let p = ffi::libvlc_event_t_union::get_media_meta_changed(pe); let p = sys::libvlc_event_t_union::get_media_meta_changed(pe);
Event::MediaMetaChanged((*p).meta_type) Event::MediaMetaChanged((*p).meta_type)
} }
}, },
@ -321,13 +321,13 @@ fn conv_event(pe: *const ffi::libvlc_event_t) -> Event {
}, },
EventType::MediaDurationChanged => { EventType::MediaDurationChanged => {
unsafe{ unsafe{
let p = ffi::libvlc_event_t_union::get_media_duration_changed(pe); let p = sys::libvlc_event_t_union::get_media_duration_changed(pe);
Event::MediaDurationChanged((*p).new_duration) Event::MediaDurationChanged((*p).new_duration)
} }
}, },
EventType::MediaParsedChanged => { EventType::MediaParsedChanged => {
unsafe{ unsafe{
let p = ffi::libvlc_event_t_union::get_media_parsed_changed(pe); let p = sys::libvlc_event_t_union::get_media_parsed_changed(pe);
Event::MediaParsedChanged((*p).new_status) Event::MediaParsedChanged((*p).new_status)
} }
}, },
@ -336,7 +336,7 @@ fn conv_event(pe: *const ffi::libvlc_event_t) -> Event {
}, },
EventType::MediaStateChanged => { EventType::MediaStateChanged => {
unsafe{ unsafe{
let p = ffi::libvlc_event_t_union::get_media_state_changed(pe); let p = sys::libvlc_event_t_union::get_media_state_changed(pe);
Event::MediaStateChanged((*p).new_state) Event::MediaStateChanged((*p).new_state)
} }
}, },
@ -354,7 +354,7 @@ fn conv_event(pe: *const ffi::libvlc_event_t) -> Event {
}, },
EventType::MediaPlayerBuffering => { EventType::MediaPlayerBuffering => {
unsafe{ unsafe{
let p = ffi::libvlc_event_t_union::get_media_player_buffering(pe); let p = sys::libvlc_event_t_union::get_media_player_buffering(pe);
Event::MediaPlayerBuffering((*p).new_cache) Event::MediaPlayerBuffering((*p).new_cache)
} }
}, },
@ -384,7 +384,7 @@ fn conv_event(pe: *const ffi::libvlc_event_t) -> Event {
}, },
EventType::MediaPlayerPositionChanged => { EventType::MediaPlayerPositionChanged => {
unsafe{ unsafe{
let p = ffi::libvlc_event_t_union::get_media_player_position_changed(pe); let p = sys::libvlc_event_t_union::get_media_player_position_changed(pe);
Event::MediaPlayerPositionChanged((*p).new_position) Event::MediaPlayerPositionChanged((*p).new_position)
} }
}, },
@ -489,6 +489,6 @@ pub struct VLCObject {
} }
pub struct Log { pub struct Log {
pub ptr: *const ffi::libvlc_log_t pub ptr: *const sys::libvlc_log_t
} }

2
src/lib.rs
View File

@ -4,7 +4,7 @@
extern crate libc; extern crate libc;
pub mod ffi; pub mod sys;
mod tools; mod tools;
mod core; mod core;

42
src/media.rs
View File

@ -2,14 +2,14 @@
// This file is part of vlc-rs. // This file is part of vlc-rs.
// Licensed under the MIT license, see the LICENSE file. // Licensed under the MIT license, see the LICENSE file.
use ffi; use sys;
use ::{Instance, EventManager}; use ::{Instance, EventManager};
use ::enums::{State, Meta, TrackType}; use ::enums::{State, Meta, TrackType};
use ::tools::{to_cstr, from_cstr, path_to_cstr}; use ::tools::{to_cstr, from_cstr, path_to_cstr};
use std::path::Path; use std::path::Path;
pub struct Media { pub struct Media {
pub ptr: *mut ffi::libvlc_media_t, pub ptr: *mut sys::libvlc_media_t,
} }
impl Media { impl Media {
@ -18,7 +18,7 @@ impl Media {
let cstr = to_cstr(mrl); let cstr = to_cstr(mrl);
unsafe{ unsafe{
let p = ffi::libvlc_media_new_location(instance.ptr, cstr.as_ptr()); let p = sys::libvlc_media_new_location(instance.ptr, cstr.as_ptr());
if p.is_null() { if p.is_null() {
return None; return None;
} }
@ -35,7 +35,7 @@ impl Media {
}; };
unsafe{ unsafe{
let p = ffi::libvlc_media_new_path(instance.ptr, cstr.as_ptr()); let p = sys::libvlc_media_new_path(instance.ptr, cstr.as_ptr());
if p.is_null() { if p.is_null() {
return None; return None;
} }
@ -46,7 +46,7 @@ impl Media {
pub fn new_fd(instance: &Instance, fd: i32) -> Option<Media> { pub fn new_fd(instance: &Instance, fd: i32) -> Option<Media> {
unsafe{ unsafe{
let p = ffi::libvlc_media_new_fd(instance.ptr, fd); let p = sys::libvlc_media_new_fd(instance.ptr, fd);
if p.is_null() { if p.is_null() {
return None; return None;
} }
@ -57,16 +57,16 @@ impl Media {
pub fn mrl(&self) -> Option<String> { pub fn mrl(&self) -> Option<String> {
unsafe{ unsafe{
let p_str = ffi::libvlc_media_get_mrl(self.ptr); let p_str = sys::libvlc_media_get_mrl(self.ptr);
let s = from_cstr(p_str); let s = from_cstr(p_str);
ffi::libvlc_free(p_str as *mut ::libc::c_void); sys::libvlc_free(p_str as *mut ::libc::c_void);
s s
} }
} }
pub fn event_manager<'a>(&'a self) -> EventManager<'a> { pub fn event_manager<'a>(&'a self) -> EventManager<'a> {
unsafe{ unsafe{
let p = ffi::libvlc_media_event_manager(self.ptr); let p = sys::libvlc_media_event_manager(self.ptr);
assert!(!p.is_null()); assert!(!p.is_null());
EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData} EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData}
} }
@ -76,9 +76,9 @@ impl Media {
/// If the media has not yet been parsed this will return None. /// If the media has not yet been parsed this will return None.
pub fn get_meta(&self, meta: Meta) -> Option<String> { pub fn get_meta(&self, meta: Meta) -> Option<String> {
unsafe{ unsafe{
let p_str = ffi::libvlc_media_get_meta(self.ptr, meta); let p_str = sys::libvlc_media_get_meta(self.ptr, meta);
let s = from_cstr(p_str); let s = from_cstr(p_str);
ffi::libvlc_free(p_str as *mut ::libc::c_void); sys::libvlc_free(p_str as *mut ::libc::c_void);
s s
} }
} }
@ -87,47 +87,47 @@ impl Media {
/// (This function will not save the meta, call save_meta in order to save the meta) /// (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) { pub fn set_meta(&self, meta: Meta, value: &str) {
unsafe{ unsafe{
ffi::libvlc_media_set_meta(self.ptr, meta, to_cstr(value).as_ptr()); sys::libvlc_media_set_meta(self.ptr, meta, to_cstr(value).as_ptr());
} }
} }
/// Save the meta previously set. /// Save the meta previously set.
pub fn save_meta(&self) -> bool { pub fn save_meta(&self) -> bool {
if unsafe{ ffi::libvlc_media_save_meta(self.ptr) } == 0 { false }else{ true } if unsafe{ sys::libvlc_media_save_meta(self.ptr) } == 0 { false }else{ true }
} }
/// Get current state of media descriptor object. /// Get current state of media descriptor object.
pub fn state(&self) -> State { pub fn state(&self) -> State {
unsafe{ ffi::libvlc_media_get_state(self.ptr) } unsafe{ sys::libvlc_media_get_state(self.ptr) }
} }
/// Get duration (in ms) of media descriptor object item. /// Get duration (in ms) of media descriptor object item.
pub fn duration(&self) -> Option<i64> { pub fn duration(&self) -> Option<i64> {
let time = unsafe{ let time = unsafe{
ffi::libvlc_media_get_duration(self.ptr) sys::libvlc_media_get_duration(self.ptr)
}; };
if time != -1 { Some(time) }else{ None } if time != -1 { Some(time) }else{ None }
} }
/// Parse a media. /// Parse a media.
pub fn parse(&self) { pub fn parse(&self) {
unsafe{ ffi::libvlc_media_parse(self.ptr) }; unsafe{ sys::libvlc_media_parse(self.ptr) };
} }
/// Parse a media. /// Parse a media.
pub fn parse_async(&self) { pub fn parse_async(&self) {
unsafe{ ffi::libvlc_media_parse_async(self.ptr) }; unsafe{ sys::libvlc_media_parse_async(self.ptr) };
} }
/// Get Parsed status for media descriptor object. /// Get Parsed status for media descriptor object.
pub fn is_parsed(&self) -> bool { pub fn is_parsed(&self) -> bool {
if unsafe{ ffi::libvlc_media_is_parsed(self.ptr) } == 0 { false }else{ true } if unsafe{ sys::libvlc_media_is_parsed(self.ptr) } == 0 { false }else{ true }
} }
pub fn tracks(&self) -> Option<Vec<MediaTrack>> { pub fn tracks(&self) -> Option<Vec<MediaTrack>> {
unsafe{ unsafe{
let mut p_track: *mut *mut ffi::libvlc_media_track_t = ::std::ptr::null_mut(); let mut p_track: *mut *mut sys::libvlc_media_track_t = ::std::ptr::null_mut();
let n = ffi::libvlc_media_tracks_get(self.ptr, &mut p_track); let n = sys::libvlc_media_tracks_get(self.ptr, &mut p_track);
if n == 0 { if n == 0 {
return None; return None;
} }
@ -177,7 +177,7 @@ impl Media {
}); });
} }
ffi::libvlc_media_tracks_release(p_track, n); sys::libvlc_media_tracks_release(p_track, n);
Some(track) Some(track)
} }
} }
@ -185,7 +185,7 @@ impl Media {
impl Drop for Media { impl Drop for Media {
fn drop(&mut self) { fn drop(&mut self) {
unsafe{ ffi::libvlc_media_release(self.ptr) }; unsafe{ sys::libvlc_media_release(self.ptr) };
} }
} }

12
src/media_library.rs
View File

@ -2,18 +2,18 @@
// This file is part of vlc-rs. // This file is part of vlc-rs.
// Licensed under the MIT license, see the LICENSE file. // Licensed under the MIT license, see the LICENSE file.
use ffi; use sys;
use ::{Instance, MediaList}; use ::{Instance, MediaList};
pub struct MediaLibrary { pub struct MediaLibrary {
pub ptr: *mut ffi::libvlc_media_library_t, pub ptr: *mut sys::libvlc_media_library_t,
} }
impl MediaLibrary { impl MediaLibrary {
/// Create an new Media Library object. /// Create an new Media Library object.
pub fn new(instance: &Instance) -> Option<MediaLibrary> { pub fn new(instance: &Instance) -> Option<MediaLibrary> {
unsafe{ unsafe{
let p = ffi::libvlc_media_library_new(instance.ptr); 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}) }
} }
} }
@ -21,14 +21,14 @@ impl MediaLibrary {
/// Load media library. /// Load media library.
pub fn load(&self) -> Result<(), ()> { pub fn load(&self) -> Result<(), ()> {
unsafe{ unsafe{
if ffi::libvlc_media_library_load(self.ptr) == 0 { Ok(()) }else{ Err(()) } if sys::libvlc_media_library_load(self.ptr) == 0 { Ok(()) }else{ Err(()) }
} }
} }
/// Get media library subitems. /// Get media library subitems.
pub fn media_list(&self) -> Option<MediaList> { pub fn media_list(&self) -> Option<MediaList> {
unsafe{ unsafe{
let p = ffi::libvlc_media_library_media_list(self.ptr); 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}) }
} }
} }
@ -36,6 +36,6 @@ impl MediaLibrary {
impl Drop for MediaLibrary { impl Drop for MediaLibrary {
fn drop(&mut self) { fn drop(&mut self) {
unsafe{ ffi::libvlc_media_library_release(self.ptr) }; unsafe{ sys::libvlc_media_library_release(self.ptr) };
} }
} }

32
src/media_list.rs
View File

@ -2,18 +2,18 @@
// This file is part of vlc-rs. // This file is part of vlc-rs.
// Licensed under the MIT license, see the LICENSE file. // Licensed under the MIT license, see the LICENSE file.
use ffi; use sys;
use ::{Instance, Media, EventManager}; use ::{Instance, Media, EventManager};
pub struct MediaList { pub struct MediaList {
pub ptr: *mut ffi::libvlc_media_list_t, pub ptr: *mut sys::libvlc_media_list_t,
} }
impl MediaList { impl MediaList {
/// Create an empty media list. /// Create an empty media list.
pub fn new(instance: &Instance) -> Option<MediaList> { pub fn new(instance: &Instance) -> Option<MediaList> {
unsafe{ unsafe{
let p = ffi::libvlc_media_list_new(instance.ptr); 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}) }
} }
} }
@ -21,14 +21,14 @@ impl MediaList {
/// Associate media instance with this media list instance. /// 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. /// 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) { pub fn set_media(&self, md: &Media) {
unsafe{ ffi::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. /// Get media instance from this media list instance.
/// The MediaList::lock should NOT be held upon entering this function. /// The MediaList::lock should NOT be held upon entering this function.
pub fn media(&self) -> Option<Media> { pub fn media(&self) -> Option<Media> {
unsafe{ unsafe{
let p = ffi::libvlc_media_list_media(self.ptr); 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}) }
} }
} }
@ -37,7 +37,7 @@ impl MediaList {
/// The MediaList::lock should be held upon entering this function. /// 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<(), ()> {
unsafe{ unsafe{
if ffi::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(()) }
} }
} }
@ -45,7 +45,7 @@ impl MediaList {
/// The MediaList::lock should be held upon entering this function. /// 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<(), ()> {
unsafe{ unsafe{
if ffi::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(()) }
} }
} }
@ -53,21 +53,21 @@ impl MediaList {
/// The MediaList::lock should be held upon entering this function. /// 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<(), ()> {
unsafe{ unsafe{
if ffi::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(()) }
} }
} }
/// Get count on media list items. /// Get count on media list items.
/// The MediaList::lock should be held upon entering this function. /// The MediaList::lock should be held upon entering this function.
pub fn count(&self) -> i32 { pub fn count(&self) -> i32 {
unsafe{ ffi::libvlc_media_list_count(self.ptr) } unsafe{ sys::libvlc_media_list_count(self.ptr) }
} }
/// List media instance in media list at a position. /// List media instance in media list at a position.
/// The MediaList::lock should be held upon entering this function. /// The MediaList::lock should be held upon entering this function.
pub fn item_at_index(&self, pos: i32) -> Option<Media> { pub fn item_at_index(&self, pos: i32) -> Option<Media> {
unsafe{ unsafe{
let p = ffi::libvlc_media_list_item_at_index(self.ptr, pos); 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}) }
} }
} }
@ -75,31 +75,31 @@ impl MediaList {
/// Find index position of List media instance in media list. /// Find index position of List media instance in media list.
pub fn index_of_item(&self, md: &Media) -> Option<i32> { pub fn index_of_item(&self, md: &Media) -> Option<i32> {
unsafe{ unsafe{
let i = ffi::libvlc_media_list_index_of_item(self.ptr, md.ptr); 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. /// This indicates if this media list is read-only from a user point of view.
pub fn is_readonly(&self) -> bool { pub fn is_readonly(&self) -> bool {
unsafe{ if ffi::libvlc_media_list_is_readonly(self.ptr) == 0 { false }else{ true } } unsafe{ if sys::libvlc_media_list_is_readonly(self.ptr) == 0 { false }else{ true } }
} }
/// Get lock on media list items /// Get lock on media list items
pub fn lock(&self) { pub fn lock(&self) {
unsafe{ ffi::libvlc_media_list_lock(self.ptr); } unsafe{ sys::libvlc_media_list_lock(self.ptr); }
} }
/// Release lock on media list items /// Release lock on media list items
/// The libvlc_media_list_lock should be held upon entering this function. /// The libvlc_media_list_lock should be held upon entering this function.
pub fn unlock(&self) { pub fn unlock(&self) {
unsafe{ ffi::libvlc_media_list_unlock(self.ptr); } unsafe{ sys::libvlc_media_list_unlock(self.ptr); }
} }
/// Get EventManager from this media list instance. /// Get EventManager from this media list instance.
pub fn event_manager<'a>(&'a self) -> EventManager<'a> { pub fn event_manager<'a>(&'a self) -> EventManager<'a> {
unsafe{ unsafe{
let p = ffi::libvlc_media_list_event_manager(self.ptr); let p = sys::libvlc_media_list_event_manager(self.ptr);
assert!(!p.is_null()); assert!(!p.is_null());
EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData} EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData}
} }
@ -108,6 +108,6 @@ impl MediaList {
impl Drop for MediaList { impl Drop for MediaList {
fn drop(&mut self) { fn drop(&mut self) {
unsafe{ ffi::libvlc_media_list_release(self.ptr) }; unsafe{ sys::libvlc_media_list_release(self.ptr) };
} }
} }

86
src/media_player.rs
View File

@ -2,7 +2,7 @@
// This file is part of vlc-rs. // This file is part of vlc-rs.
// Licensed under the MIT license, see the LICENSE file. // Licensed under the MIT license, see the LICENSE file.
use ffi; use sys;
use ::Instance; use ::Instance;
use ::Media; use ::Media;
use ::EventManager; use ::EventManager;
@ -12,14 +12,14 @@ use std::mem::transmute;
/// A LibVLC media player plays one media (usually in a custom drawable). /// A LibVLC media player plays one media (usually in a custom drawable).
pub struct MediaPlayer { pub struct MediaPlayer {
pub ptr: *mut ffi::libvlc_media_player_t, pub ptr: *mut sys::libvlc_media_player_t,
} }
impl MediaPlayer { impl MediaPlayer {
/// Create an empty Media Player object /// Create an empty Media Player object
pub fn new(instance: &Instance) -> Option<MediaPlayer> { pub fn new(instance: &Instance) -> Option<MediaPlayer> {
unsafe{ unsafe{
let p = ffi::libvlc_media_player_new(instance.ptr); let p = sys::libvlc_media_player_new(instance.ptr);
if p.is_null() { if p.is_null() {
return None; return None;
@ -30,12 +30,12 @@ impl MediaPlayer {
/// Set the media that will be used by the media_player. If any, previous md will be released. /// 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) { pub fn set_media(&self, md: &Media) {
unsafe{ ffi::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. /// Get the media used by the media_player.
pub fn get_media(&self) -> Option<Media> { pub fn get_media(&self) -> Option<Media> {
let p = unsafe{ ffi::libvlc_media_player_get_media(self.ptr) }; let p = unsafe{ sys::libvlc_media_player_get_media(self.ptr) };
if p.is_null() { if p.is_null() {
None None
}else{ }else{
@ -46,7 +46,7 @@ impl MediaPlayer {
/// Get the Event Manager from which the media player send event. /// Get the Event Manager from which the media player send event.
pub fn event_manager<'a>(&'a self) -> EventManager<'a> { pub fn event_manager<'a>(&'a self) -> EventManager<'a> {
unsafe{ unsafe{
let p = ffi::libvlc_media_player_event_manager(self.ptr); let p = sys::libvlc_media_player_event_manager(self.ptr);
assert!(!p.is_null()); assert!(!p.is_null());
EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData} EventManager{ptr: p, _phantomdata: ::std::marker::PhantomData}
} }
@ -54,7 +54,7 @@ impl MediaPlayer {
/// is_playing /// is_playing
pub fn is_playing(&self) -> bool { pub fn is_playing(&self) -> bool {
if unsafe{ ffi::libvlc_media_player_is_playing(self.ptr) } == 0 { if unsafe{ sys::libvlc_media_player_is_playing(self.ptr) } == 0 {
false false
}else{ }else{
true true
@ -63,7 +63,7 @@ impl MediaPlayer {
/// Play /// Play
pub fn play(&self) -> Result<(), ()> { pub fn play(&self) -> Result<(), ()> {
if unsafe{ ffi::libvlc_media_player_play(self.ptr) } == 0 { if unsafe{ sys::libvlc_media_player_play(self.ptr) } == 0 {
Ok(()) Ok(())
}else{ }else{
Err(()) Err(())
@ -72,17 +72,17 @@ impl MediaPlayer {
/// Pause or resume (no effect if there is no media) /// Pause or resume (no effect if there is no media)
pub fn set_pause(&self, do_pause: bool) { pub fn set_pause(&self, do_pause: bool) {
unsafe{ ffi::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) /// Toggle pause (no effect if there is no media)
pub fn pause(&self) { pub fn pause(&self) {
unsafe{ ffi::libvlc_media_player_pause(self.ptr) }; unsafe{ sys::libvlc_media_player_pause(self.ptr) };
} }
/// Stop (no effect if there is no media) /// Stop (no effect if there is no media)
pub fn stop(&self) { pub fn stop(&self) {
unsafe{ ffi::libvlc_media_player_stop(self.ptr) }; unsafe{ sys::libvlc_media_player_stop(self.ptr) };
} }
pub fn set_callbacks<F>( pub fn set_callbacks<F>(
@ -106,7 +106,7 @@ impl MediaPlayer {
let data = Box::into_raw(Box::new(data)); let data = Box::into_raw(Box::new(data));
unsafe{ unsafe{
ffi::libvlc_audio_set_callbacks( sys::libvlc_audio_set_callbacks(
self.ptr, self.ptr,
Some(audio_cb_play), Some(audio_cb_play),
if flag_pause {Some(audio_cb_pause)} else {None}, if flag_pause {Some(audio_cb_pause)} else {None},
@ -119,42 +119,42 @@ impl MediaPlayer {
/// Set the NSView handler where the media player should render its video output. /// Set the NSView handler where the media player should render its video output.
pub fn set_nsobject(&self, drawable: *mut c_void) { pub fn set_nsobject(&self, drawable: *mut c_void) {
unsafe{ ffi::libvlc_media_player_set_nsobject(self.ptr, drawable) }; unsafe{ sys::libvlc_media_player_set_nsobject(self.ptr, drawable) };
} }
/// Get the NSView handler previously set with set_nsobject(). /// Get the NSView handler previously set with set_nsobject().
pub fn get_nsobject(&self) -> Option<*mut c_void> { pub fn get_nsobject(&self) -> Option<*mut c_void> {
let nso = unsafe{ ffi::libvlc_media_player_get_nsobject(self.ptr) }; 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. /// Set an X Window System drawable where the media player should render its video output.
pub fn set_xwindow(&self, drawable: u32) { pub fn set_xwindow(&self, drawable: u32) {
unsafe{ ffi::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(). /// Get the X Window System window identifier previously set with set_xwindow().
pub fn get_xwindow(&self) -> Option<u32> { pub fn get_xwindow(&self) -> Option<u32> {
let id = unsafe{ ffi::libvlc_media_player_get_xwindow(self.ptr) }; 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. /// 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. /// If LibVLC was built without Win32/Win64 API output support, then this has no effects.
pub fn set_hwnd(&self, drawable: *mut c_void) { pub fn set_hwnd(&self, drawable: *mut c_void) {
unsafe{ ffi::libvlc_media_player_set_hwnd(self.ptr, drawable) }; unsafe{ sys::libvlc_media_player_set_hwnd(self.ptr, drawable) };
} }
/// Get the Windows API window handle (HWND) previously set with set_hwnd(). /// Get the Windows API window handle (HWND) previously set with set_hwnd().
pub fn get_hwnd(&self) -> Option<*mut c_void> { pub fn get_hwnd(&self) -> Option<*mut c_void> {
let hwnd = unsafe{ ffi::libvlc_media_player_get_hwnd(self.ptr) }; 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). /// Get the current movie time (in ms).
pub fn get_time(&self) -> Option<i64> { pub fn get_time(&self) -> Option<i64> {
unsafe{ unsafe{
let t = ffi::libvlc_media_player_get_time(self.ptr); let t = sys::libvlc_media_player_get_time(self.ptr);
if t == -1 { None }else{ Some(t) } if t == -1 { None }else{ Some(t) }
} }
} }
@ -162,13 +162,13 @@ impl MediaPlayer {
/// Set the movie time (in ms). /// Set the movie time (in ms).
/// This has no effect if no media is being played. Not all formats and protocols support this. /// This has no effect if no media is being played. Not all formats and protocols support this.
pub fn set_time(&self, time: i64) { pub fn set_time(&self, time: i64) {
unsafe{ ffi::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. /// Get movie position as percentage between 0.0 and 1.0.
pub fn get_position(&self) -> Option<f32> { pub fn get_position(&self) -> Option<f32> {
unsafe{ unsafe{
let pos = ffi::libvlc_media_player_get_position(self.ptr); let pos = sys::libvlc_media_player_get_position(self.ptr);
if pos == -1f32 { None }else{ Some(pos) } if pos == -1f32 { None }else{ Some(pos) }
} }
} }
@ -176,18 +176,18 @@ impl MediaPlayer {
/// Set movie position as percentage between 0.0 and 1.0. /// 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. /// 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) { pub fn set_position(&self, pos: f32) {
unsafe{ ffi::libvlc_media_player_set_position(self.ptr, pos); } unsafe{ sys::libvlc_media_player_set_position(self.ptr, pos); }
} }
/// Set movie chapter (if applicable). /// Set movie chapter (if applicable).
pub fn set_chapter(&self, chapter: i32) { pub fn set_chapter(&self, chapter: i32) {
unsafe{ ffi::libvlc_media_player_set_chapter(self.ptr, chapter); } unsafe{ sys::libvlc_media_player_set_chapter(self.ptr, chapter); }
} }
/// Get movie chapter. /// Get movie chapter.
pub fn get_chapter(&self) -> Option<i32> { pub fn get_chapter(&self) -> Option<i32> {
unsafe{ unsafe{
let c = ffi::libvlc_media_player_get_chapter(self.ptr); let c = sys::libvlc_media_player_get_chapter(self.ptr);
if c == -1 { None }else{ Some(c) } if c == -1 { None }else{ Some(c) }
} }
} }
@ -195,7 +195,7 @@ impl MediaPlayer {
/// Get movie chapter count. /// Get movie chapter count.
pub fn chapter_count(&self) -> Option<i32> { pub fn chapter_count(&self) -> Option<i32> {
unsafe{ unsafe{
let c = ffi::libvlc_media_player_get_chapter_count(self.ptr); 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) }
} }
} }
@ -203,7 +203,7 @@ impl MediaPlayer {
/// Is the player able to play. /// Is the player able to play.
pub fn will_play(&self) -> bool { pub fn will_play(&self) -> bool {
unsafe{ unsafe{
let b = ffi::libvlc_media_player_will_play(self.ptr); let b = sys::libvlc_media_player_will_play(self.ptr);
if b == 0 { false }else{ true } if b == 0 { false }else{ true }
} }
} }
@ -211,20 +211,20 @@ impl MediaPlayer {
/// Get title chapter count. /// Get title chapter count.
pub fn chapter_count_for_title(&self, title: i32) -> Option<i32> { pub fn chapter_count_for_title(&self, title: i32) -> Option<i32> {
unsafe{ unsafe{
let c = ffi::libvlc_media_player_get_chapter_count_for_title(self.ptr, title); 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. /// Set movie title.
pub fn set_title(&self, title: i32) { pub fn set_title(&self, title: i32) {
unsafe{ ffi::libvlc_media_player_set_title(self.ptr, title); } unsafe{ sys::libvlc_media_player_set_title(self.ptr, title); }
} }
/// Get movie title. /// Get movie title.
pub fn get_title(&self) -> Option<i32> { pub fn get_title(&self) -> Option<i32> {
unsafe{ unsafe{
let t = ffi::libvlc_media_player_get_title(self.ptr); let t = sys::libvlc_media_player_get_title(self.ptr);
if t == -1 { None }else{ Some(t) } if t == -1 { None }else{ Some(t) }
} }
} }
@ -232,30 +232,30 @@ impl MediaPlayer {
/// Get movie title count. /// Get movie title count.
pub fn title_count(&self) -> Option<i32> { pub fn title_count(&self) -> Option<i32> {
unsafe{ unsafe{
let t = ffi::libvlc_media_player_get_title_count(self.ptr); 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) /// Set previous chapter (if applicable)
pub fn previous_chapter(&self) { pub fn previous_chapter(&self) {
unsafe{ ffi::libvlc_media_player_previous_chapter(self.ptr); } unsafe{ sys::libvlc_media_player_previous_chapter(self.ptr); }
} }
/// Set next chapter (if applicable) /// Set next chapter (if applicable)
pub fn next_chapter(&self) { pub fn next_chapter(&self) {
unsafe{ ffi::libvlc_media_player_next_chapter(self.ptr); } unsafe{ sys::libvlc_media_player_next_chapter(self.ptr); }
} }
/// Get the requested movie play rate. /// Get the requested movie play rate.
pub fn get_rate(&self) -> f32 { pub fn get_rate(&self) -> f32 {
unsafe{ ffi::libvlc_media_player_get_rate(self.ptr) } unsafe{ sys::libvlc_media_player_get_rate(self.ptr) }
} }
/// Set movie play rate. /// Set movie play rate.
pub fn set_rate(&self, rate: f32) -> Result<(),()> { pub fn set_rate(&self, rate: f32) -> Result<(),()> {
unsafe{ unsafe{
if ffi::libvlc_media_player_set_rate(self.ptr, rate) == -1 { if sys::libvlc_media_player_set_rate(self.ptr, rate) == -1 {
Err(()) Err(())
}else{ }else{
Ok(()) Ok(())
@ -265,18 +265,18 @@ impl MediaPlayer {
/// Get current movie state. /// Get current movie state.
pub fn state(&self) -> State { pub fn state(&self) -> State {
unsafe{ ffi::libvlc_media_player_get_state(self.ptr) } unsafe{ sys::libvlc_media_player_get_state(self.ptr) }
} }
/// How many video outputs does this media player have? /// How many video outputs does this media player have?
pub fn has_vout(&self) -> u32 { pub fn has_vout(&self) -> u32 {
unsafe{ ffi::libvlc_media_player_has_vout(self.ptr) } unsafe{ sys::libvlc_media_player_has_vout(self.ptr) }
} }
/// Is this media player seekable? /// Is this media player seekable?
pub fn is_seekable(&self) -> bool { pub fn is_seekable(&self) -> bool {
unsafe{ unsafe{
let b = ffi::libvlc_media_player_is_seekable(self.ptr); let b = sys::libvlc_media_player_is_seekable(self.ptr);
if b == 0 { false }else{ true } if b == 0 { false }else{ true }
} }
} }
@ -284,7 +284,7 @@ impl MediaPlayer {
/// Can this media player be paused? /// Can this media player be paused?
pub fn can_pause(&self) -> bool { pub fn can_pause(&self) -> bool {
unsafe{ unsafe{
let b = ffi::libvlc_media_player_can_pause(self.ptr); let b = sys::libvlc_media_player_can_pause(self.ptr);
if b == 0 { false }else{ true } if b == 0 { false }else{ true }
} }
} }
@ -292,30 +292,30 @@ impl MediaPlayer {
/// Check if the current program is scrambled. /// Check if the current program is scrambled.
pub fn program_scrambled(&self) -> bool { pub fn program_scrambled(&self) -> bool {
unsafe{ unsafe{
let b = ffi::libvlc_media_player_program_scrambled(self.ptr); let b = sys::libvlc_media_player_program_scrambled(self.ptr);
if b == 0 { false }else{ true } if b == 0 { false }else{ true }
} }
} }
/// Display the next frame (if supported) /// Display the next frame (if supported)
pub fn next_frame(&self) { pub fn next_frame(&self) {
unsafe{ ffi::libvlc_media_player_next_frame(self.ptr); } unsafe{ sys::libvlc_media_player_next_frame(self.ptr); }
} }
/// Navigate through DVD Menu. /// Navigate through DVD Menu.
pub fn navigate(&self, navigate: u32) { pub fn navigate(&self, navigate: u32) {
unsafe{ ffi::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. /// 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) { pub fn set_video_title_display(&self, position: Position, timeout: u32) {
unsafe{ ffi::libvlc_media_player_set_video_title_display(self.ptr, position, timeout); } unsafe{ sys::libvlc_media_player_set_video_title_display(self.ptr, position, timeout); }
} }
} }
impl Drop for MediaPlayer { impl Drop for MediaPlayer {
fn drop(&mut self) { fn drop(&mut self) {
unsafe{ ffi::libvlc_media_player_release(self.ptr) }; unsafe{ sys::libvlc_media_player_release(self.ptr) };
} }
} }

0
src/ffi.rs → src/sys.rs
View File

44
src/video.rs
View File

@ -2,7 +2,7 @@
// This file is part of vlc-rs. // This file is part of vlc-rs.
// Licensed under the MIT license, see the LICENSE file. // Licensed under the MIT license, see the LICENSE file.
use ffi; use sys;
use ::MediaPlayer; use ::MediaPlayer;
use ::TrackDescription; use ::TrackDescription;
use ::enums::VideoAdjustOption; use ::enums::VideoAdjustOption;
@ -32,25 +32,25 @@ pub trait MediaPlayerVideoEx {
impl MediaPlayerVideoEx for MediaPlayer { impl MediaPlayerVideoEx for MediaPlayer {
fn toggle_fullscreen(&self) { fn toggle_fullscreen(&self) {
unsafe{ ffi::libvlc_toggle_fullscreen(self.ptr); } unsafe{ sys::libvlc_toggle_fullscreen(self.ptr); }
} }
fn set_fullscreen(&self, fullscreen: bool) { fn set_fullscreen(&self, fullscreen: bool) {
unsafe{ ffi::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 { fn get_fullscreen(&self) -> bool {
unsafe{ if ffi::libvlc_get_fullscreen(self.ptr) == 0 { false }else{ true } } unsafe{ if sys::libvlc_get_fullscreen(self.ptr) == 0 { false }else{ true } }
} }
fn set_key_input(&self, on: bool) { fn set_key_input(&self, on: bool) {
unsafe{ ffi::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) { fn set_mouse_input(&self, on: bool) {
unsafe{ ffi::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)> { fn get_size(&self, num: u32) -> Option<(u32, u32)> {
unsafe{ unsafe{
let mut x = 0; let mut x = 0;
let mut y = 0; let mut y = 0;
let res = ffi::libvlc_video_get_size(self.ptr, num, &mut x, &mut y); 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)) }
} }
} }
@ -58,45 +58,45 @@ impl MediaPlayerVideoEx for MediaPlayer {
unsafe{ unsafe{
let mut x = 0; let mut x = 0;
let mut y = 0; let mut y = 0;
let res = ffi::libvlc_video_get_cursor(self.ptr, num, &mut x, &mut y); 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 { fn get_scale(&self) -> f32 {
unsafe{ ffi::libvlc_video_get_scale(self.ptr) } unsafe{ sys::libvlc_video_get_scale(self.ptr) }
} }
fn set_scale(&self, factor: f32) { fn set_scale(&self, factor: f32) {
unsafe{ ffi::libvlc_video_set_scale(self.ptr, factor); } unsafe{ sys::libvlc_video_set_scale(self.ptr, factor); }
} }
fn get_video_track(&self) -> Option<i32> { fn get_video_track(&self) -> Option<i32> {
unsafe{ unsafe{
let track = ffi::libvlc_video_get_track(self.ptr); 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) { fn set_video_track(&self, track: i32) {
unsafe{ ffi::libvlc_video_set_track(self.ptr, track); } unsafe{ sys::libvlc_video_set_track(self.ptr, track); }
} }
fn get_aspect_ratio(&self) -> Option<String> { fn get_aspect_ratio(&self) -> Option<String> {
unsafe{ unsafe{
let p = ffi::libvlc_video_get_aspect_ratio(self.ptr); let p = sys::libvlc_video_get_aspect_ratio(self.ptr);
let s = from_cstr(p); let s = from_cstr(p);
if !p.is_null() { ffi::libvlc_free(p as *mut c_void); } if !p.is_null() { sys::libvlc_free(p as *mut c_void); }
s s
} }
} }
fn set_aspect_ratio(&self, aspect: Option<&str>) { fn set_aspect_ratio(&self, aspect: Option<&str>) {
unsafe{ unsafe{
if let Some(a) = aspect { if let Some(a) = aspect {
ffi::libvlc_video_set_aspect_ratio(self.ptr, to_cstr(a).as_ptr()); sys::libvlc_video_set_aspect_ratio(self.ptr, to_cstr(a).as_ptr());
}else{ }else{
ffi::libvlc_video_set_aspect_ratio(self.ptr, ::std::ptr::null()); sys::libvlc_video_set_aspect_ratio(self.ptr, ::std::ptr::null());
} }
} }
} }
fn get_video_track_description(&self) -> Option<Vec<TrackDescription>> { fn get_video_track_description(&self) -> Option<Vec<TrackDescription>> {
unsafe{ unsafe{
let p0 = ffi::libvlc_video_get_track_description(self.ptr); 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 td = Vec::new();
let mut p = p0; let mut p = p0;
@ -105,20 +105,20 @@ impl MediaPlayerVideoEx for MediaPlayer {
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; p = (*p).p_next;
} }
ffi::libvlc_track_description_list_release(p0); sys::libvlc_track_description_list_release(p0);
Some(td) Some(td)
} }
} }
fn get_adjust_int(&self, option: VideoAdjustOption) -> i32 { fn get_adjust_int(&self, option: VideoAdjustOption) -> i32 {
unsafe{ ffi::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) { fn set_adjust_int(&self, option: VideoAdjustOption, value: i32) {
unsafe{ ffi::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 { fn get_adjust_float(&self, option: VideoAdjustOption) -> f32 {
unsafe{ ffi::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) { fn set_adjust_float(&self, option: VideoAdjustOption, value: f32) {
unsafe{ ffi::libvlc_video_set_adjust_float(self.ptr, option as u32, value); } unsafe{ sys::libvlc_video_set_adjust_float(self.ptr, option as u32, value); }
} }
} }