rafaelcaricio/gstreamer-rs
1
0
Fork 0
forked from mirrors/gstreamer-rs
Code Pull requests Activity

Add bindings for pad probes

Browse source 
Missing for this to be actually useful: Buffer, BufferList, Event, Query bindings
This commit is contained in:
Sebastian Dröge 2017-07-24 11:51:14 +03:00
parent c750b62e98
commit e87c459099
7 changed files with 287 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
Gir_Gst.toml
View file

@ -49,6 +49,8 @@ generate = [
"Gst.ProgressType",
"Gst.BusSyncReply",
"Gst.TagMergeMode",
"Gst.PadProbeType",
"Gst.PadProbeReturn",
]
manual = [
@ -259,6 +261,11 @@ status = "generate"
# Caps is not a GObject
ignore = true
[[object.function]]
name = "remove_probe"
# Don't use a ulong
ignore = true
[[object]]
name = "Gst.Stream"
status = "generate"

66
gstreamer/src/auto/enums.rs
View file

@ -711,6 +711,72 @@ impl SetValue for PadPresence {
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PadProbeReturn {
Drop,
Ok,
Remove,
Pass,
Handled,
#[doc(hidden)]
__Unknown(i32),
}
#[doc(hidden)]
impl ToGlib for PadProbeReturn {
type GlibType = ffi::GstPadProbeReturn;
fn to_glib(&self) -> ffi::GstPadProbeReturn {
match *self {
PadProbeReturn::Drop => ffi::GST_PAD_PROBE_DROP,
PadProbeReturn::Ok => ffi::GST_PAD_PROBE_OK,
PadProbeReturn::Remove => ffi::GST_PAD_PROBE_REMOVE,
PadProbeReturn::Pass => ffi::GST_PAD_PROBE_PASS,
PadProbeReturn::Handled => ffi::GST_PAD_PROBE_HANDLED,
PadProbeReturn::__Unknown(value) => unsafe{std::mem::transmute(value)}
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstPadProbeReturn> for PadProbeReturn {
fn from_glib(value: ffi::GstPadProbeReturn) -> Self {
skip_assert_initialized!();
match value as i32 {
0 => PadProbeReturn::Drop,
1 => PadProbeReturn::Ok,
2 => PadProbeReturn::Remove,
3 => PadProbeReturn::Pass,
4 => PadProbeReturn::Handled,
value => PadProbeReturn::__Unknown(value),
}
}
}
impl StaticType for PadProbeReturn {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_pad_probe_return_get_type()) }
}
}
impl<'a> FromValueOptional<'a> for PadProbeReturn {
unsafe fn from_value_optional(value: &Value) -> Option<Self> {
Some(FromValue::from_value(value))
}
}
impl<'a> FromValue<'a> for PadProbeReturn {
unsafe fn from_value(value: &Value) -> Self {
from_glib(std::mem::transmute::<i32, ffi::GstPadProbeReturn>(gobject_ffi::g_value_get_enum(value.to_glib_none().0)))
}
}
impl SetValue for PadProbeReturn {
unsafe fn set_value(value: &mut Value, this: &Self) {
gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib() as i32)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ParseError {
Syntax,

68
gstreamer/src/auto/flags.rs
View file

@ -8,6 +8,74 @@ use glib::value::{Value, SetValue, FromValue, FromValueOptional};
use gobject_ffi;
use glib::translate::*;
bitflags! {
pub struct PadProbeType: u32 {
const PAD_PROBE_TYPE_INVALID = 0;
const PAD_PROBE_TYPE_IDLE = 1;
const PAD_PROBE_TYPE_BLOCK = 2;
const PAD_PROBE_TYPE_BUFFER = 16;
const PAD_PROBE_TYPE_BUFFER_LIST = 32;
const PAD_PROBE_TYPE_EVENT_DOWNSTREAM = 64;
const PAD_PROBE_TYPE_EVENT_UPSTREAM = 128;
const PAD_PROBE_TYPE_EVENT_FLUSH = 256;
const PAD_PROBE_TYPE_QUERY_DOWNSTREAM = 512;
const PAD_PROBE_TYPE_QUERY_UPSTREAM = 1024;
const PAD_PROBE_TYPE_PUSH = 4096;
const PAD_PROBE_TYPE_PULL = 8192;
const PAD_PROBE_TYPE_BLOCKING = 3;
const PAD_PROBE_TYPE_DATA_DOWNSTREAM = 112;
const PAD_PROBE_TYPE_DATA_UPSTREAM = 128;
const PAD_PROBE_TYPE_DATA_BOTH = 240;
const PAD_PROBE_TYPE_BLOCK_DOWNSTREAM = 114;
const PAD_PROBE_TYPE_BLOCK_UPSTREAM = 130;
const PAD_PROBE_TYPE_EVENT_BOTH = 192;
const PAD_PROBE_TYPE_QUERY_BOTH = 1536;
const PAD_PROBE_TYPE_ALL_BOTH = 1776;
const PAD_PROBE_TYPE_SCHEDULING = 12288;
}
}
#[doc(hidden)]
impl ToGlib for PadProbeType {
type GlibType = ffi::GstPadProbeType;
fn to_glib(&self) -> ffi::GstPadProbeType {
ffi::GstPadProbeType::from_bits_truncate(self.bits())
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstPadProbeType> for PadProbeType {
fn from_glib(value: ffi::GstPadProbeType) -> PadProbeType {
skip_assert_initialized!();
PadProbeType::from_bits_truncate(value.bits())
}
}
impl StaticType for PadProbeType {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_pad_probe_type_get_type()) }
}
}
impl<'a> FromValueOptional<'a> for PadProbeType {
unsafe fn from_value_optional(value: &Value) -> Option<Self> {
Some(FromValue::from_value(value))
}
}
impl<'a> FromValue<'a> for PadProbeType {
unsafe fn from_value(value: &Value) -> Self {
from_glib(ffi::GstPadProbeType::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
}
}
impl SetValue for PadProbeType {
unsafe fn set_value(value: &mut Value, this: &Self) {
gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
}
}
bitflags! {
pub struct SeekFlags: u32 {
const SEEK_FLAG_NONE = 0;

24
gstreamer/src/auto/mod.rs
View file

@ -82,6 +82,7 @@ pub use self::enums::LibraryError;
pub use self::enums::PadDirection;
pub use self::enums::PadLinkReturn;
pub use self::enums::PadPresence;
pub use self::enums::PadProbeReturn;
pub use self::enums::ParseError;
pub use self::enums::PluginError;
pub use self::enums::ProgressType;
@ -98,6 +99,29 @@ pub use self::enums::URIError;
pub use self::enums::URIType;
mod flags;
pub use self::flags::PadProbeType;
pub use self::flags::PAD_PROBE_TYPE_INVALID;
pub use self::flags::PAD_PROBE_TYPE_IDLE;
pub use self::flags::PAD_PROBE_TYPE_BLOCK;
pub use self::flags::PAD_PROBE_TYPE_BUFFER;
pub use self::flags::PAD_PROBE_TYPE_BUFFER_LIST;
pub use self::flags::PAD_PROBE_TYPE_EVENT_DOWNSTREAM;
pub use self::flags::PAD_PROBE_TYPE_EVENT_UPSTREAM;
pub use self::flags::PAD_PROBE_TYPE_EVENT_FLUSH;
pub use self::flags::PAD_PROBE_TYPE_QUERY_DOWNSTREAM;
pub use self::flags::PAD_PROBE_TYPE_QUERY_UPSTREAM;
pub use self::flags::PAD_PROBE_TYPE_PUSH;
pub use self::flags::PAD_PROBE_TYPE_PULL;
pub use self::flags::PAD_PROBE_TYPE_BLOCKING;
pub use self::flags::PAD_PROBE_TYPE_DATA_DOWNSTREAM;
pub use self::flags::PAD_PROBE_TYPE_DATA_UPSTREAM;
pub use self::flags::PAD_PROBE_TYPE_DATA_BOTH;
pub use self::flags::PAD_PROBE_TYPE_BLOCK_DOWNSTREAM;
pub use self::flags::PAD_PROBE_TYPE_BLOCK_UPSTREAM;
pub use self::flags::PAD_PROBE_TYPE_EVENT_BOTH;
pub use self::flags::PAD_PROBE_TYPE_QUERY_BOTH;
pub use self::flags::PAD_PROBE_TYPE_ALL_BOTH;
pub use self::flags::PAD_PROBE_TYPE_SCHEDULING;
pub use self::flags::SeekFlags;
pub use self::flags::SEEK_FLAG_NONE;
pub use self::flags::SEEK_FLAG_FLUSH;

13
gstreamer/src/auto/pad.rs
View file

@ -20,7 +20,6 @@ use glib::signal::connect;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use libc;
use std::boxed::Box as Box_;
use std::mem;
use std::mem::transmute;
@ -71,7 +70,7 @@ unsafe impl Sync for Pad {}
pub trait PadExt {
//fn activate_mode(&self, mode: /*Ignored*/PadMode, active: bool) -> bool;
//fn add_probe<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, mask: /*Ignored*/PadProbeType, callback: /*Unknown conversion*//*Unimplemented*/PadProbeCallback, user_data: P, destroy_data: /*Unknown conversion*//*Unimplemented*/DestroyNotify) -> libc::c_ulong;
//fn add_probe<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, mask: PadProbeType, callback: /*Unknown conversion*//*Unimplemented*/PadProbeCallback, user_data: P, destroy_data: /*Unknown conversion*//*Unimplemented*/DestroyNotify) -> libc::c_ulong;
fn can_link<P: IsA<Pad>>(&self, sinkpad: &P) -> bool;
@ -191,8 +190,6 @@ pub trait PadExt {
fn query_position(&self, format: Format) -> Option<i64>;
fn remove_probe(&self, id: libc::c_ulong);
//fn send_event(&self, event: /*Ignored*/&mut Event) -> bool;
//fn set_activate_function_full<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, activate: /*Unknown conversion*//*Unimplemented*/PadActivateFunction, user_data: P, notify: /*Unknown conversion*//*Unimplemented*/DestroyNotify);
@ -249,7 +246,7 @@ impl<O: IsA<Pad> + IsA<glib::object::Object>> PadExt for O {
// unsafe { TODO: call ffi::gst_pad_activate_mode() }
//}
//fn add_probe<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, mask: /*Ignored*/PadProbeType, callback: /*Unknown conversion*//*Unimplemented*/PadProbeCallback, user_data: P, destroy_data: /*Unknown conversion*//*Unimplemented*/DestroyNotify) -> libc::c_ulong {
//fn add_probe<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, mask: PadProbeType, callback: /*Unknown conversion*//*Unimplemented*/PadProbeCallback, user_data: P, destroy_data: /*Unknown conversion*//*Unimplemented*/DestroyNotify) -> libc::c_ulong {
// unsafe { TODO: call ffi::gst_pad_add_probe() }
//}
@ -571,12 +568,6 @@ impl<O: IsA<Pad> + IsA<glib::object::Object>> PadExt for O {
}
}
fn remove_probe(&self, id: libc::c_ulong) {
unsafe {
ffi::gst_pad_remove_probe(self.to_glib_none().0, id);
}
}
//fn send_event(&self, event: /*Ignored*/&mut Event) -> bool {
// unsafe { TODO: call ffi::gst_pad_send_event() }
//}

2
gstreamer/src/lib.rs
View file

@ -61,8 +61,10 @@ pub use tags::*;
mod element;
mod bin;
mod bus;
mod pad;
mod gobject;
pub use bin::BinExtManual;
pub use pad::PadExtManual;
pub use gobject::GObjectExtManualGst;
mod value;

118
gstreamer/src/pad.rs Normal file
View file

@ -0,0 +1,118 @@
// Copyright (C) 2017 Sebastian Dröge <sebastian@centricular.com>
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use Pad;
use PadProbeType;
use PadProbeReturn;
use std::cell::RefCell;
use std::mem::transmute;
use glib::IsA;
use glib::translate::{ToGlib, from_glib, from_glib_none};
use glib::source::CallbackGuard;
use glib_ffi::gpointer;
use libc;
use ffi;
pub struct PadProbeId(libc::c_ulong);
pub struct PadProbeInfo {
pub mask: PadProbeType,
pub id: PadProbeId,
pub offset: u64,
pub size: u32,
pub data: Option<PadProbeData>,
}
pub enum PadProbeData {
// Buffer(&Buffer),
// BufferList(&BufferList),
// Query(&Query),
// Event(&Event),
Unknown,
}
pub trait PadExtManual {
fn add_probe<F>(&self, mask: PadProbeType, func: F) -> PadProbeId
where
F: FnMut(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static;
fn remove_probe(&self, id: PadProbeId);
}
impl<O: IsA<Pad>> PadExtManual for O {
fn add_probe<F>(&self, mask: PadProbeType, func: F) -> PadProbeId
where
F: FnMut(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static,
{
unsafe {
let id = ffi::gst_pad_add_probe(
self.to_glib_none().0,
mask.to_glib(),
Some(trampoline_pad_probe),
into_raw_pad_probe(func),
Some(destroy_closure_pad_probe),
);
PadProbeId(id)
}
}
fn remove_probe(&self, id: PadProbeId) {
unsafe {
ffi::gst_pad_remove_probe(self.to_glib_none().0, id.0 as libc::c_ulong);
}
}
}
unsafe extern "C" fn trampoline_pad_probe(
pad: *mut ffi::GstPad,
info: *mut ffi::GstPadProbeInfo,
func: gpointer,
) -> ffi::GstPadProbeReturn {
let _guard = CallbackGuard::new();
let func: &RefCell<
Box<FnMut(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static>,
> = transmute(func);
let mut probe_info = PadProbeInfo {
mask: from_glib((*info).type_),
id: PadProbeId((*info).id),
offset: (*info).offset,
size: (*info).size,
data: if (*info).data.is_null() {
None
} else {
Some(PadProbeData::Unknown)
},
};
let ret = (&mut *func.borrow_mut())(&from_glib_none(pad), &mut probe_info).to_glib();
// TODO: Possibly replace info.data
ret
}
unsafe extern "C" fn destroy_closure_pad_probe(ptr: gpointer) {
let _guard = CallbackGuard::new();
Box::<RefCell<Box<FnMut(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static>>>::from_raw(ptr as *mut _);
}
fn into_raw_pad_probe<
F: FnMut(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static,
>(
func: F,
) -> gpointer {
let func: Box<
RefCell<Box<FnMut(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static>>,
> = Box::new(RefCell::new(Box::new(func)));
Box::into_raw(func) as gpointer
}