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

Run everything through latest rustfmt-nightly

Browse source
This commit is contained in:
Sebastian Dröge 2018-02-22 11:18:37 +01:00
parent 1fbc5e7644
commit 4117c01ff2
37 changed files with 213 additions and 265 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
examples/src/bin/appsink.rs
View file

@ -32,7 +32,8 @@ struct ErrorMessage {
src: String,
error: String,
debug: Option<String>,
#[cause] cause: glib::Error,
#[cause]
cause: glib::Error,
}
fn create_pipeline() -> Result<gst::Pipeline, Error> {

3
examples/src/bin/appsrc.rs
View file

@ -28,7 +28,8 @@ struct ErrorMessage {
src: String,
error: String,
debug: Option<String>,
#[cause] cause: glib::Error,
#[cause]
cause: glib::Error,
}
const WIDTH: usize = 320;

3
examples/src/bin/decodebin.rs
View file

@ -28,7 +28,8 @@ struct ErrorMessage {
src: String,
error: String,
debug: Option<String>,
#[cause] cause: glib::Error,
#[cause]
cause: glib::Error,
}
fn example_main() -> Result<(), Error> {

32
examples/src/bin/rtpfecclient.rs
View file

@ -38,7 +38,8 @@ struct ErrorMessage {
src: String,
error: String,
debug: Option<String>,
#[cause] cause: glib::Error,
#[cause]
cause: glib::Error,
}
fn make_element<'a, P: Into<Option<&'a str>>>(
@ -121,16 +122,7 @@ fn example_main() -> Result<(), Error> {
let scale = make_element("videoscale", None)?;
let filter = make_element("capsfilter", None)?;
pipeline.add_many(&[
&src,
&netsim,
&rtpbin,
&depay,
&dec,
&conv,
&scale,
&filter,
])?;
pipeline.add_many(&[&src, &netsim, &rtpbin, &depay, &dec, &conv, &scale, &filter])?;
gst::Element::link_many(&[&depay, &dec, &conv, &scale, &filter])?;
match args[1].as_str() {
@ -253,16 +245,14 @@ fn example_main() -> Result<(), Error> {
match msg.view() {
MessageView::Eos(..) => break,
MessageView::Error(err) => {
return Err(
ErrorMessage {
src: msg.get_src()
.map(|s| s.get_path_string())
.unwrap_or(String::from("None")),
error: err.get_error().description().into(),
debug: err.get_debug(),
cause: err.get_error(),
}.into(),
);
return Err(ErrorMessage {
src: msg.get_src()
.map(|s| s.get_path_string())
.unwrap_or(String::from("None")),
error: err.get_error().description().into(),
debug: err.get_debug(),
cause: err.get_error(),
}.into());
}
MessageView::StateChanged(s) => match msg.get_src() {
Some(element) => if element == pipeline && s.get_current() == gst::State::Playing {

21
examples/src/bin/rtpfecserver.rs
View file

@ -35,7 +35,8 @@ struct ErrorMessage {
src: String,
error: String,
debug: Option<String>,
#[cause] cause: glib::Error,
#[cause]
cause: glib::Error,
}
fn make_element<'a, P: Into<Option<&'a str>>>(
@ -183,16 +184,14 @@ fn example_main() -> Result<(), Error> {
match msg.view() {
MessageView::Eos(..) => break,
MessageView::Error(err) => {
return Err(
ErrorMessage {
src: msg.get_src()
.map(|s| s.get_path_string())
.unwrap_or(String::from("None")),
error: err.get_error().description().into(),
debug: err.get_debug(),
cause: err.get_error(),
}.into(),
);
return Err(ErrorMessage {
src: msg.get_src()
.map(|s| s.get_path_string())
.unwrap_or(String::from("None")),
error: err.get_error().description().into(),
debug: err.get_debug(),
cause: err.get_error(),
}.into());
}
MessageView::StateChanged(s) => match msg.get_src() {
Some(element) => if element == pipeline && s.get_current() == gst::State::Playing {

9
examples/src/bin/rtsp-server.rs
View file

@ -50,7 +50,10 @@ fn main_loop() -> Result<(), Error> {
server.attach(None);
println!("Stream ready at rtsp://127.0.0.1:{}/test", server.get_bound_port());
println!(
"Stream ready at rtsp://127.0.0.1:{}/test",
server.get_bound_port()
);
main_loop.run();
@ -62,7 +65,9 @@ fn example_main() -> Result<(), Error> {
#[cfg(not(feature = "gst-rtsp-server"))]
{
eprintln!("Feature gst-rtsp-server is required. Please rebuild with --features gst-rtsp-server");
eprintln!(
"Feature gst-rtsp-server is required. Please rebuild with --features gst-rtsp-server"
);
std::process::exit(-1)
}

3
examples/src/bin/tagsetter.rs
View file

@ -24,7 +24,8 @@ struct ErrorMessage {
src: String,
error: String,
debug: Option<String>,
#[cause] cause: glib::Error,
#[cause]
cause: glib::Error,
}
fn example_main() -> Result<(), Error> {

3
gstreamer-audio/src/audio_info.rs
View file

@ -298,8 +298,7 @@ impl glib::types::StaticType for AudioInfo {
#[doc(hidden)]
impl<'a> glib::value::FromValueOptional<'a> for AudioInfo {
unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
Option::<AudioInfo>::from_glib_none(gobject_ffi::g_value_get_boxed(value.to_glib_none().0)
as *mut ffi::GstAudioInfo)
Option::<AudioInfo>::from_glib_none(gobject_ffi::g_value_get_boxed(value.to_glib_none().0) as *mut ffi::GstAudioInfo)
}
}

4
gstreamer-player/src/config.rs
View file

@ -46,9 +46,7 @@ impl AsMut<gst::StructureRef> for PlayerConfig {
impl PlayerConfig {
pub fn get_position_update_interval(&self) -> u32 {
assert_initialized_main_thread!();
unsafe {
ffi::gst_player_config_get_position_update_interval(self.0.to_glib_none().0)
}
unsafe { ffi::gst_player_config_get_position_update_interval(self.0.to_glib_none().0) }
}
pub fn get_seek_accurate(&self) -> bool {

10
gstreamer-rtsp-server/src/lib.rs
View file

@ -10,19 +10,19 @@
extern crate bitflags;
extern crate libc;
extern crate gio;
extern crate gio_sys as gio_ffi;
#[macro_use]
extern crate glib;
extern crate glib_sys as glib_ffi;
extern crate gio;
extern crate gio_sys as gio_ffi;
extern crate gobject_sys as gobject_ffi;
extern crate gstreamer as gst;
extern crate gstreamer_sys as gst_ffi;
extern crate gstreamer_rtsp as gst_rtsp;
extern crate gstreamer_rtsp_sys as gst_rtsp_ffi;
extern crate gstreamer_net as gst_net;
extern crate gstreamer_net_sys as gst_net_ffi;
extern crate gstreamer_rtsp as gst_rtsp;
extern crate gstreamer_rtsp_server_sys as ffi;
extern crate gstreamer_rtsp_sys as gst_rtsp_ffi;
extern crate gstreamer_sys as gst_ffi;
macro_rules! assert_initialized_main_thread {
() => (

27
gstreamer-rtsp-server/src/r_t_s_p_address_pool.rs
View file

@ -7,17 +7,36 @@ use glib::translate::*;
use std::ptr;
pub trait RTSPAddressPoolExtManual {
fn reserve_address(&self, ip_address: &str, port: u32, n_ports: u32, ttl: u32) -> Result<RTSPAddress, RTSPAddressPoolResult>;
fn reserve_address(
&self,
ip_address: &str,
port: u32,
n_ports: u32,
ttl: u32,
) -> Result<RTSPAddress, RTSPAddressPoolResult>;
}
impl<O: IsA<RTSPAddressPool>> RTSPAddressPoolExtManual for O {
fn reserve_address(&self, ip_address: &str, port: u32, n_ports: u32, ttl: u32) -> Result<RTSPAddress, RTSPAddressPoolResult> {
fn reserve_address(
&self,
ip_address: &str,
port: u32,
n_ports: u32,
ttl: u32,
) -> Result<RTSPAddress, RTSPAddressPoolResult> {
unsafe {
let mut address = ptr::null_mut();
let ret = from_glib(ffi::gst_rtsp_address_pool_reserve_address(self.to_glib_none().0, ip_address.to_glib_none().0, port, n_ports, ttl, &mut address));
let ret = from_glib(ffi::gst_rtsp_address_pool_reserve_address(
self.to_glib_none().0,
ip_address.to_glib_none().0,
port,
n_ports,
ttl,
&mut address,
));
match ret {
RTSPAddressPoolResult::Ok => Ok(from_glib_full(address)),
_ => Err(ret)
_ => Err(ret),
}
}
}

5
gstreamer-rtsp-server/src/r_t_s_p_client.rs
View file

@ -14,7 +14,10 @@ impl<O: IsA<RTSPClient>> RTSPClientExtManual for O {
let context = context.into();
let context = context.to_glib_none();
unsafe {
from_glib(ffi::gst_rtsp_client_attach(self.to_glib_none().0, context.0))
from_glib(ffi::gst_rtsp_client_attach(
self.to_glib_none().0,
context.0,
))
}
}
}

5
gstreamer-rtsp-server/src/r_t_s_p_server.rs
View file

@ -14,7 +14,10 @@ impl<O: IsA<RTSPServer>> RTSPServerExtManual for O {
let context = context.into();
let context = context.to_glib_none();
unsafe {
from_glib(ffi::gst_rtsp_server_attach(self.to_glib_none().0, context.0))
from_glib(ffi::gst_rtsp_server_attach(
self.to_glib_none().0,
context.0,
))
}
}
}

2
gstreamer-rtsp-server/src/r_t_s_p_session_pool.rs
View file

@ -50,7 +50,7 @@ impl<O: IsA<RTSPSessionPool>> RTSPSessionPoolExtManual for O {
func: F,
) -> glib::Source
where
F: FnMut(&RTSPSessionPool) -> Continue + Send + 'static
F: FnMut(&RTSPSessionPool) -> Continue + Send + 'static,
{
skip_assert_initialized!();
unsafe {

4
gstreamer-rtsp/src/lib.rs
View file

@ -15,10 +15,10 @@ extern crate glib;
extern crate glib_sys as glib_ffi;
extern crate gobject_sys as gobject_ffi;
extern crate gstreamer as gst;
extern crate gstreamer_sys as gst_ffi;
extern crate gstreamer_rtsp_sys as ffi;
extern crate gstreamer_sdp as gst_sdp;
extern crate gstreamer_sdp_sys as gst_sdp_ffi;
extern crate gstreamer_rtsp_sys as ffi;
extern crate gstreamer_sys as gst_ffi;
macro_rules! assert_initialized_main_thread {
() => (

2
gstreamer-sdp/src/lib.rs
View file

@ -13,8 +13,8 @@ extern crate glib;
extern crate glib_sys as glib_ffi;
extern crate gobject_sys as gobject_ffi;
extern crate gstreamer as gst;
extern crate gstreamer_sys as gst_ffi;
extern crate gstreamer_sdp_sys as ffi;
extern crate gstreamer_sys as gst_ffi;
macro_rules! skip_assert_initialized {
() => (

2
gstreamer-video/src/lib.rs
View file

@ -16,8 +16,8 @@ extern crate glib_sys as glib_ffi;
extern crate gobject_sys as gobject_ffi;
extern crate gstreamer as gst;
extern crate gstreamer_base as gst_base;
extern crate gstreamer_sys as gst_ffi;
extern crate gstreamer_base_sys as gst_base_ffi;
extern crate gstreamer_sys as gst_ffi;
extern crate gstreamer_video_sys as ffi;
macro_rules! assert_initialized_main_thread {

5
gstreamer-video/src/video_frame.rs
View file

@ -395,7 +395,10 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
self.0.id
}
pub fn copy(&self, dest: &mut VideoFrameRef<&mut gst::BufferRef>) -> Result<(), glib::BoolError> {
pub fn copy(
&self,
dest: &mut VideoFrameRef<&mut gst::BufferRef>,
) -> Result<(), glib::BoolError> {
unsafe {
let res: bool = from_glib(ffi::gst_video_frame_copy(&mut dest.0, &self.0));
if res {

9
gstreamer-video/src/video_info.rs
View file

@ -26,7 +26,8 @@ pub enum VideoColorRange {
Unknown,
Range0255,
Range16235,
#[doc(hidden)] __Unknown(i32),
#[doc(hidden)]
__Unknown(i32),
}
#[doc(hidden)]
@ -205,7 +206,8 @@ pub struct VideoInfoBuilder<'a> {
stride: Option<&'a [i32]>,
multiview_mode: Option<::VideoMultiviewMode>,
multiview_flags: Option<::VideoMultiviewFlags>,
#[cfg(any(feature = "v1_12", feature = "dox"))] field_order: Option<::VideoFieldOrder>,
#[cfg(any(feature = "v1_12", feature = "dox"))]
field_order: Option<::VideoFieldOrder>,
}
impl<'a> VideoInfoBuilder<'a> {
@ -636,8 +638,7 @@ impl glib::types::StaticType for VideoInfo {
#[doc(hidden)]
impl<'a> glib::value::FromValueOptional<'a> for VideoInfo {
unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
Option::<VideoInfo>::from_glib_none(gobject_ffi::g_value_get_boxed(value.to_glib_none().0)
as *mut ffi::GstVideoInfo)
Option::<VideoInfo>::from_glib_none(gobject_ffi::g_value_get_boxed(value.to_glib_none().0) as *mut ffi::GstVideoInfo)
}
}

22
gstreamer/src/buffer.rs
View file

@ -157,9 +157,7 @@ impl GstRc<BufferRef> {
pub fn append(buffer: Self, other: Self) -> Self {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_buffer_append(buffer.into_ptr(), other.into_ptr()))
}
unsafe { from_glib_full(ffi::gst_buffer_append(buffer.into_ptr(), other.into_ptr())) }
}
}
@ -172,9 +170,8 @@ impl Default for GstRc<BufferRef> {
impl BufferRef {
pub fn map_readable(&self) -> Option<BufferMap<Readable>> {
let mut map_info: ffi::GstMapInfo = unsafe { mem::zeroed() };
let res = unsafe {
ffi::gst_buffer_map(self.as_mut_ptr(), &mut map_info, ffi::GST_MAP_READ)
};
let res =
unsafe { ffi::gst_buffer_map(self.as_mut_ptr(), &mut map_info, ffi::GST_MAP_READ) };
if res == glib_ffi::GTRUE {
Some(BufferMap {
buffer: self,
@ -385,10 +382,7 @@ impl ToOwned for BufferRef {
type Owned = GstRc<BufferRef>;
fn to_owned(&self) -> GstRc<BufferRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}
@ -440,9 +434,7 @@ impl<'a, T> BufferMap<'a, T> {
impl<'a> BufferMap<'a, Writable> {
pub fn as_mut_slice(&mut self) -> &mut [u8] {
unsafe {
slice::from_raw_parts_mut(self.map_info.data as *mut u8, self.map_info.size)
}
unsafe { slice::from_raw_parts_mut(self.map_info.data as *mut u8, self.map_info.size) }
}
}
@ -521,9 +513,7 @@ impl<T> MappedBuffer<T> {
impl MappedBuffer<Writable> {
pub fn as_mut_slice(&mut self) -> &mut [u8] {
unsafe {
slice::from_raw_parts_mut(self.map_info.data as *mut u8, self.map_info.size)
}
unsafe { slice::from_raw_parts_mut(self.map_info.data as *mut u8, self.map_info.size) }
}
}

5
gstreamer/src/bufferlist.rs
View file

@ -88,10 +88,7 @@ impl ToOwned for BufferListRef {
type Owned = GstRc<BufferListRef>;
fn to_owned(&self) -> GstRc<BufferListRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}

4
gstreamer/src/bus.rs
View file

@ -132,9 +132,7 @@ impl Bus {
}
pub fn unset_sync_handler(&self) {
unsafe {
ffi::gst_bus_set_sync_handler(self.to_glib_none().0, None, ptr::null_mut(), None)
}
unsafe { ffi::gst_bus_set_sync_handler(self.to_glib_none().0, None, ptr::null_mut(), None) }
}
}

5
gstreamer/src/caps.rs
View file

@ -359,10 +359,7 @@ impl ToOwned for CapsRef {
type Owned = GstRc<CapsRef>;
fn to_owned(&self) -> GstRc<CapsRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}

9
gstreamer/src/context.rs
View file

@ -59,9 +59,7 @@ impl ContextRef {
}
pub fn get_structure(&self) -> &StructureRef {
unsafe {
StructureRef::from_glib_borrow(ffi::gst_context_get_structure(self.as_mut_ptr()))
}
unsafe { StructureRef::from_glib_borrow(ffi::gst_context_get_structure(self.as_mut_ptr())) }
}
pub fn get_mut_structure(&mut self) -> &mut StructureRef {
@ -92,10 +90,7 @@ impl ToOwned for ContextRef {
type Owned = GstRc<ContextRef>;
fn to_owned(&self) -> GstRc<ContextRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}

21
gstreamer/src/event.rs
View file

@ -454,10 +454,7 @@ impl ToOwned for EventRef {
type Owned = GstRc<EventRef>;
fn to_owned(&self) -> GstRc<EventRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}
@ -884,30 +881,32 @@ impl<'a> EventBuilder<'a> {
Self {
seqnum: None,
running_time_offset: None,
other_fields: Vec::new()
other_fields: Vec::new(),
}
}
fn seqnum(self, seqnum: Seqnum) -> Self {
Self {
seqnum: Some(seqnum),
.. self
..self
}
}
fn running_time_offset(self, running_time_offset: i64) -> Self {
Self {
running_time_offset: Some(running_time_offset),
.. self
..self
}
}
fn other_fields(self, other_fields: &[(&'a str, &'a ToSendValue)]) -> Self {
Self {
other_fields: self.other_fields.iter().cloned()
other_fields: self.other_fields
.iter()
.cloned()
.chain(other_fields.iter().cloned())
.collect(),
.. self
..self
}
}
}
@ -1618,7 +1617,7 @@ mod tests {
EventView::FlushStart(flush_start_evt) => {
assert!(!flush_start_evt.is_sticky());
assert!(flush_start_evt.get_structure().is_none());
},
}
_ => panic!("flush_start_evt.view() is not an EventView::FlushStart(_)"),
}
@ -1631,7 +1630,7 @@ mod tests {
if let Some(other_fields) = flush_start_evt.get_structure() {
assert!(other_fields.has_field("extra-field"));
}
},
}
_ => panic!("flush_start_evt.view() is not an EventView::FlushStart(_)"),
}

32
gstreamer/src/message.rs
View file

@ -372,10 +372,7 @@ impl ToOwned for MessageRef {
type Owned = GstRc<MessageRef>;
fn to_owned(&self) -> GstRc<MessageRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}
@ -1171,7 +1168,7 @@ impl<'a> MessageBuilder<'a> {
Self {
src: None,
seqnum: None,
other_fields: Vec::new()
other_fields: Vec::new(),
}
}
@ -1181,14 +1178,14 @@ impl<'a> MessageBuilder<'a> {
let o = (*o).clone();
o.upcast::<Object>()
}),
.. self
..self
}
}
fn seqnum(self, seqnum: Seqnum) -> Self {
Self {
seqnum: Some(seqnum),
.. self
..self
}
}
@ -1284,7 +1281,8 @@ pub struct ErrorBuilder<'a, T> {
error: T,
message: &'a str,
debug: Option<&'a str>,
#[allow(unused)] details: Option<Structure>,
#[allow(unused)]
details: Option<Structure>,
}
impl<'a, T: MessageErrorDomain> ErrorBuilder<'a, T> {
fn new(error: T, message: &'a str) -> Self {
@ -1348,7 +1346,8 @@ pub struct WarningBuilder<'a, T> {
error: T,
message: &'a str,
debug: Option<&'a str>,
#[allow(unused)] details: Option<Structure>,
#[allow(unused)]
details: Option<Structure>,
}
impl<'a, T: MessageErrorDomain> WarningBuilder<'a, T> {
fn new(error: T, message: &'a str) -> Self {
@ -1412,7 +1411,8 @@ pub struct InfoBuilder<'a, T> {
error: T,
message: &'a str,
debug: Option<&'a str>,
#[allow(unused)] details: Option<Structure>,
#[allow(unused)]
details: Option<Structure>,
}
impl<'a, T: MessageErrorDomain> InfoBuilder<'a, T> {
fn new(error: T, message: &'a str) -> Self {
@ -2241,8 +2241,10 @@ impl<'a> StreamCollectionBuilder<'a> {
#[cfg(any(feature = "v1_10", feature = "dox"))]
pub struct StreamsSelectedBuilder<'a> {
builder: MessageBuilder<'a>,
#[cfg(any(feature = "v1_10", feature = "dox"))] collection: &'a ::StreamCollection,
#[cfg(any(feature = "v1_10", feature = "dox"))] streams: Option<&'a [&'a ::Stream]>,
#[cfg(any(feature = "v1_10", feature = "dox"))]
collection: &'a ::StreamCollection,
#[cfg(any(feature = "v1_10", feature = "dox"))]
streams: Option<&'a [&'a ::Stream]>,
}
#[cfg(any(feature = "v1_10", feature = "dox"))]
impl<'a> StreamsSelectedBuilder<'a> {
@ -2363,14 +2365,12 @@ mod tests {
::init().unwrap();
// Message without arguments
let eos_msg = Message::new_eos()
.seqnum(Seqnum(1))
.build();
let eos_msg = Message::new_eos().seqnum(Seqnum(1)).build();
match eos_msg.view() {
MessageView::Eos(eos_msg) => {
assert_eq!(eos_msg.get_seqnum(), Seqnum(1));
assert!(eos_msg.get_structure().is_none());
},
}
_ => panic!("eos_msg.view() is not a MessageView::Eos(_)"),
}

35
gstreamer/src/miniobject.rs
View file

@ -66,9 +66,10 @@ impl<T: MiniObject> GstRc<T> {
return &mut *self.obj;
}
self.obj = T::from_mut_ptr(ffi::gst_mini_object_make_writable(self.as_mut_ptr()
as *mut ffi::GstMiniObject)
as *mut T::GstType);
self.obj = T::from_mut_ptr(
ffi::gst_mini_object_make_writable(self.as_mut_ptr() as *mut ffi::GstMiniObject)
as *mut T::GstType,
);
assert!(self.is_writable());
&mut *self.obj
@ -85,8 +86,7 @@ impl<T: MiniObject> GstRc<T> {
pub fn is_writable(&self) -> bool {
unsafe {
from_glib(ffi::gst_mini_object_is_writable(self.as_ptr()
as *const ffi::GstMiniObject))
from_glib(ffi::gst_mini_object_is_writable(self.as_ptr() as *const ffi::GstMiniObject))
}
}
@ -191,9 +191,10 @@ where
fn copy(&self) -> GstRc<Self> {
unsafe {
GstRc::from_glib_full(ffi::gst_mini_object_copy(self.as_ptr()
as *const ffi::GstMiniObject)
as *const Self::GstType)
GstRc::from_glib_full(
ffi::gst_mini_object_copy(self.as_ptr() as *const ffi::GstMiniObject)
as *const Self::GstType,
)
}
}
}
@ -287,7 +288,8 @@ impl<'a, T: MiniObject + 'static> ToGlibContainerFromSlice<'a, *mut *mut T::GstT
}
impl<'a, T: MiniObject + 'static> ToGlibContainerFromSlice<'a, *const *mut T::GstType>
for GstRc<T> {
for GstRc<T>
{
#[cfg_attr(feature = "cargo-clippy", allow(type_complexity))]
type Storage = (
Vec<Stash<'a, *mut T::GstType, GstRc<T>>>,
@ -351,7 +353,8 @@ impl<T: MiniObject + 'static> FromGlibPtrBorrow<*mut T::GstType> for GstRc<T> {
}
impl<T: MiniObject + 'static> FromGlibContainerAsVec<*mut T::GstType, *mut *mut T::GstType>
for GstRc<T> {
for GstRc<T>
{
unsafe fn from_glib_none_num_as_vec(ptr: *mut *mut T::GstType, num: usize) -> Vec<Self> {
if num == 0 || ptr.is_null() {
return Vec::new();
@ -385,7 +388,8 @@ impl<T: MiniObject + 'static> FromGlibContainerAsVec<*mut T::GstType, *mut *mut
}
impl<T: MiniObject + 'static> FromGlibPtrArrayContainerAsVec<*mut T::GstType, *mut *mut T::GstType>
for GstRc<T> {
for GstRc<T>
{
unsafe fn from_glib_none_as_vec(ptr: *mut *mut T::GstType) -> Vec<Self> {
FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, c_ptr_array_len(ptr))
}
@ -400,7 +404,8 @@ impl<T: MiniObject + 'static> FromGlibPtrArrayContainerAsVec<*mut T::GstType, *m
}
impl<T: MiniObject + 'static> FromGlibContainerAsVec<*mut T::GstType, *const *mut T::GstType>
for GstRc<T> {
for GstRc<T>
{
unsafe fn from_glib_none_num_as_vec(ptr: *const *mut T::GstType, num: usize) -> Vec<Self> {
FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr as *mut *mut _, num)
}
@ -418,7 +423,8 @@ impl<T: MiniObject + 'static> FromGlibContainerAsVec<*mut T::GstType, *const *mu
impl<
T: MiniObject + 'static,
> FromGlibPtrArrayContainerAsVec<*mut T::GstType, *const *mut T::GstType> for GstRc<T> {
> FromGlibPtrArrayContainerAsVec<*mut T::GstType, *const *mut T::GstType> for GstRc<T>
{
unsafe fn from_glib_none_as_vec(ptr: *const *mut T::GstType) -> Vec<Self> {
FromGlibPtrArrayContainerAsVec::from_glib_none_as_vec(ptr as *mut *mut _)
}
@ -441,7 +447,8 @@ impl<T: MiniObject + glib::StaticType> glib::StaticType for GstRc<T> {
}
impl<'a, T: MiniObject + glib::StaticType + 'static> glib::value::FromValueOptional<'a>
for GstRc<T> {
for GstRc<T>
{
unsafe fn from_value_optional(v: &'a glib::Value) -> Option<Self> {
let ptr = gobject_ffi::g_value_get_boxed(v.to_glib_none().0);
from_glib_none(ptr as *const T::GstType)

126
gstreamer/src/query.rs
View file

@ -35,120 +35,80 @@ unsafe impl MiniObject for QueryRef {
impl GstRc<QueryRef> {
pub fn new_position(fmt: ::Format) -> Position<Self> {
assert_initialized_main_thread!();
unsafe {
Position::<Self>(
from_glib_full(ffi::gst_query_new_position(fmt.to_glib()))
)
}
unsafe { Position::<Self>(from_glib_full(ffi::gst_query_new_position(fmt.to_glib()))) }
}
pub fn new_duration(fmt: ::Format) -> Duration<Self> {
assert_initialized_main_thread!();
unsafe {
Duration::<Self>(
from_glib_full(ffi::gst_query_new_duration(fmt.to_glib()))
)
}
unsafe { Duration::<Self>(from_glib_full(ffi::gst_query_new_duration(fmt.to_glib()))) }
}
pub fn new_latency() -> Latency<Self> {
assert_initialized_main_thread!();
unsafe {
Latency::<Self>(
from_glib_full(ffi::gst_query_new_latency())
)
}
unsafe { Latency::<Self>(from_glib_full(ffi::gst_query_new_latency())) }
}
pub fn new_seeking(fmt: ::Format) -> Seeking<Self> {
assert_initialized_main_thread!();
unsafe {
Seeking::<Self>(
from_glib_full(ffi::gst_query_new_seeking(fmt.to_glib()))
)
}
unsafe { Seeking::<Self>(from_glib_full(ffi::gst_query_new_seeking(fmt.to_glib()))) }
}
pub fn new_segment(fmt: ::Format) -> Segment<Self> {
assert_initialized_main_thread!();
unsafe {
Segment::<Self>(
from_glib_full(ffi::gst_query_new_segment(fmt.to_glib()))
)
}
unsafe { Segment::<Self>(from_glib_full(ffi::gst_query_new_segment(fmt.to_glib()))) }
}
pub fn new_convert<V: Into<GenericFormattedValue>>(
value: V,
dest_fmt: ::Format
dest_fmt: ::Format,
) -> Convert<Self> {
assert_initialized_main_thread!();
let value = value.into();
unsafe {
Convert::<Self>(
from_glib_full(ffi::gst_query_new_convert(
value.get_format().to_glib(),
value.get_value(),
dest_fmt.to_glib(),
))
)
Convert::<Self>(from_glib_full(ffi::gst_query_new_convert(
value.get_format().to_glib(),
value.get_value(),
dest_fmt.to_glib(),
)))
}
}
pub fn new_formats() -> Formats<Self> {
assert_initialized_main_thread!();
unsafe {
Formats::<Self>(
from_glib_full(ffi::gst_query_new_formats())
)
}
unsafe { Formats::<Self>(from_glib_full(ffi::gst_query_new_formats())) }
}
pub fn new_buffering(fmt: ::Format) -> Buffering<Self> {
assert_initialized_main_thread!();
unsafe {
Buffering::<Self>(
from_glib_full(ffi::gst_query_new_buffering(fmt.to_glib()))
)
}
unsafe { Buffering::<Self>(from_glib_full(ffi::gst_query_new_buffering(fmt.to_glib()))) }
}
pub fn new_custom(structure: ::Structure) -> Custom<Self> {
assert_initialized_main_thread!();
unsafe {
Custom::<Self>(
from_glib_full(ffi::gst_query_new_custom(
ffi::GST_QUERY_CUSTOM,
structure.into_ptr(),
))
)
Custom::<Self>(from_glib_full(ffi::gst_query_new_custom(
ffi::GST_QUERY_CUSTOM,
structure.into_ptr(),
)))
}
}
pub fn new_uri() -> Uri<Self> {
assert_initialized_main_thread!();
unsafe {
Uri::<Self>(
from_glib_full(ffi::gst_query_new_uri())
)
}
unsafe { Uri::<Self>(from_glib_full(ffi::gst_query_new_uri())) }
}
pub fn new_scheduling() -> Scheduling<Self> {
assert_initialized_main_thread!();
unsafe {
Scheduling::<Self>(
from_glib_full(ffi::gst_query_new_scheduling())
)
}
unsafe { Scheduling::<Self>(from_glib_full(ffi::gst_query_new_scheduling())) }
}
pub fn new_accept_caps(caps: &::Caps) -> AcceptCaps<Self> {
assert_initialized_main_thread!();
unsafe {
AcceptCaps::<Self>(
from_glib_full(ffi::gst_query_new_accept_caps(caps.as_mut_ptr()))
)
AcceptCaps::<Self>(from_glib_full(ffi::gst_query_new_accept_caps(
caps.as_mut_ptr(),
)))
}
}
@ -156,27 +116,23 @@ impl GstRc<QueryRef> {
assert_initialized_main_thread!();
let filter = filter.into();
unsafe {
Caps::<Self>(
from_glib_full(ffi::gst_query_new_caps(filter.to_glib_none().0))
)
Caps::<Self>(from_glib_full(ffi::gst_query_new_caps(
filter.to_glib_none().0,
)))
}
}
pub fn new_drain() -> Drain<Self> {
assert_initialized_main_thread!();
unsafe {
Drain::<Self>(
from_glib_full(ffi::gst_query_new_drain())
)
}
unsafe { Drain::<Self>(from_glib_full(ffi::gst_query_new_drain())) }
}
pub fn new_context(context_type: &str) -> Context<Self> {
assert_initialized_main_thread!();
unsafe {
Context::<Self>(
from_glib_full(ffi::gst_query_new_context(context_type.to_glib_none().0))
)
Context::<Self>(from_glib_full(ffi::gst_query_new_context(
context_type.to_glib_none().0,
)))
}
}
}
@ -201,21 +157,15 @@ impl QueryRef {
}
pub fn is_downstream(&self) -> bool {
unsafe {
((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_DOWNSTREAM.bits()) != 0
}
unsafe { ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_DOWNSTREAM.bits()) != 0 }
}
pub fn is_upstream(&self) -> bool {
unsafe {
((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_UPSTREAM.bits()) != 0
}
unsafe { ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_UPSTREAM.bits()) != 0 }
}
pub fn is_serialized(&self) -> bool {
unsafe {
((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_SERIALIZED.bits()) != 0
}
unsafe { ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_SERIALIZED.bits()) != 0 }
}
pub fn view(&self) -> QueryView<&Self> {
@ -1128,7 +1078,9 @@ mod tests {
QueryView::Position(ref p) => {
let pos = p.get_result();
assert_eq!(pos.try_into_time(), Ok(3 * ::SECOND));
unsafe { assert!(!p.as_mut_ptr().is_null()); }
unsafe {
assert!(!p.as_mut_ptr().is_null());
}
}
_ => panic!("Wrong concrete Query in Query"),
}
@ -1168,7 +1120,7 @@ mod tests {
match query.view_mut() {
QueryView::Duration(ref mut d) => {
d.set(2 * ::SECOND);
},
}
_ => (),
}
@ -1176,7 +1128,7 @@ mod tests {
QueryView::Duration(ref d) => {
let duration = d.get_result();
assert_eq!(duration.try_into_time(), Ok(2 * ::SECOND));
},
}
_ => (),
}
}
@ -1186,6 +1138,8 @@ mod tests {
::init().unwrap();
let p = Query::new_position(::Format::Time);
unsafe { assert!(!p.as_mut_ptr().is_null()); }
unsafe {
assert!(!p.as_mut_ptr().is_null());
}
}
}

5
gstreamer/src/sample.rs
View file

@ -110,10 +110,7 @@ impl ToOwned for SampleRef {
type Owned = GstRc<SampleRef>;
fn to_owned(&self) -> GstRc<SampleRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}

9
gstreamer/src/segment.rs
View file

@ -567,8 +567,7 @@ impl<T: FormattedValue> glib::types::StaticType for FormattedSegment<T> {
#[doc(hidden)]
impl<'a> glib::value::FromValueOptional<'a> for Segment {
unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
Option::<Segment>::from_glib_none(gobject_ffi::g_value_get_boxed(value.to_glib_none().0)
as *mut ffi::GstSegment)
Option::<Segment>::from_glib_none(gobject_ffi::g_value_get_boxed(value.to_glib_none().0) as *mut ffi::GstSegment)
}
}
@ -601,7 +600,8 @@ impl<T: FormattedValue> glib::translate::GlibPtrDefault for FormattedSegment<T>
#[doc(hidden)]
impl<'a, T: FormattedValue> glib::translate::ToGlibPtr<'a, *const ffi::GstSegment>
for FormattedSegment<T> {
for FormattedSegment<T>
{
type Storage = &'a FormattedSegment<T>;
fn to_glib_none(&'a self) -> glib::translate::Stash<'a, *const ffi::GstSegment, Self> {
@ -615,7 +615,8 @@ impl<'a, T: FormattedValue> glib::translate::ToGlibPtr<'a, *const ffi::GstSegmen
#[doc(hidden)]
impl<'a, T: FormattedValue> glib::translate::ToGlibPtrMut<'a, *mut ffi::GstSegment>
for FormattedSegment<T> {
for FormattedSegment<T>
{
type Storage = &'a mut FormattedSegment<T>;
#[inline]

3
gstreamer/src/static_caps.rs
View file

@ -36,8 +36,7 @@ impl glib::types::StaticType for StaticCaps {
#[doc(hidden)]
impl<'a> glib::value::FromValueOptional<'a> for StaticCaps {
unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
Option::<StaticCaps>::from_glib_none(gobject_ffi::g_value_get_boxed(value.to_glib_none().0)
as *mut ffi::GstStaticCaps)
Option::<StaticCaps>::from_glib_none(gobject_ffi::g_value_get_boxed(value.to_glib_none().0) as *mut ffi::GstStaticCaps)
}
}

4
gstreamer/src/structure.rs
View file

@ -37,9 +37,7 @@ impl Structure {
pub fn new_empty(name: &str) -> Structure {
assert_initialized_main_thread!();
Structure(
unsafe {
ffi::gst_structure_new_empty(name.to_glib_none().0) as *mut StructureRef
},
unsafe { ffi::gst_structure_new_empty(name.to_glib_none().0) as *mut StructureRef },
PhantomData,
)
}

13
gstreamer/src/tags.rs
View file

@ -306,9 +306,7 @@ impl TagListRef {
}
pub fn get_size<'a, T: Tag<'a>>(&'a self) -> u32 {
unsafe {
ffi::gst_tag_list_get_tag_size(self.as_ptr(), T::tag_name().to_glib_none().0)
}
unsafe { ffi::gst_tag_list_get_tag_size(self.as_ptr(), T::tag_name().to_glib_none().0) }
}
pub fn iter_tag<'a, T: Tag<'a>>(&'a self) -> TagIterator<'a, T> {
@ -320,9 +318,7 @@ impl TagListRef {
}
pub fn insert(&mut self, other: &TagListRef, mode: TagMergeMode) {
unsafe {
ffi::gst_tag_list_insert(self.as_mut_ptr(), other.as_ptr(), mode.to_glib())
}
unsafe { ffi::gst_tag_list_insert(self.as_mut_ptr(), other.as_ptr(), mode.to_glib()) }
}
pub fn merge(&self, other: &TagListRef, mode: TagMergeMode) -> TagList {
@ -360,10 +356,7 @@ impl ToOwned for TagListRef {
type Owned = GstRc<TagListRef>;
fn to_owned(&self) -> GstRc<TagListRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}

18
gstreamer/src/toc.rs
View file

@ -43,15 +43,11 @@ impl TocRef {
}
pub fn find_entry(&self, uid: &str) -> Option<TocEntry> {
unsafe {
from_glib_none(ffi::gst_toc_find_entry(self.as_ptr(), uid.to_glib_none().0))
}
unsafe { from_glib_none(ffi::gst_toc_find_entry(self.as_ptr(), uid.to_glib_none().0)) }
}
pub fn get_entries(&self) -> Vec<TocEntry> {
unsafe {
FromGlibPtrContainer::from_glib_none(ffi::gst_toc_get_entries(self.as_ptr()))
}
unsafe { FromGlibPtrContainer::from_glib_none(ffi::gst_toc_get_entries(self.as_ptr())) }
}
pub fn append_entry(&mut self, entry: TocEntry) {
@ -93,10 +89,7 @@ impl ToOwned for TocRef {
type Owned = GstRc<TocRef>;
fn to_owned(&self) -> GstRc<TocRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}
@ -241,10 +234,7 @@ impl ToOwned for TocEntryRef {
type Owned = GstRc<TocEntryRef>;
fn to_owned(&self) -> GstRc<TocEntryRef> {
unsafe {
from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _)
as *mut _)
}
unsafe { from_glib_full(ffi::gst_mini_object_copy(self.as_ptr() as *const _) as *mut _) }
}
}

6
tutorials/src/bin/basic-tutorial-3.rs
View file

@ -100,7 +100,11 @@ fn tutorial_main() {
break;
}
MessageView::StateChanged(state_changed) => {
if state_changed.get_src().map(|s| s == pipeline).unwrap_or(false) {
if state_changed
.get_src()
.map(|s| s == pipeline)
.unwrap_or(false)
{
println!(
"Pipeline state changed from {:?} to {:?}",
state_changed.get_old(),

3
tutorials/src/bin/basic-tutorial-4.rs
View file

@ -114,7 +114,8 @@ fn handle_message(custom_data: &mut CustomData, msg: &gst::GstRc<gst::MessageRef
// The duration has changed, mark the current one as invalid
custom_data.duration = gst::CLOCK_TIME_NONE;
}
MessageView::StateChanged(state_changed) => if state_changed.get_src()
MessageView::StateChanged(state_changed) => if state_changed
.get_src()
.map(|s| s == custom_data.playbin)
.unwrap_or(false)
{

6
tutorials/src/bin/basic-tutorial-5.rs
View file

@ -347,7 +347,11 @@ mod tutorial5 {
// This is called when the pipeline changes states. We use it to
// keep track of the current state.
gst::MessageView::StateChanged(state_changed) => {
if state_changed.get_src().map(|s| s == pipeline).unwrap_or(false) {
if state_changed
.get_src()
.map(|s| s == pipeline)
.unwrap_or(false)
{
println!("State set to {:?}", state_changed.get_current());
}
}