mirrors/gst-plugins-rs
mirrors/gst-plugins-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git synced 2024-11-25 21:11:00 +00:00
Code Issues Projects Releases Wiki Activity

Rename used crates (gst -> gst_ffi, etc) and import gstreamer code

Browse source
This commit is contained in:
Sebastian Dröge 2017-07-31 23:26:52 +01:00
parent 6f04ddf797
commit dd5af12ebe
17 changed files with 532 additions and 530 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
gst-plugin/Cargo.toml
View file

@ -14,11 +14,13 @@ slog = { version = "2.0", features = ["max_level_trace"] }
lazy_static = "0.2" lazy_static = "0.2"
byteorder = "1.0" byteorder = "1.0"
num-rational = { version = "0.1", default-features = false, features = [] } num-rational = { version = "0.1", default-features = false, features = [] }
glib-sys = "0.3.4"
gobject-sys = "0.3.4"
gstreamer-sys = { version = "0.1.1", features = ["v1_10"] }
gstreamer-base-sys = { version = "0.1.1", features = ["v1_10"] }
derivative = "1.0" derivative = "1.0"
glib-sys = { version = "0.3.4", git = "https://github.com/gtk-rs/sys" }
gobject-sys = { version = "0.3.4", git = "https://github.com/gtk-rs/sys" }
gstreamer-sys = { version = "0.1.1", git = "https://github.com/sdroege/gstreamer-sys", features = ["v1_10"] }
gstreamer-base-sys = { version = "0.1.1", git = "https://github.com/sdroege/gstreamer-sys", features = ["v1_10"] }
glib = { version = "0.1.3", git = "https://github.com/gtk-rs/glib" }
gstreamer = { version = "0.1.0", git = "https://github.com/sdroege/gstreamer-rs", features = ["v1_10"] }
[build-dependencies] [build-dependencies]
gcc = "0.3" gcc = "0.3"

4
gst-plugin/src/adapter.rs
View file

