From 5505715cc452e772f32ca0a730015943609417e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Laignel?= Date: Wed, 28 Apr 2021 14:34:56 +0200 Subject: [PATCH] Manual code updates for *Return types --- gstreamer-app/src/app_sink.rs | 65 ------- gstreamer-app/src/app_src.rs | 30 +--- gstreamer-audio/src/audio_decoder.rs | 21 +-- gstreamer-audio/src/audio_encoder.rs | 7 +- gstreamer-audio/src/subclass/audio_decoder.rs | 33 ++-- gstreamer-audio/src/subclass/audio_encoder.rs | 13 +- gstreamer-base/src/aggregator.rs | 14 +- gstreamer-base/src/base_parse.rs | 3 +- gstreamer-base/src/base_sink.rs | 56 ------ gstreamer-base/src/base_src.rs | 28 --- gstreamer-base/src/flow_combiner.rs | 14 +- gstreamer-base/src/subclass/aggregator.rs | 21 +-- gstreamer-base/src/subclass/aggregator_pad.rs | 5 +- gstreamer-base/src/subclass/base_parse.rs | 27 ++- gstreamer-base/src/subclass/base_sink.rs | 16 +- gstreamer-base/src/subclass/base_src.rs | 15 +- gstreamer-base/src/subclass/base_transform.rs | 37 ++-- gstreamer-base/src/subclass/push_src.rs | 17 +- gstreamer-check/src/harness.rs | 31 ++-- gstreamer-rtsp-server/src/lib.rs | 4 - gstreamer-rtsp-server/src/rtsp_stream.rs | 33 ---- .../src/rtsp_stream_transport.rs | 30 ---- gstreamer-video/src/subclass/video_decoder.rs | 20 +-- gstreamer-video/src/subclass/video_encoder.rs | 10 +- gstreamer-video/src/subclass/video_sink.rs | 5 +- gstreamer-video/src/video_decoder.rs | 48 ++--- gstreamer-video/src/video_encoder.rs | 21 +-- gstreamer/src/buffer_pool.rs | 11 +- gstreamer/src/clock.rs | 22 +-- gstreamer/src/element.rs | 83 +-------- gstreamer/src/enums.rs | 165 +++++++----------- gstreamer/src/pad.rs | 134 ++++---------- gstreamer/src/proxy_pad.rs | 23 ++- gstreamer/src/subclass/clock.rs | 8 +- gstreamer/src/subclass/element.rs | 3 +- 35 files changed, 290 insertions(+), 783 deletions(-) delete mode 100644 gstreamer-rtsp-server/src/rtsp_stream.rs delete mode 100644 gstreamer-rtsp-server/src/rtsp_stream_transport.rs diff --git a/gstreamer-app/src/app_sink.rs b/gstreamer-app/src/app_sink.rs index c1590eb87..745e5b1c6 100644 --- a/gstreamer-app/src/app_sink.rs +++ b/gstreamer-app/src/app_sink.rs @@ -2,13 +2,8 @@ use crate::AppSink; use glib::ffi::gpointer; -use glib::object::ObjectType; -use glib::signal::connect_raw; -use glib::signal::SignalHandlerId; use glib::translate::*; -use std::boxed::Box as Box_; use std::cell::RefCell; -use std::mem::transmute; use std::panic; use std::ptr; use std::sync::atomic::{AtomicBool, Ordering}; @@ -277,72 +272,12 @@ impl AppSink { } } - pub fn connect_new_sample< - F: Fn(&AppSink) -> Result + Send + 'static, - >( - &self, - f: F, - ) -> SignalHandlerId { - unsafe { - let f: Box_ = Box_::new(f); - connect_raw( - self.as_ptr() as *mut _, - b"new-sample\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>( - new_sample_trampoline:: as *const (), - )), - Box_::into_raw(f), - ) - } - } - - pub fn connect_new_preroll< - F: Fn(&AppSink) -> Result + Send + 'static, - >( - &self, - f: F, - ) -> SignalHandlerId { - unsafe { - let f: Box_ = Box_::new(f); - connect_raw( - self.as_ptr() as *mut _, - b"new-preroll\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>( - new_preroll_trampoline:: as *const (), - )), - Box_::into_raw(f), - ) - } - } - #[cfg(any(feature = "v1_10"))] pub fn stream(&self) -> AppSinkStream { AppSinkStream::new(self) } } -unsafe extern "C" fn new_sample_trampoline< - F: Fn(&AppSink) -> Result + Send + 'static, ->( - this: *mut ffi::GstAppSink, - f: glib::ffi::gpointer, -) -> gst::ffi::GstFlowReturn { - let f: &F = &*(f as *const F); - let ret: gst::FlowReturn = f(&from_glib_borrow(this)).into(); - ret.into_glib() -} - -unsafe extern "C" fn new_preroll_trampoline< - F: Fn(&AppSink) -> Result + Send + 'static, ->( - this: *mut ffi::GstAppSink, - f: glib::ffi::gpointer, -) -> gst::ffi::GstFlowReturn { - let f: &F = &*(f as *const F); - let ret: gst::FlowReturn = f(&from_glib_borrow(this)).into(); - ret.into_glib() -} - #[cfg(any(feature = "v1_10"))] #[derive(Debug)] pub struct AppSinkStream { diff --git a/gstreamer-app/src/app_src.rs b/gstreamer-app/src/app_src.rs index cf680f552..901165a48 100644 --- a/gstreamer-app/src/app_src.rs +++ b/gstreamer-app/src/app_src.rs @@ -207,20 +207,13 @@ unsafe extern "C" fn destroy_callbacks(ptr: gpointer) { } impl AppSrc { - pub fn end_of_stream(&self) -> Result { - let ret: gst::FlowReturn = - unsafe { from_glib(ffi::gst_app_src_end_of_stream(self.to_glib_none().0)) }; - ret.into_result() - } - pub fn push_buffer(&self, buffer: gst::Buffer) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_app_src_push_buffer( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_app_src_push_buffer( self.to_glib_none().0, buffer.into_ptr(), )) - }; - ret.into_result() + } } #[cfg(any(feature = "v1_14", feature = "dox"))] @@ -229,23 +222,12 @@ impl AppSrc { &self, list: gst::BufferList, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_app_src_push_buffer_list( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_app_src_push_buffer_list( self.to_glib_none().0, list.into_ptr(), )) - }; - ret.into_result() - } - - pub fn push_sample(&self, sample: &gst::Sample) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_app_src_push_sample( - self.to_glib_none().0, - sample.to_glib_none().0, - )) - }; - ret.into_result() + } } pub fn set_callbacks(&self, callbacks: AppSrcCallbacks) { diff --git a/gstreamer-audio/src/audio_decoder.rs b/gstreamer-audio/src/audio_decoder.rs index 2e0520f37..5b2f43878 100644 --- a/gstreamer-audio/src/audio_decoder.rs +++ b/gstreamer-audio/src/audio_decoder.rs @@ -65,14 +65,13 @@ impl> AudioDecoderExtManual for O { buffer: Option, frames: i32, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_audio_decoder_finish_frame( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_audio_decoder_finish_frame( self.as_ref().to_glib_none().0, buffer.map(|b| b.into_ptr()).unwrap_or(ptr::null_mut()), frames, )) - }; - ret.into_result() + } } #[cfg(any(feature = "v1_16", feature = "dox"))] @@ -81,13 +80,12 @@ impl> AudioDecoderExtManual for O { &self, buffer: Option, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_audio_decoder_finish_subframe( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_audio_decoder_finish_subframe( self.as_ref().to_glib_none().0, buffer.map(|b| b.into_ptr()).unwrap_or(ptr::null_mut()), )) - }; - ret.into_result() + } } fn negotiate(&self) -> Result<(), gst::FlowError> { @@ -156,8 +154,8 @@ impl> AudioDecoderExtManual for O { function: &str, line: u32, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(_gst_audio_decoder_error( + unsafe { + gst::FlowSuccess::try_from_glib(_gst_audio_decoder_error( self.as_ref().to_glib_none().0, weight, T::domain().into_glib(), @@ -168,8 +166,7 @@ impl> AudioDecoderExtManual for O { function.to_glib_none().0, line as i32, )) - }; - ret.into_result() + } } } diff --git a/gstreamer-audio/src/audio_encoder.rs b/gstreamer-audio/src/audio_encoder.rs index 41375dd8b..1989eb7d0 100644 --- a/gstreamer-audio/src/audio_encoder.rs +++ b/gstreamer-audio/src/audio_encoder.rs @@ -30,14 +30,13 @@ impl> AudioEncoderExtManual for O { buffer: Option, frames: i32, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_audio_encoder_finish_frame( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_audio_encoder_finish_frame( self.as_ref().to_glib_none().0, buffer.map(|b| b.into_ptr()).unwrap_or(ptr::null_mut()), frames, )) - }; - ret.into_result() + } } fn negotiate(&self) -> Result<(), gst::FlowError> { diff --git a/gstreamer-audio/src/subclass/audio_decoder.rs b/gstreamer-audio/src/subclass/audio_decoder.rs index 39b0b7ad7..7c3f4035d 100644 --- a/gstreamer-audio/src/subclass/audio_decoder.rs +++ b/gstreamer-audio/src/subclass/audio_decoder.rs @@ -295,23 +295,19 @@ impl AudioDecoderImplExt for T { .map(|f| { let mut offset = mem::MaybeUninit::uninit(); let mut len = mem::MaybeUninit::uninit(); - match gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, adapter.to_glib_none().0, offset.as_mut_ptr(), len.as_mut_ptr(), )) - .into_result() - { - Ok(_) => { - let offset = offset.assume_init(); - let len = len.assume_init(); - assert!(offset >= 0); - assert!(len >= 0); - Ok((offset as u32, len as u32)) - } - Err(err) => Err(err), - } + .map(|_| { + let offset = offset.assume_init(); + let len = len.assume_init(); + assert!(offset >= 0); + assert!(len >= 0); + (offset as u32, len as u32) + }) }) .unwrap_or_else(|| Ok((0, adapter.available() as u32))) } @@ -328,15 +324,14 @@ impl AudioDecoderImplExt for T { (*parent_class) .handle_frame .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buffer .map(|buffer| buffer.as_mut_ptr() as *mut *mut gst::ffi::GstBuffer) .unwrap_or(ptr::null_mut()), )) }) - .unwrap_or(gst::FlowReturn::Error) - .into_result() + .unwrap_or(Err(gst::FlowError::Error)) } } @@ -350,15 +345,11 @@ impl AudioDecoderImplExt for T { let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; if let Some(f) = (*parent_class).pre_push { let mut buffer = buffer.into_ptr(); - match gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, &mut buffer, )) - .into_result() - { - Ok(_) => Ok(from_glib_full(buffer)), - Err(err) => Err(err), - } + .map(|_| from_glib_full(buffer)) } else { Ok(Some(buffer)) } diff --git a/gstreamer-audio/src/subclass/audio_encoder.rs b/gstreamer-audio/src/subclass/audio_encoder.rs index 75c01ff21..b05e8ce71 100644 --- a/gstreamer-audio/src/subclass/audio_encoder.rs +++ b/gstreamer-audio/src/subclass/audio_encoder.rs @@ -279,15 +279,14 @@ impl AudioEncoderImplExt for T { (*parent_class) .handle_frame .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buffer .map(|buffer| buffer.as_mut_ptr() as *mut *mut gst::ffi::GstBuffer) .unwrap_or(ptr::null_mut()), )) }) - .unwrap_or(gst::FlowReturn::Error) - .into_result() + .unwrap_or(Err(gst::FlowError::Error)) } } @@ -301,15 +300,11 @@ impl AudioEncoderImplExt for T { let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; if let Some(f) = (*parent_class).pre_push { let mut buffer = buffer.into_ptr(); - match gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, &mut buffer, )) - .into_result() - { - Ok(_) => Ok(from_glib_full(buffer)), - Err(err) => Err(err), - } + .map(|_| from_glib_full(buffer)) } else { Ok(Some(buffer)) } diff --git a/gstreamer-base/src/aggregator.rs b/gstreamer-base/src/aggregator.rs index 0848b7a99..25c236d10 100644 --- a/gstreamer-base/src/aggregator.rs +++ b/gstreamer-base/src/aggregator.rs @@ -99,13 +99,12 @@ impl> AggregatorExtManual for O { } fn finish_buffer(&self, buffer: gst::Buffer) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_aggregator_finish_buffer( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_aggregator_finish_buffer( self.as_ref().to_glib_none().0, buffer.into_ptr(), )) - }; - ret.into_result() + } } #[cfg(any(feature = "v1_18", feature = "dox"))] @@ -114,13 +113,12 @@ impl> AggregatorExtManual for O { &self, bufferlist: gst::BufferList, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_aggregator_finish_buffer_list( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_aggregator_finish_buffer_list( self.as_ref().to_glib_none().0, bufferlist.into_ptr(), )) - }; - ret.into_result() + } } #[cfg(any(feature = "v1_16", feature = "dox"))] diff --git a/gstreamer-base/src/base_parse.rs b/gstreamer-base/src/base_parse.rs index b28f0f4ed..b7f82d117 100644 --- a/gstreamer-base/src/base_parse.rs +++ b/gstreamer-base/src/base_parse.rs @@ -128,12 +128,11 @@ impl> BaseParseExtManual for O { size: u32, ) -> Result { unsafe { - gst::FlowReturn::from_glib(ffi::gst_base_parse_finish_frame( + gst::FlowSuccess::try_from_glib(ffi::gst_base_parse_finish_frame( self.as_ref().to_glib_none().0, frame.to_glib_none().0, i32::try_from(size).expect("size higher than i32::MAX"), )) - .into_result() } } } diff --git a/gstreamer-base/src/base_sink.rs b/gstreamer-base/src/base_sink.rs index a2239ec01..8d91f5bf4 100644 --- a/gstreamer-base/src/base_sink.rs +++ b/gstreamer-base/src/base_sink.rs @@ -9,20 +9,6 @@ pub trait BaseSinkExtManual: 'static { #[doc(alias = "get_segment")] fn segment(&self) -> gst::Segment; - fn wait( - &self, - time: gst::ClockTime, - ) -> (Result, gst::ClockTimeDiff); - - fn wait_preroll(&self) -> Result; - fn wait_clock( - &self, - time: gst::ClockTime, - ) -> ( - Result, - gst::ClockTimeDiff, - ); - fn query_latency( &self, ) -> Result<(bool, bool, gst::ClockTime, gst::ClockTime), glib::BoolError>; @@ -37,48 +23,6 @@ impl> BaseSinkExtManual for O { } } - fn wait( - &self, - time: gst::ClockTime, - ) -> (Result, gst::ClockTimeDiff) { - unsafe { - let mut jitter = 0; - let ret: gst::FlowReturn = from_glib(ffi::gst_base_sink_wait( - self.as_ref().to_glib_none().0, - time.into_glib(), - &mut jitter, - )); - (ret.into_result(), jitter) - } - } - - fn wait_preroll(&self) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_base_sink_wait_preroll( - self.as_ref().to_glib_none().0, - )) - }; - ret.into_result() - } - - fn wait_clock( - &self, - time: gst::ClockTime, - ) -> ( - Result, - gst::ClockTimeDiff, - ) { - unsafe { - let mut jitter = 0; - let ret: gst::ClockReturn = from_glib(ffi::gst_base_sink_wait_clock( - self.as_ref().to_glib_none().0, - time.into_glib(), - &mut jitter, - )); - (ret.into_result(), jitter) - } - } - fn query_latency( &self, ) -> Result<(bool, bool, gst::ClockTime, gst::ClockTime), glib::BoolError> { diff --git a/gstreamer-base/src/base_src.rs b/gstreamer-base/src/base_src.rs index 55788a0a6..2b1ace3a7 100644 --- a/gstreamer-base/src/base_src.rs +++ b/gstreamer-base/src/base_src.rs @@ -14,12 +14,6 @@ pub trait BaseSrcExtManual: 'static { #[doc(alias = "get_segment")] fn segment(&self) -> gst::Segment; - fn start_complete(&self, ret: Result); - - fn start_wait(&self) -> Result; - - fn wait_playing(&self) -> Result; - fn query_latency(&self) -> Result<(bool, gst::ClockTime, gst::ClockTime), glib::BoolError>; #[cfg(any(feature = "v1_18", feature = "dox"))] @@ -49,28 +43,6 @@ impl> BaseSrcExtManual for O { } } - fn start_complete(&self, ret: Result) { - let ret: gst::FlowReturn = ret.into(); - unsafe { - ffi::gst_base_src_start_complete(self.as_ref().to_glib_none().0, ret.into_glib()); - } - } - - fn start_wait(&self) -> Result { - let ret: gst::FlowReturn = - unsafe { from_glib(ffi::gst_base_src_start_wait(self.as_ref().to_glib_none().0)) }; - ret.into_result() - } - - fn wait_playing(&self) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_base_src_wait_playing( - self.as_ref().to_glib_none().0, - )) - }; - ret.into_result() - } - fn query_latency(&self) -> Result<(bool, gst::ClockTime, gst::ClockTime), glib::BoolError> { unsafe { let mut live = mem::MaybeUninit::uninit(); diff --git a/gstreamer-base/src/flow_combiner.rs b/gstreamer-base/src/flow_combiner.rs index 0cb2698ae..2628035cd 100644 --- a/gstreamer-base/src/flow_combiner.rs +++ b/gstreamer-base/src/flow_combiner.rs @@ -65,13 +65,12 @@ impl FlowCombiner { fret: FRet, ) -> Result { let fret: gst::FlowReturn = fret.into(); - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_flow_combiner_update_flow( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_flow_combiner_update_flow( self.to_glib_none().0, fret.into_glib(), )) - }; - ret.into_result() + } } pub fn update_pad_flow, FRet: Into>( @@ -80,14 +79,13 @@ impl FlowCombiner { fret: FRet, ) -> Result { let fret: gst::FlowReturn = fret.into(); - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_flow_combiner_update_pad_flow( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_flow_combiner_update_pad_flow( self.to_glib_none().0, pad.as_ref().to_glib_none().0, fret.into_glib(), )) - }; - ret.into_result() + } } } diff --git a/gstreamer-base/src/subclass/aggregator.rs b/gstreamer-base/src/subclass/aggregator.rs index 7740f7f2a..fd9fad008 100644 --- a/gstreamer-base/src/subclass/aggregator.rs +++ b/gstreamer-base/src/subclass/aggregator.rs @@ -288,13 +288,12 @@ impl AggregatorImplExt for T { (*parent_class) .flush .map(|f| { - from_glib(f(aggregator + gst::FlowSuccess::try_from_glib(f(aggregator .unsafe_cast_ref::() .to_glib_none() .0)) }) - .unwrap_or(gst::FlowReturn::Ok) - .into_result() + .unwrap_or(Ok(gst::FlowSuccess::Ok)) } } @@ -329,11 +328,10 @@ impl AggregatorImplExt for T { let f = (*parent_class) .finish_buffer .expect("Missing parent function `finish_buffer`"); - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( aggregator.unsafe_cast_ref::().to_glib_none().0, buffer.into_ptr(), )) - .into_result() } } @@ -350,11 +348,10 @@ impl AggregatorImplExt for T { let f = (*parent_class) .finish_buffer_list .expect("Missing parent function `finish_buffer_list`"); - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( aggregator.unsafe_cast_ref::().to_glib_none().0, buffer_list.into_ptr(), )) - .into_result() } } @@ -392,12 +389,11 @@ impl AggregatorImplExt for T { let f = (*parent_class) .sink_event_pre_queue .expect("Missing parent function `sink_event_pre_queue`"); - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( aggregator.unsafe_cast_ref::().to_glib_none().0, aggregator_pad.to_glib_none().0, event.into_ptr(), )) - .into_result() } } @@ -506,11 +502,10 @@ impl AggregatorImplExt for T { let f = (*parent_class) .aggregate .expect("Missing parent function `aggregate`"); - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( aggregator.unsafe_cast_ref::().to_glib_none().0, timeout.into_glib(), )) - .into_result() } } @@ -613,12 +608,12 @@ impl AggregatorImplExt for T { .expect("Missing parent function `update_src_caps`"); let mut out_caps = ptr::null_mut(); - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( aggregator.unsafe_cast_ref::().to_glib_none().0, caps.as_mut_ptr(), &mut out_caps, )) - .into_result_value(|| from_glib_full(out_caps)) + .map(|_| from_glib_full(out_caps)) } } diff --git a/gstreamer-base/src/subclass/aggregator_pad.rs b/gstreamer-base/src/subclass/aggregator_pad.rs index e3b93d1ea..bca29675b 100644 --- a/gstreamer-base/src/subclass/aggregator_pad.rs +++ b/gstreamer-base/src/subclass/aggregator_pad.rs @@ -54,7 +54,7 @@ impl AggregatorPadImplExt for T { (*parent_class) .flush .map(|f| { - from_glib(f( + gst::FlowSuccess::try_from_glib(f( aggregator_pad .unsafe_cast_ref::() .to_glib_none() @@ -62,8 +62,7 @@ impl AggregatorPadImplExt for T { aggregator.to_glib_none().0, )) }) - .unwrap_or(gst::FlowReturn::Ok) - .into_result() + .unwrap_or(Ok(gst::FlowSuccess::Ok)) } } diff --git a/gstreamer-base/src/subclass/base_parse.rs b/gstreamer-base/src/subclass/base_parse.rs index 1bedb94fd..4ceefa7eb 100644 --- a/gstreamer-base/src/subclass/base_parse.rs +++ b/gstreamer-base/src/subclass/base_parse.rs @@ -149,22 +149,17 @@ impl BaseParseImplExt for T { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass; let mut skipsize = 0; - let res = (*parent_class).handle_frame.map(|f| { - let res = gst::FlowReturn::from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, - frame.to_glib_none().0, - &mut skipsize, - )); - (res, skipsize as u32) - }); - - match res { - Some((res, skipsize)) => { - let res = res.into_result(); - Ok((res.unwrap(), skipsize)) - } - None => Err(gst::FlowError::Error), - } + (*parent_class) + .handle_frame + .map(|f| { + let res = gst::FlowSuccess::try_from_glib(f( + element.unsafe_cast_ref::().to_glib_none().0, + frame.to_glib_none().0, + &mut skipsize, + )); + (res.unwrap(), skipsize as u32) + }) + .ok_or(gst::FlowError::Error) } } diff --git a/gstreamer-base/src/subclass/base_sink.rs b/gstreamer-base/src/subclass/base_sink.rs index 4aa7fc6b2..540c5b8dc 100644 --- a/gstreamer-base/src/subclass/base_sink.rs +++ b/gstreamer-base/src/subclass/base_sink.rs @@ -179,13 +179,12 @@ impl BaseSinkImplExt for T { (*parent_class) .render .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buffer.to_glib_none().0, )) }) - .unwrap_or(gst::FlowReturn::Ok) - .into_result() + .unwrap_or(Ok(gst::FlowSuccess::Ok)) } } @@ -200,13 +199,12 @@ impl BaseSinkImplExt for T { (*parent_class) .prepare .map(|f| { - from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buffer.to_glib_none().0, )) }) - .unwrap_or(gst::FlowReturn::Ok) - .into_result() + .unwrap_or(Ok(gst::FlowSuccess::Ok)) } } @@ -221,11 +219,10 @@ impl BaseSinkImplExt for T { (*parent_class) .render_list .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, list.to_glib_none().0, )) - .into_result() }) .unwrap_or_else(|| { for buffer in list.iter() { @@ -247,11 +244,10 @@ impl BaseSinkImplExt for T { (*parent_class) .prepare_list .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, list.to_glib_none().0, )) - .into_result() }) .unwrap_or_else(|| { for buffer in list.iter() { diff --git a/gstreamer-base/src/subclass/base_src.rs b/gstreamer-base/src/subclass/base_src.rs index 5d72c6a7c..3a13a1640 100644 --- a/gstreamer-base/src/subclass/base_src.rs +++ b/gstreamer-base/src/subclass/base_src.rs @@ -284,15 +284,14 @@ impl BaseSrcImplExt for T { (*parent_class) .fill .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, offset, length, buffer.as_mut_ptr(), )) }) - .unwrap_or(gst::FlowReturn::NotSupported) - .into_result() + .unwrap_or(Err(gst::FlowError::NotSupported)) } } @@ -314,13 +313,13 @@ impl BaseSrcImplExt for T { // https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3 let buffer_ref = &mut buffer_ptr as *mut _ as *mut gst::ffi::GstBuffer; - let res = gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, offset, length, buffer_ref, - )); - res.into_result_value(|| from_glib_full(buffer_ptr)) + )) + .map(|_| from_glib_full(buffer_ptr)) }) .unwrap_or(Err(gst::FlowError::NotSupported)) } @@ -349,14 +348,14 @@ impl BaseSrcImplExt for T { // https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3 let buffer_ref = &mut buffer_ptr as *mut _ as *mut gst::ffi::GstBuffer; - gst::FlowReturn::from_glib( + gst::FlowSuccess::try_from_glib( f( element.unsafe_cast_ref::().to_glib_none().0, offset, length, buffer_ref, ) - ).into_result()?; + )?; if let Some(passed_buffer) = buffer { if buffer_ptr != orig_buffer_ptr { diff --git a/gstreamer-base/src/subclass/base_transform.rs b/gstreamer-base/src/subclass/base_transform.rs index 0afc9f8b5..8f89a7afc 100644 --- a/gstreamer-base/src/subclass/base_transform.rs +++ b/gstreamer-base/src/subclass/base_transform.rs @@ -572,22 +572,18 @@ impl BaseTransformImplExt for T { .map(|f| { let mut outbuf: *mut gst::ffi::GstBuffer = ptr::null_mut(); // FIXME: Wrong signature in FFI - let res = from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, inbuf.as_ptr() as *mut gst::ffi::GstBuffer, (&mut outbuf) as *mut *mut gst::ffi::GstBuffer as *mut gst::ffi::GstBuffer, - )); - - match gst::FlowReturn::into_result(res) { - Err(err) => Err(err), - Ok(_) => { - if outbuf == inbuf.as_ptr() as *mut _ { - Ok(PrepareOutputBufferSuccess::InputBuffer) - } else { - Ok(PrepareOutputBufferSuccess::Buffer(from_glib_full(outbuf))) - } + )) + .map(|_| { + if outbuf == inbuf.as_ptr() as *mut _ { + PrepareOutputBufferSuccess::InputBuffer + } else { + PrepareOutputBufferSuccess::Buffer(from_glib_full(outbuf)) } - } + }) }) .unwrap_or(Err(gst::FlowError::NotSupported)) } @@ -605,7 +601,7 @@ impl BaseTransformImplExt for T { (*parent_class) .transform .map(|f| { - from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, inbuf.to_glib_none().0, outbuf.as_mut_ptr(), @@ -613,7 +609,7 @@ impl BaseTransformImplExt for T { }) .unwrap_or_else(|| { if !element.unsafe_cast_ref::().is_in_place() { - gst::FlowReturn::NotSupported + Err(gst::FlowError::NotSupported) } else { unreachable!(concat!( "parent `transform` called ", @@ -621,7 +617,6 @@ impl BaseTransformImplExt for T { )); } }) - .into_result() } } @@ -647,11 +642,10 @@ impl BaseTransformImplExt for T { } }); - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buf.as_mut_ptr() as *mut _, )) - .into_result() } } @@ -679,11 +673,10 @@ impl BaseTransformImplExt for T { // FIXME: Wrong signature in FFI let buf: *mut gst::ffi::GstBuffer = buf.to_glib_none().0; - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buf as *mut _, )) - .into_result() } } @@ -762,12 +755,11 @@ impl BaseTransformImplExt for T { .submit_input_buffer .expect("Missing parent function `submit_input_buffer`"); - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, is_discont.into_glib(), inbuf.into_ptr(), )) - .into_result() } } @@ -783,11 +775,10 @@ impl BaseTransformImplExt for T { .expect("Missing parent function `generate_output`"); let mut outbuf = ptr::null_mut(); - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, &mut outbuf, )) - .into_result() .map(|res| { if res == crate::BASE_TRANSFORM_FLOW_DROPPED { GenerateOutputSuccess::Dropped diff --git a/gstreamer-base/src/subclass/push_src.rs b/gstreamer-base/src/subclass/push_src.rs index 74684bff2..b339ef487 100644 --- a/gstreamer-base/src/subclass/push_src.rs +++ b/gstreamer-base/src/subclass/push_src.rs @@ -51,13 +51,12 @@ impl PushSrcImplExt for T { (*parent_class) .fill .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buffer.as_mut_ptr(), )) }) - .unwrap_or(gst::FlowReturn::NotSupported) - .into_result() + .unwrap_or(Err(gst::FlowError::NotSupported)) } } @@ -74,11 +73,11 @@ impl PushSrcImplExt for T { // https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3 let buffer_ref = &mut buffer_ptr as *mut _ as *mut gst::ffi::GstBuffer; - let res = gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buffer_ref, - )); - res.into_result_value(|| from_glib_full(buffer_ref)) + )) + .map(|_| from_glib_full(buffer_ref)) }) .unwrap_or(Err(gst::FlowError::NotSupported)) } @@ -97,11 +96,11 @@ impl PushSrcImplExt for T { // https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3 let buffer_ref = &mut buffer_ptr as *mut _ as *mut gst::ffi::GstBuffer; - let res = gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buffer_ref, - )); - res.into_result_value(|| from_glib_full(buffer_ref)) + )) + .map(|_| from_glib_full(buffer_ref)) }) .unwrap_or(Err(gst::FlowError::NotSupported)) } diff --git a/gstreamer-check/src/harness.rs b/gstreamer-check/src/harness.rs index 76b7485e1..6bfec4006 100644 --- a/gstreamer-check/src/harness.rs +++ b/gstreamer-check/src/harness.rs @@ -272,9 +272,12 @@ impl Harness { } pub fn push(&mut self, buffer: gst::Buffer) -> Result { - let ret: gst::FlowReturn = - unsafe { from_glib(ffi::gst_harness_push(self.0.as_ptr(), buffer.into_ptr())) }; - ret.into_result() + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_harness_push( + self.0.as_ptr(), + buffer.into_ptr(), + )) + } } pub fn push_and_pull(&mut self, buffer: gst::Buffer) -> Result { @@ -297,15 +300,11 @@ impl Harness { } pub fn push_from_src(&mut self) -> Result { - let ret: gst::FlowReturn = - unsafe { from_glib(ffi::gst_harness_push_from_src(self.0.as_ptr())) }; - ret.into_result() + unsafe { gst::FlowSuccess::try_from_glib(ffi::gst_harness_push_from_src(self.0.as_ptr())) } } pub fn push_to_sink(&mut self) -> Result { - let ret: gst::FlowReturn = - unsafe { from_glib(ffi::gst_harness_push_to_sink(self.0.as_ptr())) }; - ret.into_result() + unsafe { gst::FlowSuccess::try_from_glib(ffi::gst_harness_push_to_sink(self.0.as_ptr())) } } pub fn push_upstream_event(&mut self, event: gst::Event) -> bool { @@ -403,13 +402,12 @@ impl Harness { } pub fn sink_push_many(&mut self, pushes: u32) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_harness_sink_push_many( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_harness_sink_push_many( self.0.as_ptr(), pushes as i32, )) - }; - ret.into_result() + } } pub fn src_crank_and_push_many( @@ -417,14 +415,13 @@ impl Harness { cranks: u32, pushes: u32, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_harness_src_crank_and_push_many( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_harness_src_crank_and_push_many( self.0.as_ptr(), cranks as i32, pushes as i32, )) - }; - ret.into_result() + } } pub fn src_push_event(&mut self) -> bool { diff --git a/gstreamer-rtsp-server/src/lib.rs b/gstreamer-rtsp-server/src/lib.rs index eea7ec8f6..c792bf7ee 100644 --- a/gstreamer-rtsp-server/src/lib.rs +++ b/gstreamer-rtsp-server/src/lib.rs @@ -39,8 +39,6 @@ mod rtsp_media; mod rtsp_media_factory; mod rtsp_server; mod rtsp_session_pool; -mod rtsp_stream; -mod rtsp_stream_transport; mod rtsp_thread; mod rtsp_token; @@ -129,6 +127,4 @@ pub mod prelude { pub use crate::rtsp_media_factory::RTSPMediaFactoryExtManual; pub use crate::rtsp_server::RTSPServerExtManual; pub use crate::rtsp_session_pool::RTSPSessionPoolExtManual; - pub use crate::rtsp_stream::RTSPStreamExtManual; - pub use crate::rtsp_stream_transport::RTSPStreamTransportExtManual; } diff --git a/gstreamer-rtsp-server/src/rtsp_stream.rs b/gstreamer-rtsp-server/src/rtsp_stream.rs deleted file mode 100644 index bf98f4b13..000000000 --- a/gstreamer-rtsp-server/src/rtsp_stream.rs +++ /dev/null @@ -1,33 +0,0 @@ -// Take a look at the license at the top of the repository in the LICENSE file. - -use crate::RTSPStream; -use glib::prelude::*; -use glib::translate::*; - -pub trait RTSPStreamExtManual: 'static { - fn recv_rtcp(&self, buffer: &gst::Buffer) -> Result; - - fn recv_rtp(&self, buffer: &gst::Buffer) -> Result; -} - -impl> RTSPStreamExtManual for O { - fn recv_rtcp(&self, buffer: &gst::Buffer) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_rtsp_stream_recv_rtcp( - self.as_ref().to_glib_none().0, - buffer.to_glib_full(), - )) - }; - ret.into_result() - } - - fn recv_rtp(&self, buffer: &gst::Buffer) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_rtsp_stream_recv_rtp( - self.as_ref().to_glib_none().0, - buffer.to_glib_full(), - )) - }; - ret.into_result() - } -} diff --git a/gstreamer-rtsp-server/src/rtsp_stream_transport.rs b/gstreamer-rtsp-server/src/rtsp_stream_transport.rs deleted file mode 100644 index 7fd437309..000000000 --- a/gstreamer-rtsp-server/src/rtsp_stream_transport.rs +++ /dev/null @@ -1,30 +0,0 @@ -// Take a look at the license at the top of the repository in the LICENSE file. - -use crate::RTSPStreamTransport; -use glib::prelude::*; -use glib::translate::*; - -pub trait RTSPStreamTransportExtManual: 'static { - fn recv_data( - &self, - channel: u32, - buffer: &gst::Buffer, - ) -> Result; -} - -impl> RTSPStreamTransportExtManual for O { - fn recv_data( - &self, - channel: u32, - buffer: &gst::Buffer, - ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_rtsp_stream_transport_recv_data( - self.as_ref().to_glib_none().0, - channel, - buffer.to_glib_full(), - )) - }; - ret.into_result() - } -} diff --git a/gstreamer-video/src/subclass/video_decoder.rs b/gstreamer-video/src/subclass/video_decoder.rs index c80eb5227..ef02a0074 100644 --- a/gstreamer-video/src/subclass/video_decoder.rs +++ b/gstreamer-video/src/subclass/video_decoder.rs @@ -269,13 +269,12 @@ impl VideoDecoderImplExt for T { (*parent_class) .finish .map(|f| { - gst::FlowReturn::from_glib(f(element + gst::FlowSuccess::try_from_glib(f(element .unsafe_cast_ref::() .to_glib_none() .0)) }) - .unwrap_or(gst::FlowReturn::Ok) - .into_result() + .unwrap_or(Ok(gst::FlowSuccess::Ok)) } } @@ -286,13 +285,12 @@ impl VideoDecoderImplExt for T { (*parent_class) .drain .map(|f| { - gst::FlowReturn::from_glib(f(element + gst::FlowSuccess::try_from_glib(f(element .unsafe_cast_ref::() .to_glib_none() .0)) }) - .unwrap_or(gst::FlowReturn::Ok) - .into_result() + .unwrap_or(Ok(gst::FlowSuccess::Ok)) } } @@ -333,15 +331,14 @@ impl VideoDecoderImplExt for T { (*parent_class) .parse .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, frame.to_glib_none().0, adapter.to_glib_none().0, at_eos.into_glib(), )) }) - .unwrap_or(gst::FlowReturn::Ok) - .into_result() + .unwrap_or(Ok(gst::FlowSuccess::Ok)) } } @@ -356,13 +353,12 @@ impl VideoDecoderImplExt for T { (*parent_class) .handle_frame .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, frame.to_glib_none().0, )) }) - .unwrap_or(gst::FlowReturn::Error) - .into_result() + .unwrap_or(Err(gst::FlowError::Error)) } } diff --git a/gstreamer-video/src/subclass/video_encoder.rs b/gstreamer-video/src/subclass/video_encoder.rs index 133619381..ff87d39b7 100644 --- a/gstreamer-video/src/subclass/video_encoder.rs +++ b/gstreamer-video/src/subclass/video_encoder.rs @@ -245,13 +245,12 @@ impl VideoEncoderImplExt for T { (*parent_class) .finish .map(|f| { - gst::FlowReturn::from_glib(f(element + gst::FlowSuccess::try_from_glib(f(element .unsafe_cast_ref::() .to_glib_none() .0)) }) - .unwrap_or(gst::FlowReturn::Ok) - .into_result() + .unwrap_or(Ok(gst::FlowSuccess::Ok)) } } @@ -290,13 +289,12 @@ impl VideoEncoderImplExt for T { (*parent_class) .handle_frame .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, frame.to_glib_none().0, )) }) - .unwrap_or(gst::FlowReturn::Error) - .into_result() + .unwrap_or(Err(gst::FlowError::Error)) } } diff --git a/gstreamer-video/src/subclass/video_sink.rs b/gstreamer-video/src/subclass/video_sink.rs index 6b227290f..21f1c8736 100644 --- a/gstreamer-video/src/subclass/video_sink.rs +++ b/gstreamer-video/src/subclass/video_sink.rs @@ -37,13 +37,12 @@ impl VideoSinkImplExt for T { (*parent_class) .show_frame .map(|f| { - gst::FlowReturn::from_glib(f( + gst::FlowSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, buffer.to_glib_none().0, )) }) - .unwrap_or(gst::FlowReturn::Error) - .into_result() + .unwrap_or(Err(gst::FlowError::Error)) } } } diff --git a/gstreamer-video/src/video_decoder.rs b/gstreamer-video/src/video_decoder.rs index cde19f4c7..43e782c28 100644 --- a/gstreamer-video/src/video_decoder.rs +++ b/gstreamer-video/src/video_decoder.rs @@ -46,7 +46,6 @@ pub trait VideoDecoderExtManual: 'static { #[doc(alias = "get_allocator")] fn allocator(&self) -> (Option, gst::AllocationParams); - fn have_frame(&self) -> Result; fn finish_frame(&self, frame: VideoCodecFrame) -> Result; fn release_frame(&self, frame: VideoCodecFrame); fn drop_frame(&self, frame: VideoCodecFrame) -> Result; @@ -101,15 +100,16 @@ impl> VideoDecoderExtManual for O { frame: &mut VideoCodecFrame, params: Option<&gst::BufferPoolAcquireParams>, ) -> Result { - let ret: gst::FlowReturn = unsafe { + unsafe { let params_ptr = params.to_glib_none().0 as *mut _; - from_glib(ffi::gst_video_decoder_allocate_output_frame_with_params( - self.as_ref().to_glib_none().0, - frame.to_glib_none().0, - params_ptr, - )) - }; - ret.into_result() + gst::FlowSuccess::try_from_glib( + ffi::gst_video_decoder_allocate_output_frame_with_params( + self.as_ref().to_glib_none().0, + frame.to_glib_none().0, + params_ptr, + ), + ) + } } fn allocator(&self) -> (Option, gst::AllocationParams) { @@ -125,23 +125,13 @@ impl> VideoDecoderExtManual for O { } } - fn have_frame(&self) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_video_decoder_have_frame( - self.as_ref().to_glib_none().0, - )) - }; - ret.into_result() - } - fn finish_frame(&self, frame: VideoCodecFrame) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_video_decoder_finish_frame( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_video_decoder_finish_frame( self.as_ref().to_glib_none().0, frame.into_ptr(), )) - }; - ret.into_result() + } } fn release_frame(&self, frame: VideoCodecFrame) { @@ -151,13 +141,12 @@ impl> VideoDecoderExtManual for O { } fn drop_frame(&self, frame: VideoCodecFrame) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_video_decoder_drop_frame( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_video_decoder_drop_frame( self.as_ref().to_glib_none().0, frame.into_ptr(), )) - }; - ret.into_result() + } } fn latency(&self) -> (gst::ClockTime, gst::ClockTime) { @@ -327,8 +316,8 @@ impl> VideoDecoderExtManual for O { function: &str, line: u32, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(_gst_video_decoder_error( + unsafe { + gst::FlowSuccess::try_from_glib(_gst_video_decoder_error( self.as_ref().to_glib_none().0, weight, T::domain().into_glib(), @@ -339,8 +328,7 @@ impl> VideoDecoderExtManual for O { function.to_glib_none().0, line as i32, )) - }; - ret.into_result() + } } } diff --git a/gstreamer-video/src/video_encoder.rs b/gstreamer-video/src/video_encoder.rs index 65cd1d244..aedaa7d28 100644 --- a/gstreamer-video/src/video_encoder.rs +++ b/gstreamer-video/src/video_encoder.rs @@ -63,14 +63,13 @@ impl> VideoEncoderExtManual for O { frame: &mut VideoCodecFrame, size: usize, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_video_encoder_allocate_output_frame( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_video_encoder_allocate_output_frame( self.as_ref().to_glib_none().0, frame.to_glib_none().0, size, )) - }; - ret.into_result() + } } fn allocator(&self) -> (Option, gst::AllocationParams) { @@ -90,25 +89,23 @@ impl> VideoEncoderExtManual for O { &self, frame: Option, ) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_video_encoder_finish_frame( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_video_encoder_finish_frame( self.as_ref().to_glib_none().0, frame.map(|f| f.into_ptr()).unwrap_or(ptr::null_mut()), )) - }; - ret.into_result() + } } #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn finish_subframe(&self, frame: &VideoCodecFrame) -> Result { - let ret: gst::FlowReturn = unsafe { - from_glib(ffi::gst_video_encoder_finish_subframe( + unsafe { + gst::FlowSuccess::try_from_glib(ffi::gst_video_encoder_finish_subframe( self.as_ref().to_glib_none().0, frame.to_glib_none().0, )) - }; - ret.into_result() + } } fn latency(&self) -> (gst::ClockTime, gst::ClockTime) { diff --git a/gstreamer/src/buffer_pool.rs b/gstreamer/src/buffer_pool.rs index c56a67da5..918064237 100644 --- a/gstreamer/src/buffer_pool.rs +++ b/gstreamer/src/buffer_pool.rs @@ -6,9 +6,7 @@ use crate::BufferPool; use crate::Structure; use glib::prelude::*; -use glib::translate::{ - from_glib, from_glib_full, from_glib_none, IntoGlib, ToGlibPtr, ToGlibPtrMut, -}; +use glib::translate::*; use std::mem; use std::ops; @@ -334,13 +332,12 @@ impl> BufferPoolExtManual for O { unsafe { let mut buffer = ptr::null_mut(); - let ret: crate::FlowReturn = from_glib(ffi::gst_buffer_pool_acquire_buffer( + crate::FlowSuccess::try_from_glib(ffi::gst_buffer_pool_acquire_buffer( self.as_ref().to_glib_none().0, &mut buffer, params_ptr, - )); - - ret.into_result_value(|| from_glib_full(buffer)) + )) + .map(|_| from_glib_full(buffer)) } } diff --git a/gstreamer/src/clock.rs b/gstreamer/src/clock.rs index 3cb65af80..09604ca76 100644 --- a/gstreamer/src/clock.rs +++ b/gstreamer/src/clock.rs @@ -45,9 +45,11 @@ impl ClockId { pub fn wait(&self) -> (Result, ClockTimeDiff) { unsafe { let mut jitter = 0; - let res: ClockReturn = - from_glib(ffi::gst_clock_id_wait(self.to_glib_none().0, &mut jitter)); - (res.into_result(), jitter) + let res = ClockSuccess::try_from_glib(ffi::gst_clock_id_wait( + self.to_glib_none().0, + &mut jitter, + )); + (res, jitter) } } @@ -160,15 +162,14 @@ impl SingleShotClockId { let func: Box> = Box::new(Some(func)); - let ret: ClockReturn = unsafe { - from_glib(ffi::gst_clock_id_wait_async( + unsafe { + ClockSuccess::try_from_glib(ffi::gst_clock_id_wait_async( self.to_glib_none().0, Some(trampoline::), Box::into_raw(func) as gpointer, Some(destroy_notify::), )) - }; - ret.into_result() + } } #[allow(clippy::type_complexity)] @@ -264,15 +265,14 @@ impl PeriodicClockId { } let func: Box = Box::new(func); - let ret: ClockReturn = unsafe { - from_glib(ffi::gst_clock_id_wait_async( + unsafe { + ClockSuccess::try_from_glib(ffi::gst_clock_id_wait_async( self.to_glib_none().0, Some(trampoline::), Box::into_raw(func) as gpointer, Some(destroy_notify::), )) - }; - ret.into_result() + } } #[allow(clippy::type_complexity)] diff --git a/gstreamer/src/element.rs b/gstreamer/src/element.rs index 16b058640..51c1f199a 100644 --- a/gstreamer/src/element.rs +++ b/gstreamer/src/element.rs @@ -18,10 +18,6 @@ use crate::QueryRef; use crate::Rank; use crate::SpecificFormattedValue; use crate::State; -use crate::StateChange; -use crate::StateChangeError; -use crate::StateChangeReturn; -use crate::StateChangeSuccess; use glib::translate::*; @@ -116,29 +112,11 @@ pub trait ElementExtManual: 'static { #[doc(alias = "get_element_class")] fn element_class(&self) -> &glib::Class; - fn change_state(&self, transition: StateChange) - -> Result; - fn continue_state( - &self, - ret: StateChangeReturn, - ) -> Result; - - #[doc(alias = "get_state")] - fn state( - &self, - timeout: ClockTime, - ) -> (Result, State, State); - fn set_state(&self, state: State) -> Result; - #[doc(alias = "get_current_state")] - fn current_state(&self) -> State { - self.state(ClockTime::from(0)).1 - } + fn current_state(&self) -> State; #[doc(alias = "get_pending_state")] - fn pending_state(&self) -> State { - self.state(ClockTime::from(0)).2 - } + fn pending_state(&self) -> State; fn query(&self, query: &mut QueryRef) -> bool; @@ -283,61 +261,12 @@ impl> ElementExtManual for O { } } - fn change_state( - &self, - transition: StateChange, - ) -> Result { - let ret: StateChangeReturn = unsafe { - from_glib(ffi::gst_element_change_state( - self.as_ref().to_glib_none().0, - transition.into_glib(), - )) - }; - ret.into_result() + fn current_state(&self) -> State { + self.state(ClockTime::zero()).1 } - fn continue_state( - &self, - ret: StateChangeReturn, - ) -> Result { - let ret: StateChangeReturn = unsafe { - from_glib(ffi::gst_element_continue_state( - self.as_ref().to_glib_none().0, - ret.into_glib(), - )) - }; - ret.into_result() - } - - fn state( - &self, - timeout: ClockTime, - ) -> (Result, State, State) { - unsafe { - let mut state = mem::MaybeUninit::uninit(); - let mut pending = mem::MaybeUninit::uninit(); - let ret: StateChangeReturn = from_glib(ffi::gst_element_get_state( - self.as_ref().to_glib_none().0, - state.as_mut_ptr(), - pending.as_mut_ptr(), - timeout.into_glib(), - )); - ( - ret.into_result(), - from_glib(state.assume_init()), - from_glib(pending.assume_init()), - ) - } - } - - fn set_state(&self, state: State) -> Result { - let ret: StateChangeReturn = unsafe { - from_glib(ffi::gst_element_set_state( - self.as_ref().to_glib_none().0, - state.into_glib(), - )) - }; - ret.into_result() + fn pending_state(&self) -> State { + self.state(ClockTime::zero()).2 } fn query(&self, query: &mut QueryRef) -> bool { diff --git a/gstreamer/src/enums.rs b/gstreamer/src/enums.rs index 745f70c1c..fd286436e 100644 --- a/gstreamer/src/enums.rs +++ b/gstreamer/src/enums.rs @@ -16,6 +16,58 @@ use glib::value::Value; use glib::StaticType; use glib::Type; +macro_rules! impl_return_result_traits { + ($ffi_type:ident, $ret_type:ident, $ok_type:ident, $err_type:ident) => { + impl From<$ok_type> for $ret_type { + fn from(value: $ok_type) -> Self { + skip_assert_initialized!(); + $ret_type::from_ok(value) + } + } + + impl IntoGlib for $ok_type { + type GlibType = <$ret_type as IntoGlib>::GlibType; + + fn into_glib(self) -> Self::GlibType { + $ret_type::from_ok(self).into_glib() + } + } + + impl From<$err_type> for $ret_type { + fn from(value: $err_type) -> Self { + skip_assert_initialized!(); + $ret_type::from_error(value) + } + } + + impl IntoGlib for $err_type { + type GlibType = <$ret_type as IntoGlib>::GlibType; + + fn into_glib(self) -> Self::GlibType { + $ret_type::from_error(self).into_glib() + } + } + + impl From> for $ret_type { + fn from(res: Result<$ok_type, $err_type>) -> Self { + skip_assert_initialized!(); + match res { + Ok(success) => $ret_type::from_ok(success), + Err(error) => $ret_type::from_error(error), + } + } + } + + impl TryFromGlib for $ok_type { + type Error = $err_type; + fn try_from_glib(val: ffi::$ffi_type) -> Result<$ok_type, $err_type> { + skip_assert_initialized!(); + unsafe { $ret_type::from_glib(val) }.into_result() + } + } + }; +} + impl StateChangeReturn { pub fn into_result(self) -> Result { match self { @@ -49,34 +101,17 @@ pub enum StateChangeSuccess { NoPreroll, } -impl From for StateChangeReturn { - fn from(value: StateChangeSuccess) -> Self { - skip_assert_initialized!(); - StateChangeReturn::from_ok(value) - } -} - #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)] #[must_use] #[error("Element failed to change its state")] pub struct StateChangeError; -impl From for StateChangeReturn { - fn from(value: StateChangeError) -> Self { - skip_assert_initialized!(); - StateChangeReturn::from_error(value) - } -} - -impl From> for StateChangeReturn { - fn from(res: Result) -> Self { - skip_assert_initialized!(); - match res { - Ok(success) => StateChangeReturn::from_ok(success), - Err(error) => StateChangeReturn::from_error(error), - } - } -} +impl_return_result_traits!( + GstStateChangeReturn, + StateChangeReturn, + StateChangeSuccess, + StateChangeError +); impl FlowReturn { pub fn into_result(self) -> Result { @@ -98,13 +133,6 @@ impl FlowReturn { } } - pub fn into_result_value T>(self, func: F) -> Result { - match self.into_result() { - Ok(_) => Ok(func()), - Err(err) => Err(err), - } - } - pub fn from_error(v: FlowError) -> Self { skip_assert_initialized!(); match v { @@ -139,13 +167,6 @@ pub enum FlowSuccess { Ok, } -impl From for FlowReturn { - fn from(value: FlowSuccess) -> Self { - skip_assert_initialized!(); - FlowReturn::from_ok(value) - } -} - #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)] #[must_use] pub enum FlowError { @@ -169,22 +190,7 @@ pub enum FlowError { CustomError2, } -impl From for FlowReturn { - fn from(value: FlowError) -> Self { - skip_assert_initialized!(); - FlowReturn::from_error(value) - } -} - -impl From> for FlowReturn { - fn from(res: Result) -> Self { - skip_assert_initialized!(); - match res { - Ok(success) => FlowReturn::from_ok(success), - Err(error) => FlowReturn::from_error(error), - } - } -} +impl_return_result_traits!(GstFlowReturn, FlowReturn, FlowSuccess, FlowError); impl PadLinkReturn { pub fn into_result(self) -> Result { @@ -221,13 +227,6 @@ impl PadLinkReturn { #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)] pub struct PadLinkSuccess; -impl From for PadLinkReturn { - fn from(value: PadLinkSuccess) -> Self { - skip_assert_initialized!(); - PadLinkReturn::from_ok(value) - } -} - #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)] #[must_use] pub enum PadLinkError { @@ -245,22 +244,12 @@ pub enum PadLinkError { Refused, } -impl From for PadLinkReturn { - fn from(value: PadLinkError) -> Self { - skip_assert_initialized!(); - PadLinkReturn::from_error(value) - } -} - -impl From> for PadLinkReturn { - fn from(res: Result) -> Self { - skip_assert_initialized!(); - match res { - Ok(success) => PadLinkReturn::from_ok(success), - Err(error) => PadLinkReturn::from_error(error), - } - } -} +impl_return_result_traits!( + GstPadLinkReturn, + PadLinkReturn, + PadLinkSuccess, + PadLinkError +); impl ClockReturn { pub fn into_result(self) -> Result { @@ -304,13 +293,6 @@ pub enum ClockSuccess { Done, } -impl From for ClockReturn { - fn from(value: ClockSuccess) -> Self { - skip_assert_initialized!(); - ClockReturn::from_ok(value) - } -} - #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)] #[must_use] pub enum ClockError { @@ -328,22 +310,7 @@ pub enum ClockError { Unsupported, } -impl From for ClockReturn { - fn from(value: ClockError) -> Self { - skip_assert_initialized!(); - ClockReturn::from_error(value) - } -} - -impl From> for ClockReturn { - fn from(res: Result) -> Self { - skip_assert_initialized!(); - match res { - Ok(success) => ClockReturn::from_ok(success), - Err(error) => ClockReturn::from_error(error), - } - } -} +impl_return_result_traits!(GstClockReturn, ClockReturn, ClockSuccess, ClockError); impl PartialEq for crate::TypeFindProbability { fn eq(&self, other: &crate::TypeFindProbability) -> bool { diff --git a/gstreamer/src/pad.rs b/gstreamer/src/pad.rs index 5de30e438..baae0d52f 100644 --- a/gstreamer/src/pad.rs +++ b/gstreamer/src/pad.rs @@ -12,10 +12,6 @@ use crate::GenericFormattedValue; use crate::LoggableError; use crate::Pad; use crate::PadFlags; -use crate::PadLinkCheck; -use crate::PadLinkError; -use crate::PadLinkReturn; -use crate::PadLinkSuccess; use crate::PadProbeReturn; use crate::PadProbeType; use crate::Query; @@ -30,9 +26,7 @@ use std::ptr; use glib::ffi::gpointer; use glib::prelude::*; -use glib::translate::{ - from_glib, from_glib_borrow, from_glib_full, FromGlib, FromGlibPtrBorrow, IntoGlib, ToGlibPtr, -}; +use glib::translate::*; #[derive(Debug, PartialEq, Eq)] pub struct PadProbeId(NonZeroU64); @@ -137,22 +131,12 @@ pub trait PadExtManual: 'static { fn push_event(&self, event: Event) -> bool; fn send_event(&self, event: Event) -> bool; - #[doc(alias = "get_last_flow_result")] - fn last_flow_result(&self) -> Result; - fn iterate_internal_links(&self) -> crate::Iterator; fn iterate_internal_links_default>( &self, parent: Option<&P>, ) -> crate::Iterator; - fn link>(&self, sinkpad: &P) -> Result; - fn link_full>( - &self, - sinkpad: &P, - flags: PadLinkCheck, - ) -> Result; - fn stream_lock(&self) -> StreamLock; unsafe fn set_activate_function(&self, func: F) @@ -269,8 +253,6 @@ pub trait PadExtManual: 'static { func: F, ); - fn store_sticky_event(&self, event: &Event) -> Result; - fn set_pad_flags(&self, flags: PadFlags); fn unset_pad_flags(&self, flags: PadFlags); @@ -310,54 +292,50 @@ impl> PadExtManual for O { fn chain(&self, buffer: Buffer) -> Result { unsafe { - FlowReturn::from_glib(ffi::gst_pad_chain( + FlowSuccess::try_from_glib(ffi::gst_pad_chain( self.as_ref().to_glib_none().0, buffer.into_ptr(), )) - .into_result() } } fn push(&self, buffer: Buffer) -> Result { unsafe { - FlowReturn::from_glib(ffi::gst_pad_push( + FlowSuccess::try_from_glib(ffi::gst_pad_push( self.as_ref().to_glib_none().0, buffer.into_ptr(), )) - .into_result() } } fn chain_list(&self, list: BufferList) -> Result { unsafe { - FlowReturn::from_glib(ffi::gst_pad_chain_list( + FlowSuccess::try_from_glib(ffi::gst_pad_chain_list( self.as_ref().to_glib_none().0, list.into_ptr(), )) - .into_result() } } fn push_list(&self, list: BufferList) -> Result { unsafe { - FlowReturn::from_glib(ffi::gst_pad_push_list( + FlowSuccess::try_from_glib(ffi::gst_pad_push_list( self.as_ref().to_glib_none().0, list.into_ptr(), )) - .into_result() } } fn range(&self, offset: u64, size: u32) -> Result { unsafe { let mut buffer = ptr::null_mut(); - let ret: FlowReturn = from_glib(ffi::gst_pad_get_range( + FlowSuccess::try_from_glib(ffi::gst_pad_get_range( self.as_ref().to_glib_none().0, offset, size, &mut buffer, - )); - ret.into_result_value(|| from_glib_full(buffer)) + )) + .map(|_| from_glib_full(buffer)) } } @@ -371,36 +349,33 @@ impl> PadExtManual for O { unsafe { let mut buffer_ref = buffer.as_mut_ptr(); - let ret: FlowReturn = from_glib(ffi::gst_pad_get_range( + FlowSuccess::try_from_glib(ffi::gst_pad_get_range( self.as_ref().to_glib_none().0, offset, size, &mut buffer_ref, - )); - match ret.into_result_value(|| ()) { - Ok(_) => { - if buffer.as_mut_ptr() != buffer_ref { - ffi::gst_mini_object_unref(buffer_ref as *mut _); - Err(crate::FlowError::Error) - } else { - Ok(()) - } + )) + .and_then(|_| { + if buffer.as_mut_ptr() != buffer_ref { + ffi::gst_mini_object_unref(buffer_ref as *mut _); + Err(crate::FlowError::Error) + } else { + Ok(()) } - Err(err) => Err(err), - } + }) } } fn pull_range(&self, offset: u64, size: u32) -> Result { unsafe { let mut buffer = ptr::null_mut(); - let ret: FlowReturn = from_glib(ffi::gst_pad_pull_range( + FlowSuccess::try_from_glib(ffi::gst_pad_pull_range( self.as_ref().to_glib_none().0, offset, size, &mut buffer, - )); - ret.into_result_value(|| from_glib_full(buffer)) + )) + .map(|_| from_glib_full(buffer)) } } @@ -414,23 +389,20 @@ impl> PadExtManual for O { unsafe { let mut buffer_ref = buffer.as_mut_ptr(); - let ret: FlowReturn = from_glib(ffi::gst_pad_pull_range( + FlowSuccess::try_from_glib(ffi::gst_pad_pull_range( self.as_ref().to_glib_none().0, offset, size, &mut buffer_ref, - )); - match ret.into_result_value(|| ()) { - Ok(_) => { - if buffer.as_mut_ptr() != buffer_ref { - ffi::gst_mini_object_unref(buffer_ref as *mut _); - Err(crate::FlowError::Error) - } else { - Ok(()) - } + )) + .and_then(|_| { + if buffer.as_mut_ptr() != buffer_ref { + ffi::gst_mini_object_unref(buffer_ref as *mut _); + Err(crate::FlowError::Error) + } else { + Ok(()) } - Err(err) => Err(err), - } + }) } } @@ -514,15 +486,6 @@ impl> PadExtManual for O { } } - fn last_flow_result(&self) -> Result { - let ret: FlowReturn = unsafe { - from_glib(ffi::gst_pad_get_last_flow_return( - self.as_ref().to_glib_none().0, - )) - }; - ret.into_result() - } - fn iterate_internal_links(&self) -> crate::Iterator { unsafe { from_glib_full(ffi::gst_pad_iterate_internal_links( @@ -543,31 +506,6 @@ impl> PadExtManual for O { } } - fn link>(&self, sinkpad: &P) -> Result { - let ret: PadLinkReturn = unsafe { - from_glib(ffi::gst_pad_link( - self.as_ref().to_glib_none().0, - sinkpad.as_ref().to_glib_none().0, - )) - }; - ret.into_result() - } - - fn link_full>( - &self, - sinkpad: &P, - flags: PadLinkCheck, - ) -> Result { - let ret: PadLinkReturn = unsafe { - from_glib(ffi::gst_pad_link_full( - self.as_ref().to_glib_none().0, - sinkpad.as_ref().to_glib_none().0, - flags.into_glib(), - )) - }; - ret.into_result() - } - fn stream_lock(&self) -> StreamLock { unsafe { let ptr: &mut ffi::GstPad = &mut *(self.as_ptr() as *mut _); @@ -1043,16 +981,6 @@ impl> PadExtManual for O { } } - fn store_sticky_event(&self, event: &Event) -> Result { - let ret: FlowReturn = unsafe { - from_glib(ffi::gst_pad_store_sticky_event( - self.as_ref().to_glib_none().0, - event.to_glib_none().0, - )) - }; - ret.into_result() - } - fn set_pad_flags(&self, flags: PadFlags) { unsafe { let ptr: *mut ffi::GstObject = self.as_ptr() as *mut _; @@ -1082,7 +1010,7 @@ unsafe fn create_probe_info<'a>( info: *mut ffi::GstPadProbeInfo, ) -> (PadProbeInfo<'a>, Option) { let mut data_type = None; - let flow_ret: FlowReturn = from_glib((*info).ABI.abi.flow_ret); + let flow_res = FlowSuccess::try_from_glib((*info).ABI.abi.flow_ret); let info = PadProbeInfo { mask: from_glib((*info).type_), id: Some(PadProbeId(NonZeroU64::new_unchecked((*info).id as u64))), @@ -1117,7 +1045,7 @@ unsafe fn create_probe_info<'a>( Some(PadProbeData::__Unknown(data)) } }, - flow_res: flow_ret.into_result(), + flow_res, }; (info, data_type) } diff --git a/gstreamer/src/proxy_pad.rs b/gstreamer/src/proxy_pad.rs index 84bf193dc..4ab2cc8f6 100644 --- a/gstreamer/src/proxy_pad.rs +++ b/gstreamer/src/proxy_pad.rs @@ -3,7 +3,6 @@ use crate::Buffer; use crate::BufferList; use crate::FlowError; -use crate::FlowReturn; use crate::FlowSuccess; use crate::Object; use crate::Pad; @@ -11,7 +10,7 @@ use crate::ProxyPad; use std::ptr; use glib::prelude::*; -use glib::translate::{from_glib, from_glib_full, ToGlibPtr}; +use glib::translate::*; pub trait ProxyPadExtManual: 'static { fn chain_default>( @@ -46,14 +45,13 @@ impl> ProxyPadExtManual for O { buffer: Buffer, ) -> Result { skip_assert_initialized!(); - let ret: FlowReturn = unsafe { - from_glib(ffi::gst_proxy_pad_chain_default( + unsafe { + FlowSuccess::try_from_glib(ffi::gst_proxy_pad_chain_default( self.as_ptr() as *mut ffi::GstPad, parent.map(|p| p.as_ref()).to_glib_none().0, buffer.into_ptr(), )) - }; - ret.into_result() + } } fn chain_list_default>( @@ -62,14 +60,13 @@ impl> ProxyPadExtManual for O { list: BufferList, ) -> Result { skip_assert_initialized!(); - let ret: FlowReturn = unsafe { - from_glib(ffi::gst_proxy_pad_chain_list_default( + unsafe { + FlowSuccess::try_from_glib(ffi::gst_proxy_pad_chain_list_default( self.as_ptr() as *mut ffi::GstPad, parent.map(|p| p.as_ref()).to_glib_none().0, list.into_ptr(), )) - }; - ret.into_result() + } } fn getrange_default>( @@ -81,14 +78,14 @@ impl> ProxyPadExtManual for O { skip_assert_initialized!(); unsafe { let mut buffer = ptr::null_mut(); - let ret: FlowReturn = from_glib(ffi::gst_proxy_pad_getrange_default( + FlowSuccess::try_from_glib(ffi::gst_proxy_pad_getrange_default( self.as_ptr() as *mut ffi::GstPad, parent.map(|p| p.as_ref()).to_glib_none().0, offset, size, &mut buffer, - )); - ret.into_result_value(|| from_glib_full(buffer)) + )) + .map(|_| from_glib_full(buffer)) } } diff --git a/gstreamer/src/subclass/clock.rs b/gstreamer/src/subclass/clock.rs index 395e2dbfc..3af1637cf 100644 --- a/gstreamer/src/subclass/clock.rs +++ b/gstreamer/src/subclass/clock.rs @@ -141,7 +141,7 @@ impl ClockImplExt for T { let mut jitter = 0; ( - ClockReturn::from_glib( + ClockSuccess::try_from_glib( (*parent_class) .wait .map(|f| { @@ -152,8 +152,7 @@ impl ClockImplExt for T { ) }) .unwrap_or(ffi::GST_CLOCK_UNSUPPORTED), - ) - .into_result(), + ), jitter, ) } @@ -167,7 +166,7 @@ impl ClockImplExt for T { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass; - ClockReturn::from_glib( + ClockSuccess::try_from_glib( (*parent_class) .wait_async .map(|f| { @@ -178,7 +177,6 @@ impl ClockImplExt for T { }) .unwrap_or(ffi::GST_CLOCK_UNSUPPORTED), ) - .into_result() } } diff --git a/gstreamer/src/subclass/element.rs b/gstreamer/src/subclass/element.rs index 86539f5dc..eaf7367ec 100644 --- a/gstreamer/src/subclass/element.rs +++ b/gstreamer/src/subclass/element.rs @@ -170,11 +170,10 @@ impl ElementImplExt for T { let f = (*parent_class) .change_state .expect("Missing parent function `change_state`"); - StateChangeReturn::from_glib(f( + StateChangeSuccess::try_from_glib(f( element.unsafe_cast_ref::().to_glib_none().0, transition.into_glib(), )) - .into_result() } }