mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-11-22 09:31:06 +00:00
Code Issues Projects Releases Wiki Activity

Get rid of GstSDPResult enum

Browse source
This commit is contained in:
Sebastian Dröge 2018-04-05 21:05:49 +03:00
parent 19b6987012
commit fb73d1bc15
10 changed files with 162 additions and 362 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Gir_GstSdp.toml
View file

@ -28,7 +28,6 @@ generate = [
"GstSdp.MIKEYSecSRTP",
"GstSdp.MIKEYTSType",
"GstSdp.MIKEYType",
"GstSdp.SDPResult",
]
manual = [

33
gstreamer-sdp/src/auto/enums.rs
View file

@ -494,36 +494,3 @@ impl FromGlib<ffi::GstMIKEYType> for MIKEYType {
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum SDPResult {
Ok,
Einval,
#[doc(hidden)]
__Unknown(i32),
}
#[doc(hidden)]
impl ToGlib for SDPResult {
type GlibType = ffi::GstSDPResult;
fn to_glib(&self) -> ffi::GstSDPResult {
match *self {
SDPResult::Ok => ffi::GST_SDP_OK,
SDPResult::Einval => ffi::GST_SDP_EINVAL,
SDPResult::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstSDPResult> for SDPResult {
fn from_glib(value: ffi::GstSDPResult) -> Self {
skip_assert_initialized!();
match value {
0 => SDPResult::Ok,
-1 => SDPResult::Einval,
value => SDPResult::__Unknown(value),
}
}
}

1
gstreamer-sdp/src/auto/mod.rs
View file

@ -21,7 +21,6 @@ pub use self::enums::MIKEYSecProto;
pub use self::enums::MIKEYSecSRTP;
pub use self::enums::MIKEYTSType;
pub use self::enums::MIKEYType;
pub use self::enums::SDPResult;
#[doc(hidden)]
pub mod traits {

11
gstreamer-sdp/src/s_d_p_attribute.rs
View file

@ -12,8 +12,6 @@ use std::mem;
use ffi;
use glib::translate::*;
use auto::SDPResult;
#[repr(C)]
pub struct SDPAttribute(pub(crate) ffi::GstSDPAttribute);
@ -22,13 +20,10 @@ impl SDPAttribute {
assert_initialized_main_thread!();
unsafe {
let mut attr = mem::zeroed();
let result = from_glib(ffi::gst_sdp_attribute_set(
&mut attr,
key.to_glib_none().0,
value.to_glib_none().0,
));
let result =
ffi::gst_sdp_attribute_set(&mut attr, key.to_glib_none().0, value.to_glib_none().0);
match result {
SDPResult::Ok => Ok(SDPAttribute(attr)),
ffi::GST_SDP_OK => Ok(SDPAttribute(attr)),
_ => Err(()),
}
}

10
gstreamer-sdp/src/s_d_p_bandwidth.rs
View file

@ -12,8 +12,6 @@ use std::mem;
use ffi;
use glib::translate::*;
use auto::SDPResult;
#[repr(C)]
pub struct SDPBandwidth(pub(crate) ffi::GstSDPBandwidth);
@ -22,13 +20,9 @@ impl SDPBandwidth {
assert_initialized_main_thread!();
unsafe {
let mut bw = mem::zeroed();
let result = from_glib(ffi::gst_sdp_bandwidth_set(
&mut bw,
bwtype.to_glib_none().0,
bandwidth,
));
let result = ffi::gst_sdp_bandwidth_set(&mut bw, bwtype.to_glib_none().0, bandwidth);
match result {
SDPResult::Ok => Ok(SDPBandwidth(bw)),
ffi::GST_SDP_OK => Ok(SDPBandwidth(bw)),
_ => Err(()),
}
}

8
gstreamer-sdp/src/s_d_p_connection.rs
View file

@ -12,8 +12,6 @@ use std::mem;
use ffi;
use glib::translate::*;
use auto::SDPResult;
#[repr(C)]
pub struct SDPConnection(pub(crate) ffi::GstSDPConnection);
@ -28,16 +26,16 @@ impl SDPConnection {
assert_initialized_main_thread!();
unsafe {
let mut conn = mem::zeroed();
let result = from_glib(ffi::gst_sdp_connection_set(
let result = ffi::gst_sdp_connection_set(
&mut conn,
nettype.to_glib_none().0,
addrtype.to_glib_none().0,
address.to_glib_none().0,
ttl,
addr_number,
));
);
match result {
SDPResult::Ok => Ok(SDPConnection(conn)),
ffi::GST_SDP_OK => Ok(SDPConnection(conn)),
_ => Err(()),
}
}

184
gstreamer-sdp/src/s_d_p_media.rs
View file

@ -15,7 +15,6 @@ use glib::translate::*;
use glib_ffi;
use gst;
use SDPResult;
use s_d_p_attribute::SDPAttribute;
use s_d_p_bandwidth::SDPBandwidth;
use s_d_p_connection::SDPConnection;
@ -41,9 +40,9 @@ impl SDPMedia {
assert_initialized_main_thread!();
unsafe {
let mut media = ptr::null_mut();
let result = from_glib(ffi::gst_sdp_media_new(&mut media));
let result = ffi::gst_sdp_media_new(&mut media);
match result {
SDPResult::Ok => Ok(from_glib_full(media)),
ffi::GST_SDP_OK => Ok(from_glib_full(media)),
_ => Err(()),
}
}
@ -57,28 +56,28 @@ impl SDPMedia {
let value = value.into();
let value = value.to_glib_none();
let result = unsafe {
from_glib(ffi::gst_sdp_media_add_attribute(
ffi::gst_sdp_media_add_attribute(
self.to_glib_none_mut().0,
key.to_glib_none().0,
value.0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn add_bandwidth(&mut self, bwtype: &str, bandwidth: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_add_bandwidth(
ffi::gst_sdp_media_add_bandwidth(
self.to_glib_none_mut().0,
bwtype.to_glib_none().0,
bandwidth,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -92,30 +91,27 @@ impl SDPMedia {
addr_number: u32,
) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_add_connection(
ffi::gst_sdp_media_add_connection(
self.to_glib_none_mut().0,
nettype.to_glib_none().0,
addrtype.to_glib_none().0,
address.to_glib_none().0,
ttl,
addr_number,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn add_format(&mut self, format: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_add_format(
self.to_glib_none_mut().0,
format.to_glib_none().0,
))
ffi::gst_sdp_media_add_format(self.to_glib_none_mut().0, format.to_glib_none().0)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -130,13 +126,10 @@ impl SDPMedia {
pub fn attributes_to_caps(&self, caps: &gst::Caps) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_attributes_to_caps(
self.to_glib_none().0,
caps.to_glib_none().0,
))
ffi::gst_sdp_media_attributes_to_caps(self.to_glib_none().0, caps.to_glib_none().0)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -311,59 +304,47 @@ impl SDPMedia {
pub fn insert_attribute(&mut self, idx: i32, mut attr: SDPAttribute) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_insert_attribute(
self.to_glib_none_mut().0,
idx,
&mut attr.0,
))
ffi::gst_sdp_media_insert_attribute(self.to_glib_none_mut().0, idx, &mut attr.0)
};
mem::forget(attr);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn insert_bandwidth(&mut self, idx: i32, mut bw: SDPBandwidth) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_insert_bandwidth(
self.to_glib_none_mut().0,
idx,
&mut bw.0,
))
ffi::gst_sdp_media_insert_bandwidth(self.to_glib_none_mut().0, idx, &mut bw.0)
};
mem::forget(bw);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn insert_connection(&mut self, idx: i32, mut conn: SDPConnection) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_insert_connection(
self.to_glib_none_mut().0,
idx,
&mut conn.0,
))
ffi::gst_sdp_media_insert_connection(self.to_glib_none_mut().0, idx, &mut conn.0)
};
mem::forget(conn);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn insert_format(&mut self, idx: i32, format: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_insert_format(
ffi::gst_sdp_media_insert_format(
self.to_glib_none_mut().0,
idx,
format.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -372,191 +353,146 @@ impl SDPMedia {
pub fn parse_keymgmt(&self) -> Result<MIKEYMessage, ()> {
unsafe {
let mut mikey = ptr::null_mut();
let result = from_glib(ffi::gst_sdp_media_parse_keymgmt(
self.to_glib_none().0,
&mut mikey,
));
let result = ffi::gst_sdp_media_parse_keymgmt(self.to_glib_none().0, &mut mikey);
match result {
SDPResult::Ok => Ok(from_glib_full(mikey)),
ffi::GST_SDP_OK => Ok(from_glib_full(mikey)),
_ => Err(()),
}
}
}
pub fn remove_attribute(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_remove_attribute(
self.to_glib_none_mut().0,
idx,
))
};
let result = unsafe { ffi::gst_sdp_media_remove_attribute(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn remove_bandwidth(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_remove_bandwidth(
self.to_glib_none_mut().0,
idx,
))
};
let result = unsafe { ffi::gst_sdp_media_remove_bandwidth(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn remove_connection(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_remove_connection(
self.to_glib_none_mut().0,
idx,
))
};
let result =
unsafe { ffi::gst_sdp_media_remove_connection(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn remove_format(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_remove_format(
self.to_glib_none_mut().0,
idx,
))
};
let result = unsafe { ffi::gst_sdp_media_remove_format(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_attribute(&mut self, idx: u32, mut attr: SDPAttribute) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_replace_attribute(
self.to_glib_none_mut().0,
idx,
&mut attr.0,
))
ffi::gst_sdp_media_replace_attribute(self.to_glib_none_mut().0, idx, &mut attr.0)
};
mem::forget(attr);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_bandwidth(&mut self, idx: u32, mut bw: SDPBandwidth) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_replace_bandwidth(
self.to_glib_none_mut().0,
idx,
&mut bw.0,
))
ffi::gst_sdp_media_replace_bandwidth(self.to_glib_none_mut().0, idx, &mut bw.0)
};
mem::forget(bw);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_connection(&mut self, idx: u32, mut conn: SDPConnection) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_replace_connection(
self.to_glib_none_mut().0,
idx,
&mut conn.0,
))
ffi::gst_sdp_media_replace_connection(self.to_glib_none_mut().0, idx, &mut conn.0)
};
mem::forget(conn);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_format(&mut self, idx: u32, format: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_replace_format(
ffi::gst_sdp_media_replace_format(
self.to_glib_none_mut().0,
idx,
format.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_information(&mut self, information: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_set_information(
ffi::gst_sdp_media_set_information(
self.to_glib_none_mut().0,
information.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_key(&mut self, type_: &str, data: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_set_key(
ffi::gst_sdp_media_set_key(
self.to_glib_none_mut().0,
type_.to_glib_none().0,
data.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_media(&mut self, med: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_set_media(
self.to_glib_none_mut().0,
med.to_glib_none().0,
))
ffi::gst_sdp_media_set_media(self.to_glib_none_mut().0, med.to_glib_none().0)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_port_info(&mut self, port: u32, num_ports: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_set_port_info(
self.to_glib_none_mut().0,
port,
num_ports,
))
};
let result =
unsafe { ffi::gst_sdp_media_set_port_info(self.to_glib_none_mut().0, port, num_ports) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_proto(&mut self, proto: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_media_set_proto(
self.to_glib_none_mut().0,
proto.to_glib_none().0,
))
ffi::gst_sdp_media_set_proto(self.to_glib_none_mut().0, proto.to_glib_none().0)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -564,14 +500,14 @@ impl SDPMedia {
pub fn set_media_from_caps(caps: &gst::Caps, media: &mut SDPMedia) -> Result<(), ()> {
assert_initialized_main_thread!();
let result = unsafe {
from_glib(ffi::gst_sdp_media_set_media_from_caps(
ffi::gst_sdp_media_set_media_from_caps(
caps.to_glib_none().0,
media.to_glib_none_mut().0,
))
)
};
mem::forget(media);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}

260
gstreamer-sdp/src/s_d_p_message.rs
View file

@ -17,7 +17,6 @@ use gobject_ffi;
use gst;
use gst::MiniObject;
use SDPResult;
use s_d_p_attribute::SDPAttribute;
use s_d_p_bandwidth::SDPBandwidth;
use s_d_p_connection::SDPConnection;
@ -53,83 +52,77 @@ impl SDPMessage {
value: P,
) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_add_attribute(
ffi::gst_sdp_message_add_attribute(
self.to_glib_none_mut().0,
key.to_glib_none().0,
value.into().to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn add_email(&mut self, email: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_add_email(
self.to_glib_none_mut().0,
email.to_glib_none().0,
))
ffi::gst_sdp_message_add_email(self.to_glib_none_mut().0, email.to_glib_none().0)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn add_media(&mut self, media: SDPMedia) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_add_media(
ffi::gst_sdp_message_add_media(
self.to_glib_none_mut().0,
media.to_glib_full() as *mut ffi::GstSDPMedia,
))
)
};
mem::forget(media);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn add_phone(&mut self, phone: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_add_phone(
self.to_glib_none_mut().0,
phone.to_glib_none().0,
))
ffi::gst_sdp_message_add_phone(self.to_glib_none_mut().0, phone.to_glib_none().0)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn add_time(&mut self, start: &str, stop: &str, repeat: &[&str]) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_add_time(
ffi::gst_sdp_message_add_time(
self.to_glib_none_mut().0,
start.to_glib_none().0,
stop.to_glib_none().0,
repeat.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn add_zone(&mut self, adj_time: &str, typed_time: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_add_zone(
ffi::gst_sdp_message_add_zone(
self.to_glib_none_mut().0,
adj_time.to_glib_none().0,
typed_time.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -144,13 +137,10 @@ impl SDPMessage {
pub fn attributes_to_caps(&self, caps: &mut gst::CapsRef) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_attributes_to_caps(
self.to_glib_none().0,
caps.as_mut_ptr(),
))
ffi::gst_sdp_message_attributes_to_caps(self.to_glib_none().0, caps.as_mut_ptr())
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -160,9 +150,9 @@ impl SDPMessage {
}
pub fn dump(&self) -> Result<(), ()> {
let result = unsafe { from_glib(ffi::gst_sdp_message_dump(self.to_glib_none().0)) };
let result = unsafe { ffi::gst_sdp_message_dump(self.to_glib_none().0) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -386,88 +376,72 @@ impl SDPMessage {
pub fn insert_attribute(&mut self, idx: i32, mut attr: SDPAttribute) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_insert_attribute(
self.to_glib_none_mut().0,
idx,
&mut attr.0,
))
ffi::gst_sdp_message_insert_attribute(self.to_glib_none_mut().0, idx, &mut attr.0)
};
mem::forget(attr);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn insert_bandwidth(&mut self, idx: i32, mut bw: SDPBandwidth) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_insert_bandwidth(
self.to_glib_none_mut().0,
idx,
&mut bw.0,
))
ffi::gst_sdp_message_insert_bandwidth(self.to_glib_none_mut().0, idx, &mut bw.0)
};
mem::forget(bw);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn insert_email(&mut self, idx: i32, email: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_insert_email(
ffi::gst_sdp_message_insert_email(
self.to_glib_none_mut().0,
idx,
email.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn insert_phone(&mut self, idx: i32, phone: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_insert_phone(
ffi::gst_sdp_message_insert_phone(
self.to_glib_none_mut().0,
idx,
phone.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn insert_time(&mut self, idx: i32, mut time: SDPTime) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_insert_time(
self.to_glib_none_mut().0,
idx,
&mut time.0,
))
ffi::gst_sdp_message_insert_time(self.to_glib_none_mut().0, idx, &mut time.0)
};
mem::forget(time);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn insert_zone(&mut self, idx: i32, mut zone: SDPZone) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_insert_zone(
self.to_glib_none_mut().0,
idx,
&mut zone.0,
))
ffi::gst_sdp_message_insert_zone(self.to_glib_none_mut().0, idx, &mut zone.0)
};
mem::forget(zone);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -478,15 +452,11 @@ impl SDPMessage {
#[cfg(any(feature = "v1_8_1", feature = "dox"))]
pub fn parse_keymgmt(&self, mikey: MIKEYMessage) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_parse_keymgmt(
self.to_glib_none().0,
&mut mikey,
))
};
let result =
unsafe { ffi::gst_sdp_message_parse_keymgmt(self.to_glib_none().0, &mut mikey) };
mem::forget(mikey);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -496,167 +466,123 @@ impl SDPMessage {
}
pub fn remove_attribute(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_remove_attribute(
self.to_glib_none_mut().0,
idx,
))
};
let result =
unsafe { ffi::gst_sdp_message_remove_attribute(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn remove_bandwidth(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_remove_bandwidth(
self.to_glib_none_mut().0,
idx,
))
};
let result =
unsafe { ffi::gst_sdp_message_remove_bandwidth(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn remove_email(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_remove_email(
self.to_glib_none_mut().0,
idx,
))
};
let result = unsafe { ffi::gst_sdp_message_remove_email(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn remove_phone(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_remove_phone(
self.to_glib_none_mut().0,
idx,
))
};
let result = unsafe { ffi::gst_sdp_message_remove_phone(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn remove_time(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_remove_time(
self.to_glib_none_mut().0,
idx,
))
};
let result = unsafe { ffi::gst_sdp_message_remove_time(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn remove_zone(&mut self, idx: u32) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_remove_zone(
self.to_glib_none_mut().0,
idx,
))
};
let result = unsafe { ffi::gst_sdp_message_remove_zone(self.to_glib_none_mut().0, idx) };
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_attribute(&mut self, idx: u32, mut attr: SDPAttribute) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_replace_attribute(
self.to_glib_none_mut().0,
idx,
&mut attr.0,
))
ffi::gst_sdp_message_replace_attribute(self.to_glib_none_mut().0, idx, &mut attr.0)
};
mem::forget(attr);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_bandwidth(&mut self, idx: u32, mut bw: SDPBandwidth) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_replace_bandwidth(
self.to_glib_none_mut().0,
idx,
&mut bw.0,
))
ffi::gst_sdp_message_replace_bandwidth(self.to_glib_none_mut().0, idx, &mut bw.0)
};
mem::forget(bw);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_email(&mut self, idx: u32, email: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_replace_email(
ffi::gst_sdp_message_replace_email(
self.to_glib_none_mut().0,
idx,
email.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_phone(&mut self, idx: u32, phone: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_replace_phone(
ffi::gst_sdp_message_replace_phone(
self.to_glib_none_mut().0,
idx,
phone.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_time(&mut self, idx: u32, mut time: SDPTime) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_replace_time(
self.to_glib_none_mut().0,
idx,
&mut time.0,
))
ffi::gst_sdp_message_replace_time(self.to_glib_none_mut().0, idx, &mut time.0)
};
mem::forget(time);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn replace_zone(&mut self, idx: u32, mut zone: SDPZone) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_replace_zone(
self.to_glib_none_mut().0,
idx,
&mut zone.0,
))
ffi::gst_sdp_message_replace_zone(self.to_glib_none_mut().0, idx, &mut zone.0)
};
mem::forget(zone);
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -670,44 +596,44 @@ impl SDPMessage {
addr_number: u32,
) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_set_connection(
ffi::gst_sdp_message_set_connection(
self.to_glib_none_mut().0,
nettype.to_glib_none().0,
addrtype.to_glib_none().0,
address.to_glib_none().0,
ttl,
addr_number,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_information(&mut self, information: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_set_information(
ffi::gst_sdp_message_set_information(
self.to_glib_none_mut().0,
information.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_key(&mut self, type_: &str, data: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_set_key(
ffi::gst_sdp_message_set_key(
self.to_glib_none_mut().0,
type_.to_glib_none().0,
data.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -722,7 +648,7 @@ impl SDPMessage {
addr: &str,
) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_set_origin(
ffi::gst_sdp_message_set_origin(
self.to_glib_none_mut().0,
username.to_glib_none().0,
sess_id.to_glib_none().0,
@ -730,49 +656,43 @@ impl SDPMessage {
nettype.to_glib_none().0,
addrtype.to_glib_none().0,
addr.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_session_name(&mut self, session_name: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_set_session_name(
ffi::gst_sdp_message_set_session_name(
self.to_glib_none_mut().0,
session_name.to_glib_none().0,
))
)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_uri(&mut self, uri: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_set_uri(
self.to_glib_none_mut().0,
uri.to_glib_none().0,
))
ffi::gst_sdp_message_set_uri(self.to_glib_none_mut().0, uri.to_glib_none().0)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
pub fn set_version(&mut self, version: &str) -> Result<(), ()> {
let result = unsafe {
from_glib(ffi::gst_sdp_message_set_version(
self.to_glib_none_mut().0,
version.to_glib_none().0,
))
ffi::gst_sdp_message_set_version(self.to_glib_none_mut().0, version.to_glib_none().0)
};
match result {
SDPResult::Ok => Ok(()),
ffi::GST_SDP_OK => Ok(()),
_ => Err(()),
}
}
@ -801,13 +721,9 @@ impl SDPMessage {
let size = data.len() as u32;
let msg = glib_ffi::g_malloc0(mem::size_of::<ffi::GstSDPMessage>())
as *mut ffi::GstSDPMessage;
let result = from_glib(ffi::gst_sdp_message_parse_buffer(
data.to_glib_none().0,
size,
msg,
));
let result = ffi::gst_sdp_message_parse_buffer(data.to_glib_none().0, size, msg);
match result {
SDPResult::Ok => Ok(from_glib_full(msg)),
ffi::GST_SDP_OK => Ok(from_glib_full(msg)),
_ => {
glib_ffi::g_free(msg as *mut _);
Err(())
@ -821,9 +737,9 @@ impl SDPMessage {
unsafe {
let msg = glib_ffi::g_malloc0(mem::size_of::<ffi::GstSDPMessage>())
as *mut ffi::GstSDPMessage;
let result = from_glib(ffi::gst_sdp_message_parse_uri(uri.to_glib_none().0, msg));
let result = ffi::gst_sdp_message_parse_uri(uri.to_glib_none().0, msg);
match result {
SDPResult::Ok => Ok(from_glib_full(msg)),
ffi::GST_SDP_OK => Ok(from_glib_full(msg)),
_ => {
glib_ffi::g_free(msg as *mut _);
Err(())

8
gstreamer-sdp/src/s_d_p_time.rs
View file

@ -13,8 +13,6 @@ use std::os::raw::c_char;
use ffi;
use glib::translate::*;
use auto::SDPResult;
#[repr(C)]
pub struct SDPTime(pub(crate) ffi::GstSDPTime);
@ -23,14 +21,14 @@ impl SDPTime {
assert_initialized_main_thread!();
unsafe {
let mut time = mem::zeroed();
let result = from_glib(ffi::gst_sdp_time_set(
let result = ffi::gst_sdp_time_set(
&mut time,
start.to_glib_none().0,
stop.to_glib_none().0,
repeat.to_glib_none().0,
));
);
match result {
SDPResult::Ok => Ok(SDPTime(time)),
ffi::GST_SDP_OK => Ok(SDPTime(time)),
_ => Err(()),
}
}

8
gstreamer-sdp/src/s_d_p_zone.rs
View file

@ -12,8 +12,6 @@ use std::mem;
use ffi;
use glib::translate::*;
use auto::SDPResult;
#[repr(C)]
pub struct SDPZone(pub(crate) ffi::GstSDPZone);
@ -22,13 +20,13 @@ impl SDPZone {
assert_initialized_main_thread!();
unsafe {
let mut zone = mem::zeroed();
let result = from_glib(ffi::gst_sdp_zone_set(
let result = ffi::gst_sdp_zone_set(
&mut zone,
time.to_glib_none().0,
typed_time.to_glib_none().0,
));
);
match result {
SDPResult::Ok => Ok(SDPZone(zone)),
ffi::GST_SDP_OK => Ok(SDPZone(zone)),
_ => Err(()),
}
}