@ -256,11 +256,11 @@ impl Adapter {
mod tests { mod tests {
use super::*; use super::*;
use std::ptr; use std::ptr;
use gst; use gst_ffi;
fn init() { fn init() {
unsafe { unsafe {
gst::gst_init(ptr::null_mut(), ptr::null_mut()); gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut());
} }
} }

90
gst-plugin/src/buffer.rs
View file

@ -15,17 +15,17 @@ use std::usize;
use miniobject::*; use miniobject::*;
use glib; use glib_ffi;
use gst; use gst_ffi;
pub struct Buffer(gst::GstBuffer); pub struct Buffer(gst_ffi::GstBuffer);
#[derive(Derivative)] #[derive(Derivative)]
#[derivative(Debug)] #[derivative(Debug)]
pub struct ReadBufferMap<'a> { pub struct ReadBufferMap<'a> {
buffer: &'a Buffer, buffer: &'a Buffer,
#[derivative(Debug = "ignore")] #[derivative(Debug = "ignore")]
map_info: gst::GstMapInfo, map_info: gst_ffi::GstMapInfo,
} }
#[derive(Derivative)] #[derive(Derivative)]
@ -33,7 +33,7 @@ pub struct ReadBufferMap<'a> {
pub struct ReadWriteBufferMap<'a> { pub struct ReadWriteBufferMap<'a> {
buffer: &'a Buffer, buffer: &'a Buffer,
#[derivative(Debug = "ignore")] #[derivative(Debug = "ignore")]
map_info: gst::GstMapInfo, map_info: gst_ffi::GstMapInfo,
} }
#[derive(Derivative)] #[derive(Derivative)]
@ -41,7 +41,7 @@ pub struct ReadWriteBufferMap<'a> {
pub struct ReadMappedBuffer { pub struct ReadMappedBuffer {
buffer: GstRc<Buffer>, buffer: GstRc<Buffer>,
#[derivative(Debug = "ignore")] #[derivative(Debug = "ignore")]
map_info: gst::GstMapInfo, map_info: gst_ffi::GstMapInfo,
} }
#[derive(Derivative)] #[derive(Derivative)]
@ -49,20 +49,20 @@ pub struct ReadMappedBuffer {
pub struct ReadWriteMappedBuffer { pub struct ReadWriteMappedBuffer {
buffer: GstRc<Buffer>, buffer: GstRc<Buffer>,
#[derivative(Debug = "ignore")] #[derivative(Debug = "ignore")]
map_info: gst::GstMapInfo, map_info: gst_ffi::GstMapInfo,
} }
unsafe impl MiniObject for Buffer { unsafe impl MiniObject for Buffer {
type PtrType = gst::GstBuffer; type PtrType = gst_ffi::GstBuffer;
} }
impl Buffer { impl Buffer {
pub fn new() -> GstRc<Buffer> { pub fn new() -> GstRc<Buffer> {
unsafe { GstRc::from_owned_ptr(gst::gst_buffer_new()) } unsafe { GstRc::from_owned_ptr(gst_ffi::gst_buffer_new()) }
} }
pub fn new_with_size(size: usize) -> Option<GstRc<Buffer>> { pub fn new_with_size(size: usize) -> Option<GstRc<Buffer>> {
let raw = unsafe { gst::gst_buffer_new_allocate(ptr::null_mut(), size, ptr::null_mut()) }; let raw = unsafe { gst_ffi::gst_buffer_new_allocate(ptr::null_mut(), size, ptr::null_mut()) };
if raw.is_null() { if raw.is_null() {
None None
} else { } else {
@ -70,7 +70,7 @@ impl Buffer {
} }
} }
unsafe extern "C" fn vec_drop(vec: glib::gpointer) { unsafe extern "C" fn vec_drop(vec: glib_ffi::gpointer) {
let vec: Box<Vec<u8>> = Box::from_raw(vec as *mut Vec<u8>); let vec: Box<Vec<u8>> = Box::from_raw(vec as *mut Vec<u8>);
drop(vec); drop(vec);
} }
@ -82,13 +82,13 @@ impl Buffer {
let size = vec.len(); let size = vec.len();
let data = vec.as_mut_ptr(); let data = vec.as_mut_ptr();
let user_data = Box::into_raw(vec); let user_data = Box::into_raw(vec);
gst::gst_buffer_new_wrapped_full( gst_ffi::gst_buffer_new_wrapped_full(
gst::GstMemoryFlags::empty(), gst_ffi::GstMemoryFlags::empty(),
data as glib::gpointer, data as glib_ffi::gpointer,
maxsize, maxsize,
0, 0,
size, size,
user_data as glib::gpointer, user_data as glib_ffi::gpointer,
Some(Buffer::vec_drop), Some(Buffer::vec_drop),
) )
}; };
@ -101,15 +101,15 @@ impl Buffer {
} }
pub fn map_read(&self) -> Option<ReadBufferMap> { pub fn map_read(&self) -> Option<ReadBufferMap> {
let mut map_info: gst::GstMapInfo = unsafe { mem::zeroed() }; let mut map_info: gst_ffi::GstMapInfo = unsafe { mem::zeroed() };
let res = unsafe { let res = unsafe {
gst::gst_buffer_map( gst_ffi::gst_buffer_map(
self.as_mut_ptr() as *mut gst::GstBuffer, self.as_mut_ptr() as *mut gst_ffi::GstBuffer,
&mut map_info, &mut map_info,
gst::GST_MAP_READ, gst_ffi::GST_MAP_READ,
) )
}; };
if res == glib::GTRUE { if res == glib_ffi::GTRUE {
Some(ReadBufferMap { Some(ReadBufferMap {
buffer: self, buffer: self,
map_info: map_info, map_info: map_info,
@ -120,11 +120,11 @@ impl Buffer {
} }
pub fn map_readwrite(&mut self) -> Option<ReadWriteBufferMap> { pub fn map_readwrite(&mut self) -> Option<ReadWriteBufferMap> {
let mut map_info: gst::GstMapInfo = unsafe { mem::zeroed() }; let mut map_info: gst_ffi::GstMapInfo = unsafe { mem::zeroed() };
let res = unsafe { let res = unsafe {
gst::gst_buffer_map(self.as_mut_ptr(), &mut map_info, gst::GST_MAP_READWRITE) gst_ffi::gst_buffer_map(self.as_mut_ptr(), &mut map_info, gst_ffi::GST_MAP_READWRITE)
}; };
if res == glib::GTRUE { if res == glib_ffi::GTRUE {
Some(ReadWriteBufferMap { Some(ReadWriteBufferMap {
buffer: self, buffer: self,
map_info: map_info, map_info: map_info,
@ -135,10 +135,10 @@ impl Buffer {
} }
pub fn into_read_mapped_buffer(buffer: GstRc<Buffer>) -> Option<ReadMappedBuffer> { pub fn into_read_mapped_buffer(buffer: GstRc<Buffer>) -> Option<ReadMappedBuffer> {
let mut map_info: gst::GstMapInfo = unsafe { mem::zeroed() }; let mut map_info: gst_ffi::GstMapInfo = unsafe { mem::zeroed() };
let res = let res =
unsafe { gst::gst_buffer_map(buffer.as_mut_ptr(), &mut map_info, gst::GST_MAP_READ) }; unsafe { gst_ffi::gst_buffer_map(buffer.as_mut_ptr(), &mut map_info, gst_ffi::GST_MAP_READ) };
if res == glib::GTRUE { if res == glib_ffi::GTRUE {
Some(ReadMappedBuffer { Some(ReadMappedBuffer {
buffer: buffer, buffer: buffer,
map_info: map_info, map_info: map_info,
@ -149,11 +149,11 @@ impl Buffer {
} }
pub fn into_readwrite_mapped_buffer(buffer: GstRc<Buffer>) -> Option<ReadWriteMappedBuffer> { pub fn into_readwrite_mapped_buffer(buffer: GstRc<Buffer>) -> Option<ReadWriteMappedBuffer> {
let mut map_info: gst::GstMapInfo = unsafe { mem::zeroed() }; let mut map_info: gst_ffi::GstMapInfo = unsafe { mem::zeroed() };
let res = unsafe { let res = unsafe {
gst::gst_buffer_map(buffer.as_mut_ptr(), &mut map_info, gst::GST_MAP_READWRITE) gst_ffi::gst_buffer_map(buffer.as_mut_ptr(), &mut map_info, gst_ffi::GST_MAP_READWRITE)
}; };
if res == glib::GTRUE { if res == glib_ffi::GTRUE {
Some(ReadWriteMappedBuffer { Some(ReadWriteMappedBuffer {
buffer: buffer, buffer: buffer,
map_info: map_info, map_info: map_info,
@ -165,9 +165,9 @@ impl Buffer {
pub fn append(buffer: GstRc<Buffer>, other: GstRc<Buffer>) -> GstRc<Buffer> { pub fn append(buffer: GstRc<Buffer>, other: GstRc<Buffer>) -> GstRc<Buffer> {
unsafe { unsafe {
GstRc::from_owned_ptr(gst::gst_buffer_append( GstRc::from_owned_ptr(gst_ffi::gst_buffer_append(
buffer.into_ptr() as *mut gst::GstBuffer, buffer.into_ptr() as *mut gst_ffi::GstBuffer,
other.into_ptr() as *mut gst::GstBuffer, other.into_ptr() as *mut gst_ffi::GstBuffer,
)) ))
} }
} }
@ -176,9 +176,9 @@ impl Buffer {
let size_real = size.unwrap_or(usize::MAX); let size_real = size.unwrap_or(usize::MAX);
let raw = unsafe { let raw = unsafe {
gst::gst_buffer_copy_region( gst_ffi::gst_buffer_copy_region(
self.as_mut_ptr(), self.as_mut_ptr(),
gst::GST_BUFFER_COPY_ALL, gst_ffi::GST_BUFFER_COPY_ALL,
offset, offset,
size_real, size_real,
) )
@ -199,7 +199,7 @@ impl Buffer {
let copied = unsafe { let copied = unsafe {
let src = slice.as_ptr(); let src = slice.as_ptr();
gst::gst_buffer_fill(self.as_mut_ptr(), offset, src as glib::gconstpointer, size) gst_ffi::gst_buffer_fill(self.as_mut_ptr(), offset, src as glib_ffi::gconstpointer, size)
}; };
if copied == size { if copied == size {
@ -217,7 +217,7 @@ impl Buffer {
let copied = unsafe { let copied = unsafe {
let dest = slice.as_mut_ptr(); let dest = slice.as_mut_ptr();
gst::gst_buffer_extract(self.as_mut_ptr(), offset, dest as glib::gpointer, size) gst_ffi::gst_buffer_extract(self.as_mut_ptr(), offset, dest as glib_ffi::gpointer, size)
}; };
if copied == size { if copied == size {
@ -228,14 +228,14 @@ impl Buffer {
} }
pub fn get_size(&self) -> usize { pub fn get_size(&self) -> usize {
unsafe { gst::gst_buffer_get_size(self.as_mut_ptr()) } unsafe { gst_ffi::gst_buffer_get_size(self.as_mut_ptr()) }
} }
pub fn get_maxsize(&self) -> usize { pub fn get_maxsize(&self) -> usize {
let mut maxsize: usize = 0; let mut maxsize: usize = 0;
unsafe { unsafe {
gst::gst_buffer_get_sizes_range( gst_ffi::gst_buffer_get_sizes_range(
self.as_mut_ptr(), self.as_mut_ptr(),
0, 0,
-1, -1,
@ -251,7 +251,7 @@ impl Buffer {
assert!(self.get_maxsize() >= size); assert!(self.get_maxsize() >= size);
unsafe { unsafe {
gst::gst_buffer_set_size(self.as_mut_ptr(), size as isize); gst_ffi::gst_buffer_set_size(self.as_mut_ptr(), size as isize);
} }
} }
@ -391,7 +391,7 @@ impl<'a> ReadBufferMap<'a> {
impl<'a> Drop for ReadBufferMap<'a> { impl<'a> Drop for ReadBufferMap<'a> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gst::gst_buffer_unmap(self.buffer.as_mut_ptr(), &mut self.map_info); gst_ffi::gst_buffer_unmap(self.buffer.as_mut_ptr(), &mut self.map_info);
} }
} }
} }
@ -417,7 +417,7 @@ impl<'a> ReadWriteBufferMap<'a> {
impl<'a> Drop for ReadWriteBufferMap<'a> { impl<'a> Drop for ReadWriteBufferMap<'a> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gst::gst_buffer_unmap(self.buffer.as_mut_ptr(), &mut self.map_info); gst_ffi::gst_buffer_unmap(self.buffer.as_mut_ptr(), &mut self.map_info);
} }
} }
} }
@ -439,7 +439,7 @@ impl ReadMappedBuffer {
impl Drop for ReadMappedBuffer { impl Drop for ReadMappedBuffer {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gst::gst_buffer_unmap(self.buffer.as_mut_ptr(), &mut self.map_info); gst_ffi::gst_buffer_unmap(self.buffer.as_mut_ptr(), &mut self.map_info);
} }
} }
} }
@ -468,7 +468,7 @@ impl ReadWriteMappedBuffer {
impl Drop for ReadWriteMappedBuffer { impl Drop for ReadWriteMappedBuffer {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gst::gst_buffer_unmap(self.buffer.as_mut_ptr(), &mut self.map_info); gst_ffi::gst_buffer_unmap(self.buffer.as_mut_ptr(), &mut self.map_info);
} }
} }
} }
@ -476,7 +476,7 @@ impl Drop for ReadWriteMappedBuffer {
unsafe impl Sync for ReadWriteMappedBuffer {} unsafe impl Sync for ReadWriteMappedBuffer {}
unsafe impl Send for ReadWriteMappedBuffer {} unsafe impl Send for ReadWriteMappedBuffer {}
// FIXME: Duplicate of gst::GstBufferFlags with nicer naming // FIXME: Duplicate of gst_ffi::GstBufferFlags with nicer naming
bitflags! { bitflags! {
#[repr(C)] #[repr(C)]
pub struct BufferFlags: u32 { pub struct BufferFlags: u32 {
@ -502,7 +502,7 @@ mod tests {
fn init() { fn init() {
unsafe { unsafe {
gst::gst_init(ptr::null_mut(), ptr::null_mut()); gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut());
} }
} }

36
gst-plugin/src/caps.rs
View file

@ -13,33 +13,33 @@ use value::*;
use miniobject::*; use miniobject::*;
use structure::*; use structure::*;
use glib; use glib_ffi;
use gst; use gst_ffi;
#[repr(C)] #[repr(C)]
pub struct Caps(gst::GstCaps); pub struct Caps(gst_ffi::GstCaps);
unsafe impl MiniObject for Caps { unsafe impl MiniObject for Caps {
type PtrType = gst::GstCaps; type PtrType = gst_ffi::GstCaps;
} }
impl Caps { impl Caps {
pub fn new_empty() -> GstRc<Self> { pub fn new_empty() -> GstRc<Self> {
unsafe { GstRc::from_owned_ptr(gst::gst_caps_new_empty()) } unsafe { GstRc::from_owned_ptr(gst_ffi::gst_caps_new_empty()) }
} }
pub fn new_any() -> GstRc<Self> { pub fn new_any() -> GstRc<Self> {
unsafe { GstRc::from_owned_ptr(gst::gst_caps_new_any()) } unsafe { GstRc::from_owned_ptr(gst_ffi::gst_caps_new_any()) }
} }
pub fn new_simple(name: &str, values: &[(&str, Value)]) -> GstRc<Self> { pub fn new_simple(name: &str, values: &[(&str, Value)]) -> GstRc<Self> {
let mut caps = Caps::new_empty(); let mut caps = Caps::new_empty();
let name_cstr = CString::new(name).unwrap(); let name_cstr = CString::new(name).unwrap();
let structure = unsafe { gst::gst_structure_new_empty(name_cstr.as_ptr()) }; let structure = unsafe { gst_ffi::gst_structure_new_empty(name_cstr.as_ptr()) };
unsafe { unsafe {
gst::gst_caps_append_structure(caps.as_mut_ptr(), structure); gst_ffi::gst_caps_append_structure(caps.as_mut_ptr(), structure);
} }
caps.get_mut().unwrap().set_simple(values); caps.get_mut().unwrap().set_simple(values);
@ -51,7 +51,7 @@ impl Caps {
let value_cstr = CString::new(value).unwrap(); let value_cstr = CString::new(value).unwrap();
unsafe { unsafe {
let caps_ptr = gst::gst_caps_from_string(value_cstr.as_ptr()); let caps_ptr = gst_ffi::gst_caps_from_string(value_cstr.as_ptr());
if caps_ptr.is_null() { if caps_ptr.is_null() {
None None
@ -66,16 +66,16 @@ impl Caps {
let name_cstr = CString::new(value.0).unwrap(); let name_cstr = CString::new(value.0).unwrap();
unsafe { unsafe {
let gvalue = value.1.as_ptr(); let gvalue = value.1.as_ptr();
gst::gst_caps_set_value(self.as_mut_ptr(), name_cstr.as_ptr(), gvalue); gst_ffi::gst_caps_set_value(self.as_mut_ptr(), name_cstr.as_ptr(), gvalue);
} }
} }
} }
pub fn to_string(&self) -> String { pub fn to_string(&self) -> String {
unsafe { unsafe {
let ptr = gst::gst_caps_to_string(self.as_ptr()); let ptr = gst_ffi::gst_caps_to_string(self.as_ptr());
let s = CStr::from_ptr(ptr).to_str().unwrap().into(); let s = CStr::from_ptr(ptr).to_str().unwrap().into();
glib::g_free(ptr as glib::gpointer); glib_ffi::g_free(ptr as glib_ffi::gpointer);
s s
} }
@ -83,26 +83,26 @@ impl Caps {
pub fn get_structure(&self, idx: u32) -> Option<&Structure> { pub fn get_structure(&self, idx: u32) -> Option<&Structure> {
unsafe { unsafe {
let structure = gst::gst_caps_get_structure(self.as_ptr(), idx); let structure = gst_ffi::gst_caps_get_structure(self.as_ptr(), idx);
if structure.is_null() { if structure.is_null() {
return None; return None;
} }
Some(Structure::from_borrowed_ptr( Some(Structure::from_borrowed_ptr(
structure as *const gst::GstStructure, structure as *const gst_ffi::GstStructure,
)) ))
} }
} }
pub fn get_mut_structure(&mut self, idx: u32) -> Option<&mut Structure> { pub fn get_mut_structure(&mut self, idx: u32) -> Option<&mut Structure> {
unsafe { unsafe {
let structure = gst::gst_caps_get_structure(self.as_ptr(), idx); let structure = gst_ffi::gst_caps_get_structure(self.as_ptr(), idx);
if structure.is_null() { if structure.is_null() {
return None; return None;
} }
Some(Structure::from_borrowed_mut_ptr( Some(Structure::from_borrowed_mut_ptr(
structure as *mut gst::GstStructure, structure as *mut gst_ffi::GstStructure,
)) ))
} }
} }
@ -118,7 +118,7 @@ impl fmt::Debug for Caps {
impl PartialEq for Caps { impl PartialEq for Caps {
fn eq(&self, other: &Caps) -> bool { fn eq(&self, other: &Caps) -> bool {
(unsafe { gst::gst_caps_is_equal(self.as_ptr(), other.as_ptr()) } == glib::GTRUE) (unsafe { gst_ffi::gst_caps_is_equal(self.as_ptr(), other.as_ptr()) } == glib_ffi::GTRUE)
} }
} }
@ -142,7 +142,7 @@ mod tests {
fn init() { fn init() {
unsafe { unsafe {
gst::gst_init(ptr::null_mut(), ptr::null_mut()); gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut());
} }
} }

112
gst-plugin/src/demuxer.rs
View file

@ -28,8 +28,8 @@ use log::*;
use caps::Caps; use caps::Caps;
use plugin::Plugin; use plugin::Plugin;
use glib; use glib_ffi;
use gst; use gst_ffi;
pub type StreamIndex = u32; pub type StreamIndex = u32;
@ -94,14 +94,14 @@ impl Stream {
} }
pub struct DemuxerWrapper { pub struct DemuxerWrapper {
raw: *mut gst::GstElement, raw: *mut gst_ffi::GstElement,
logger: Logger, logger: Logger,
demuxer: Mutex<Box<Demuxer>>, demuxer: Mutex<Box<Demuxer>>,
panicked: AtomicBool, panicked: AtomicBool,
} }
impl DemuxerWrapper { impl DemuxerWrapper {
fn new(raw: *mut gst::GstElement, demuxer: Box<Demuxer>) -> DemuxerWrapper { fn new(raw: *mut gst_ffi::GstElement, demuxer: Box<Demuxer>) -> DemuxerWrapper {
DemuxerWrapper { DemuxerWrapper {
raw: raw, raw: raw,
logger: Logger::root( logger: Logger::root(
@ -175,44 +175,44 @@ impl DemuxerWrapper {
} }
fn get_position(&self, position: &mut u64) -> glib::gboolean { fn get_position(&self, position: &mut u64) -> glib_ffi::gboolean {
let demuxer = &self.demuxer.lock().unwrap(); let demuxer = &self.demuxer.lock().unwrap();
match demuxer.get_position() { match demuxer.get_position() {
None => { None => {
trace!(self.logger, "Got no position"); trace!(self.logger, "Got no position");
*position = u64::MAX; *position = u64::MAX;
glib::GFALSE glib_ffi::GFALSE
} }
Some(pos) => { Some(pos) => {
trace!(self.logger, "Returning position {}", pos); trace!(self.logger, "Returning position {}", pos);
*position = pos; *position = pos;
glib::GTRUE glib_ffi::GTRUE
} }
} }
} }
fn get_duration(&self, duration: &mut u64) -> glib::gboolean { fn get_duration(&self, duration: &mut u64) -> glib_ffi::gboolean {
let demuxer = &self.demuxer.lock().unwrap(); let demuxer = &self.demuxer.lock().unwrap();
match demuxer.get_duration() { match demuxer.get_duration() {
None => { None => {
trace!(self.logger, "Got no duration"); trace!(self.logger, "Got no duration");
*duration = u64::MAX; *duration = u64::MAX;
glib::GFALSE glib_ffi::GFALSE
} }
Some(dur) => { Some(dur) => {
trace!(self.logger, "Returning duration {}", dur); trace!(self.logger, "Returning duration {}", dur);
*duration = dur; *duration = dur;
glib::GTRUE glib_ffi::GTRUE
} }
} }
} }
fn seek(&self, start: u64, stop: u64, offset: &mut u64) -> bool { fn seek(&self, start: u64, stop: u64, offset: &mut u64) -> bool {
extern "C" { extern "C" {
fn gst_rs_demuxer_stream_eos(raw: *mut gst::GstElement, index: u32); fn gst_rs_demuxer_stream_eos(raw: *mut gst_ffi::GstElement, index: u32);
}; };
let stop = if stop == u64::MAX { None } else { Some(stop) }; let stop = if stop == u64::MAX { None } else { Some(stop) };
@ -255,27 +255,27 @@ impl DemuxerWrapper {
} }
} }
fn handle_buffer(&self, buffer: GstRc<Buffer>) -> gst::GstFlowReturn { fn handle_buffer(&self, buffer: GstRc<Buffer>) -> gst_ffi::GstFlowReturn {
extern "C" { extern "C" {
fn gst_rs_demuxer_stream_eos(raw: *mut gst::GstElement, index: u32); fn gst_rs_demuxer_stream_eos(raw: *mut gst_ffi::GstElement, index: u32);
fn gst_rs_demuxer_add_stream( fn gst_rs_demuxer_add_stream(
raw: *mut gst::GstElement, raw: *mut gst_ffi::GstElement,
index: u32, index: u32,
caps: *const gst::GstCaps, caps: *const gst_ffi::GstCaps,
stream_id: *const c_char, stream_id: *const c_char,
); );
fn gst_rs_demuxer_added_all_streams(raw: *mut gst::GstElement); fn gst_rs_demuxer_added_all_streams(raw: *mut gst_ffi::GstElement);
// fn gst_rs_demuxer_remove_all_streams(raw: *mut gst::GstElement); // fn gst_rs_demuxer_remove_all_streams(raw: *mut gst_ffi::GstElement);
fn gst_rs_demuxer_stream_format_changed( fn gst_rs_demuxer_stream_format_changed(
raw: *mut gst::GstElement, raw: *mut gst_ffi::GstElement,
index: u32, index: u32,
caps: *const gst::GstCaps, caps: *const gst_ffi::GstCaps,
); );
fn gst_rs_demuxer_stream_push_buffer( fn gst_rs_demuxer_stream_push_buffer(
raw: *mut gst::GstElement, raw: *mut gst_ffi::GstElement,
index: u32, index: u32,
buffer: *mut gst::GstBuffer, buffer: *mut gst_ffi::GstBuffer,
) -> gst::GstFlowReturn; ) -> gst_ffi::GstFlowReturn;
}; };
let mut res = { let mut res = {
@ -304,7 +304,7 @@ impl DemuxerWrapper {
match res { match res {
HandleBufferResult::NeedMoreData => { HandleBufferResult::NeedMoreData => {
return gst::GST_FLOW_OK; return gst_ffi::GST_FLOW_OK;
} }
HandleBufferResult::StreamAdded(stream) => { HandleBufferResult::StreamAdded(stream) => {
let stream_id_cstr = CString::new(stream.stream_id.as_bytes()).unwrap(); let stream_id_cstr = CString::new(stream.stream_id.as_bytes()).unwrap();
@ -342,10 +342,10 @@ impl DemuxerWrapper {
gst_rs_demuxer_stream_push_buffer( gst_rs_demuxer_stream_push_buffer(
self.raw, self.raw,
index, index,
buffer.into_ptr() as *mut gst::GstBuffer, buffer.into_ptr() as *mut gst_ffi::GstBuffer,
) )
}; };
if flow_ret != gst::GST_FLOW_OK { if flow_ret != gst_ffi::GST_FLOW_OK {
return flow_ret; return flow_ret;
} }
} }
@ -356,7 +356,7 @@ impl DemuxerWrapper {
gst_rs_demuxer_stream_eos(self.raw, index); gst_rs_demuxer_stream_eos(self.raw, index);
} }
return gst::GST_FLOW_EOS; return gst_ffi::GST_FLOW_EOS;
} }
HandleBufferResult::Again => { HandleBufferResult::Again => {
// nothing, just call again // nothing, just call again
@ -406,7 +406,7 @@ impl DemuxerWrapper {
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn demuxer_new( pub unsafe extern "C" fn demuxer_new(
demuxer: *mut gst::GstElement, demuxer: *mut gst_ffi::GstElement,
create_instance: fn(Element) -> Box<Demuxer>, create_instance: fn(Element) -> Box<Demuxer>,
) -> *mut DemuxerWrapper { ) -> *mut DemuxerWrapper {
let instance = create_instance(Element::new(demuxer)); let instance = create_instance(Element::new(demuxer));
@ -422,41 +422,41 @@ pub unsafe extern "C" fn demuxer_drop(ptr: *mut DemuxerWrapper) {
pub unsafe extern "C" fn demuxer_start( pub unsafe extern "C" fn demuxer_start(
ptr: *const DemuxerWrapper, ptr: *const DemuxerWrapper,
upstream_size: u64, upstream_size: u64,
random_access: glib::gboolean, random_access: glib_ffi::gboolean,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
let wrap: &DemuxerWrapper = &*ptr; let wrap: &DemuxerWrapper = &*ptr;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
if wrap.start(upstream_size, random_access != glib::GFALSE) { if wrap.start(upstream_size, random_access != glib_ffi::GFALSE) {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn demuxer_stop(ptr: *const DemuxerWrapper) -> glib::gboolean { pub unsafe extern "C" fn demuxer_stop(ptr: *const DemuxerWrapper) -> glib_ffi::gboolean {
let wrap: &DemuxerWrapper = &*ptr; let wrap: &DemuxerWrapper = &*ptr;
panic_to_error!(wrap, glib::GTRUE, { panic_to_error!(wrap, glib_ffi::GTRUE, {
if wrap.stop() { if wrap.stop() {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn demuxer_is_seekable(ptr: *const DemuxerWrapper) -> glib::gboolean { pub unsafe extern "C" fn demuxer_is_seekable(ptr: *const DemuxerWrapper) -> glib_ffi::gboolean {
let wrap: &DemuxerWrapper = &*ptr; let wrap: &DemuxerWrapper = &*ptr;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
if wrap.is_seekable() { if wrap.is_seekable() {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
@ -465,10 +465,10 @@ pub unsafe extern "C" fn demuxer_is_seekable(ptr: *const DemuxerWrapper) -> glib
pub unsafe extern "C" fn demuxer_get_position( pub unsafe extern "C" fn demuxer_get_position(
ptr: *const DemuxerWrapper, ptr: *const DemuxerWrapper,
position: *mut u64, position: *mut u64,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
let wrap: &DemuxerWrapper = &*ptr; let wrap: &DemuxerWrapper = &*ptr;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
let position = &mut *position; let position = &mut *position;
wrap.get_position(position) wrap.get_position(position)
}) })
@ -478,10 +478,10 @@ pub unsafe extern "C" fn demuxer_get_position(
pub unsafe extern "C" fn demuxer_get_duration( pub unsafe extern "C" fn demuxer_get_duration(
ptr: *const DemuxerWrapper, ptr: *const DemuxerWrapper,
duration: *mut u64, duration: *mut u64,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
let wrap: &DemuxerWrapper = &*ptr; let wrap: &DemuxerWrapper = &*ptr;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
let duration = &mut *duration; let duration = &mut *duration;
wrap.get_duration(duration) wrap.get_duration(duration)
}) })
@ -493,17 +493,17 @@ pub unsafe extern "C" fn demuxer_seek(
start: u64, start: u64,
stop: u64, stop: u64,
offset: *mut u64, offset: *mut u64,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
let wrap: &mut DemuxerWrapper = &mut *ptr; let wrap: &mut DemuxerWrapper = &mut *ptr;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
let offset = &mut *offset; let offset = &mut *offset;
if wrap.seek(start, stop, offset) { if wrap.seek(start, stop, offset) {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
@ -511,11 +511,11 @@ pub unsafe extern "C" fn demuxer_seek(
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn demuxer_handle_buffer( pub unsafe extern "C" fn demuxer_handle_buffer(
ptr: *mut DemuxerWrapper, ptr: *mut DemuxerWrapper,
buffer: *mut gst::GstBuffer, buffer: *mut gst_ffi::GstBuffer,
) -> gst::GstFlowReturn { ) -> gst_ffi::GstFlowReturn {
let wrap: &mut DemuxerWrapper = &mut *ptr; let wrap: &mut DemuxerWrapper = &mut *ptr;
panic_to_error!(wrap, gst::GST_FLOW_ERROR, { panic_to_error!(wrap, gst_ffi::GST_FLOW_ERROR, {
let buffer = GstRc::from_owned_ptr(buffer); let buffer = GstRc::from_owned_ptr(buffer);
wrap.handle_buffer(buffer) wrap.handle_buffer(buffer)
}) })
@ -545,7 +545,7 @@ pub struct DemuxerInfo<'a> {
pub fn demuxer_register(plugin: &Plugin, demuxer_info: &DemuxerInfo) { pub fn demuxer_register(plugin: &Plugin, demuxer_info: &DemuxerInfo) {
extern "C" { extern "C" {
fn gst_rs_demuxer_register( fn gst_rs_demuxer_register(
plugin: *const gst::GstPlugin, plugin: *const gst_ffi::GstPlugin,
name: *const c_char, name: *const c_char,
long_name: *const c_char, long_name: *const c_char,
description: *const c_char, description: *const c_char,
@ -553,9 +553,9 @@ pub fn demuxer_register(plugin: &Plugin, demuxer_info: &DemuxerInfo) {
author: *const c_char, author: *const c_char,
rank: i32, rank: i32,
create_instance: *const c_void, create_instance: *const c_void,
input_caps: *const gst::GstCaps, input_caps: *const gst_ffi::GstCaps,
output_caps: *const gst::GstCaps, output_caps: *const gst_ffi::GstCaps,
) -> glib::gboolean; ) -> glib_ffi::gboolean;
} }
let cname = CString::new(demuxer_info.name).unwrap(); let cname = CString::new(demuxer_info.name).unwrap();

42
gst-plugin/src/error.rs
View file

@ -16,8 +16,8 @@ use std::borrow::Cow;
use url::Url; use url::Url;
use glib; use glib_ffi;
use gst; use gst_ffi;
#[macro_export] #[macro_export]
macro_rules! error_msg( macro_rules! error_msg(
@ -61,12 +61,12 @@ pub trait ToGError {
fn to_gerror(&self) -> (u32, i32); fn to_gerror(&self) -> (u32, i32);
} }
pub fn gst_library_error_domain() -> glib::GQuark { pub fn gst_library_error_domain() -> glib_ffi::GQuark {
unsafe { gst::gst_library_error_quark() } unsafe { gst_ffi::gst_library_error_quark() }
} }
pub fn gst_resource_error_domain() -> glib::GQuark { pub fn gst_resource_error_domain() -> glib_ffi::GQuark {
unsafe { gst::gst_resource_error_quark() } unsafe { gst_ffi::gst_resource_error_quark() }
} }
#[derive(Debug)] #[derive(Debug)]
@ -103,7 +103,7 @@ impl ErrorMessage {
} }
pub unsafe fn post(&self, element: *mut gst::GstElement) { pub unsafe fn post(&self, element: *mut gst_ffi::GstElement) {
let ErrorMessage { let ErrorMessage {
error_domain, error_domain,
error_code, error_code,
@ -126,13 +126,13 @@ impl ErrorMessage {
let function_cstr = CString::new(function.as_bytes()).unwrap(); let function_cstr = CString::new(function.as_bytes()).unwrap();
let function_ptr = function_cstr.as_ptr(); let function_ptr = function_cstr.as_ptr();
gst::gst_element_message_full( gst_ffi::gst_element_message_full(
element, element,
gst::GST_MESSAGE_ERROR, gst_ffi::GST_MESSAGE_ERROR,
error_domain, error_domain,
error_code, error_code,
glib::g_strndup(message_ptr, message_len), glib_ffi::g_strndup(message_ptr, message_len),
glib::g_strndup(debug_ptr, debug_len), glib_ffi::g_strndup(debug_ptr, debug_len),
file_ptr, file_ptr,
function_ptr, function_ptr,
line as i32, line as i32,
@ -149,12 +149,12 @@ pub enum FlowError {
} }
impl FlowError { impl FlowError {
pub fn to_native(&self) -> gst::GstFlowReturn { pub fn to_native(&self) -> gst_ffi::GstFlowReturn {
match *self { match *self {
FlowError::Flushing => gst::GST_FLOW_FLUSHING, FlowError::Flushing => gst_ffi::GST_FLOW_FLUSHING,
FlowError::Eos => gst::GST_FLOW_EOS, FlowError::Eos => gst_ffi::GST_FLOW_EOS,
FlowError::NotNegotiated(..) => gst::GST_FLOW_NOT_NEGOTIATED, FlowError::NotNegotiated(..) => gst_ffi::GST_FLOW_NOT_NEGOTIATED,
FlowError::Error(..) => gst::GST_FLOW_ERROR, FlowError::Error(..) => gst_ffi::GST_FLOW_ERROR,
} }
} }
} }
@ -220,19 +220,19 @@ impl UriError {
&self.error_kind &self.error_kind
} }
pub unsafe fn into_gerror(self, err: *mut *mut glib::GError) { pub unsafe fn into_gerror(self, err: *mut *mut glib_ffi::GError) {
if let Some(msg) = self.message { if let Some(msg) = self.message {
let cmsg = CString::new(msg.as_str()).unwrap(); let cmsg = CString::new(msg.as_str()).unwrap();
glib::g_set_error_literal( glib_ffi::g_set_error_literal(
err, err,
gst::gst_uri_error_quark(), gst_ffi::gst_uri_error_quark(),
self.error_kind as i32, self.error_kind as i32,
cmsg.as_ptr(), cmsg.as_ptr(),
); );
} else { } else {
glib::g_set_error_literal( glib_ffi::g_set_error_literal(
err, err,
gst::gst_uri_error_quark(), gst_ffi::gst_uri_error_quark(),
self.error_kind as i32, self.error_kind as i32,
ptr::null(), ptr::null(),
); );

16
gst-plugin/src/lib.rs
View file

@ -19,10 +19,12 @@ extern crate byteorder;
extern crate num_rational; extern crate num_rational;
#[macro_use] #[macro_use]
extern crate derivative; extern crate derivative;
pub extern crate gobject_sys as gobject; pub extern crate gobject_sys as gobject_ffi;
pub extern crate glib_sys as glib; pub extern crate glib_sys as glib_ffi;
pub extern crate gstreamer_sys as gst; pub extern crate gstreamer_sys as gst_ffi;
pub extern crate gstreamer_base_sys as gst_base; pub extern crate gstreamer_base_sys as gst_base_ffi;
pub extern crate gstreamer as gst;
#[macro_use] #[macro_use]
pub mod utils; pub mod utils;
@ -45,7 +47,7 @@ pub mod miniobject;
pub mod structure; pub mod structure;
pub mod ffi { pub mod ffi {
pub use glib; pub use glib_ffi as glib;
pub use gobject; pub use gobject_ffi as gobject;
pub use gst; pub use gst_ffi as gst;
} }

36
gst-plugin/src/log.rs
View file

@ -15,12 +15,12 @@ use std::mem;
use utils::Element; use utils::Element;
use gobject; use gobject_ffi;
use gst; use gst_ffi;
pub struct GstDebugDrain { pub struct GstDebugDrain {
category: *mut gst::GstDebugCategory, category: *mut gst_ffi::GstDebugCategory,
element: Box<gobject::GWeakRef>, element: Box<gobject_ffi::GWeakRef>,
} }
impl GstDebugDrain { impl GstDebugDrain {
@ -35,7 +35,7 @@ impl GstDebugDrain {
name: *const c_char, name: *const c_char,
color: u32, color: u32,
description: *const c_char, description: *const c_char,
) -> *mut gst::GstDebugCategory; ) -> *mut gst_ffi::GstDebugCategory;
} }
let name_cstr = CString::new(name.as_bytes()).unwrap(); let name_cstr = CString::new(name.as_bytes()).unwrap();
@ -58,7 +58,7 @@ impl GstDebugDrain {
if !element.is_null() { if !element.is_null() {
unsafe { unsafe {
gobject::g_weak_ref_set(&mut *drain.element, element as *mut gobject::GObject); gobject_ffi::g_weak_ref_set(&mut *drain.element, element as *mut gobject_ffi::GObject);
} }
} }
@ -69,7 +69,7 @@ impl GstDebugDrain {
impl Drop for GstDebugDrain { impl Drop for GstDebugDrain {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gobject::g_weak_ref_clear(&mut *self.element); gobject_ffi::g_weak_ref_clear(&mut *self.element);
} }
} }
} }
@ -80,14 +80,14 @@ impl Drain for GstDebugDrain {
fn log(&self, record: &Record, _: &OwnedKVList) -> Result<(), Never> { fn log(&self, record: &Record, _: &OwnedKVList) -> Result<(), Never> {
let level = match record.level() { let level = match record.level() {
Level::Critical | Level::Error => gst::GST_LEVEL_ERROR, Level::Critical | Level::Error => gst_ffi::GST_LEVEL_ERROR,
Level::Warning => gst::GST_LEVEL_WARNING, Level::Warning => gst_ffi::GST_LEVEL_WARNING,
Level::Info => gst::GST_LEVEL_INFO, Level::Info => gst_ffi::GST_LEVEL_INFO,
Level::Debug => gst::GST_LEVEL_DEBUG, Level::Debug => gst_ffi::GST_LEVEL_DEBUG,
Level::Trace => gst::GST_LEVEL_TRACE, Level::Trace => gst_ffi::GST_LEVEL_TRACE,
}; };
let threshold = unsafe { gst::gst_debug_category_get_threshold(self.category) }; let threshold = unsafe { gst_ffi::gst_debug_category_get_threshold(self.category) };
if level as u32 > threshold as u32 { if level as u32 > threshold as u32 {
return Ok(()); return Ok(());
@ -101,22 +101,22 @@ impl Drain for GstDebugDrain {
let message_cstr = CString::new(fmt::format(*record.msg()).as_bytes()).unwrap(); let message_cstr = CString::new(fmt::format(*record.msg()).as_bytes()).unwrap();
unsafe { unsafe {
let element = gobject::g_weak_ref_get( let element = gobject_ffi::g_weak_ref_get(
&*self.element as *const gobject::GWeakRef as *mut gobject::GWeakRef, &*self.element as *const gobject_ffi::GWeakRef as *mut gobject_ffi::GWeakRef,
); );
gst::gst_debug_log( gst_ffi::gst_debug_log(
self.category, self.category,
level, level,
file_cstr.as_ptr(), file_cstr.as_ptr(),
function_cstr.as_ptr(), function_cstr.as_ptr(),
record.line() as i32, record.line() as i32,
element as *mut gobject::GObject, element as *mut gobject_ffi::GObject,
message_cstr.as_ptr(), message_cstr.as_ptr(),
); );
if !element.is_null() { if !element.is_null() {
gst::gst_object_unref(element as *mut gst::GstObject); gst_ffi::gst_object_unref(element as *mut gst_ffi::GstObject);
} }
} }

16
gst-plugin/src/miniobject.rs
View file

@ -10,8 +10,8 @@ use std::{borrow, fmt, ops};
use std::mem; use std::mem;
use std::marker::PhantomData; use std::marker::PhantomData;
use glib; use glib_ffi;
use gst; use gst_ffi;
#[derive(Hash, Debug, PartialEq, Eq, PartialOrd, Ord)] #[derive(Hash, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct GstRc<T: MiniObject>(*mut T, PhantomData<T>); pub struct GstRc<T: MiniObject>(*mut T, PhantomData<T>);
@ -21,7 +21,7 @@ impl<T: MiniObject> GstRc<T> {
assert!(!obj.is_null()); assert!(!obj.is_null());
if !owned { if !owned {
gst::gst_mini_object_ref((&*obj).as_ptr() as *mut gst::GstMiniObject); gst_ffi::gst_mini_object_ref((&*obj).as_ptr() as *mut gst_ffi::GstMiniObject);
} }
GstRc(obj as *mut T, PhantomData) GstRc(obj as *mut T, PhantomData)
@ -42,7 +42,7 @@ impl<T: MiniObject> GstRc<T> {
} }
self.0 = T::from_mut_ptr( self.0 = T::from_mut_ptr(
gst::gst_mini_object_make_writable(self.as_mut_ptr() as *mut gst::GstMiniObject) as gst_ffi::gst_mini_object_make_writable(self.as_mut_ptr() as *mut gst_ffi::GstMiniObject) as
*mut T::PtrType, *mut T::PtrType,
); );
assert!(self.is_writable()); assert!(self.is_writable());
@ -62,15 +62,15 @@ impl<T: MiniObject> GstRc<T> {
pub fn copy(&self) -> Self { pub fn copy(&self) -> Self {
unsafe { unsafe {
GstRc::from_owned_ptr( GstRc::from_owned_ptr(
gst::gst_mini_object_copy(self.as_ptr() as *const gst::GstMiniObject) as gst_ffi::gst_mini_object_copy(self.as_ptr() as *const gst_ffi::GstMiniObject) as
*const T::PtrType, *const T::PtrType,
) )
} }
} }
fn is_writable(&self) -> bool { fn is_writable(&self) -> bool {
(unsafe { gst::gst_mini_object_is_writable(self.as_ptr() as *const gst::GstMiniObject) } == (unsafe { gst_ffi::gst_mini_object_is_writable(self.as_ptr() as *const gst_ffi::GstMiniObject) } ==
glib::GTRUE) glib_ffi::GTRUE)
} }
pub unsafe fn into_ptr(self) -> *mut T::PtrType { pub unsafe fn into_ptr(self) -> *mut T::PtrType {
@ -118,7 +118,7 @@ impl<T: MiniObject> Clone for GstRc<T> {
impl<T: MiniObject> Drop for GstRc<T> { impl<T: MiniObject> Drop for GstRc<T> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gst::gst_mini_object_unref(self.as_ptr() as *mut gst::GstMiniObject); gst_ffi::gst_mini_object_unref(self.as_ptr() as *mut gst_ffi::GstMiniObject);
} }
} }
} }

22
gst-plugin/src/plugin.rs
View file

@ -6,16 +6,16 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use gst; use gst_ffi;
pub struct Plugin(*mut gst::GstPlugin); pub struct Plugin(*mut gst_ffi::GstPlugin);
impl Plugin { impl Plugin {
pub unsafe fn new(plugin: *mut gst::GstPlugin) -> Plugin { pub unsafe fn new(plugin: *mut gst_ffi::GstPlugin) -> Plugin {
Plugin(plugin) Plugin(plugin)
} }
pub unsafe fn as_ptr(&self) -> *mut gst::GstPlugin { pub unsafe fn as_ptr(&self) -> *mut gst_ffi::GstPlugin {
self.0 self.0
} }
} }
@ -27,20 +27,18 @@ macro_rules! plugin_define(
$package:expr, $origin:expr, $release_datetime:expr) => { $package:expr, $origin:expr, $release_datetime:expr) => {
pub mod plugin_desc { pub mod plugin_desc {
use $crate::plugin::Plugin; use $crate::plugin::Plugin;
use $crate::ffi::gst;
use $crate::ffi::glib;
// Not using c_char here because it requires the libc crate // Not using c_char here because it requires the libc crate
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
type c_char = i8; type c_char = i8;
#[repr(C)] #[repr(C)]
pub struct GstPluginDesc(gst::GstPluginDesc); pub struct GstPluginDesc($crate::ffi::gst::GstPluginDesc);
unsafe impl Sync for GstPluginDesc {} unsafe impl Sync for GstPluginDesc {}
#[no_mangle] #[no_mangle]
#[allow(non_upper_case_globals)] #[allow(non_upper_case_globals)]
pub static gst_plugin_desc: GstPluginDesc = GstPluginDesc(gst::GstPluginDesc { pub static gst_plugin_desc: GstPluginDesc = GstPluginDesc($crate::ffi::gst::GstPluginDesc {
major_version: 1, major_version: 1,
minor_version: 10, minor_version: 10,
name: $name as *const u8 as *const c_char, name: $name as *const u8 as *const c_char,
@ -52,14 +50,14 @@ macro_rules! plugin_define(
package: $package as *const u8 as *const c_char, package: $package as *const u8 as *const c_char,
origin: $origin as *const u8 as *const c_char, origin: $origin as *const u8 as *const c_char,
release_datetime: $release_datetime as *const u8 as *const c_char, release_datetime: $release_datetime as *const u8 as *const c_char,
_gst_reserved: [0 as glib::gpointer; 4], _gst_reserved: [0 as $crate::ffi::glib::gpointer; 4],
}); });
unsafe extern "C" fn plugin_init_trampoline(plugin: *mut gst::GstPlugin) -> glib::gboolean { unsafe extern "C" fn plugin_init_trampoline(plugin: *mut $crate::ffi::gst::GstPlugin) -> $crate::ffi::glib::gboolean {
if super::$plugin_init(&Plugin::new(plugin)) { if super::$plugin_init(&Plugin::new(plugin)) {
glib::GTRUE $crate::ffi::glib::GTRUE
} else { } else {
glib::GFALSE $crate::ffi::glib::GFALSE
} }
} }
} }

142
gst-plugin/src/sink.rs
View file

@ -29,10 +29,10 @@ use log::*;
use plugin::Plugin; use plugin::Plugin;
use caps::*; use caps::*;
use glib; use glib_ffi;
use gobject; use gobject_ffi;
use gst; use gst_ffi;
use gst_base; use gst_base_ffi;
#[derive(Debug)] #[derive(Debug)]
pub enum SinkError { pub enum SinkError {
@ -56,7 +56,7 @@ impl ToGError for SinkError {
} }
pub struct SinkWrapper { pub struct SinkWrapper {
raw: *mut gst::GstElement, raw: *mut gst_ffi::GstElement,
logger: Logger, logger: Logger,
uri: Mutex<(Option<Url>, bool)>, uri: Mutex<(Option<Url>, bool)>,
uri_validator: Box<UriValidator>, uri_validator: Box<UriValidator>,
@ -74,7 +74,7 @@ pub trait Sink {
} }
impl SinkWrapper { impl SinkWrapper {
fn new(raw: *mut gst::GstElement, sink: Box<Sink>) -> SinkWrapper { fn new(raw: *mut gst_ffi::GstElement, sink: Box<Sink>) -> SinkWrapper {
SinkWrapper { SinkWrapper {
raw: raw, raw: raw,
logger: Logger::root( logger: Logger::root(
@ -181,13 +181,13 @@ impl SinkWrapper {
} }
} }
fn render(&self, buffer: &Buffer) -> gst::GstFlowReturn { fn render(&self, buffer: &Buffer) -> gst_ffi::GstFlowReturn {
let sink = &mut self.sink.lock().unwrap(); let sink = &mut self.sink.lock().unwrap();
trace!(self.logger, "Rendering buffer {:?}", buffer); trace!(self.logger, "Rendering buffer {:?}", buffer);
match sink.render(buffer) { match sink.render(buffer) {
Ok(..) => gst::GST_FLOW_OK, Ok(..) => gst_ffi::GST_FLOW_OK,
Err(flow_error) => { Err(flow_error) => {
error!(self.logger, "Failed to render: {:?}", flow_error); error!(self.logger, "Failed to render: {:?}", flow_error);
match flow_error { match flow_error {
@ -211,12 +211,12 @@ impl SinkWrapper {
unsafe fn sink_set_uri( unsafe fn sink_set_uri(
ptr: *const RsSink, ptr: *const RsSink,
uri_ptr: *const c_char, uri_ptr: *const c_char,
cerr: *mut *mut glib::GError, cerr: *mut *mut glib_ffi::GError,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
let sink = &*(ptr as *const RsSink); let sink = &*(ptr as *const RsSink);
let wrap: &SinkWrapper = &*sink.wrap; let wrap: &SinkWrapper = &*sink.wrap;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
let uri_str = if uri_ptr.is_null() { let uri_str = if uri_ptr.is_null() {
None None
} else { } else {
@ -227,9 +227,9 @@ unsafe fn sink_set_uri(
Err(err) => { Err(err) => {
error!(wrap.logger, "Failed to set URI {:?}", err); error!(wrap.logger, "Failed to set URI {:?}", err);
err.into_gerror(cerr); err.into_gerror(cerr);
glib::GFALSE glib_ffi::GFALSE
} }
Ok(_) => glib::GTRUE, Ok(_) => glib_ffi::GTRUE,
} }
}) })
} }
@ -240,47 +240,47 @@ unsafe fn sink_get_uri(ptr: *const RsSink) -> *mut c_char {
panic_to_error!(wrap, ptr::null_mut(), { panic_to_error!(wrap, ptr::null_mut(), {
match wrap.get_uri() { match wrap.get_uri() {
Some(uri_str) => glib::g_strndup(uri_str.as_ptr() as *const c_char, uri_str.len()), Some(uri_str) => glib_ffi::g_strndup(uri_str.as_ptr() as *const c_char, uri_str.len()),
None => ptr::null_mut(), None => ptr::null_mut(),
} }
}) })
} }
unsafe extern "C" fn sink_start(ptr: *mut gst_base::GstBaseSink) -> glib::gboolean { unsafe extern "C" fn sink_start(ptr: *mut gst_base_ffi::GstBaseSink) -> glib_ffi::gboolean {
let sink = &*(ptr as *const RsSink); let sink = &*(ptr as *const RsSink);
let wrap: &SinkWrapper = &*sink.wrap; let wrap: &SinkWrapper = &*sink.wrap;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
if wrap.start() { if wrap.start() {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
unsafe extern "C" fn sink_stop(ptr: *mut gst_base::GstBaseSink) -> glib::gboolean { unsafe extern "C" fn sink_stop(ptr: *mut gst_base_ffi::GstBaseSink) -> glib_ffi::gboolean {
let sink = &*(ptr as *const RsSink); let sink = &*(ptr as *const RsSink);
let wrap: &SinkWrapper = &*sink.wrap; let wrap: &SinkWrapper = &*sink.wrap;
panic_to_error!(wrap, glib::GTRUE, { panic_to_error!(wrap, glib_ffi::GTRUE, {
if wrap.stop() { if wrap.stop() {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
unsafe extern "C" fn sink_render( unsafe extern "C" fn sink_render(
ptr: *mut gst_base::GstBaseSink, ptr: *mut gst_base_ffi::GstBaseSink,
buffer: *mut gst::GstBuffer, buffer: *mut gst_ffi::GstBuffer,
) -> gst::GstFlowReturn { ) -> gst_ffi::GstFlowReturn {
let sink = &*(ptr as *const RsSink); let sink = &*(ptr as *const RsSink);
let wrap: &SinkWrapper = &*sink.wrap; let wrap: &SinkWrapper = &*sink.wrap;
let buffer: &Buffer = Buffer::from_ptr(buffer); let buffer: &Buffer = Buffer::from_ptr(buffer);
panic_to_error!(wrap, gst::GST_FLOW_ERROR, { wrap.render(buffer) }) panic_to_error!(wrap, gst_ffi::GST_FLOW_ERROR, { wrap.render(buffer) })
} }
pub struct SinkInfo { pub struct SinkInfo {
@ -296,40 +296,40 @@ pub struct SinkInfo {
#[repr(C)] #[repr(C)]
struct RsSink { struct RsSink {
parent: gst_base::GstBaseSink, parent: gst_base_ffi::GstBaseSink,
wrap: *mut SinkWrapper, wrap: *mut SinkWrapper,
sink_info: *const SinkInfo, sink_info: *const SinkInfo,
} }
#[repr(C)] #[repr(C)]
struct RsSinkClass { struct RsSinkClass {
parent_class: gst_base::GstBaseSinkClass, parent_class: gst_base_ffi::GstBaseSinkClass,
sink_info: *const SinkInfo, sink_info: *const SinkInfo,
protocols: *const Vec<*const c_char>, protocols: *const Vec<*const c_char>,
parent_vtable: glib::gconstpointer, parent_vtable: glib_ffi::gconstpointer,
} }
unsafe extern "C" fn sink_finalize(obj: *mut gobject::GObject) { unsafe extern "C" fn sink_finalize(obj: *mut gobject_ffi::GObject) {
let sink = &mut *(obj as *mut RsSink); let sink = &mut *(obj as *mut RsSink);
drop(Box::from_raw(sink.wrap)); drop(Box::from_raw(sink.wrap));
let sink_klass = &**(obj as *const *const RsSinkClass); let sink_klass = &**(obj as *const *const RsSinkClass);
let parent_klass = &*(sink_klass.parent_vtable as *const gobject::GObjectClass); let parent_klass = &*(sink_klass.parent_vtable as *const gobject_ffi::GObjectClass);
parent_klass.finalize.map(|f| f(obj)); parent_klass.finalize.map(|f| f(obj));
} }
unsafe extern "C" fn sink_set_property( unsafe extern "C" fn sink_set_property(
obj: *mut gobject::GObject, obj: *mut gobject_ffi::GObject,
id: u32, id: u32,
value: *mut gobject::GValue, value: *mut gobject_ffi::GValue,
_pspec: *mut gobject::GParamSpec, _pspec: *mut gobject_ffi::GParamSpec,
) { ) {
let sink = &*(obj as *const RsSink); let sink = &*(obj as *const RsSink);
match id { match id {
1 => { 1 => {
let uri_ptr = gobject::g_value_get_string(value); let uri_ptr = gobject_ffi::g_value_get_string(value);
sink_set_uri(sink, uri_ptr, ptr::null_mut()); sink_set_uri(sink, uri_ptr, ptr::null_mut());
} }
_ => unreachable!(), _ => unreachable!(),
@ -337,23 +337,23 @@ unsafe extern "C" fn sink_set_property(
} }
unsafe extern "C" fn sink_get_property( unsafe extern "C" fn sink_get_property(
obj: *mut gobject::GObject, obj: *mut gobject_ffi::GObject,
id: u32, id: u32,
value: *mut gobject::GValue, value: *mut gobject_ffi::GValue,
_pspec: *mut gobject::GParamSpec, _pspec: *mut gobject_ffi::GParamSpec,
) { ) {
let sink = &*(obj as *const RsSink); let sink = &*(obj as *const RsSink);
match id { match id {
1 => { 1 => {
let uri_ptr = sink_get_uri(sink); let uri_ptr = sink_get_uri(sink);
gobject::g_value_take_string(value, uri_ptr); gobject_ffi::g_value_take_string(value, uri_ptr);
} }
_ => unreachable!(), _ => unreachable!(),
} }
} }
unsafe extern "C" fn sink_class_init(klass: glib::gpointer, klass_data: glib::gpointer) { unsafe extern "C" fn sink_class_init(klass: glib_ffi::gpointer, klass_data: glib_ffi::gpointer) {
let sink_klass = &mut *(klass as *mut RsSinkClass); let sink_klass = &mut *(klass as *mut RsSinkClass);
let sink_info = &*(klass_data as *const SinkInfo); let sink_info = &*(klass_data as *const SinkInfo);
@ -371,15 +371,15 @@ unsafe extern "C" fn sink_class_init(klass: glib::gpointer, klass_data: glib::gp
let nick_cstr = CString::new("URI").unwrap(); let nick_cstr = CString::new("URI").unwrap();
let blurb_cstr = CString::new("URI to read from").unwrap(); let blurb_cstr = CString::new("URI to read from").unwrap();
gobject::g_object_class_install_property( gobject_ffi::g_object_class_install_property(
klass as *mut gobject::GObjectClass, klass as *mut gobject_ffi::GObjectClass,
1, 1,
gobject::g_param_spec_string( gobject_ffi::g_param_spec_string(
name_cstr.as_ptr(), name_cstr.as_ptr(),
nick_cstr.as_ptr(), nick_cstr.as_ptr(),
blurb_cstr.as_ptr(), blurb_cstr.as_ptr(),
ptr::null_mut(), ptr::null_mut(),
gobject::G_PARAM_READWRITE, gobject_ffi::G_PARAM_READWRITE,
), ),
); );
} }
@ -392,7 +392,7 @@ unsafe extern "C" fn sink_class_init(klass: glib::gpointer, klass_data: glib::gp
let description_cstr = CString::new(sink_info.classification.clone()).unwrap(); let description_cstr = CString::new(sink_info.classification.clone()).unwrap();
let author_cstr = CString::new(sink_info.author.clone()).unwrap(); let author_cstr = CString::new(sink_info.author.clone()).unwrap();
gst::gst_element_class_set_static_metadata( gst_ffi::gst_element_class_set_static_metadata(
element_klass, element_klass,
longname_cstr.into_raw(), longname_cstr.into_raw(),
classification_cstr.into_raw(), classification_cstr.into_raw(),
@ -402,13 +402,13 @@ unsafe extern "C" fn sink_class_init(klass: glib::gpointer, klass_data: glib::gp
let caps = Caps::new_any(); let caps = Caps::new_any();
let templ_name = CString::new("sink").unwrap(); let templ_name = CString::new("sink").unwrap();
let pad_template = gst::gst_pad_template_new( let pad_template = gst_ffi::gst_pad_template_new(
templ_name.into_raw(), templ_name.into_raw(),
gst::GST_PAD_SINK, gst_ffi::GST_PAD_SINK,
gst::GST_PAD_ALWAYS, gst_ffi::GST_PAD_ALWAYS,
caps.as_ptr() as *mut gst::GstCaps, caps.as_ptr() as *mut gst_ffi::GstCaps,
); );
gst::gst_element_class_add_pad_template(element_klass, pad_template); gst_ffi::gst_element_class_add_pad_template(element_klass, pad_template);
} }
{ {
@ -426,10 +426,10 @@ unsafe extern "C" fn sink_class_init(klass: glib::gpointer, klass_data: glib::gp
} }
protocols.push(ptr::null()); protocols.push(ptr::null());
sink_klass.protocols = Box::into_raw(protocols) as *const Vec<*const c_char>; sink_klass.protocols = Box::into_raw(protocols) as *const Vec<*const c_char>;
sink_klass.parent_vtable = gobject::g_type_class_peek_parent(klass); sink_klass.parent_vtable = gobject_ffi::g_type_class_peek_parent(klass);
} }
unsafe extern "C" fn sink_init(instance: *mut gobject::GTypeInstance, klass: glib::gpointer) { unsafe extern "C" fn sink_init(instance: *mut gobject_ffi::GTypeInstance, klass: glib_ffi::gpointer) {
let sink = &mut *(instance as *mut RsSink); let sink = &mut *(instance as *mut RsSink);
let sink_klass = &*(klass as *const RsSinkClass); let sink_klass = &*(klass as *const RsSinkClass);
let sink_info = &*sink_klass.sink_info; let sink_info = &*sink_klass.sink_info;
@ -442,33 +442,33 @@ unsafe extern "C" fn sink_init(instance: *mut gobject::GTypeInstance, klass: gli
)); ));
sink.wrap = Box::into_raw(wrap); sink.wrap = Box::into_raw(wrap);
gst_base::gst_base_sink_set_sync(&mut sink.parent, glib::GFALSE); gst_base_ffi::gst_base_sink_set_sync(&mut sink.parent, glib_ffi::GFALSE);
} }
unsafe extern "C" fn sink_uri_handler_get_type(_type: glib::GType) -> gst::GstURIType { unsafe extern "C" fn sink_uri_handler_get_type(_type: glib_ffi::GType) -> gst_ffi::GstURIType {
gst::GST_URI_SINK gst_ffi::GST_URI_SINK
} }
unsafe extern "C" fn sink_uri_handler_get_protocols(type_: glib::GType) -> *const *const c_char { unsafe extern "C" fn sink_uri_handler_get_protocols(type_: glib_ffi::GType) -> *const *const c_char {
let klass = gobject::g_type_class_peek(type_); let klass = gobject_ffi::g_type_class_peek(type_);
let sink_klass = &*(klass as *const RsSinkClass); let sink_klass = &*(klass as *const RsSinkClass);
(*sink_klass.protocols).as_ptr() (*sink_klass.protocols).as_ptr()
} }
unsafe extern "C" fn sink_uri_handler_get_uri(uri_handler: *mut gst::GstURIHandler) -> *mut c_char { unsafe extern "C" fn sink_uri_handler_get_uri(uri_handler: *mut gst_ffi::GstURIHandler) -> *mut c_char {
sink_get_uri(uri_handler as *const RsSink) sink_get_uri(uri_handler as *const RsSink)
} }
unsafe extern "C" fn sink_uri_handler_set_uri( unsafe extern "C" fn sink_uri_handler_set_uri(
uri_handler: *mut gst::GstURIHandler, uri_handler: *mut gst_ffi::GstURIHandler,
uri: *const c_char, uri: *const c_char,
err: *mut *mut glib::GError, err: *mut *mut glib_ffi::GError,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
sink_set_uri(uri_handler as *const RsSink, uri, err) sink_set_uri(uri_handler as *const RsSink, uri, err)
} }
unsafe extern "C" fn sink_uri_handler_init(iface: glib::gpointer, _iface_data: glib::gpointer) { unsafe extern "C" fn sink_uri_handler_init(iface: glib_ffi::gpointer, _iface_data: glib_ffi::gpointer) {
let uri_handler_iface = &mut *(iface as *mut gst::GstURIHandlerInterface); let uri_handler_iface = &mut *(iface as *mut gst_ffi::GstURIHandlerInterface);
uri_handler_iface.get_type = Some(sink_uri_handler_get_type); uri_handler_iface.get_type = Some(sink_uri_handler_get_type);
uri_handler_iface.get_protocols = Some(sink_uri_handler_get_protocols); uri_handler_iface.get_protocols = Some(sink_uri_handler_get_protocols);
@ -478,7 +478,7 @@ unsafe extern "C" fn sink_uri_handler_init(iface: glib::gpointer, _iface_data: g
pub fn sink_register(plugin: &Plugin, sink_info: SinkInfo) { pub fn sink_register(plugin: &Plugin, sink_info: SinkInfo) {
unsafe { unsafe {
let parent_type = gst_base::gst_base_sink_get_type(); let parent_type = gst_base_ffi::gst_base_sink_get_type();
let mut type_name = String::from("RsSink-"); let mut type_name = String::from("RsSink-");
type_name.push_str(&sink_info.name); type_name.push_str(&sink_info.name);
let type_name_cstr = CString::new(type_name.into_bytes()).unwrap(); let type_name_cstr = CString::new(type_name.into_bytes()).unwrap();
@ -487,9 +487,9 @@ pub fn sink_register(plugin: &Plugin, sink_info: SinkInfo) {
let rank = sink_info.rank; let rank = sink_info.rank;
let sink_info = Box::new(sink_info); let sink_info = Box::new(sink_info);
let sink_info_ptr = Box::into_raw(sink_info) as glib::gpointer; let sink_info_ptr = Box::into_raw(sink_info) as glib_ffi::gpointer;
let type_info = gobject::GTypeInfo { let type_info = gobject_ffi::GTypeInfo {
class_size: mem::size_of::<RsSinkClass>() as u16, class_size: mem::size_of::<RsSinkClass>() as u16,
base_init: None, base_init: None,
base_finalize: None, base_finalize: None,
@ -502,20 +502,20 @@ pub fn sink_register(plugin: &Plugin, sink_info: SinkInfo) {
value_table: ptr::null(), value_table: ptr::null(),
}; };
let type_ = gobject::g_type_register_static( let type_ = gobject_ffi::g_type_register_static(
parent_type, parent_type,
type_name_cstr.as_ptr(), type_name_cstr.as_ptr(),
&type_info, &type_info,
gobject::GTypeFlags::empty(), gobject_ffi::GTypeFlags::empty(),
); );
let iface_info = gobject::GInterfaceInfo { let iface_info = gobject_ffi::GInterfaceInfo {
interface_init: Some(sink_uri_handler_init), interface_init: Some(sink_uri_handler_init),
interface_finalize: None, interface_finalize: None,
interface_data: ptr::null_mut(), interface_data: ptr::null_mut(),
}; };
gobject::g_type_add_interface_static(type_, gst::gst_uri_handler_get_type(), &iface_info); gobject_ffi::g_type_add_interface_static(type_, gst_ffi::gst_uri_handler_get_type(), &iface_info);
gst::gst_element_register(plugin.as_ptr(), name_cstr.as_ptr(), rank, type_); gst_ffi::gst_element_register(plugin.as_ptr(), name_cstr.as_ptr(), rank, type_);
} }
} }

172
gst-plugin/src/source.rs
View file

@ -29,10 +29,10 @@ use miniobject::*;
use log::*; use log::*;
use caps::*; use caps::*;
use glib; use glib_ffi;
use gobject; use gobject_ffi;
use gst; use gst_ffi;
use gst_base; use gst_base_ffi;
#[derive(Debug)] #[derive(Debug)]
pub enum SourceError { pub enum SourceError {
@ -56,7 +56,7 @@ impl ToGError for SourceError {
} }
pub struct SourceWrapper { pub struct SourceWrapper {
raw: *mut gst::GstElement, raw: *mut gst_ffi::GstElement,
logger: Logger, logger: Logger,
uri: Mutex<(Option<Url>, bool)>, uri: Mutex<(Option<Url>, bool)>,
uri_validator: Box<UriValidator>, uri_validator: Box<UriValidator>,
@ -77,7 +77,7 @@ pub trait Source {
} }
impl SourceWrapper { impl SourceWrapper {
fn new(raw: *mut gst::GstElement, source: Box<Source>) -> SourceWrapper { fn new(raw: *mut gst_ffi::GstElement, source: Box<Source>) -> SourceWrapper {
SourceWrapper { SourceWrapper {
raw: raw, raw: raw,
logger: Logger::root( logger: Logger::root(
@ -194,7 +194,7 @@ impl SourceWrapper {
} }
} }
fn fill(&self, offset: u64, length: u32, buffer: &mut Buffer) -> gst::GstFlowReturn { fn fill(&self, offset: u64, length: u32, buffer: &mut Buffer) -> gst_ffi::GstFlowReturn {
let source = &mut self.source.lock().unwrap(); let source = &mut self.source.lock().unwrap();
trace!( trace!(
@ -206,7 +206,7 @@ impl SourceWrapper {
); );
match source.fill(offset, length, buffer) { match source.fill(offset, length, buffer) {
Ok(()) => gst::GST_FLOW_OK, Ok(()) => gst_ffi::GST_FLOW_OK,
Err(flow_error) => { Err(flow_error) => {
error!(self.logger, "Failed to fill: {:?}", flow_error); error!(self.logger, "Failed to fill: {:?}", flow_error);
match flow_error { match flow_error {
@ -245,12 +245,12 @@ impl SourceWrapper {
unsafe fn source_set_uri( unsafe fn source_set_uri(
ptr: *const RsSrc, ptr: *const RsSrc,
uri_ptr: *const c_char, uri_ptr: *const c_char,
cerr: *mut *mut glib::GError, cerr: *mut *mut glib_ffi::GError,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
let src = &*(ptr as *const RsSrc); let src = &*(ptr as *const RsSrc);
let wrap: &SourceWrapper = &*src.wrap; let wrap: &SourceWrapper = &*src.wrap;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
let uri_str = if uri_ptr.is_null() { let uri_str = if uri_ptr.is_null() {
None None
} else { } else {
@ -261,9 +261,9 @@ unsafe fn source_set_uri(
Err(err) => { Err(err) => {
error!(wrap.logger, "Failed to set URI {:?}", err); error!(wrap.logger, "Failed to set URI {:?}", err);
err.into_gerror(cerr); err.into_gerror(cerr);
glib::GFALSE glib_ffi::GFALSE
} }
Ok(_) => glib::GTRUE, Ok(_) => glib_ffi::GTRUE,
} }
}) })
} }
@ -274,96 +274,96 @@ unsafe fn source_get_uri(ptr: *const RsSrc) -> *mut c_char {
panic_to_error!(wrap, ptr::null_mut(), { panic_to_error!(wrap, ptr::null_mut(), {
match wrap.get_uri() { match wrap.get_uri() {
Some(uri_str) => glib::g_strndup(uri_str.as_ptr() as *const c_char, uri_str.len()), Some(uri_str) => glib_ffi::g_strndup(uri_str.as_ptr() as *const c_char, uri_str.len()),
None => ptr::null_mut(), None => ptr::null_mut(),
} }
}) })
} }
unsafe extern "C" fn source_is_seekable(ptr: *mut gst_base::GstBaseSrc) -> glib::gboolean { unsafe extern "C" fn source_is_seekable(ptr: *mut gst_base_ffi::GstBaseSrc) -> glib_ffi::gboolean {
let src = &*(ptr as *const RsSrc); let src = &*(ptr as *const RsSrc);
let wrap: &SourceWrapper = &*src.wrap; let wrap: &SourceWrapper = &*src.wrap;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
if wrap.is_seekable() { if wrap.is_seekable() {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
unsafe extern "C" fn source_get_size( unsafe extern "C" fn source_get_size(
ptr: *mut gst_base::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
size: *mut u64, size: *mut u64,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
let src = &*(ptr as *const RsSrc); let src = &*(ptr as *const RsSrc);
let wrap: &SourceWrapper = &*src.wrap; let wrap: &SourceWrapper = &*src.wrap;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
*size = wrap.get_size(); *size = wrap.get_size();
glib::GTRUE glib_ffi::GTRUE
}) })
} }
unsafe extern "C" fn source_start(ptr: *mut gst_base::GstBaseSrc) -> glib::gboolean { unsafe extern "C" fn source_start(ptr: *mut gst_base_ffi::GstBaseSrc) -> glib_ffi::gboolean {
let src = &*(ptr as *const RsSrc); let src = &*(ptr as *const RsSrc);
let wrap: &SourceWrapper = &*src.wrap; let wrap: &SourceWrapper = &*src.wrap;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
if wrap.start() { if wrap.start() {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
unsafe extern "C" fn source_stop(ptr: *mut gst_base::GstBaseSrc) -> glib::gboolean { unsafe extern "C" fn source_stop(ptr: *mut gst_base_ffi::GstBaseSrc) -> glib_ffi::gboolean {
let src = &*(ptr as *const RsSrc); let src = &*(ptr as *const RsSrc);
let wrap: &SourceWrapper = &*src.wrap; let wrap: &SourceWrapper = &*src.wrap;
panic_to_error!(wrap, glib::GTRUE, { panic_to_error!(wrap, glib_ffi::GTRUE, {
if wrap.stop() { if wrap.stop() {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
unsafe extern "C" fn source_fill( unsafe extern "C" fn source_fill(
ptr: *mut gst_base::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
offset: u64, offset: u64,
length: u32, length: u32,
buffer: *mut gst::GstBuffer, buffer: *mut gst_ffi::GstBuffer,
) -> gst::GstFlowReturn { ) -> gst_ffi::GstFlowReturn {
let src = &*(ptr as *const RsSrc); let src = &*(ptr as *const RsSrc);
let wrap: &SourceWrapper = &*src.wrap; let wrap: &SourceWrapper = &*src.wrap;
let buffer: &mut Buffer = <Buffer as MiniObject>::from_mut_ptr(buffer); let buffer: &mut Buffer = <Buffer as MiniObject>::from_mut_ptr(buffer);
panic_to_error!( panic_to_error!(
wrap, wrap,
gst::GST_FLOW_ERROR, gst_ffi::GST_FLOW_ERROR,
{ wrap.fill(offset, length, buffer) } { wrap.fill(offset, length, buffer) }
) )
} }
unsafe extern "C" fn source_seek( unsafe extern "C" fn source_seek(
ptr: *mut gst_base::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
segment: *mut gst::GstSegment, segment: *mut gst_ffi::GstSegment,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
let src = &*(ptr as *const RsSrc); let src = &*(ptr as *const RsSrc);
let wrap: &SourceWrapper = &*src.wrap; let wrap: &SourceWrapper = &*src.wrap;
let start = (*segment).start; let start = (*segment).start;
let stop = (*segment).stop; let stop = (*segment).stop;
panic_to_error!(wrap, glib::GFALSE, { panic_to_error!(wrap, glib_ffi::GFALSE, {
if wrap.seek(start, if stop == u64::MAX { None } else { Some(stop) }) { if wrap.seek(start, if stop == u64::MAX { None } else { Some(stop) }) {
glib::GTRUE glib_ffi::GTRUE
} else { } else {
glib::GFALSE glib_ffi::GFALSE
} }
}) })
} }
@ -382,40 +382,40 @@ pub struct SourceInfo {
#[repr(C)] #[repr(C)]
struct RsSrc { struct RsSrc {
parent: gst_base::GstPushSrc, parent: gst_base_ffi::GstPushSrc,
wrap: *mut SourceWrapper, wrap: *mut SourceWrapper,
source_info: *const SourceInfo, source_info: *const SourceInfo,
} }
#[repr(C)] #[repr(C)]
struct RsSrcClass { struct RsSrcClass {
parent_class: gst_base::GstPushSrcClass, parent_class: gst_base_ffi::GstPushSrcClass,
source_info: *const SourceInfo, source_info: *const SourceInfo,
protocols: *const Vec<*const c_char>, protocols: *const Vec<*const c_char>,
parent_vtable: glib::gconstpointer, parent_vtable: glib_ffi::gconstpointer,
} }
unsafe extern "C" fn source_finalize(obj: *mut gobject::GObject) { unsafe extern "C" fn source_finalize(obj: *mut gobject_ffi::GObject) {
let src = &mut *(obj as *mut RsSrc); let src = &mut *(obj as *mut RsSrc);
drop(Box::from_raw(src.wrap)); drop(Box::from_raw(src.wrap));
let src_klass = &**(obj as *const *const RsSrcClass); let src_klass = &**(obj as *const *const RsSrcClass);
let parent_klass = &*(src_klass.parent_vtable as *const gobject::GObjectClass); let parent_klass = &*(src_klass.parent_vtable as *const gobject_ffi::GObjectClass);
parent_klass.finalize.map(|f| f(obj)); parent_klass.finalize.map(|f| f(obj));
} }
unsafe extern "C" fn source_set_property( unsafe extern "C" fn source_set_property(
obj: *mut gobject::GObject, obj: *mut gobject_ffi::GObject,
id: u32, id: u32,
value: *mut gobject::GValue, value: *mut gobject_ffi::GValue,
_pspec: *mut gobject::GParamSpec, _pspec: *mut gobject_ffi::GParamSpec,
) { ) {
let src = &*(obj as *const RsSrc); let src = &*(obj as *const RsSrc);
match id { match id {
1 => { 1 => {
let uri_ptr = gobject::g_value_get_string(value); let uri_ptr = gobject_ffi::g_value_get_string(value);
source_set_uri(src, uri_ptr, ptr::null_mut()); source_set_uri(src, uri_ptr, ptr::null_mut());
} }
_ => unreachable!(), _ => unreachable!(),
@ -423,23 +423,23 @@ unsafe extern "C" fn source_set_property(
} }
unsafe extern "C" fn source_get_property( unsafe extern "C" fn source_get_property(
obj: *mut gobject::GObject, obj: *mut gobject_ffi::GObject,
id: u32, id: u32,
value: *mut gobject::GValue, value: *mut gobject_ffi::GValue,
_pspec: *mut gobject::GParamSpec, _pspec: *mut gobject_ffi::GParamSpec,
) { ) {
let src = &*(obj as *const RsSrc); let src = &*(obj as *const RsSrc);
match id { match id {
1 => { 1 => {
let uri_ptr = source_get_uri(src); let uri_ptr = source_get_uri(src);
gobject::g_value_take_string(value, uri_ptr); gobject_ffi::g_value_take_string(value, uri_ptr);
} }
_ => unreachable!(), _ => unreachable!(),
} }
} }
unsafe extern "C" fn source_class_init(klass: glib::gpointer, klass_data: glib::gpointer) { unsafe extern "C" fn source_class_init(klass: glib_ffi::gpointer, klass_data: glib_ffi::gpointer) {
let src_klass = &mut *(klass as *mut RsSrcClass); let src_klass = &mut *(klass as *mut RsSrcClass);
let source_info = &*(klass_data as *const SourceInfo); let source_info = &*(klass_data as *const SourceInfo);
@ -458,15 +458,15 @@ unsafe extern "C" fn source_class_init(klass: glib::gpointer, klass_data: glib::
let nick_cstr = CString::new("URI").unwrap(); let nick_cstr = CString::new("URI").unwrap();
let blurb_cstr = CString::new("URI to read from").unwrap(); let blurb_cstr = CString::new("URI to read from").unwrap();
gobject::g_object_class_install_property( gobject_ffi::g_object_class_install_property(
klass as *mut gobject::GObjectClass, klass as *mut gobject_ffi::GObjectClass,
1, 1,
gobject::g_param_spec_string( gobject_ffi::g_param_spec_string(
name_cstr.as_ptr(), name_cstr.as_ptr(),
nick_cstr.as_ptr(), nick_cstr.as_ptr(),
blurb_cstr.as_ptr(), blurb_cstr.as_ptr(),
ptr::null_mut(), ptr::null_mut(),
gobject::G_PARAM_READWRITE, gobject_ffi::G_PARAM_READWRITE,
), ),
); );
} }
@ -479,7 +479,7 @@ unsafe extern "C" fn source_class_init(klass: glib::gpointer, klass_data: glib::
let description_cstr = CString::new(source_info.classification.clone()).unwrap(); let description_cstr = CString::new(source_info.classification.clone()).unwrap();
let author_cstr = CString::new(source_info.author.clone()).unwrap(); let author_cstr = CString::new(source_info.author.clone()).unwrap();
gst::gst_element_class_set_static_metadata( gst_ffi::gst_element_class_set_static_metadata(
element_klass, element_klass,
longname_cstr.into_raw(), longname_cstr.into_raw(),
classification_cstr.into_raw(), classification_cstr.into_raw(),
@ -489,13 +489,13 @@ unsafe extern "C" fn source_class_init(klass: glib::gpointer, klass_data: glib::
let caps = Caps::new_any(); let caps = Caps::new_any();
let templ_name = CString::new("src").unwrap(); let templ_name = CString::new("src").unwrap();
let pad_template = gst::gst_pad_template_new( let pad_template = gst_ffi::gst_pad_template_new(
templ_name.into_raw(), templ_name.into_raw(),
gst::GST_PAD_SRC, gst_ffi::GST_PAD_SRC,
gst::GST_PAD_ALWAYS, gst_ffi::GST_PAD_ALWAYS,
caps.as_ptr() as *mut gst::GstCaps, caps.as_ptr() as *mut gst_ffi::GstCaps,
); );
gst::gst_element_class_add_pad_template(element_klass, pad_template); gst_ffi::gst_element_class_add_pad_template(element_klass, pad_template);
} }
{ {
@ -516,10 +516,10 @@ unsafe extern "C" fn source_class_init(klass: glib::gpointer, klass_data: glib::
} }
protocols.push(ptr::null()); protocols.push(ptr::null());
src_klass.protocols = Box::into_raw(protocols) as *const Vec<*const c_char>; src_klass.protocols = Box::into_raw(protocols) as *const Vec<*const c_char>;
src_klass.parent_vtable = gobject::g_type_class_peek_parent(klass); src_klass.parent_vtable = gobject_ffi::g_type_class_peek_parent(klass);
} }
unsafe extern "C" fn source_init(instance: *mut gobject::GTypeInstance, klass: glib::gpointer) { unsafe extern "C" fn source_init(instance: *mut gobject_ffi::GTypeInstance, klass: glib_ffi::gpointer) {
let src = &mut *(instance as *mut RsSrc); let src = &mut *(instance as *mut RsSrc);
let src_klass = &*(klass as *const RsSrcClass); let src_klass = &*(klass as *const RsSrcClass);
let source_info = &*src_klass.source_info; let source_info = &*src_klass.source_info;
@ -532,35 +532,35 @@ unsafe extern "C" fn source_init(instance: *mut gobject::GTypeInstance, klass: g
)); ));
src.wrap = Box::into_raw(wrap); src.wrap = Box::into_raw(wrap);
gst_base::gst_base_src_set_blocksize(&mut src.parent.parent, 4096); gst_base_ffi::gst_base_src_set_blocksize(&mut src.parent.parent, 4096);
} }
unsafe extern "C" fn source_uri_handler_get_type(_type: glib::GType) -> gst::GstURIType { unsafe extern "C" fn source_uri_handler_get_type(_type: glib_ffi::GType) -> gst_ffi::GstURIType {
gst::GST_URI_SRC gst_ffi::GST_URI_SRC
} }
unsafe extern "C" fn source_uri_handler_get_protocols(type_: glib::GType) -> *const *const c_char { unsafe extern "C" fn source_uri_handler_get_protocols(type_: glib_ffi::GType) -> *const *const c_char {
let klass = gobject::g_type_class_peek(type_); let klass = gobject_ffi::g_type_class_peek(type_);
let src_klass = &*(klass as *const RsSrcClass); let src_klass = &*(klass as *const RsSrcClass);
(*src_klass.protocols).as_ptr() (*src_klass.protocols).as_ptr()
} }
unsafe extern "C" fn source_uri_handler_get_uri( unsafe extern "C" fn source_uri_handler_get_uri(
uri_handler: *mut gst::GstURIHandler, uri_handler: *mut gst_ffi::GstURIHandler,
) -> *mut c_char { ) -> *mut c_char {
source_get_uri(uri_handler as *const RsSrc) source_get_uri(uri_handler as *const RsSrc)
} }
unsafe extern "C" fn source_uri_handler_set_uri( unsafe extern "C" fn source_uri_handler_set_uri(
uri_handler: *mut gst::GstURIHandler, uri_handler: *mut gst_ffi::GstURIHandler,
uri: *const c_char, uri: *const c_char,
err: *mut *mut glib::GError, err: *mut *mut glib_ffi::GError,
) -> glib::gboolean { ) -> glib_ffi::gboolean {
source_set_uri(uri_handler as *const RsSrc, uri, err) source_set_uri(uri_handler as *const RsSrc, uri, err)
} }
unsafe extern "C" fn source_uri_handler_init(iface: glib::gpointer, _iface_data: glib::gpointer) { unsafe extern "C" fn source_uri_handler_init(iface: glib_ffi::gpointer, _iface_data: glib_ffi::gpointer) {
let uri_handler_iface = &mut *(iface as *mut gst::GstURIHandlerInterface); let uri_handler_iface = &mut *(iface as *mut gst_ffi::GstURIHandlerInterface);
uri_handler_iface.get_type = Some(source_uri_handler_get_type); uri_handler_iface.get_type = Some(source_uri_handler_get_type);
uri_handler_iface.get_protocols = Some(source_uri_handler_get_protocols); uri_handler_iface.get_protocols = Some(source_uri_handler_get_protocols);
@ -571,9 +571,9 @@ unsafe extern "C" fn source_uri_handler_init(iface: glib::gpointer, _iface_data:
pub fn source_register(plugin: &Plugin, source_info: SourceInfo) { pub fn source_register(plugin: &Plugin, source_info: SourceInfo) {
unsafe { unsafe {
let parent_type = if source_info.push_only { let parent_type = if source_info.push_only {
gst_base::gst_push_src_get_type() gst_base_ffi::gst_push_src_get_type()
} else { } else {
gst_base::gst_base_src_get_type() gst_base_ffi::gst_base_src_get_type()
}; };
let mut type_name = String::from("RsSrc-"); let mut type_name = String::from("RsSrc-");
type_name.push_str(&source_info.name); type_name.push_str(&source_info.name);
@ -583,9 +583,9 @@ pub fn source_register(plugin: &Plugin, source_info: SourceInfo) {
let rank = source_info.rank; let rank = source_info.rank;
let source_info = Box::new(source_info); let source_info = Box::new(source_info);
let source_info_ptr = Box::into_raw(source_info) as glib::gpointer; let source_info_ptr = Box::into_raw(source_info) as glib_ffi::gpointer;
let type_info = gobject::GTypeInfo { let type_info = gobject_ffi::GTypeInfo {
class_size: mem::size_of::<RsSrcClass>() as u16, class_size: mem::size_of::<RsSrcClass>() as u16,
base_init: None, base_init: None,
base_finalize: None, base_finalize: None,
@ -598,20 +598,20 @@ pub fn source_register(plugin: &Plugin, source_info: SourceInfo) {
value_table: ptr::null(), value_table: ptr::null(),
}; };
let type_ = gobject::g_type_register_static( let type_ = gobject_ffi::g_type_register_static(
parent_type, parent_type,
type_name_cstr.as_ptr(), type_name_cstr.as_ptr(),
&type_info, &type_info,
gobject::GTypeFlags::empty(), gobject_ffi::GTypeFlags::empty(),
); );
let iface_info = gobject::GInterfaceInfo { let iface_info = gobject_ffi::GInterfaceInfo {
interface_init: Some(source_uri_handler_init), interface_init: Some(source_uri_handler_init),
interface_finalize: None, interface_finalize: None,
interface_data: ptr::null_mut(), interface_data: ptr::null_mut(),
}; };
gobject::g_type_add_interface_static(type_, gst::gst_uri_handler_get_type(), &iface_info); gobject_ffi::g_type_add_interface_static(type_, gst_ffi::gst_uri_handler_get_type(), &iface_info);
gst::gst_element_register(plugin.as_ptr(), name_cstr.as_ptr(), rank, type_); gst_ffi::gst_element_register(plugin.as_ptr(), name_cstr.as_ptr(), rank, type_);
} }
} }

62
gst-plugin/src/streams.rs
View file

@ -13,10 +13,10 @@ use caps::Caps;
use miniobject::*; use miniobject::*;
use tags::TagList; use tags::TagList;
use gst; use gst_ffi;
pub struct Stream(*mut gst::GstStream); pub struct Stream(*mut gst_ffi::GstStream);
pub struct StreamCollection(*mut gst::GstStreamCollection); pub struct StreamCollection(*mut gst_ffi::GstStreamCollection);
bitflags! { bitflags! {
#[repr(C)] #[repr(C)]
@ -50,7 +50,7 @@ impl Stream {
.unwrap_or(ptr::null_mut()); .unwrap_or(ptr::null_mut());
Stream(unsafe { Stream(unsafe {
gst::gst_stream_new( gst_ffi::gst_stream_new(
stream_id_cstr.as_ptr(), stream_id_cstr.as_ptr(),
caps, caps,
mem::transmute(t.bits()), mem::transmute(t.bits()),
@ -59,12 +59,12 @@ impl Stream {
}) })
} }
pub unsafe fn as_ptr(&self) -> *const gst::GstStream { pub unsafe fn as_ptr(&self) -> *const gst_ffi::GstStream {
self.0 self.0
} }
pub fn get_caps(&self) -> Option<&Caps> { pub fn get_caps(&self) -> Option<&Caps> {
let ptr = unsafe { gst::gst_stream_get_caps(self.0) }; let ptr = unsafe { gst_ffi::gst_stream_get_caps(self.0) };
if ptr.is_null() { if ptr.is_null() {
return None; return None;
@ -74,20 +74,20 @@ impl Stream {
} }
pub fn get_stream_flags(&self) -> StreamFlags { pub fn get_stream_flags(&self) -> StreamFlags {
StreamFlags::from_bits_truncate(unsafe { gst::gst_stream_get_stream_flags(self.0).bits() }) StreamFlags::from_bits_truncate(unsafe { gst_ffi::gst_stream_get_stream_flags(self.0).bits() })
} }
pub fn get_stream_type(&self) -> StreamType { pub fn get_stream_type(&self) -> StreamType {
StreamType::from_bits_truncate(unsafe { gst::gst_stream_get_stream_type(self.0).bits() }) StreamType::from_bits_truncate(unsafe { gst_ffi::gst_stream_get_stream_type(self.0).bits() })
} }
pub fn get_stream_id(&self) -> &str { pub fn get_stream_id(&self) -> &str {
let cstr = unsafe { CStr::from_ptr(gst::gst_stream_get_stream_id(self.0)) }; let cstr = unsafe { CStr::from_ptr(gst_ffi::gst_stream_get_stream_id(self.0)) };
cstr.to_str().unwrap() cstr.to_str().unwrap()
} }
pub fn get_tags(&self) -> Option<&TagList> { pub fn get_tags(&self) -> Option<&TagList> {
let ptr = unsafe { gst::gst_stream_get_tags(self.0) }; let ptr = unsafe { gst_ffi::gst_stream_get_tags(self.0) };
if ptr.is_null() { if ptr.is_null() {
return None; return None;
@ -100,37 +100,37 @@ impl Stream {
let ptr = caps.map(|caps| unsafe { caps.as_mut_ptr() }) let ptr = caps.map(|caps| unsafe { caps.as_mut_ptr() })
.unwrap_or(ptr::null_mut()); .unwrap_or(ptr::null_mut());
unsafe { gst::gst_stream_set_caps(self.0, ptr) } unsafe { gst_ffi::gst_stream_set_caps(self.0, ptr) }
} }
pub fn set_stream_flags(&self, flags: StreamFlags) { pub fn set_stream_flags(&self, flags: StreamFlags) {
unsafe { gst::gst_stream_set_stream_flags(self.0, mem::transmute(flags.bits())) } unsafe { gst_ffi::gst_stream_set_stream_flags(self.0, mem::transmute(flags.bits())) }
} }
pub fn set_stream_type(&self, t: StreamType) { pub fn set_stream_type(&self, t: StreamType) {
unsafe { gst::gst_stream_set_stream_type(self.0, mem::transmute(t.bits())) } unsafe { gst_ffi::gst_stream_set_stream_type(self.0, mem::transmute(t.bits())) }
} }
pub fn set_tags(&self, tags: Option<TagList>) { pub fn set_tags(&self, tags: Option<TagList>) {
let ptr = tags.map(|tags| unsafe { tags.as_mut_ptr() }) let ptr = tags.map(|tags| unsafe { tags.as_mut_ptr() })
.unwrap_or(ptr::null_mut()); .unwrap_or(ptr::null_mut());
unsafe { gst::gst_stream_set_tags(self.0, ptr) } unsafe { gst_ffi::gst_stream_set_tags(self.0, ptr) }
} }
} }
impl Clone for Stream { impl Clone for Stream {
fn clone(&self) -> Self { fn clone(&self) -> Self {
unsafe { unsafe {
Stream(gst::gst_object_ref(self.0 as *mut gst::GstObject) as Stream(gst_ffi::gst_object_ref(self.0 as *mut gst_ffi::GstObject) as
*mut gst::GstStream) *mut gst_ffi::GstStream)
} }
} }
} }
impl Drop for Stream { impl Drop for Stream {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { gst::gst_object_unref(self.0 as *mut gst::GstObject) } unsafe { gst_ffi::gst_object_unref(self.0 as *mut gst_ffi::GstObject) }
} }
} }
@ -138,11 +138,11 @@ impl StreamCollection {
pub fn new(upstream_id: &str, streams: &[Stream]) -> Self { pub fn new(upstream_id: &str, streams: &[Stream]) -> Self {
let upstream_id_cstr = CString::new(upstream_id).unwrap(); let upstream_id_cstr = CString::new(upstream_id).unwrap();
let collection = StreamCollection(unsafe { let collection = StreamCollection(unsafe {
gst::gst_stream_collection_new(upstream_id_cstr.as_ptr()) gst_ffi::gst_stream_collection_new(upstream_id_cstr.as_ptr())
}); });
for stream in streams { for stream in streams {
unsafe { gst::gst_stream_collection_add_stream(collection.0, stream.clone().0) }; unsafe { gst_ffi::gst_stream_collection_add_stream(collection.0, stream.clone().0) };
} }
collection collection
@ -153,7 +153,7 @@ impl StreamCollection {
} }
pub fn len(&self) -> u32 { pub fn len(&self) -> u32 {
unsafe { gst::gst_stream_collection_get_size(self.0) } unsafe { gst_ffi::gst_stream_collection_get_size(self.0) }
} }
pub fn empty(&self) -> bool { pub fn empty(&self) -> bool {
@ -161,11 +161,11 @@ impl StreamCollection {
} }
pub fn get_upstream_id(&self) -> &str { pub fn get_upstream_id(&self) -> &str {
let cstr = unsafe { CStr::from_ptr(gst::gst_stream_collection_get_upstream_id(self.0)) }; let cstr = unsafe { CStr::from_ptr(gst_ffi::gst_stream_collection_get_upstream_id(self.0)) };
cstr.to_str().unwrap() cstr.to_str().unwrap()
} }
pub unsafe fn as_ptr(&self) -> *const gst::GstStreamCollection { pub unsafe fn as_ptr(&self) -> *const gst_ffi::GstStreamCollection {
self.0 self.0
} }
} }
@ -195,7 +195,7 @@ impl<'a> Iterator for StreamCollectionIterator<'a> {
} }
let stream = let stream =
unsafe { gst::gst_stream_collection_get_stream(self.collection.0, self.position) }; unsafe { gst_ffi::gst_stream_collection_get_stream(self.collection.0, self.position) };
if stream.is_null() { if stream.is_null() {
self.position = self.length; self.position = self.length;
return None; return None;
@ -203,8 +203,8 @@ impl<'a> Iterator for StreamCollectionIterator<'a> {
self.position += 1; self.position += 1;
Some(unsafe { Some(unsafe {
Stream(gst::gst_object_ref(stream as *mut gst::GstObject) as Stream(gst_ffi::gst_object_ref(stream as *mut gst_ffi::GstObject) as
*mut gst::GstStream) *mut gst_ffi::GstStream)
}) })
} }
@ -228,15 +228,15 @@ impl<'a> DoubleEndedIterator for StreamCollectionIterator<'a> {
self.length -= 1; self.length -= 1;
let stream = let stream =
unsafe { gst::gst_stream_collection_get_stream(self.collection.0, self.length) }; unsafe { gst_ffi::gst_stream_collection_get_stream(self.collection.0, self.length) };
if stream.is_null() { if stream.is_null() {
self.position = self.length; self.position = self.length;
return None; return None;
} }
Some(unsafe { Some(unsafe {
Stream(gst::gst_object_ref(stream as *mut gst::GstObject) as Stream(gst_ffi::gst_object_ref(stream as *mut gst_ffi::GstObject) as
*mut gst::GstStream) *mut gst_ffi::GstStream)
}) })
} }
} }
@ -246,14 +246,14 @@ impl<'a> ExactSizeIterator for StreamCollectionIterator<'a> {}
impl Clone for StreamCollection { impl Clone for StreamCollection {
fn clone(&self) -> Self { fn clone(&self) -> Self {
unsafe { unsafe {
StreamCollection(gst::gst_object_ref(self.0 as *mut gst::GstObject) as StreamCollection(gst_ffi::gst_object_ref(self.0 as *mut gst_ffi::GstObject) as
*mut gst::GstStreamCollection) *mut gst_ffi::GstStreamCollection)
} }
} }
} }
impl Drop for StreamCollection { impl Drop for StreamCollection {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { gst::gst_object_unref(self.0 as *mut gst::GstObject) } unsafe { gst_ffi::gst_object_unref(self.0 as *mut gst_ffi::GstObject) }
} }
} }

48
gst-plugin/src/structure.rs
View file

@ -16,8 +16,8 @@ use std::marker::PhantomData;
use value::*; use value::*;
use glib; use glib_ffi;
use gst; use gst_ffi;
pub struct OwnedStructure(*mut Structure, PhantomData<Structure>); pub struct OwnedStructure(*mut Structure, PhantomData<Structure>);
@ -25,7 +25,7 @@ impl OwnedStructure {
pub fn new_empty(name: &str) -> OwnedStructure { pub fn new_empty(name: &str) -> OwnedStructure {
let name_cstr = CString::new(name).unwrap(); let name_cstr = CString::new(name).unwrap();
OwnedStructure( OwnedStructure(
unsafe { gst::gst_structure_new_empty(name_cstr.as_ptr()) as *mut Structure }, unsafe { gst_ffi::gst_structure_new_empty(name_cstr.as_ptr()) as *mut Structure },
PhantomData, PhantomData,
) )
} }
@ -43,7 +43,7 @@ impl OwnedStructure {
pub fn from_string(s: &str) -> Option<OwnedStructure> { pub fn from_string(s: &str) -> Option<OwnedStructure> {
unsafe { unsafe {
let cstr = CString::new(s).unwrap(); let cstr = CString::new(s).unwrap();
let structure = gst::gst_structure_from_string(cstr.as_ptr(), ptr::null_mut()); let structure = gst_ffi::gst_structure_from_string(cstr.as_ptr(), ptr::null_mut());
if structure.is_null() { if structure.is_null() {
None None
} else { } else {
@ -52,8 +52,8 @@ impl OwnedStructure {
} }
} }
pub unsafe fn into_ptr(self) -> *mut gst::GstStructure { pub unsafe fn into_ptr(self) -> *mut gst_ffi::GstStructure {
let ptr = self.0 as *mut Structure as *mut gst::GstStructure; let ptr = self.0 as *mut Structure as *mut gst_ffi::GstStructure;
mem::forget(self); mem::forget(self);
ptr ptr
@ -89,7 +89,7 @@ impl AsMut<Structure> for OwnedStructure {
impl Clone for OwnedStructure { impl Clone for OwnedStructure {
fn clone(&self) -> Self { fn clone(&self) -> Self {
OwnedStructure( OwnedStructure(
unsafe { gst::gst_structure_copy(&(*self.0).0) as *mut Structure }, unsafe { gst_ffi::gst_structure_copy(&(*self.0).0) as *mut Structure },
PhantomData, PhantomData,
) )
} }
@ -97,7 +97,7 @@ impl Clone for OwnedStructure {
impl Drop for OwnedStructure { impl Drop for OwnedStructure {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { gst::gst_structure_free(&mut (*self.0).0) } unsafe { gst_ffi::gst_structure_free(&mut (*self.0).0) }
} }
} }
@ -138,23 +138,23 @@ impl ToOwned for Structure {
fn to_owned(&self) -> OwnedStructure { fn to_owned(&self) -> OwnedStructure {
OwnedStructure( OwnedStructure(
unsafe { gst::gst_structure_copy(&self.0) as *mut Structure }, unsafe { gst_ffi::gst_structure_copy(&self.0) as *mut Structure },
PhantomData, PhantomData,
) )
} }
} }
#[repr(C)] #[repr(C)]
pub struct Structure(gst::GstStructure); pub struct Structure(gst_ffi::GstStructure);
impl Structure { impl Structure {
pub unsafe fn from_borrowed_ptr<'a>(ptr: *const gst::GstStructure) -> &'a Structure { pub unsafe fn from_borrowed_ptr<'a>(ptr: *const gst_ffi::GstStructure) -> &'a Structure {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
&*(ptr as *mut Structure) &*(ptr as *mut Structure)
} }
pub unsafe fn from_borrowed_mut_ptr<'a>(ptr: *mut gst::GstStructure) -> &'a mut Structure { pub unsafe fn from_borrowed_mut_ptr<'a>(ptr: *mut gst_ffi::GstStructure) -> &'a mut Structure {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
&mut *(ptr as *mut Structure) &mut *(ptr as *mut Structure)
@ -162,9 +162,9 @@ impl Structure {
pub fn to_string(&self) -> String { pub fn to_string(&self) -> String {
unsafe { unsafe {
let ptr = gst::gst_structure_to_string(&self.0); let ptr = gst_ffi::gst_structure_to_string(&self.0);
let s = CStr::from_ptr(ptr).to_str().unwrap().into(); let s = CStr::from_ptr(ptr).to_str().unwrap().into();
glib::g_free(ptr as glib::gpointer); glib_ffi::g_free(ptr as glib_ffi::gpointer);
s s
} }
@ -178,7 +178,7 @@ impl Structure {
unsafe { unsafe {
let name_cstr = CString::new(name).unwrap(); let name_cstr = CString::new(name).unwrap();
let value = gst::gst_structure_get_value(&self.0, name_cstr.as_ptr()); let value = gst_ffi::gst_structure_get_value(&self.0, name_cstr.as_ptr());
if value.is_null() { if value.is_null() {
return None; return None;
@ -193,14 +193,14 @@ impl Structure {
let name_cstr = CString::new(name).unwrap(); let name_cstr = CString::new(name).unwrap();
let mut gvalue = value.into().into_raw(); let mut gvalue = value.into().into_raw();
gst::gst_structure_take_value(&mut self.0, name_cstr.as_ptr(), &mut gvalue); gst_ffi::gst_structure_take_value(&mut self.0, name_cstr.as_ptr(), &mut gvalue);
mem::forget(gvalue); mem::forget(gvalue);
} }
} }
pub fn get_name(&self) -> &str { pub fn get_name(&self) -> &str {
unsafe { unsafe {
let cstr = CStr::from_ptr(gst::gst_structure_get_name(&self.0)); let cstr = CStr::from_ptr(gst_ffi::gst_structure_get_name(&self.0));
cstr.to_str().unwrap() cstr.to_str().unwrap()
} }
} }
@ -208,20 +208,20 @@ impl Structure {
pub fn has_field(&self, field: &str) -> bool { pub fn has_field(&self, field: &str) -> bool {
unsafe { unsafe {
let cstr = CString::new(field).unwrap(); let cstr = CString::new(field).unwrap();
gst::gst_structure_has_field(&self.0, cstr.as_ptr()) == glib::GTRUE gst_ffi::gst_structure_has_field(&self.0, cstr.as_ptr()) == glib_ffi::GTRUE
} }
} }
pub fn remove_field(&mut self, field: &str) { pub fn remove_field(&mut self, field: &str) {
unsafe { unsafe {
let cstr = CString::new(field).unwrap(); let cstr = CString::new(field).unwrap();
gst::gst_structure_remove_field(&mut self.0, cstr.as_ptr()); gst_ffi::gst_structure_remove_field(&mut self.0, cstr.as_ptr());
} }
} }
pub fn remove_all_fields(&mut self) { pub fn remove_all_fields(&mut self) {
unsafe { unsafe {
gst::gst_structure_remove_all_fields(&mut self.0); gst_ffi::gst_structure_remove_all_fields(&mut self.0);
} }
} }
@ -235,7 +235,7 @@ impl Structure {
fn get_nth_field_name(&self, idx: u32) -> Option<&str> { fn get_nth_field_name(&self, idx: u32) -> Option<&str> {
unsafe { unsafe {
let field_name = gst::gst_structure_nth_field_name(&self.0, idx); let field_name = gst_ffi::gst_structure_nth_field_name(&self.0, idx);
if field_name.is_null() { if field_name.is_null() {
return None; return None;
} }
@ -246,7 +246,7 @@ impl Structure {
} }
fn n_fields(&self) -> u32 { fn n_fields(&self) -> u32 {
unsafe { gst::gst_structure_n_fields(&self.0) as u32 } unsafe { gst_ffi::gst_structure_n_fields(&self.0) as u32 }
} }
// TODO: Various operations // TODO: Various operations
@ -260,7 +260,7 @@ impl fmt::Debug for Structure {
impl PartialEq for Structure { impl PartialEq for Structure {
fn eq(&self, other: &Structure) -> bool { fn eq(&self, other: &Structure) -> bool {
(unsafe { gst::gst_structure_is_equal(&self.0, &other.0) } == glib::GTRUE) (unsafe { gst_ffi::gst_structure_is_equal(&self.0, &other.0) } == glib_ffi::GTRUE)
} }
} }
@ -377,7 +377,7 @@ mod tests {
#[test] #[test]
fn new_set_get() { fn new_set_get() {
unsafe { gst::gst_init(ptr::null_mut(), ptr::null_mut()) }; unsafe { gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut()) };
let mut s = OwnedStructure::new_empty("test"); let mut s = OwnedStructure::new_empty("test");
assert_eq!(s.get_name(), "test"); assert_eq!(s.get_name(), "test");

46
gst-plugin/src/tags.rs
View file

@ -13,9 +13,9 @@ use std::marker::PhantomData;
use value::*; use value::*;
use miniobject::*; use miniobject::*;
use glib; use glib_ffi;
use gobject; use gobject_ffi;
use gst; use gst_ffi;
pub trait Tag<'a> { pub trait Tag<'a> {
type TagType: ValueType<'a>; type TagType: ValueType<'a>;
@ -57,27 +57,27 @@ pub enum MergeMode {
} }
impl MergeMode { impl MergeMode {
fn to_ffi(&self) -> gst::GstTagMergeMode { fn to_ffi(&self) -> gst_ffi::GstTagMergeMode {
match *self { match *self {
MergeMode::ReplaceAll => gst::GST_TAG_MERGE_REPLACE_ALL, MergeMode::ReplaceAll => gst_ffi::GST_TAG_MERGE_REPLACE_ALL,
MergeMode::Replace => gst::GST_TAG_MERGE_REPLACE, MergeMode::Replace => gst_ffi::GST_TAG_MERGE_REPLACE,
MergeMode::Append => gst::GST_TAG_MERGE_APPEND, MergeMode::Append => gst_ffi::GST_TAG_MERGE_APPEND,
MergeMode::Prepend => gst::GST_TAG_MERGE_PREPEND, MergeMode::Prepend => gst_ffi::GST_TAG_MERGE_PREPEND,
MergeMode::Keep => gst::GST_TAG_MERGE_KEEP, MergeMode::Keep => gst_ffi::GST_TAG_MERGE_KEEP,
MergeMode::KeepAll => gst::GST_TAG_MERGE_KEEP_ALL, MergeMode::KeepAll => gst_ffi::GST_TAG_MERGE_KEEP_ALL,
} }
} }
} }
pub struct TagList(gst::GstTagList); pub struct TagList(gst_ffi::GstTagList);
unsafe impl MiniObject for TagList { unsafe impl MiniObject for TagList {
type PtrType = gst::GstTagList; type PtrType = gst_ffi::GstTagList;
} }
impl TagList { impl TagList {
pub fn new() -> GstRc<Self> { pub fn new() -> GstRc<Self> {
unsafe { GstRc::from_owned_ptr(gst::gst_tag_list_new_empty()) } unsafe { GstRc::from_owned_ptr(gst_ffi::gst_tag_list_new_empty()) }
} }
pub fn add<'a, T: Tag<'a>>(&mut self, value: T::TagType, mode: MergeMode) pub fn add<'a, T: Tag<'a>>(&mut self, value: T::TagType, mode: MergeMode)
@ -89,14 +89,14 @@ impl TagList {
let mut gvalue = v.into_raw(); let mut gvalue = v.into_raw();
let tag_name = CString::new(T::tag_name()).unwrap(); let tag_name = CString::new(T::tag_name()).unwrap();
gst::gst_tag_list_add_value( gst_ffi::gst_tag_list_add_value(
self.as_mut_ptr(), self.as_mut_ptr(),
mode.to_ffi(), mode.to_ffi(),
tag_name.as_ptr(), tag_name.as_ptr(),
&gvalue, &gvalue,
); );
gobject::g_value_unset(&mut gvalue); gobject_ffi::g_value_unset(&mut gvalue);
} }
} }
@ -105,9 +105,9 @@ impl TagList {
let mut gvalue = mem::zeroed(); let mut gvalue = mem::zeroed();
let tag_name = CString::new(T::tag_name()).unwrap(); let tag_name = CString::new(T::tag_name()).unwrap();
let found = gst::gst_tag_list_copy_value(&mut gvalue, self.as_ptr(), tag_name.as_ptr()); let found = gst_ffi::gst_tag_list_copy_value(&mut gvalue, self.as_ptr(), tag_name.as_ptr());
if found == glib::GFALSE { if found == glib_ffi::GFALSE {
return None; return None;
} }
@ -119,7 +119,7 @@ impl TagList {
unsafe { unsafe {
let tag_name = CString::new(T::tag_name()).unwrap(); let tag_name = CString::new(T::tag_name()).unwrap();
let value = gst::gst_tag_list_get_value_index(self.as_ptr(), tag_name.as_ptr(), idx); let value = gst_ffi::gst_tag_list_get_value_index(self.as_ptr(), tag_name.as_ptr(), idx);
if value.is_null() { if value.is_null() {
return None; return None;
@ -133,7 +133,7 @@ impl TagList {
unsafe { unsafe {
let tag_name = CString::new(T::tag_name()).unwrap(); let tag_name = CString::new(T::tag_name()).unwrap();
gst::gst_tag_list_get_tag_size(self.as_ptr(), tag_name.as_ptr()) gst_ffi::gst_tag_list_get_tag_size(self.as_ptr(), tag_name.as_ptr())
} }
} }
@ -143,9 +143,9 @@ impl TagList {
pub fn to_string(&self) -> String { pub fn to_string(&self) -> String {
unsafe { unsafe {
let ptr = gst::gst_tag_list_to_string(self.as_ptr()); let ptr = gst_ffi::gst_tag_list_to_string(self.as_ptr());
let s = CStr::from_ptr(ptr).to_str().unwrap().into(); let s = CStr::from_ptr(ptr).to_str().unwrap().into();
glib::g_free(ptr as glib::gpointer); glib_ffi::g_free(ptr as glib_ffi::gpointer);
s s
} }
@ -160,7 +160,7 @@ impl fmt::Debug for TagList {
impl PartialEq for TagList { impl PartialEq for TagList {
fn eq(&self, other: &TagList) -> bool { fn eq(&self, other: &TagList) -> bool {
(unsafe { gst::gst_tag_list_is_equal(self.as_ptr(), other.as_ptr()) } == glib::GTRUE) (unsafe { gst_ffi::gst_tag_list_is_equal(self.as_ptr(), other.as_ptr()) } == glib_ffi::GTRUE)
} }
} }
@ -240,7 +240,7 @@ mod tests {
fn init() { fn init() {
unsafe { unsafe {
gst::gst_init(ptr::null_mut(), ptr::null_mut()); gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut());
} }
} }

12
gst-plugin/src/utils.rs
View file

@ -11,22 +11,22 @@ use std::ffi::CString;
use std::i32; use std::i32;
use num_rational::Rational32; use num_rational::Rational32;
use gst; use gst_ffi;
pub struct Element(*mut gst::GstElement); pub struct Element(*mut gst_ffi::GstElement);
impl Element { impl Element {
pub unsafe fn new(element: *mut gst::GstElement) -> Element { pub unsafe fn new(element: *mut gst_ffi::GstElement) -> Element {
if element.is_null() { if element.is_null() {
panic!("NULL not allowed"); panic!("NULL not allowed");
} }
gst::gst_object_ref(element as *mut gst::GstObject); gst_ffi::gst_object_ref(element as *mut gst_ffi::GstObject);
Element(element) Element(element)
} }
pub unsafe fn as_ptr(&self) -> *mut gst::GstElement { pub unsafe fn as_ptr(&self) -> *mut gst_ffi::GstElement {
self.0 self.0
} }
} }
@ -34,7 +34,7 @@ impl Element {
impl Drop for Element { impl Drop for Element {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gst::gst_object_unref(self.0 as *mut gst::GstObject); gst_ffi::gst_object_unref(self.0 as *mut gst_ffi::GstObject);
} }
} }
} }

196
gst-plugin/src/value.rs
View file

@ -19,12 +19,12 @@ pub use num_rational::Rational32;
use buffer::*; use buffer::*;
use miniobject::*; use miniobject::*;
use glib; use glib_ffi;
use gobject; use gobject_ffi;
use gst; use gst_ffi;
#[repr(C)] #[repr(C)]
pub struct Value(gobject::GValue); pub struct Value(gobject_ffi::GValue);
#[derive(Clone, PartialEq, Eq, Debug)] #[derive(Clone, PartialEq, Eq, Debug)]
pub enum ValueView<'a> { pub enum ValueView<'a> {
@ -49,31 +49,31 @@ pub trait ValueType<'a>
where where
Self: Sized, Self: Sized,
{ {
fn g_type() -> glib::GType; fn g_type() -> glib_ffi::GType;
fn from_value(v: &'a gobject::GValue) -> Option<Self>; fn from_value(v: &'a gobject_ffi::GValue) -> Option<Self>;
fn from_value_view(v: &'a ValueView<'a>) -> Option<Self>; fn from_value_view(v: &'a ValueView<'a>) -> Option<Self>;
} }
lazy_static! { lazy_static! {
static ref TYPE_BUFFER: glib::GType = unsafe { gst::gst_buffer_get_type() }; static ref TYPE_BUFFER: glib_ffi::GType = unsafe { gst_ffi::gst_buffer_get_type() };
static ref TYPE_FRACTION: glib::GType = unsafe { gst::gst_fraction_get_type() }; static ref TYPE_FRACTION: glib_ffi::GType = unsafe { gst_ffi::gst_fraction_get_type() };
static ref TYPE_GST_VALUE_ARRAY: glib::GType = unsafe { gst::gst_value_array_get_type() }; static ref TYPE_GST_VALUE_ARRAY: glib_ffi::GType = unsafe { gst_ffi::gst_value_array_get_type() };
} }
impl Value { impl Value {
pub unsafe fn as_ptr(&self) -> *const gobject::GValue { pub unsafe fn as_ptr(&self) -> *const gobject_ffi::GValue {
&self.0 &self.0
} }
pub unsafe fn from_ptr(ptr: *const gobject::GValue) -> Option<Value> { pub unsafe fn from_ptr(ptr: *const gobject_ffi::GValue) -> Option<Value> {
if ptr.is_null() || !Value::is_supported_type((*ptr).g_type) { if ptr.is_null() || !Value::is_supported_type((*ptr).g_type) {
return None; return None;
} }
let mut value = Value(mem::zeroed()); let mut value = Value(mem::zeroed());
gobject::g_value_init(&mut value.0, (*ptr).g_type); gobject_ffi::g_value_init(&mut value.0, (*ptr).g_type);
gobject::g_value_copy(ptr, &mut value.0); gobject_ffi::g_value_copy(ptr, &mut value.0);
Some(value) Some(value)
} }
@ -82,28 +82,28 @@ impl Value {
unsafe { Value::from_ptr(v.0) }.unwrap() unsafe { Value::from_ptr(v.0) }.unwrap()
} }
pub unsafe fn from_raw(value: gobject::GValue) -> Option<Value> { pub unsafe fn from_raw(value: gobject_ffi::GValue) -> Option<Value> {
if !Value::is_supported_type(value.g_type) { if !Value::is_supported_type(value.g_type) {
return None; return None;
} }
Some(Value(value)) Some(Value(value))
} }
pub unsafe fn into_raw(mut self) -> gobject::GValue { pub unsafe fn into_raw(mut self) -> gobject_ffi::GValue {
let v = mem::replace(&mut self.0, mem::zeroed()); let v = mem::replace(&mut self.0, mem::zeroed());
mem::forget(self); mem::forget(self);
v v
} }
fn is_supported_type(typ: glib::GType) -> bool { fn is_supported_type(typ: glib_ffi::GType) -> bool {
match typ { match typ {
gobject::G_TYPE_BOOLEAN | gobject_ffi::G_TYPE_BOOLEAN |
gobject::G_TYPE_INT | gobject_ffi::G_TYPE_INT |
gobject::G_TYPE_UINT | gobject_ffi::G_TYPE_UINT |
gobject::G_TYPE_INT64 | gobject_ffi::G_TYPE_INT64 |
gobject::G_TYPE_UINT64 | gobject_ffi::G_TYPE_UINT64 |
gobject::G_TYPE_STRING => true, gobject_ffi::G_TYPE_STRING => true,
typ if typ == *TYPE_FRACTION => true, typ if typ == *TYPE_FRACTION => true,
//typ if typ == *TYPE_BUFFER => true //typ if typ == *TYPE_BUFFER => true
typ if typ == *TYPE_GST_VALUE_ARRAY => true, typ if typ == *TYPE_GST_VALUE_ARRAY => true,
@ -131,15 +131,15 @@ impl Value {
pub fn get(&self) -> ValueView { pub fn get(&self) -> ValueView {
match self.0.g_type { match self.0.g_type {
gobject::G_TYPE_BOOLEAN => ValueView::Bool(bool::from_value(&self.0).unwrap()), gobject_ffi::G_TYPE_BOOLEAN => ValueView::Bool(bool::from_value(&self.0).unwrap()),
gobject::G_TYPE_INT => ValueView::Int(i32::from_value(&self.0).unwrap()), gobject_ffi::G_TYPE_INT => ValueView::Int(i32::from_value(&self.0).unwrap()),
gobject::G_TYPE_UINT => ValueView::UInt(u32::from_value(&self.0).unwrap()), gobject_ffi::G_TYPE_UINT => ValueView::UInt(u32::from_value(&self.0).unwrap()),
gobject::G_TYPE_INT64 => ValueView::Int64(i64::from_value(&self.0).unwrap()), gobject_ffi::G_TYPE_INT64 => ValueView::Int64(i64::from_value(&self.0).unwrap()),
gobject::G_TYPE_UINT64 => ValueView::UInt64(u64::from_value(&self.0).unwrap()), gobject_ffi::G_TYPE_UINT64 => ValueView::UInt64(u64::from_value(&self.0).unwrap()),
typ if typ == *TYPE_FRACTION => { typ if typ == *TYPE_FRACTION => {
ValueView::Fraction(Rational32::from_value(&self.0).unwrap()) ValueView::Fraction(Rational32::from_value(&self.0).unwrap())
} }
gobject::G_TYPE_STRING => ValueView::String(Cow::Borrowed( gobject_ffi::G_TYPE_STRING => ValueView::String(Cow::Borrowed(
<&str as ValueType>::from_value(&self.0).unwrap(), <&str as ValueType>::from_value(&self.0).unwrap(),
)), )),
typ if typ == *TYPE_GST_VALUE_ARRAY => ValueView::Array(Cow::Borrowed( typ if typ == *TYPE_GST_VALUE_ARRAY => ValueView::Array(Cow::Borrowed(
@ -161,8 +161,8 @@ impl Clone for Value {
fn clone(&self) -> Self { fn clone(&self) -> Self {
unsafe { unsafe {
let mut new_value = Value(mem::zeroed()); let mut new_value = Value(mem::zeroed());
gobject::g_value_init(&mut new_value.0, self.0.g_type); gobject_ffi::g_value_init(&mut new_value.0, self.0.g_type);
gobject::g_value_copy(&self.0, &mut new_value.0); gobject_ffi::g_value_copy(&self.0, &mut new_value.0);
new_value new_value
} }
@ -191,18 +191,18 @@ impl fmt::Debug for Value {
impl Drop for Value { impl Drop for Value {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
if self.0.g_type != gobject::G_TYPE_NONE { if self.0.g_type != gobject_ffi::G_TYPE_NONE {
gobject::g_value_unset(&mut self.0); gobject_ffi::g_value_unset(&mut self.0);
} }
} }
} }
} }
#[derive(Clone)] #[derive(Clone)]
pub struct ValueRef<'a>(&'a gobject::GValue); pub struct ValueRef<'a>(&'a gobject_ffi::GValue);
impl<'a> ValueRef<'a> { impl<'a> ValueRef<'a> {
pub unsafe fn as_ptr(&self) -> *const gobject::GValue { pub unsafe fn as_ptr(&self) -> *const gobject_ffi::GValue {
self.0 self.0
} }
@ -210,7 +210,7 @@ impl<'a> ValueRef<'a> {
ValueRef(&v.0) ValueRef(&v.0)
} }
pub unsafe fn from_ptr(ptr: *const gobject::GValue) -> Option<ValueRef<'a>> { pub unsafe fn from_ptr(ptr: *const gobject_ffi::GValue) -> Option<ValueRef<'a>> {
if ptr.is_null() || !Value::is_supported_type((*ptr).g_type) { if ptr.is_null() || !Value::is_supported_type((*ptr).g_type) {
return None; return None;
} }
@ -220,15 +220,15 @@ impl<'a> ValueRef<'a> {
pub fn get(&self) -> ValueView { pub fn get(&self) -> ValueView {
match self.0.g_type { match self.0.g_type {
gobject::G_TYPE_BOOLEAN => ValueView::Bool(bool::from_value(self.0).unwrap()), gobject_ffi::G_TYPE_BOOLEAN => ValueView::Bool(bool::from_value(self.0).unwrap()),
gobject::G_TYPE_INT => ValueView::Int(i32::from_value(self.0).unwrap()), gobject_ffi::G_TYPE_INT => ValueView::Int(i32::from_value(self.0).unwrap()),
gobject::G_TYPE_UINT => ValueView::UInt(u32::from_value(self.0).unwrap()), gobject_ffi::G_TYPE_UINT => ValueView::UInt(u32::from_value(self.0).unwrap()),
gobject::G_TYPE_INT64 => ValueView::Int64(i64::from_value(self.0).unwrap()), gobject_ffi::G_TYPE_INT64 => ValueView::Int64(i64::from_value(self.0).unwrap()),
gobject::G_TYPE_UINT64 => ValueView::UInt64(u64::from_value(self.0).unwrap()), gobject_ffi::G_TYPE_UINT64 => ValueView::UInt64(u64::from_value(self.0).unwrap()),
typ if typ == *TYPE_FRACTION => { typ if typ == *TYPE_FRACTION => {
ValueView::Fraction(Rational32::from_value(self.0).unwrap()) ValueView::Fraction(Rational32::from_value(self.0).unwrap())
} }
gobject::G_TYPE_STRING => ValueView::String(Cow::Borrowed( gobject_ffi::G_TYPE_STRING => ValueView::String(Cow::Borrowed(
<&str as ValueType>::from_value(self.0).unwrap(), <&str as ValueType>::from_value(self.0).unwrap(),
)), )),
typ if typ == *TYPE_GST_VALUE_ARRAY => ValueView::Array(Cow::Borrowed( typ if typ == *TYPE_GST_VALUE_ARRAY => ValueView::Array(Cow::Borrowed(
@ -268,11 +268,11 @@ impl<'a> fmt::Debug for ValueRef<'a> {
macro_rules! impl_value_type_simple( macro_rules! impl_value_type_simple(
($typ:ty, $variant:ident, $g_type:expr, $getter:expr, $setter:expr) => { ($typ:ty, $variant:ident, $g_type:expr, $getter:expr, $setter:expr) => {
impl<'a> ValueType<'a> for $typ { impl<'a> ValueType<'a> for $typ {
fn g_type() -> glib::GType { fn g_type() -> glib_ffi::GType {
$g_type $g_type
} }
fn from_value(value: &'a gobject::GValue) -> Option<Self> { fn from_value(value: &'a gobject_ffi::GValue) -> Option<Self> {
if value.g_type != Self::g_type() { if value.g_type != Self::g_type() {
return None; return None;
} }
@ -296,7 +296,7 @@ macro_rules! impl_value_type_simple(
unsafe { unsafe {
let mut value = Value(mem::zeroed()); let mut value = Value(mem::zeroed());
gobject::g_value_init(&mut value.0, <$typ as ValueType>::g_type()); gobject_ffi::g_value_init(&mut value.0, <$typ as ValueType>::g_type());
$setter(&mut value.0, v); $setter(&mut value.0, v);
value value
@ -308,59 +308,59 @@ macro_rules! impl_value_type_simple(
impl_value_type_simple!(bool, impl_value_type_simple!(bool,
Bool, Bool,
gobject::G_TYPE_BOOLEAN, gobject_ffi::G_TYPE_BOOLEAN,
|value: &gobject::GValue| !(gobject::g_value_get_boolean(value) == 0), |value: &gobject_ffi::GValue| !(gobject_ffi::g_value_get_boolean(value) == 0),
|value: &mut gobject::GValue, v| { |value: &mut gobject_ffi::GValue, v| {
gobject::g_value_set_boolean(value, gobject_ffi::g_value_set_boolean(value,
if v { glib::GTRUE } else { glib::GFALSE }) if v { glib_ffi::GTRUE } else { glib_ffi::GFALSE })
}); });
impl_value_type_simple!(i32, impl_value_type_simple!(i32,
Int, Int,
gobject::G_TYPE_INT, gobject_ffi::G_TYPE_INT,
|value: &gobject::GValue| gobject::g_value_get_int(value), |value: &gobject_ffi::GValue| gobject_ffi::g_value_get_int(value),
|value: &mut gobject::GValue, v| gobject::g_value_set_int(value, v)); |value: &mut gobject_ffi::GValue, v| gobject_ffi::g_value_set_int(value, v));
impl_value_type_simple!(u32, impl_value_type_simple!(u32,
UInt, UInt,
gobject::G_TYPE_UINT, gobject_ffi::G_TYPE_UINT,
|value: &gobject::GValue| gobject::g_value_get_uint(value), |value: &gobject_ffi::GValue| gobject_ffi::g_value_get_uint(value),
|value: &mut gobject::GValue, v| gobject::g_value_set_uint(value, v)); |value: &mut gobject_ffi::GValue, v| gobject_ffi::g_value_set_uint(value, v));
impl_value_type_simple!(i64, impl_value_type_simple!(i64,
Int64, Int64,
gobject::G_TYPE_INT64, gobject_ffi::G_TYPE_INT64,
|value: &gobject::GValue| gobject::g_value_get_int64(value), |value: &gobject_ffi::GValue| gobject_ffi::g_value_get_int64(value),
|value: &mut gobject::GValue, v| gobject::g_value_set_int64(value, v)); |value: &mut gobject_ffi::GValue, v| gobject_ffi::g_value_set_int64(value, v));
impl_value_type_simple!(u64, impl_value_type_simple!(u64,
UInt64, UInt64,
gobject::G_TYPE_UINT64, gobject_ffi::G_TYPE_UINT64,
|value: &gobject::GValue| gobject::g_value_get_uint64(value), |value: &gobject_ffi::GValue| gobject_ffi::g_value_get_uint64(value),
|value: &mut gobject::GValue, v| gobject::g_value_set_uint64(value, v)); |value: &mut gobject_ffi::GValue, v| gobject_ffi::g_value_set_uint64(value, v));
impl_value_type_simple!( impl_value_type_simple!(
Rational32, Rational32,
Fraction, Fraction,
*TYPE_FRACTION, *TYPE_FRACTION,
|value: &gobject::GValue| { |value: &gobject_ffi::GValue| {
Rational32::new( Rational32::new(
gst::gst_value_get_fraction_numerator(value), gst_ffi::gst_value_get_fraction_numerator(value),
gst::gst_value_get_fraction_denominator(value), gst_ffi::gst_value_get_fraction_denominator(value),
) )
}, },
|value: &mut gobject::GValue, v: Rational32| { |value: &mut gobject_ffi::GValue, v: Rational32| {
gst::gst_value_set_fraction(value, *v.numer(), *v.denom()) gst_ffi::gst_value_set_fraction(value, *v.numer(), *v.denom())
} }
); );
impl<'a> ValueType<'a> for &'a str { impl<'a> ValueType<'a> for &'a str {
fn g_type() -> glib::GType { fn g_type() -> glib_ffi::GType {
gobject::G_TYPE_STRING gobject_ffi::G_TYPE_STRING
} }
fn from_value(value: &'a gobject::GValue) -> Option<Self> { fn from_value(value: &'a gobject_ffi::GValue) -> Option<Self> {
if value.g_type != Self::g_type() { if value.g_type != Self::g_type() {
return None; return None;
} }
unsafe { unsafe {
let s = gobject::g_value_get_string(value); let s = gobject_ffi::g_value_get_string(value);
if s.is_null() { if s.is_null() {
return Some(""); return Some("");
} }
@ -384,9 +384,9 @@ impl<'a> From<Cow<'a, str>> for Value {
unsafe { unsafe {
let mut value = Value(mem::zeroed()); let mut value = Value(mem::zeroed());
gobject::g_value_init(&mut value.0, <&str as ValueType>::g_type()); gobject_ffi::g_value_init(&mut value.0, <&str as ValueType>::g_type());
let v_cstr = glib::g_strndup(v.as_ptr() as *const c_char, v.len()); let v_cstr = glib_ffi::g_strndup(v.as_ptr() as *const c_char, v.len());
gobject::g_value_take_string(&mut value.0, v_cstr); gobject_ffi::g_value_take_string(&mut value.0, v_cstr);
value value
} }
@ -406,17 +406,17 @@ impl<'a> From<&'a str> for Value {
} }
impl<'a> ValueType<'a> for GstRc<Buffer> { impl<'a> ValueType<'a> for GstRc<Buffer> {
fn g_type() -> glib::GType { fn g_type() -> glib_ffi::GType {
*TYPE_BUFFER *TYPE_BUFFER
} }
fn from_value(value: &'a gobject::GValue) -> Option<Self> { fn from_value(value: &'a gobject_ffi::GValue) -> Option<Self> {
if value.g_type != Self::g_type() { if value.g_type != Self::g_type() {
return None; return None;
} }
unsafe { unsafe {
let buffer = gobject::g_value_get_boxed(value) as *mut gst::GstBuffer; let buffer = gobject_ffi::g_value_get_boxed(value) as *mut gst_ffi::GstBuffer;
Some(GstRc::from_unowned_ptr(buffer)) Some(GstRc::from_unowned_ptr(buffer))
} }
} }
@ -447,8 +447,8 @@ impl<'a> From<&'a Buffer> for Value {
unsafe { unsafe {
let mut value = Value(mem::zeroed()); let mut value = Value(mem::zeroed());
gobject::g_value_init(&mut value.0, <GstRc<Buffer> as ValueType>::g_type()); gobject_ffi::g_value_init(&mut value.0, <GstRc<Buffer> as ValueType>::g_type());
gobject::g_value_set_boxed(&mut value.0, v.as_ptr() as glib::gpointer); gobject_ffi::g_value_set_boxed(&mut value.0, v.as_ptr() as glib_ffi::gpointer);
value value
} }
@ -456,17 +456,17 @@ impl<'a> From<&'a Buffer> for Value {
} }
impl<'a> ValueType<'a> for &'a [Value] { impl<'a> ValueType<'a> for &'a [Value] {
fn g_type() -> glib::GType { fn g_type() -> glib_ffi::GType {
*TYPE_GST_VALUE_ARRAY *TYPE_GST_VALUE_ARRAY
} }
fn from_value(value: &'a gobject::GValue) -> Option<Self> { fn from_value(value: &'a gobject_ffi::GValue) -> Option<Self> {
if value.g_type != Self::g_type() { if value.g_type != Self::g_type() {
return None; return None;
} }
unsafe { unsafe {
let arr = value.data[0] as *const glib::GArray; let arr = value.data[0] as *const glib_ffi::GArray;
if arr.is_null() { if arr.is_null() {
Some(&[]) Some(&[])
@ -494,19 +494,19 @@ impl<'a> From<Cow<'a, [Value]>> for Value {
unsafe { unsafe {
let mut value = Value(mem::zeroed()); let mut value = Value(mem::zeroed());
gobject::g_value_init(&mut value.0, <&[Value] as ValueType>::g_type()); gobject_ffi::g_value_init(&mut value.0, <&[Value] as ValueType>::g_type());
match v { match v {
Cow::Borrowed(array) => for e in array { Cow::Borrowed(array) => for e in array {
gst::gst_value_array_append_value( gst_ffi::gst_value_array_append_value(
&mut value.0, &mut value.0,
e.as_ptr() as *mut gobject::GValue, e.as_ptr() as *mut gobject_ffi::GValue,
); );
}, },
Cow::Owned(array) => for e in array { Cow::Owned(array) => for e in array {
gst::gst_value_array_append_and_take_value( gst_ffi::gst_value_array_append_and_take_value(
&mut value.0, &mut value.0,
e.as_ptr() as *mut gobject::GValue, e.as_ptr() as *mut gobject_ffi::GValue,
); );
mem::forget(e); mem::forget(e);
}, },
@ -593,25 +593,25 @@ where
self.value self.value
} }
pub unsafe fn as_ptr(&self) -> *const gobject::GValue { pub unsafe fn as_ptr(&self) -> *const gobject_ffi::GValue {
&self.value.0 &self.value.0
} }
pub unsafe fn from_ptr(ptr: *const gobject::GValue) -> Option<TypedValue<T>> { pub unsafe fn from_ptr(ptr: *const gobject_ffi::GValue) -> Option<TypedValue<T>> {
if let Some(value) = Value::from_ptr(ptr) { if let Some(value) = Value::from_ptr(ptr) {
return TypedValue::from_value(value); return TypedValue::from_value(value);
} }
None None
} }
pub unsafe fn from_raw(value: gobject::GValue) -> Option<TypedValue<T>> { pub unsafe fn from_raw(value: gobject_ffi::GValue) -> Option<TypedValue<T>> {
if let Some(value) = Value::from_raw(value) { if let Some(value) = Value::from_raw(value) {
return TypedValue::from_value(value); return TypedValue::from_value(value);
} }
None None
} }
pub unsafe fn into_raw(mut self) -> gobject::GValue { pub unsafe fn into_raw(mut self) -> gobject_ffi::GValue {
mem::replace(&mut self.value.0, mem::zeroed()) mem::replace(&mut self.value.0, mem::zeroed())
} }
} }
@ -703,11 +703,11 @@ where
self.value self.value
} }
pub unsafe fn as_ptr(&self) -> *const gobject::GValue { pub unsafe fn as_ptr(&self) -> *const gobject_ffi::GValue {
self.value.0 self.value.0
} }
pub unsafe fn from_ptr(ptr: *const gobject::GValue) -> Option<TypedValueRef<'a, T>> { pub unsafe fn from_ptr(ptr: *const gobject_ffi::GValue) -> Option<TypedValueRef<'a, T>> {
if let Some(value) = ValueRef::from_ptr(ptr) { if let Some(value) = ValueRef::from_ptr(ptr) {
return TypedValueRef::from_value_ref(value); return TypedValueRef::from_value_ref(value);
} }
@ -724,7 +724,7 @@ mod tests {
($name: ident, $typ:ty, $value:expr, $variant:ident) => { ($name: ident, $typ:ty, $value:expr, $variant:ident) => {
#[test] #[test]
fn $name() { fn $name() {
unsafe { gst::gst_init(ptr::null_mut(), ptr::null_mut()) }; unsafe { gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut()) };
let value = Value::new($value); let value = Value::new($value);
if let ValueView::$variant(v) = value.get() { if let ValueView::$variant(v) = value.get() {
@ -770,7 +770,7 @@ mod tests {
#[test] #[test]
fn string_owned() { fn string_owned() {
unsafe { gst::gst_init(ptr::null_mut(), ptr::null_mut()) }; unsafe { gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut()) };
let orig_v = String::from("foo"); let orig_v = String::from("foo");
@ -813,7 +813,7 @@ mod tests {
#[test] #[test]
fn string_borrowed() { fn string_borrowed() {
unsafe { gst::gst_init(ptr::null_mut(), ptr::null_mut()) }; unsafe { gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut()) };
let orig_v = "foo"; let orig_v = "foo";
@ -852,7 +852,7 @@ mod tests {
#[test] #[test]
fn array_owned() { fn array_owned() {
unsafe { gst::gst_init(ptr::null_mut(), ptr::null_mut()) }; unsafe { gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut()) };
let orig_v = vec![Value::new("a"), Value::new("b")]; let orig_v = vec![Value::new("a"), Value::new("b")];
@ -887,7 +887,7 @@ mod tests {
#[test] #[test]
fn array_borrowed() { fn array_borrowed() {
unsafe { gst::gst_init(ptr::null_mut(), ptr::null_mut()) }; unsafe { gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut()) };
let orig_v = vec![Value::new("a"), Value::new("b")]; let orig_v = vec![Value::new("a"), Value::new("b")];
@ -919,7 +919,7 @@ mod tests {
#[test] #[test]
fn buffer() { fn buffer() {
unsafe { gst::gst_init(ptr::null_mut(), ptr::null_mut()) }; unsafe { gst_ffi::gst_init(ptr::null_mut(), ptr::null_mut()) };
let orig_v = Buffer::from_vec(vec![1, 2, 3, 4]).unwrap(); let orig_v = Buffer::from_vec(vec![1, 2, 3, 4]).unwrap();