From f17781e1885945d1d793edc19138091f7e78db5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Sat, 8 Oct 2022 21:50:06 +0300 Subject: [PATCH] Change *Impl trait methods to only take &self and not Self::Type in addition --- examples/src/bin/cairo_compositor.rs | 54 +- examples/src/bin/fd_allocator.rs | 14 +- examples/src/bin/glfilter.rs | 25 +- examples/src/bin/rtsp-server-subclass.rs | 34 +- examples/src/bin/subclass.rs | 9 +- .../src/subclass/audio_aggregator.rs | 40 +- .../src/subclass/audio_aggregator_pad.rs | 29 +- gstreamer-audio/src/subclass/audio_decoder.rs | 346 +++++----- gstreamer-audio/src/subclass/audio_encoder.rs | 319 +++++---- gstreamer-audio/src/subclass/audio_sink.rs | 151 +++-- gstreamer-audio/src/subclass/audio_src.rs | 155 +++-- gstreamer-base/src/subclass/aggregator.rs | 514 ++++++-------- gstreamer-base/src/subclass/aggregator_pad.rs | 61 +- gstreamer-base/src/subclass/base_parse.rs | 124 ++-- gstreamer-base/src/subclass/base_sink.rs | 318 ++++----- gstreamer-base/src/subclass/base_src.rs | 411 ++++++------ gstreamer-base/src/subclass/base_transform.rs | 474 ++++++------- gstreamer-base/src/subclass/push_src.rs | 88 ++- gstreamer-gl/src/subclass/gl_base_filter.rs | 79 +-- gstreamer-gl/src/subclass/gl_base_src.rs | 68 +- gstreamer-gl/src/subclass/gl_filter.rs | 141 ++-- .../src/subclass/audio_visualizer.rs | 63 +- .../src/subclass/play_video_renderer.rs | 13 +- .../src/subclass/player_video_renderer.rs | 21 +- .../src/subclass/rtp_base_depayload.rs | 68 +- .../src/subclass/rtp_base_payload.rs | 145 ++-- .../src/subclass/rtp_header_extension.rs | 144 ++-- .../src/subclass/rtsp_client.rs | 631 +++++++----------- .../src/subclass/rtsp_media.rs | 326 ++++----- .../src/subclass/rtsp_media_factory.rs | 138 ++-- .../src/subclass/rtsp_mount_points.rs | 26 +- .../src/subclass/rtsp_onvif_media_factory.rs | 15 +- .../src/subclass/rtsp_server.rs | 33 +- gstreamer-video/src/subclass/navigation.rs | 36 +- .../src/subclass/video_aggregator.rs | 87 +-- .../src/subclass/video_aggregator_pad.rs | 48 +- gstreamer-video/src/subclass/video_decoder.rs | 346 +++++----- gstreamer-video/src/subclass/video_encoder.rs | 295 ++++---- gstreamer-video/src/subclass/video_filter.rs | 88 ++- gstreamer-video/src/subclass/video_sink.rs | 30 +- gstreamer/src/log.rs | 2 +- gstreamer/src/subclass/bin.rs | 87 ++- gstreamer/src/subclass/buffer_pool.rs | 149 ++--- gstreamer/src/subclass/child_proxy.rs | 80 ++- gstreamer/src/subclass/clock.rs | 120 ++-- gstreamer/src/subclass/device.rs | 53 +- gstreamer/src/subclass/device_provider.rs | 44 +- gstreamer/src/subclass/element.rs | 219 +++--- gstreamer/src/subclass/error.rs | 15 +- gstreamer/src/subclass/pad.rs | 34 +- gstreamer/src/subclass/task_pool.rs | 36 +- gstreamer/src/subclass/uri_handler.rs | 32 +- 52 files changed, 2979 insertions(+), 3899 deletions(-) diff --git a/examples/src/bin/cairo_compositor.rs b/examples/src/bin/cairo_compositor.rs index 276005587..1d49403c8 100644 --- a/examples/src/bin/cairo_compositor.rs +++ b/examples/src/bin/cairo_compositor.rs @@ -73,13 +73,7 @@ mod cairo_compositor { } // Called by the application whenever the value of a property should be changed. - fn set_property( - &self, - _obj: &Self::Type, - _id: usize, - value: &glib::Value, - pspec: &glib::ParamSpec, - ) { + fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) { let mut settings = self.settings.lock().unwrap(); match pspec.name() { @@ -91,12 +85,7 @@ mod cairo_compositor { } // Called by the application whenever the value of a property should be retrieved. - fn property( - &self, - _obj: &Self::Type, - _id: usize, - pspec: &glib::ParamSpec, - ) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { let settings = self.settings.lock().unwrap(); match pspec.name() { @@ -180,19 +169,20 @@ mod cairo_compositor { // Notify via the child proxy interface whenever a new pad is added or removed. fn request_new_pad( &self, - element: &Self::Type, templ: &gst::PadTemplate, name: Option, caps: Option<&gst::Caps>, ) -> Option { - let pad = self.parent_request_new_pad(element, templ, name, caps)?; + let element = self.instance(); + let pad = self.parent_request_new_pad(templ, name, caps)?; element.child_added(&pad, &pad.name()); Some(pad) } - fn release_pad(&self, element: &Self::Type, pad: &gst::Pad) { + fn release_pad(&self, pad: &gst::Pad) { + let element = self.instance(); element.child_removed(pad, &pad.name()); - self.parent_release_pad(element, pad); + self.parent_release_pad(pad); } } @@ -201,7 +191,6 @@ mod cairo_compositor { // Called whenever a query arrives at the given sink pad of the compositor. fn sink_query( &self, - aggregator: &Self::Type, aggregator_pad: &gst_base::AggregatorPad, query: &mut gst::QueryRef, ) -> bool { @@ -232,7 +221,7 @@ mod cairo_compositor { true } - _ => self.parent_sink_query(aggregator, aggregator_pad, query), + _ => self.parent_sink_query(aggregator_pad, query), } } } @@ -242,7 +231,6 @@ mod cairo_compositor { // Called by videoaggregator whenever the output format should be determined. fn find_best_format( &self, - _element: &Self::Type, _downstream_caps: &gst::Caps, ) -> Option<(gst_video::VideoInfo, bool)> { // Let videoaggregator select whatever format downstream wants. @@ -257,10 +245,10 @@ mod cairo_compositor { // time. fn aggregate_frames( &self, - element: &Self::Type, token: &gst_video::subclass::AggregateFramesToken, outbuf: &mut gst::BufferRef, ) -> Result { + let element = self.instance(); let pads = element.sink_pads(); // Map the output frame writable. @@ -326,11 +314,13 @@ mod cairo_compositor { // // This allows accessing the pads and their properties from e.g. gst-launch. impl ChildProxyImpl for CairoCompositor { - fn children_count(&self, object: &Self::Type) -> u32 { + fn children_count(&self) -> u32 { + let object = self.instance(); object.num_pads() as u32 } - fn child_by_name(&self, object: &Self::Type, name: &str) -> Option { + fn child_by_name(&self, name: &str) -> Option { + let object = self.instance(); object .pads() .into_iter() @@ -338,7 +328,8 @@ mod cairo_compositor { .map(|p| p.upcast()) } - fn child_by_index(&self, object: &Self::Type, index: u32) -> Option { + fn child_by_index(&self, index: u32) -> Option { + let object = self.instance(); object .pads() .into_iter() @@ -522,13 +513,7 @@ mod cairo_compositor { } // Called by the application whenever the value of a property should be changed. - fn set_property( - &self, - _obj: &Self::Type, - _id: usize, - value: &glib::Value, - pspec: &glib::ParamSpec, - ) { + fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) { let mut settings = self.settings.lock().unwrap(); match pspec.name() { @@ -552,12 +537,7 @@ mod cairo_compositor { } // Called by the application whenever the value of a property should be retrieved. - fn property( - &self, - _obj: &Self::Type, - _id: usize, - pspec: &glib::ParamSpec, - ) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { let settings = self.settings.lock().unwrap(); match pspec.name() { diff --git a/examples/src/bin/fd_allocator.rs b/examples/src/bin/fd_allocator.rs index c730b1d4f..f6c0ffe1a 100644 --- a/examples/src/bin/fd_allocator.rs +++ b/examples/src/bin/fd_allocator.rs @@ -389,16 +389,9 @@ mod video_filter { use std::{cmp, mem::ManuallyDrop, os::unix::prelude::FromRawFd}; use anyhow::Error; - use glib::subclass::{object::ObjectImpl, types::ObjectSubclass}; - use gst::{ - subclass::prelude::{ElementImpl, GstObjectImpl}, - PadDirection, PadPresence, PadTemplate, - }; + use gst::{subclass::prelude::*, PadDirection, PadPresence, PadTemplate}; use gst_app::gst_base::subclass::BaseTransformMode; - use gst_video::{ - subclass::prelude::{BaseTransformImpl, VideoFilterImpl}, - VideoFrameRef, - }; + use gst_video::{subclass::prelude::*, VideoFrameRef}; use memmap2::MmapMut; use once_cell::sync::Lazy; @@ -490,11 +483,10 @@ mod video_filter { impl VideoFilterImpl for FdMemoryFadeInVideoFilter { fn transform_frame_ip( &self, - element: &Self::Type, frame: &mut VideoFrameRef<&mut gst::BufferRef>, ) -> Result { self.transform_fd_mem_ip(frame).map_err(|err| { - gst::error!(CAT, obj: element, "Failed to transform frame`: {}", err); + gst::error!(CAT, imp: self, "Failed to transform frame`: {}", err); gst::FlowError::Error })?; diff --git a/examples/src/bin/glfilter.rs b/examples/src/bin/glfilter.rs index 761572776..ed237ec5b 100644 --- a/examples/src/bin/glfilter.rs +++ b/examples/src/bin/glfilter.rs @@ -67,11 +67,7 @@ mod mirror { } impl GLMirrorFilter { - fn create_shader( - &self, - filter: &::Type, - context: &GLContext, - ) -> Result<(), gst::LoggableError> { + fn create_shader(&self, context: &GLContext) -> Result<(), gst::LoggableError> { let shader = GLShader::new(context); let vertex = GLSLStage::new_default_vertex(context); @@ -80,7 +76,7 @@ mod mirror { gst::debug!( CAT, - obj: filter, + imp: self, "Compiling fragment shader {}", FRAGMENT_SHADER ); @@ -99,7 +95,7 @@ mod mirror { gst::debug!( CAT, - obj: filter, + imp: self, "Successfully compiled and linked {:?}", shader ); @@ -127,12 +123,14 @@ mod mirror { const TRANSFORM_IP_ON_PASSTHROUGH: bool = false; } impl GLBaseFilterImpl for GLMirrorFilter { - fn gl_start(&self, filter: &Self::Type) -> Result<(), gst::LoggableError> { + fn gl_start(&self) -> Result<(), gst::LoggableError> { + let filter = self.instance(); + // Create a shader when GL is started, knowing that the OpenGL context is // available. - let context = GLBaseFilterExt::context(filter).unwrap(); - self.create_shader(filter, &context)?; - self.parent_gl_start(filter) + let context = GLBaseFilterExt::context(&*filter).unwrap(); + self.create_shader(&context)?; + self.parent_gl_start() } } impl GLFilterImpl for GLMirrorFilter { @@ -140,10 +138,11 @@ mod mirror { fn filter_texture( &self, - filter: &Self::Type, input: &gst_gl::GLMemory, output: &gst_gl::GLMemory, ) -> Result<(), gst::LoggableError> { + let filter = self.instance(); + let shader = self.shader.lock().unwrap(); // Use the underlying filter implementation to transform the input texture into // an output texture with the shader. @@ -154,7 +153,7 @@ mod mirror { .as_ref() .expect("No shader, call `create_shader` first!"), ); - self.parent_filter_texture(filter, input, output) + self.parent_filter_texture(input, output) } } } diff --git a/examples/src/bin/rtsp-server-subclass.rs b/examples/src/bin/rtsp-server-subclass.rs index db5ffa1ed..ffa9d5742 100644 --- a/examples/src/bin/rtsp-server-subclass.rs +++ b/examples/src/bin/rtsp-server-subclass.rs @@ -105,9 +105,10 @@ mod media_factory { // Implementation of glib::Object virtual methods impl ObjectImpl for Factory { - fn constructed(&self, factory: &Self::Type) { - self.parent_constructed(factory); + fn constructed(&self) { + self.parent_constructed(); + let factory = self.instance(); // All media created by this factory are our custom media type. This would // not require a media factory subclass and can also be called on the normal // RTSPMediaFactory. @@ -117,11 +118,7 @@ mod media_factory { // Implementation of gst_rtsp_server::RTSPMediaFactory virtual methods impl RTSPMediaFactoryImpl for Factory { - fn create_element( - &self, - _factory: &Self::Type, - _url: &gst_rtsp::RTSPUrl, - ) -> Option { + fn create_element(&self, _url: &gst_rtsp::RTSPUrl) -> Option { // Create a simple VP8 videotestsrc input let bin = gst::Bin::new(None); let src = gst::ElementFactory::make("videotestsrc", None).unwrap(); @@ -187,11 +184,10 @@ mod media { impl RTSPMediaImpl for Media { fn setup_sdp( &self, - media: &Self::Type, sdp: &mut gst_sdp::SDPMessageRef, info: &gst_rtsp_server::subclass::SDPInfo, ) -> Result<(), gst::LoggableError> { - self.parent_setup_sdp(media, sdp, info)?; + self.parent_setup_sdp(sdp, info)?; sdp.add_attribute("my-custom-attribute", Some("has-a-value")); @@ -237,7 +233,8 @@ mod server { // Implementation of gst_rtsp_server::RTSPServer virtual methods impl RTSPServerImpl for Server { - fn create_client(&self, server: &Self::Type) -> Option { + fn create_client(&self) -> Option { + let server = self.instance(); let client = super::client::Client::default(); // Duplicated from the default implementation @@ -249,8 +246,8 @@ mod server { Some(client.upcast()) } - fn client_connected(&self, server: &Self::Type, client: &gst_rtsp_server::RTSPClient) { - self.parent_client_connected(server, client); + fn client_connected(&self, client: &gst_rtsp_server::RTSPClient) { + self.parent_client_connected(client); println!("Client {:?} connected", client); } } @@ -297,8 +294,9 @@ mod client { // Implementation of gst_rtsp_server::RTSPClient virtual methods impl RTSPClientImpl for Client { - fn closed(&self, client: &Self::Type) { - self.parent_closed(client); + fn closed(&self) { + let client = self.instance(); + self.parent_closed(); println!("Client {:?} closed", client); } } @@ -343,13 +341,9 @@ mod mount_points { // Implementation of gst_rtsp_server::RTSPClient virtual methods impl RTSPMountPointsImpl for MountPoints { - fn make_path( - &self, - mount_points: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { + fn make_path(&self, url: &gst_rtsp::RTSPUrl) -> Option { println!("Make path called for {:?} ", url); - self.parent_make_path(mount_points, url) + self.parent_make_path(url) } } } diff --git a/examples/src/bin/subclass.rs b/examples/src/bin/subclass.rs index 33cb610d2..c6e16e8f8 100644 --- a/examples/src/bin/subclass.rs +++ b/examples/src/bin/subclass.rs @@ -135,18 +135,18 @@ mod fir_filter { // Returns the size of one processing unit (i.e. a frame in our case) corresponding // to the given caps. This is used for allocating a big enough output buffer and // sanity checking the input buffer size, among other things. - fn unit_size(&self, _element: &Self::Type, caps: &gst::Caps) -> Option { + fn unit_size(&self, caps: &gst::Caps) -> Option { let audio_info = gst_audio::AudioInfo::from_caps(caps).ok(); audio_info.map(|info| info.bpf() as usize) } // Called when shutting down the element so we can release all stream-related state // There's also start(), which is called whenever starting the element again - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { // Drop state self.history.lock().unwrap().clear(); - gst::info!(CAT, obj: element, "Stopped"); + gst::info!(CAT, imp: self, "Stopped"); Ok(()) } @@ -154,9 +154,10 @@ mod fir_filter { // Does the actual transformation of the input buffer to the output buffer fn transform_ip( &self, - element: &Self::Type, buf: &mut gst::BufferRef, ) -> Result { + let element = self.instance(); + // Get coefficients and return directly if we have none let coeffs = self.coeffs.lock().unwrap(); if coeffs.is_empty() { diff --git a/gstreamer-audio/src/subclass/audio_aggregator.rs b/gstreamer-audio/src/subclass/audio_aggregator.rs index ff17821ff..0b300bafa 100644 --- a/gstreamer-audio/src/subclass/audio_aggregator.rs +++ b/gstreamer-audio/src/subclass/audio_aggregator.rs @@ -11,14 +11,13 @@ use crate::AudioAggregator; use crate::AudioAggregatorPad; pub trait AudioAggregatorImpl: AudioAggregatorImplExt + AggregatorImpl { - fn create_output_buffer(&self, element: &Self::Type, num_frames: u32) -> Option { - self.parent_create_output_buffer(element, num_frames) + fn create_output_buffer(&self, num_frames: u32) -> Option { + self.parent_create_output_buffer(num_frames) } #[allow(clippy::too_many_arguments)] fn aggregate_one_buffer( &self, - element: &Self::Type, pad: &AudioAggregatorPad, inbuf: &gst::BufferRef, in_offset: u32, @@ -26,23 +25,16 @@ pub trait AudioAggregatorImpl: AudioAggregatorImplExt + AggregatorImpl { out_offset: u32, num_frames: u32, ) -> bool { - self.parent_aggregate_one_buffer( - element, pad, inbuf, in_offset, outbuf, out_offset, num_frames, - ) + self.parent_aggregate_one_buffer(pad, inbuf, in_offset, outbuf, out_offset, num_frames) } } pub trait AudioAggregatorImplExt: ObjectSubclass { - fn parent_create_output_buffer( - &self, - element: &Self::Type, - num_frames: u32, - ) -> Option; + fn parent_create_output_buffer(&self, num_frames: u32) -> Option; #[allow(clippy::too_many_arguments)] fn parent_aggregate_one_buffer( &self, - element: &Self::Type, pad: &AudioAggregatorPad, inbuf: &gst::BufferRef, in_offset: u32, @@ -53,11 +45,7 @@ pub trait AudioAggregatorImplExt: ObjectSubclass { } impl AudioAggregatorImplExt for T { - fn parent_create_output_buffer( - &self, - element: &Self::Type, - num_frames: u32, - ) -> Option { + fn parent_create_output_buffer(&self, num_frames: u32) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioAggregatorClass; @@ -66,7 +54,7 @@ impl AudioAggregatorImplExt for T { .expect("Missing parent function `create_output_buffer`"); from_glib_full(f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -77,7 +65,6 @@ impl AudioAggregatorImplExt for T { fn parent_aggregate_one_buffer( &self, - element: &Self::Type, pad: &AudioAggregatorPad, inbuf: &gst::BufferRef, in_offset: u32, @@ -93,7 +80,7 @@ impl AudioAggregatorImplExt for T { .expect("Missing parent function `aggregate_one_buffer`"); from_glib(f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -124,13 +111,10 @@ unsafe extern "C" fn audio_aggregator_create_output_buffer *mut gst::ffi::GstBuffer { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), None, { - imp.create_output_buffer(wrap.unsafe_cast_ref(), num_frames) - }) - .map(|buffer| buffer.into_glib_ptr()) - .unwrap_or(ptr::null_mut()) + gst::panic_to_error!(imp, None, { imp.create_output_buffer(num_frames) }) + .map(|buffer| buffer.into_glib_ptr()) + .unwrap_or(ptr::null_mut()) } unsafe extern "C" fn audio_aggregator_aggregate_one_buffer( @@ -144,11 +128,9 @@ unsafe extern "C" fn audio_aggregator_aggregate_one_buffer glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), true, { + gst::panic_to_error!(imp, true, { imp.aggregate_one_buffer( - wrap.unsafe_cast_ref(), &from_glib_borrow(pad), gst::BufferRef::from_ptr(inbuf), in_offset, diff --git a/gstreamer-audio/src/subclass/audio_aggregator_pad.rs b/gstreamer-audio/src/subclass/audio_aggregator_pad.rs index fa87c5e89..2c8809b68 100644 --- a/gstreamer-audio/src/subclass/audio_aggregator_pad.rs +++ b/gstreamer-audio/src/subclass/audio_aggregator_pad.rs @@ -12,27 +12,25 @@ use crate::AudioAggregatorPad; pub trait AudioAggregatorPadImpl: AudioAggregatorPadImplExt + AggregatorPadImpl { const HANDLE_CONVERSION: bool = false; - fn update_conversion_info(&self, pad: &Self::Type) { - self.parent_update_conversion_info(pad) + fn update_conversion_info(&self) { + self.parent_update_conversion_info() } fn convert_buffer( &self, - pad: &Self::Type, in_info: &crate::AudioInfo, out_info: &crate::AudioInfo, buffer: &gst::Buffer, ) -> Option { - self.parent_convert_buffer(pad, in_info, out_info, buffer) + self.parent_convert_buffer(in_info, out_info, buffer) } } pub trait AudioAggregatorPadImplExt: ObjectSubclass { - fn parent_update_conversion_info(&self, pad: &Self::Type); + fn parent_update_conversion_info(&self); fn parent_convert_buffer( &self, - pad: &Self::Type, in_info: &crate::AudioInfo, out_info: &crate::AudioInfo, buffer: &gst::Buffer, @@ -40,19 +38,22 @@ pub trait AudioAggregatorPadImplExt: ObjectSubclass { } impl AudioAggregatorPadImplExt for T { - fn parent_update_conversion_info(&self, pad: &Self::Type) { + fn parent_update_conversion_info(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioAggregatorPadClass; if let Some(f) = (*parent_class).update_conversion_info { - f(pad.unsafe_cast_ref::().to_glib_none().0); + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0); } } } fn parent_convert_buffer( &self, - pad: &Self::Type, in_info: &crate::AudioInfo, out_info: &crate::AudioInfo, buffer: &gst::Buffer, @@ -64,7 +65,10 @@ impl AudioAggregatorPadImplExt for T { .convert_buffer .expect("Missing parent function `convert_buffer`"); from_glib_full(f( - pad.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, mut_override(in_info.to_glib_none().0), mut_override(out_info.to_glib_none().0), buffer.as_mut_ptr(), @@ -90,9 +94,8 @@ unsafe extern "C" fn audio_aggregator_pad_update_conversion_info = from_glib_borrow(ptr); - imp.update_conversion_info(wrap.unsafe_cast_ref()); + imp.update_conversion_info(); } unsafe extern "C" fn audio_aggregator_pad_convert_buffer( @@ -103,10 +106,8 @@ unsafe extern "C" fn audio_aggregator_pad_convert_buffer *mut gst::ffi::GstBuffer { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); imp.convert_buffer( - wrap.unsafe_cast_ref(), &from_glib_none(in_info), &from_glib_none(out_info), &from_glib_borrow(buffer), diff --git a/gstreamer-audio/src/subclass/audio_decoder.rs b/gstreamer-audio/src/subclass/audio_decoder.rs index b6dfd54c1..6fcc166bf 100644 --- a/gstreamer-audio/src/subclass/audio_decoder.rs +++ b/gstreamer-audio/src/subclass/audio_decoder.rs @@ -12,164 +12,139 @@ use crate::prelude::*; use crate::AudioDecoder; pub trait AudioDecoderImpl: AudioDecoderImplExt + ElementImpl { - fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_open(element) + fn open(&self) -> Result<(), gst::ErrorMessage> { + self.parent_open() } - fn close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_close(element) + fn close(&self) -> Result<(), gst::ErrorMessage> { + self.parent_close() } - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(element) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(element) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } - fn set_format(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> { - self.parent_set_format(element, caps) + fn set_format(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_set_format(caps) } - fn parse( - &self, - element: &Self::Type, - adapter: &gst_base::Adapter, - ) -> Result<(u32, u32), gst::FlowError> { - self.parent_parse(element, adapter) + fn parse(&self, adapter: &gst_base::Adapter) -> Result<(u32, u32), gst::FlowError> { + self.parent_parse(adapter) } fn handle_frame( &self, - element: &Self::Type, buffer: Option<&gst::Buffer>, ) -> Result { - self.parent_handle_frame(element, buffer) + self.parent_handle_frame(buffer) } - fn pre_push( - &self, - element: &Self::Type, - buffer: gst::Buffer, - ) -> Result, gst::FlowError> { - self.parent_pre_push(element, buffer) + fn pre_push(&self, buffer: gst::Buffer) -> Result, gst::FlowError> { + self.parent_pre_push(buffer) } - fn flush(&self, element: &Self::Type, hard: bool) { - self.parent_flush(element, hard) + fn flush(&self, hard: bool) { + self.parent_flush(hard) } - fn negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { - self.parent_negotiate(element) + fn negotiate(&self) -> Result<(), gst::LoggableError> { + self.parent_negotiate() } - fn caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { - self.parent_caps(element, filter) + fn caps(&self, filter: Option<&gst::Caps>) -> gst::Caps { + self.parent_caps(filter) } - fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_sink_event(element, event) + fn sink_event(&self, event: gst::Event) -> bool { + self.parent_sink_event(event) } - fn sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_sink_query(element, query) + fn sink_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_sink_query(query) } - fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_src_event(element, event) + fn src_event(&self, event: gst::Event) -> bool { + self.parent_src_event(event) } - fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_src_query(element, query) + fn src_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_src_query(query) } fn propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_propose_allocation(element, query) + self.parent_propose_allocation(query) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } } pub trait AudioDecoderImplExt: ObjectSubclass { - fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_open(&self) -> Result<(), gst::ErrorMessage>; - fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_close(&self) -> Result<(), gst::ErrorMessage>; - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; - fn parent_set_format( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError>; + fn parent_set_format(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError>; - fn parent_parse( - &self, - element: &Self::Type, - adapter: &gst_base::Adapter, - ) -> Result<(u32, u32), gst::FlowError>; + fn parent_parse(&self, adapter: &gst_base::Adapter) -> Result<(u32, u32), gst::FlowError>; fn parent_handle_frame( &self, - element: &Self::Type, buffer: Option<&gst::Buffer>, ) -> Result; - fn parent_pre_push( - &self, - element: &Self::Type, - buffer: gst::Buffer, - ) -> Result, gst::FlowError>; + fn parent_pre_push(&self, buffer: gst::Buffer) -> Result, gst::FlowError>; - fn parent_flush(&self, element: &Self::Type, hard: bool); + fn parent_flush(&self, hard: bool); - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>; + fn parent_negotiate(&self) -> Result<(), gst::LoggableError>; - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps; + fn parent_caps(&self, filter: Option<&gst::Caps>) -> gst::Caps; - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_sink_event(&self, event: gst::Event) -> bool; - fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_sink_query(&self, query: &mut gst::QueryRef) -> bool; - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_src_event(&self, event: gst::Event) -> bool; - fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool; fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; } impl AudioDecoderImplExt for T { - fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_open(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; (*parent_class) .open .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -186,14 +161,15 @@ impl AudioDecoderImplExt for T { } } - fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_close(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; (*parent_class) .close .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -210,14 +186,15 @@ impl AudioDecoderImplExt for T { } } - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; (*parent_class) .start .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -234,14 +211,15 @@ impl AudioDecoderImplExt for T { } } - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; (*parent_class) .stop .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -258,11 +236,7 @@ impl AudioDecoderImplExt for T { } } - fn parent_set_format( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn parent_set_format(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -271,7 +245,10 @@ impl AudioDecoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.to_glib_none().0 ), gst::CAT_RUST, @@ -282,11 +259,7 @@ impl AudioDecoderImplExt for T { } } - fn parent_parse( - &self, - element: &Self::Type, - adapter: &gst_base::Adapter, - ) -> Result<(u32, u32), gst::FlowError> { + fn parent_parse(&self, adapter: &gst_base::Adapter) -> Result<(u32, u32), gst::FlowError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -296,7 +269,10 @@ impl AudioDecoderImplExt for T { let mut offset = mem::MaybeUninit::uninit(); let mut len = mem::MaybeUninit::uninit(); gst::FlowSuccess::try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, adapter.to_glib_none().0, offset.as_mut_ptr(), len.as_mut_ptr(), @@ -315,7 +291,6 @@ impl AudioDecoderImplExt for T { fn parent_handle_frame( &self, - element: &Self::Type, buffer: Option<&gst::Buffer>, ) -> Result { unsafe { @@ -325,7 +300,10 @@ impl AudioDecoderImplExt for T { .handle_frame .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .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()), @@ -335,18 +313,17 @@ impl AudioDecoderImplExt for T { } } - fn parent_pre_push( - &self, - element: &Self::Type, - buffer: gst::Buffer, - ) -> Result, gst::FlowError> { + fn parent_pre_push(&self, buffer: gst::Buffer) -> Result, gst::FlowError> { unsafe { let data = Self::type_data(); 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_glib_ptr(); gst::FlowSuccess::try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, &mut buffer, )) .map(|_| from_glib_full(buffer)) @@ -356,7 +333,7 @@ impl AudioDecoderImplExt for T { } } - fn parent_flush(&self, element: &Self::Type, hard: bool) { + fn parent_flush(&self, hard: bool) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -364,7 +341,10 @@ impl AudioDecoderImplExt for T { .flush .map(|f| { f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, hard.into_glib(), ) }) @@ -372,7 +352,7 @@ impl AudioDecoderImplExt for T { } } - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { + fn parent_negotiate(&self) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -380,7 +360,11 @@ impl AudioDecoderImplExt for T { .negotiate .map(|f| { gst::result_from_gboolean!( - f(element.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Parent function `negotiate` failed" ) @@ -389,7 +373,7 @@ impl AudioDecoderImplExt for T { } } - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { + fn parent_caps(&self, filter: Option<&gst::Caps>) -> gst::Caps { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -397,19 +381,22 @@ impl AudioDecoderImplExt for T { .getcaps .map(|f| { from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, filter.to_glib_none().0, )) }) .unwrap_or_else(|| { - element + self.instance() .unsafe_cast_ref::() .proxy_getcaps(None, filter) }) } } - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_sink_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -417,13 +404,16 @@ impl AudioDecoderImplExt for T { .sink_event .expect("Missing parent function `sink_event`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_sink_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -431,13 +421,16 @@ impl AudioDecoderImplExt for T { .sink_query .expect("Missing parent function `sink_query`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } } - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_src_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -445,13 +438,16 @@ impl AudioDecoderImplExt for T { .src_event .expect("Missing parent function `src_event`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioDecoderClass; @@ -459,7 +455,10 @@ impl AudioDecoderImplExt for T { .src_query .expect("Missing parent function `src_query`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } @@ -467,7 +466,6 @@ impl AudioDecoderImplExt for T { fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -478,7 +476,10 @@ impl AudioDecoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -491,7 +492,6 @@ impl AudioDecoderImplExt for T { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -502,7 +502,10 @@ impl AudioDecoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -543,13 +546,12 @@ unsafe extern "C" fn audio_decoder_open( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.open(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.open() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -562,13 +564,12 @@ unsafe extern "C" fn audio_decoder_close( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.close(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.close() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -581,13 +582,12 @@ unsafe extern "C" fn audio_decoder_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -600,13 +600,12 @@ unsafe extern "C" fn audio_decoder_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -620,13 +619,12 @@ unsafe extern "C" fn audio_decoder_set_format( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_format(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) { + gst::panic_to_error!(imp, false, { + match imp.set_format(&from_glib_borrow(caps)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -642,10 +640,9 @@ unsafe extern "C" fn audio_decoder_parse( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.parse(wrap.unsafe_cast_ref(), &from_glib_borrow(adapter)) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.parse(&from_glib_borrow(adapter)) { Ok((new_offset, new_len)) => { assert!(new_offset <= std::i32::MAX as u32); assert!(new_len <= std::i32::MAX as u32); @@ -668,14 +665,10 @@ unsafe extern "C" fn audio_decoder_handle_frame( let buffer = buffer as *mut gst::ffi::GstBuffer; let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.handle_frame( - wrap.unsafe_cast_ref(), - Option::::from_glib_none(buffer).as_ref(), - ) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.handle_frame(Option::::from_glib_none(buffer).as_ref()) + .into() }) .into_glib() } @@ -686,10 +679,9 @@ unsafe extern "C" fn audio_decoder_pre_push( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.pre_push(wrap.unsafe_cast_ref(), from_glib_full(*buffer)) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.pre_push(from_glib_full(*buffer)) { Ok(Some(new_buffer)) => { *buffer = new_buffer.into_glib_ptr(); Ok(gst::FlowSuccess::Ok) @@ -711,11 +703,8 @@ unsafe extern "C" fn audio_decoder_flush( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), (), { - AudioDecoderImpl::flush(imp, wrap.unsafe_cast_ref(), from_glib(hard)) - }) + gst::panic_to_error!(imp, (), { AudioDecoderImpl::flush(imp, from_glib(hard)) }) } unsafe extern "C" fn audio_decoder_negotiate( @@ -723,13 +712,12 @@ unsafe extern "C" fn audio_decoder_negotiate( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.negotiate(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.negotiate() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -743,12 +731,10 @@ unsafe extern "C" fn audio_decoder_getcaps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { + gst::panic_to_error!(imp, gst::Caps::new_empty(), { AudioDecoderImpl::caps( imp, - wrap.unsafe_cast_ref(), Option::::from_glib_borrow(filter) .as_ref() .as_ref(), @@ -763,12 +749,8 @@ unsafe extern "C" fn audio_decoder_sink_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.sink_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn audio_decoder_sink_query( @@ -777,10 +759,9 @@ unsafe extern "C" fn audio_decoder_sink_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.sink_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -791,12 +772,8 @@ unsafe extern "C" fn audio_decoder_src_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.src_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn audio_decoder_src_query( @@ -805,10 +782,9 @@ unsafe extern "C" fn audio_decoder_src_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.src_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -819,17 +795,16 @@ unsafe extern "C" fn audio_decoder_propose_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.propose_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.propose_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -843,17 +818,16 @@ unsafe extern "C" fn audio_decoder_decide_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.decide_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer-audio/src/subclass/audio_encoder.rs b/gstreamer-audio/src/subclass/audio_encoder.rs index 2193f3d49..cce52af1e 100644 --- a/gstreamer-audio/src/subclass/audio_encoder.rs +++ b/gstreamer-audio/src/subclass/audio_encoder.rs @@ -12,150 +12,133 @@ use crate::AudioEncoder; use crate::AudioInfo; pub trait AudioEncoderImpl: AudioEncoderImplExt + ElementImpl { - fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_open(element) + fn open(&self) -> Result<(), gst::ErrorMessage> { + self.parent_open() } - fn close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_close(element) + fn close(&self) -> Result<(), gst::ErrorMessage> { + self.parent_close() } - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(element) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(element) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } - fn set_format(&self, element: &Self::Type, info: &AudioInfo) -> Result<(), gst::LoggableError> { - self.parent_set_format(element, info) + fn set_format(&self, info: &AudioInfo) -> Result<(), gst::LoggableError> { + self.parent_set_format(info) } fn handle_frame( &self, - element: &Self::Type, buffer: Option<&gst::Buffer>, ) -> Result { - self.parent_handle_frame(element, buffer) + self.parent_handle_frame(buffer) } - fn pre_push( - &self, - element: &Self::Type, - buffer: gst::Buffer, - ) -> Result, gst::FlowError> { - self.parent_pre_push(element, buffer) + fn pre_push(&self, buffer: gst::Buffer) -> Result, gst::FlowError> { + self.parent_pre_push(buffer) } - fn flush(&self, element: &Self::Type) { - self.parent_flush(element) + fn flush(&self) { + self.parent_flush() } - fn negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { - self.parent_negotiate(element) + fn negotiate(&self) -> Result<(), gst::LoggableError> { + self.parent_negotiate() } - fn caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { - self.parent_caps(element, filter) + fn caps(&self, filter: Option<&gst::Caps>) -> gst::Caps { + self.parent_caps(filter) } - fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_sink_event(element, event) + fn sink_event(&self, event: gst::Event) -> bool { + self.parent_sink_event(event) } - fn sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_sink_query(element, query) + fn sink_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_sink_query(query) } - fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_src_event(element, event) + fn src_event(&self, event: gst::Event) -> bool { + self.parent_src_event(event) } - fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_src_query(element, query) + fn src_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_src_query(query) } fn propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_propose_allocation(element, query) + self.parent_propose_allocation(query) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } } pub trait AudioEncoderImplExt: ObjectSubclass { - fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_open(&self) -> Result<(), gst::ErrorMessage>; - fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_close(&self) -> Result<(), gst::ErrorMessage>; - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; - fn parent_set_format( - &self, - element: &Self::Type, - info: &AudioInfo, - ) -> Result<(), gst::LoggableError>; + fn parent_set_format(&self, info: &AudioInfo) -> Result<(), gst::LoggableError>; fn parent_handle_frame( &self, - element: &Self::Type, buffer: Option<&gst::Buffer>, ) -> Result; - fn parent_pre_push( - &self, - element: &Self::Type, - buffer: gst::Buffer, - ) -> Result, gst::FlowError>; + fn parent_pre_push(&self, buffer: gst::Buffer) -> Result, gst::FlowError>; - fn parent_flush(&self, element: &Self::Type); + fn parent_flush(&self); - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>; + fn parent_negotiate(&self) -> Result<(), gst::LoggableError>; - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps; + fn parent_caps(&self, filter: Option<&gst::Caps>) -> gst::Caps; - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_sink_event(&self, event: gst::Event) -> bool; - fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_sink_query(&self, query: &mut gst::QueryRef) -> bool; - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_src_event(&self, event: gst::Event) -> bool; - fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool; fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; } impl AudioEncoderImplExt for T { - fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_open(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; (*parent_class) .open .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -172,14 +155,15 @@ impl AudioEncoderImplExt for T { } } - fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_close(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; (*parent_class) .close .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -196,14 +180,15 @@ impl AudioEncoderImplExt for T { } } - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; (*parent_class) .start .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -220,14 +205,15 @@ impl AudioEncoderImplExt for T { } } - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; (*parent_class) .stop .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -244,11 +230,7 @@ impl AudioEncoderImplExt for T { } } - fn parent_set_format( - &self, - element: &Self::Type, - info: &AudioInfo, - ) -> Result<(), gst::LoggableError> { + fn parent_set_format(&self, info: &AudioInfo) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; @@ -257,7 +239,10 @@ impl AudioEncoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, info.to_glib_none().0 as *mut _ ), gst::CAT_RUST, @@ -270,7 +255,6 @@ impl AudioEncoderImplExt for T { fn parent_handle_frame( &self, - element: &Self::Type, buffer: Option<&gst::Buffer>, ) -> Result { unsafe { @@ -280,7 +264,10 @@ impl AudioEncoderImplExt for T { .handle_frame .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .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()), @@ -290,18 +277,17 @@ impl AudioEncoderImplExt for T { } } - fn parent_pre_push( - &self, - element: &Self::Type, - buffer: gst::Buffer, - ) -> Result, gst::FlowError> { + fn parent_pre_push(&self, buffer: gst::Buffer) -> Result, gst::FlowError> { unsafe { let data = Self::type_data(); 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_glib_ptr(); gst::FlowSuccess::try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, &mut buffer, )) .map(|_| from_glib_full(buffer)) @@ -311,18 +297,24 @@ impl AudioEncoderImplExt for T { } } - fn parent_flush(&self, element: &Self::Type) { + fn parent_flush(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; (*parent_class) .flush - .map(|f| f(element.unsafe_cast_ref::().to_glib_none().0)) + .map(|f| { + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0) + }) .unwrap_or(()) } } - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { + fn parent_negotiate(&self) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; @@ -330,7 +322,11 @@ impl AudioEncoderImplExt for T { .negotiate .map(|f| { gst::result_from_gboolean!( - f(element.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Parent function `negotiate` failed" ) @@ -339,7 +335,7 @@ impl AudioEncoderImplExt for T { } } - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { + fn parent_caps(&self, filter: Option<&gst::Caps>) -> gst::Caps { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; @@ -347,19 +343,22 @@ impl AudioEncoderImplExt for T { .getcaps .map(|f| { from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, filter.to_glib_none().0, )) }) .unwrap_or_else(|| { - element + self.instance() .unsafe_cast_ref::() .proxy_getcaps(None, filter) }) } } - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_sink_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; @@ -367,13 +366,16 @@ impl AudioEncoderImplExt for T { .sink_event .expect("Missing parent function `sink_event`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_sink_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; @@ -381,13 +383,16 @@ impl AudioEncoderImplExt for T { .sink_query .expect("Missing parent function `sink_query`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } } - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_src_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; @@ -395,13 +400,16 @@ impl AudioEncoderImplExt for T { .src_event .expect("Missing parent function `src_event`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioEncoderClass; @@ -409,7 +417,10 @@ impl AudioEncoderImplExt for T { .src_query .expect("Missing parent function `src_query`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } @@ -417,7 +428,6 @@ impl AudioEncoderImplExt for T { fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -428,7 +438,10 @@ impl AudioEncoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -441,7 +454,6 @@ impl AudioEncoderImplExt for T { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -452,7 +464,10 @@ impl AudioEncoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -492,13 +507,12 @@ unsafe extern "C" fn audio_encoder_open( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.open(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.open() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -511,13 +525,12 @@ unsafe extern "C" fn audio_encoder_close( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.close(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.close() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -530,13 +543,12 @@ unsafe extern "C" fn audio_encoder_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -549,13 +561,12 @@ unsafe extern "C" fn audio_encoder_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -569,13 +580,12 @@ unsafe extern "C" fn audio_encoder_set_format( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_format(wrap.unsafe_cast_ref(), &from_glib_none(info)) { + gst::panic_to_error!(imp, false, { + match imp.set_format(&from_glib_none(info)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -591,14 +601,10 @@ unsafe extern "C" fn audio_encoder_handle_frame( let buffer = buffer as *mut gst::ffi::GstBuffer; let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.handle_frame( - wrap.unsafe_cast_ref(), - Option::::from_glib_none(buffer).as_ref(), - ) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.handle_frame(Option::::from_glib_none(buffer).as_ref()) + .into() }) .into_glib() } @@ -609,10 +615,9 @@ unsafe extern "C" fn audio_encoder_pre_push( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.pre_push(wrap.unsafe_cast_ref(), from_glib_full(*buffer)) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.pre_push(from_glib_full(*buffer)) { Ok(Some(new_buffer)) => { *buffer = new_buffer.into_glib_ptr(); Ok(gst::FlowSuccess::Ok) @@ -631,11 +636,8 @@ unsafe extern "C" fn audio_encoder_pre_push( unsafe extern "C" fn audio_encoder_flush(ptr: *mut ffi::GstAudioEncoder) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), (), { - AudioEncoderImpl::flush(imp, wrap.unsafe_cast_ref()) - }) + gst::panic_to_error!(imp, (), { AudioEncoderImpl::flush(imp,) }) } unsafe extern "C" fn audio_encoder_negotiate( @@ -643,13 +645,12 @@ unsafe extern "C" fn audio_encoder_negotiate( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.negotiate(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.negotiate() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -663,12 +664,10 @@ unsafe extern "C" fn audio_encoder_getcaps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { + gst::panic_to_error!(imp, gst::Caps::new_empty(), { AudioEncoderImpl::caps( imp, - wrap.unsafe_cast_ref(), Option::::from_glib_borrow(filter) .as_ref() .as_ref(), @@ -683,12 +682,8 @@ unsafe extern "C" fn audio_encoder_sink_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.sink_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn audio_encoder_sink_query( @@ -697,10 +692,9 @@ unsafe extern "C" fn audio_encoder_sink_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.sink_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -711,12 +705,8 @@ unsafe extern "C" fn audio_encoder_src_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.src_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn audio_encoder_src_query( @@ -725,10 +715,9 @@ unsafe extern "C" fn audio_encoder_src_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.src_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -739,17 +728,16 @@ unsafe extern "C" fn audio_encoder_propose_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.propose_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.propose_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -763,17 +751,16 @@ unsafe extern "C" fn audio_encoder_decide_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.decide_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer-audio/src/subclass/audio_sink.rs b/gstreamer-audio/src/subclass/audio_sink.rs index cc9df23b5..3ccc50a6c 100644 --- a/gstreamer-audio/src/subclass/audio_sink.rs +++ b/gstreamer-audio/src/subclass/audio_sink.rs @@ -11,55 +11,47 @@ use crate::AudioRingBufferSpec; use crate::AudioSink; pub trait AudioSinkImpl: AudioSinkImplExt + AudioBaseSinkImpl { - fn close(&self, sink: &Self::Type) -> Result<(), LoggableError> { - self.parent_close(sink) + fn close(&self) -> Result<(), LoggableError> { + self.parent_close() } - fn delay(&self, sink: &Self::Type) -> u32 { - self.parent_delay(sink) + fn delay(&self) -> u32 { + self.parent_delay() } - fn open(&self, sink: &Self::Type) -> Result<(), LoggableError> { - self.parent_open(sink) + fn open(&self) -> Result<(), LoggableError> { + self.parent_open() } - fn prepare( - &self, - sink: &Self::Type, - spec: &mut AudioRingBufferSpec, - ) -> Result<(), LoggableError> { - AudioSinkImplExt::parent_prepare(self, sink, spec) + fn prepare(&self, spec: &mut AudioRingBufferSpec) -> Result<(), LoggableError> { + AudioSinkImplExt::parent_prepare(self, spec) } - fn unprepare(&self, sink: &Self::Type) -> Result<(), LoggableError> { - self.parent_unprepare(sink) + fn unprepare(&self) -> Result<(), LoggableError> { + self.parent_unprepare() } - fn write(&self, sink: &Self::Type, audio_data: &[u8]) -> Result { - self.parent_write(sink, audio_data) + fn write(&self, audio_data: &[u8]) -> Result { + self.parent_write(audio_data) } - fn reset(&self, sink: &Self::Type) { - self.parent_reset(sink) + fn reset(&self) { + self.parent_reset() } } pub trait AudioSinkImplExt: ObjectSubclass { - fn parent_close(&self, sink: &Self::Type) -> Result<(), LoggableError>; - fn parent_delay(&self, sink: &Self::Type) -> u32; - fn parent_open(&self, sink: &Self::Type) -> Result<(), LoggableError>; - fn parent_prepare( - &self, - sink: &Self::Type, - spec: &mut AudioRingBufferSpec, - ) -> Result<(), LoggableError>; - fn parent_unprepare(&self, sink: &Self::Type) -> Result<(), LoggableError>; - fn parent_write(&self, sink: &Self::Type, audio_data: &[u8]) -> Result; - fn parent_reset(&self, sink: &Self::Type); + fn parent_close(&self) -> Result<(), LoggableError>; + fn parent_delay(&self) -> u32; + fn parent_open(&self) -> Result<(), LoggableError>; + fn parent_prepare(&self, spec: &mut AudioRingBufferSpec) -> Result<(), LoggableError>; + fn parent_unprepare(&self) -> Result<(), LoggableError>; + fn parent_write(&self, audio_data: &[u8]) -> Result; + fn parent_reset(&self); } impl AudioSinkImplExt for T { - fn parent_close(&self, sink: &Self::Type) -> Result<(), LoggableError> { + fn parent_close(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSinkClass; @@ -68,14 +60,18 @@ impl AudioSinkImplExt for T { Some(f) => f, }; gst::result_from_gboolean!( - f(sink.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Failed to close element using the parent function" ) } } - fn parent_delay(&self, sink: &Self::Type) -> u32 { + fn parent_delay(&self) -> u32 { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSinkClass; @@ -83,11 +79,15 @@ impl AudioSinkImplExt for T { Some(f) => f, None => return 0, }; - f(sink.unsafe_cast_ref::().to_glib_none().0) + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0) } } - fn parent_open(&self, sink: &Self::Type) -> Result<(), LoggableError> { + fn parent_open(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSinkClass; @@ -96,18 +96,18 @@ impl AudioSinkImplExt for T { None => return Ok(()), }; gst::result_from_gboolean!( - f(sink.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Failed to open element using the parent function" ) } } - fn parent_prepare( - &self, - sink: &Self::Type, - spec: &mut AudioRingBufferSpec, - ) -> Result<(), LoggableError> { + fn parent_prepare(&self, spec: &mut AudioRingBufferSpec) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSinkClass; @@ -117,7 +117,10 @@ impl AudioSinkImplExt for T { }; gst::result_from_gboolean!( f( - sink.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, &mut spec.0 ), gst::CAT_RUST, @@ -126,7 +129,7 @@ impl AudioSinkImplExt for T { } } - fn parent_unprepare(&self, sink: &Self::Type) -> Result<(), LoggableError> { + fn parent_unprepare(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSinkClass; @@ -140,14 +143,18 @@ impl AudioSinkImplExt for T { } }; gst::result_from_gboolean!( - f(sink.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Failed to unprepare element using the parent function" ) } } - fn parent_write(&self, sink: &Self::Type, buffer: &[u8]) -> Result { + fn parent_write(&self, buffer: &[u8]) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSinkClass; @@ -157,7 +164,10 @@ impl AudioSinkImplExt for T { }; let buffer_ptr = buffer.as_ptr() as *const _ as *mut _; let ret = f( - sink.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer_ptr, buffer.len() as u32, ); @@ -172,12 +182,16 @@ impl AudioSinkImplExt for T { } } - fn parent_reset(&self, sink: &Self::Type) { + fn parent_reset(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSinkClass; if let Some(f) = (*parent_class).reset { - f(sink.unsafe_cast_ref::().to_glib_none().0) + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0) } } } @@ -202,13 +216,12 @@ unsafe extern "C" fn audiosink_close( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.close(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.close() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -219,11 +232,8 @@ unsafe extern "C" fn audiosink_close( unsafe extern "C" fn audiosink_delay(ptr: *mut ffi::GstAudioSink) -> u32 { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), 0, { - imp.delay(wrap.unsafe_cast_ref()) - }) + gst::panic_to_error!(imp, 0, { imp.delay() }) } unsafe extern "C" fn audiosink_open( @@ -231,13 +241,12 @@ unsafe extern "C" fn audiosink_open( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.open(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.open() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -251,15 +260,14 @@ unsafe extern "C" fn audiosink_prepare( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let spec = &mut *(spec as *mut AudioRingBufferSpec); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match AudioSinkImpl::prepare(imp, wrap.unsafe_cast_ref(), spec) { + gst::panic_to_error!(imp, false, { + match AudioSinkImpl::prepare(imp, spec) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -272,13 +280,12 @@ unsafe extern "C" fn audiosink_unprepare( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.unprepare(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.unprepare() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -293,24 +300,20 @@ unsafe extern "C" fn audiosink_write( ) -> i32 { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let data_slice = if length == 0 { &[] } else { std::slice::from_raw_parts(data as *const u8, length as usize) }; - gst::panic_to_error!(&wrap, imp.panicked(), -1, { - imp.write(wrap.unsafe_cast_ref(), data_slice).unwrap_or(-1) - }) + gst::panic_to_error!(imp, -1, { imp.write(data_slice).unwrap_or(-1) }) } unsafe extern "C" fn audiosink_reset(ptr: *mut ffi::GstAudioSink) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), (), { - imp.reset(wrap.unsafe_cast_ref()); + gst::panic_to_error!(imp, (), { + imp.reset(); }); } diff --git a/gstreamer-audio/src/subclass/audio_src.rs b/gstreamer-audio/src/subclass/audio_src.rs index 5d640f7c3..c654559ec 100644 --- a/gstreamer-audio/src/subclass/audio_src.rs +++ b/gstreamer-audio/src/subclass/audio_src.rs @@ -13,63 +13,50 @@ use crate::AudioRingBufferSpec; use crate::AudioSrc; pub trait AudioSrcImpl: AudioSrcImplExt + AudioBaseSrcImpl { - fn close(&self, src: &Self::Type) -> Result<(), LoggableError> { - self.parent_close(src) + fn close(&self) -> Result<(), LoggableError> { + self.parent_close() } - fn delay(&self, src: &Self::Type) -> u32 { - self.parent_delay(src) + fn delay(&self) -> u32 { + self.parent_delay() } - fn open(&self, src: &Self::Type) -> Result<(), LoggableError> { - self.parent_open(src) + fn open(&self) -> Result<(), LoggableError> { + self.parent_open() } - fn prepare( - &self, - src: &Self::Type, - spec: &mut AudioRingBufferSpec, - ) -> Result<(), LoggableError> { - AudioSrcImplExt::parent_prepare(self, src, spec) + fn prepare(&self, spec: &mut AudioRingBufferSpec) -> Result<(), LoggableError> { + AudioSrcImplExt::parent_prepare(self, spec) } - fn unprepare(&self, src: &Self::Type) -> Result<(), LoggableError> { - self.parent_unprepare(src) + fn unprepare(&self) -> Result<(), LoggableError> { + self.parent_unprepare() } - fn read( - &self, - src: &Self::Type, - audio_data: &mut [u8], - ) -> Result<(u32, Option), LoggableError> { - self.parent_read(src, audio_data) + fn read(&self, audio_data: &mut [u8]) -> Result<(u32, Option), LoggableError> { + self.parent_read(audio_data) } - fn reset(&self, src: &Self::Type) { - self.parent_reset(src) + fn reset(&self) { + self.parent_reset() } } pub trait AudioSrcImplExt: ObjectSubclass { - fn parent_close(&self, src: &Self::Type) -> Result<(), LoggableError>; - fn parent_delay(&self, src: &Self::Type) -> u32; - fn parent_open(&self, src: &Self::Type) -> Result<(), LoggableError>; - fn parent_prepare( - &self, - src: &Self::Type, - spec: &mut AudioRingBufferSpec, - ) -> Result<(), LoggableError>; - fn parent_unprepare(&self, src: &Self::Type) -> Result<(), LoggableError>; + fn parent_close(&self) -> Result<(), LoggableError>; + fn parent_delay(&self) -> u32; + fn parent_open(&self) -> Result<(), LoggableError>; + fn parent_prepare(&self, spec: &mut AudioRingBufferSpec) -> Result<(), LoggableError>; + fn parent_unprepare(&self) -> Result<(), LoggableError>; fn parent_read( &self, - src: &Self::Type, audio_data: &mut [u8], ) -> Result<(u32, Option), LoggableError>; - fn parent_reset(&self, src: &Self::Type); + fn parent_reset(&self); } impl AudioSrcImplExt for T { - fn parent_close(&self, src: &Self::Type) -> Result<(), LoggableError> { + fn parent_close(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass; @@ -78,14 +65,18 @@ impl AudioSrcImplExt for T { Some(f) => f, }; gst::result_from_gboolean!( - f(src.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Failed to close element using the parent function" ) } } - fn parent_delay(&self, src: &Self::Type) -> u32 { + fn parent_delay(&self) -> u32 { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass; @@ -93,11 +84,15 @@ impl AudioSrcImplExt for T { Some(f) => f, None => return 0, }; - f(src.unsafe_cast_ref::().to_glib_none().0) + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0) } } - fn parent_open(&self, src: &Self::Type) -> Result<(), LoggableError> { + fn parent_open(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass; @@ -106,18 +101,18 @@ impl AudioSrcImplExt for T { None => return Ok(()), }; gst::result_from_gboolean!( - f(src.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Failed to open element using the parent function" ) } } - fn parent_prepare( - &self, - src: &Self::Type, - spec: &mut AudioRingBufferSpec, - ) -> Result<(), LoggableError> { + fn parent_prepare(&self, spec: &mut AudioRingBufferSpec) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass; @@ -127,7 +122,10 @@ impl AudioSrcImplExt for T { }; gst::result_from_gboolean!( f( - src.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, &mut spec.0 ), gst::CAT_RUST, @@ -136,7 +134,7 @@ impl AudioSrcImplExt for T { } } - fn parent_unprepare(&self, src: &Self::Type) -> Result<(), LoggableError> { + fn parent_unprepare(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass; @@ -150,7 +148,11 @@ impl AudioSrcImplExt for T { } }; gst::result_from_gboolean!( - f(src.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Failed to unprepare element using the parent function" ) @@ -159,7 +161,6 @@ impl AudioSrcImplExt for T { fn parent_read( &self, - src: &Self::Type, buffer: &mut [u8], ) -> Result<(u32, Option), LoggableError> { unsafe { @@ -172,7 +173,10 @@ impl AudioSrcImplExt for T { let buffer_ptr = buffer.as_mut_ptr() as *mut _; let mut timestamp = mem::MaybeUninit::uninit(); let ret = f( - src.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer_ptr, buffer.len() as u32, timestamp.as_mut_ptr(), @@ -188,12 +192,16 @@ impl AudioSrcImplExt for T { } } - fn parent_reset(&self, src: &Self::Type) { + fn parent_reset(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass; if let Some(f) = (*parent_class).reset { - f(src.unsafe_cast_ref::().to_glib_none().0) + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0) } } } @@ -218,13 +226,12 @@ unsafe extern "C" fn audiosrc_close( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.close(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.close() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -235,11 +242,8 @@ unsafe extern "C" fn audiosrc_close( unsafe extern "C" fn audiosrc_delay(ptr: *mut ffi::GstAudioSrc) -> u32 { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), 0, { - imp.delay(wrap.unsafe_cast_ref()) - }) + gst::panic_to_error!(imp, 0, { imp.delay() }) } unsafe extern "C" fn audiosrc_open( @@ -247,13 +251,12 @@ unsafe extern "C" fn audiosrc_open( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.open(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.open() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -267,15 +270,14 @@ unsafe extern "C" fn audiosrc_prepare( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let spec = &mut *(spec as *mut AudioRingBufferSpec); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match AudioSrcImpl::prepare(imp, wrap.unsafe_cast_ref(), spec) { + gst::panic_to_error!(imp, false, { + match AudioSrcImpl::prepare(imp, spec) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -288,13 +290,12 @@ unsafe extern "C" fn audiosrc_unprepare( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.unprepare(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.unprepare() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -310,17 +311,14 @@ unsafe extern "C" fn audiosrc_read( ) -> u32 { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let data_slice = if length == 0 { &mut [] } else { std::slice::from_raw_parts_mut(data as *mut u8, length as usize) }; - gst::panic_to_error!(&wrap, imp.panicked(), 0, { - let (res, timestamp_res) = imp - .read(wrap.unsafe_cast_ref(), data_slice) - .unwrap_or((0, gst::ClockTime::NONE)); + gst::panic_to_error!(imp, 0, { + let (res, timestamp_res) = imp.read(data_slice).unwrap_or((0, gst::ClockTime::NONE)); *timestamp = timestamp_res.into_glib(); res @@ -330,9 +328,8 @@ unsafe extern "C" fn audiosrc_read( unsafe extern "C" fn audiosrc_reset(ptr: *mut ffi::GstAudioSrc) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), (), { - imp.reset(wrap.unsafe_cast_ref()); + gst::panic_to_error!(imp, (), { + imp.reset(); }); } diff --git a/gstreamer-base/src/subclass/aggregator.rs b/gstreamer-base/src/subclass/aggregator.rs index 945638237..24e36ac8a 100644 --- a/gstreamer-base/src/subclass/aggregator.rs +++ b/gstreamer-base/src/subclass/aggregator.rs @@ -11,283 +11,205 @@ use crate::Aggregator; use crate::AggregatorPad; pub trait AggregatorImpl: AggregatorImplExt + ElementImpl { - fn flush(&self, aggregator: &Self::Type) -> Result { - self.parent_flush(aggregator) + fn flush(&self) -> Result { + self.parent_flush() } - fn clip( - &self, - aggregator: &Self::Type, - aggregator_pad: &AggregatorPad, - buffer: gst::Buffer, - ) -> Option { - self.parent_clip(aggregator, aggregator_pad, buffer) + fn clip(&self, aggregator_pad: &AggregatorPad, buffer: gst::Buffer) -> Option { + self.parent_clip(aggregator_pad, buffer) } #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn finish_buffer_list( &self, - aggregator: &Self::Type, buffer_list: gst::BufferList, ) -> Result { - self.parent_finish_buffer_list(aggregator, buffer_list) + self.parent_finish_buffer_list(buffer_list) } - fn finish_buffer( - &self, - aggregator: &Self::Type, - buffer: gst::Buffer, - ) -> Result { - self.parent_finish_buffer(aggregator, buffer) + fn finish_buffer(&self, buffer: gst::Buffer) -> Result { + self.parent_finish_buffer(buffer) } - fn sink_event( - &self, - aggregator: &Self::Type, - aggregator_pad: &AggregatorPad, - event: gst::Event, - ) -> bool { - self.parent_sink_event(aggregator, aggregator_pad, event) + fn sink_event(&self, aggregator_pad: &AggregatorPad, event: gst::Event) -> bool { + self.parent_sink_event(aggregator_pad, event) } #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn sink_event_pre_queue( &self, - aggregator: &Self::Type, aggregator_pad: &AggregatorPad, event: gst::Event, ) -> Result { - self.parent_sink_event_pre_queue(aggregator, aggregator_pad, event) + self.parent_sink_event_pre_queue(aggregator_pad, event) } - fn sink_query( - &self, - aggregator: &Self::Type, - aggregator_pad: &AggregatorPad, - query: &mut gst::QueryRef, - ) -> bool { - self.parent_sink_query(aggregator, aggregator_pad, query) + fn sink_query(&self, aggregator_pad: &AggregatorPad, query: &mut gst::QueryRef) -> bool { + self.parent_sink_query(aggregator_pad, query) } #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn sink_query_pre_queue( &self, - aggregator: &Self::Type, aggregator_pad: &AggregatorPad, query: &mut gst::QueryRef, ) -> bool { - self.parent_sink_query_pre_queue(aggregator, aggregator_pad, query) + self.parent_sink_query_pre_queue(aggregator_pad, query) } - fn src_event(&self, aggregator: &Self::Type, event: gst::Event) -> bool { - self.parent_src_event(aggregator, event) + fn src_event(&self, event: gst::Event) -> bool { + self.parent_src_event(event) } - fn src_query(&self, aggregator: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_src_query(aggregator, query) + fn src_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_src_query(query) } - fn src_activate( - &self, - aggregator: &Self::Type, - mode: gst::PadMode, - active: bool, - ) -> Result<(), gst::LoggableError> { - self.parent_src_activate(aggregator, mode, active) + fn src_activate(&self, mode: gst::PadMode, active: bool) -> Result<(), gst::LoggableError> { + self.parent_src_activate(mode, active) } - fn aggregate( - &self, - aggregator: &Self::Type, - timeout: bool, - ) -> Result { - self.parent_aggregate(aggregator, timeout) + fn aggregate(&self, timeout: bool) -> Result { + self.parent_aggregate(timeout) } - fn start(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(aggregator) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(aggregator) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } - fn next_time(&self, aggregator: &Self::Type) -> Option { - self.parent_next_time(aggregator) + fn next_time(&self) -> Option { + self.parent_next_time() } fn create_new_pad( &self, - aggregator: &Self::Type, templ: &gst::PadTemplate, req_name: Option<&str>, caps: Option<&gst::Caps>, ) -> Option { - self.parent_create_new_pad(aggregator, templ, req_name, caps) + self.parent_create_new_pad(templ, req_name, caps) } - fn update_src_caps( - &self, - aggregator: &Self::Type, - caps: &gst::Caps, - ) -> Result { - self.parent_update_src_caps(aggregator, caps) + fn update_src_caps(&self, caps: &gst::Caps) -> Result { + self.parent_update_src_caps(caps) } - fn fixate_src_caps(&self, aggregator: &Self::Type, caps: gst::Caps) -> gst::Caps { - self.parent_fixate_src_caps(aggregator, caps) + fn fixate_src_caps(&self, caps: gst::Caps) -> gst::Caps { + self.parent_fixate_src_caps(caps) } - fn negotiated_src_caps( - &self, - aggregator: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { - self.parent_negotiated_src_caps(aggregator, caps) + fn negotiated_src_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_negotiated_src_caps(caps) } fn propose_allocation( &self, - element: &Self::Type, pad: &AggregatorPad, decide_query: Option<&gst::query::Allocation>, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_propose_allocation(element, pad, decide_query, query) + self.parent_propose_allocation(pad, decide_query, query) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] - fn negotiate(&self, aggregator: &Self::Type) -> bool { - self.parent_negotiate(aggregator) + fn negotiate(&self) -> bool { + self.parent_negotiate() } #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] - fn peek_next_sample( - &self, - aggregator: &Self::Type, - pad: &AggregatorPad, - ) -> Option { - self.parent_peek_next_sample(aggregator, pad) + fn peek_next_sample(&self, pad: &AggregatorPad) -> Option { + self.parent_peek_next_sample(pad) } } pub trait AggregatorImplExt: ObjectSubclass { - fn parent_flush(&self, aggregator: &Self::Type) -> Result; + fn parent_flush(&self) -> Result; fn parent_clip( &self, - aggregator: &Self::Type, aggregator_pad: &AggregatorPad, buffer: gst::Buffer, ) -> Option; - fn parent_finish_buffer( - &self, - aggregator: &Self::Type, - buffer: gst::Buffer, - ) -> Result; + fn parent_finish_buffer(&self, buffer: gst::Buffer) + -> Result; #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn parent_finish_buffer_list( &self, - aggregator: &Self::Type, buffer_list: gst::BufferList, ) -> Result; - fn parent_sink_event( - &self, - aggregator: &Self::Type, - aggregator_pad: &AggregatorPad, - event: gst::Event, - ) -> bool; + fn parent_sink_event(&self, aggregator_pad: &AggregatorPad, event: gst::Event) -> bool; #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn parent_sink_event_pre_queue( &self, - aggregator: &Self::Type, aggregator_pad: &AggregatorPad, event: gst::Event, ) -> Result; - fn parent_sink_query( - &self, - aggregator: &Self::Type, - aggregator_pad: &AggregatorPad, - query: &mut gst::QueryRef, - ) -> bool; + fn parent_sink_query(&self, aggregator_pad: &AggregatorPad, query: &mut gst::QueryRef) -> bool; #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn parent_sink_query_pre_queue( &self, - aggregator: &Self::Type, aggregator_pad: &AggregatorPad, query: &mut gst::QueryRef, ) -> bool; - fn parent_src_event(&self, aggregator: &Self::Type, event: gst::Event) -> bool; + fn parent_src_event(&self, event: gst::Event) -> bool; - fn parent_src_query(&self, aggregator: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool; fn parent_src_activate( &self, - aggregator: &Self::Type, mode: gst::PadMode, active: bool, ) -> Result<(), gst::LoggableError>; - fn parent_aggregate( - &self, - aggregator: &Self::Type, - timeout: bool, - ) -> Result; + fn parent_aggregate(&self, timeout: bool) -> Result; - fn parent_start(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; - fn parent_next_time(&self, aggregator: &Self::Type) -> Option; + fn parent_next_time(&self) -> Option; fn parent_create_new_pad( &self, - aggregator: &Self::Type, templ: &gst::PadTemplate, req_name: Option<&str>, caps: Option<&gst::Caps>, ) -> Option; - fn parent_update_src_caps( - &self, - aggregator: &Self::Type, - caps: &gst::Caps, - ) -> Result; + fn parent_update_src_caps(&self, caps: &gst::Caps) -> Result; - fn parent_fixate_src_caps(&self, aggregator: &Self::Type, caps: gst::Caps) -> gst::Caps; + fn parent_fixate_src_caps(&self, caps: gst::Caps) -> gst::Caps; - fn parent_negotiated_src_caps( - &self, - aggregator: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError>; + fn parent_negotiated_src_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError>; fn parent_propose_allocation( &self, - element: &Self::Type, pad: &AggregatorPad, decide_query: Option<&gst::query::Allocation>, query: &mut gst::query::Allocation, @@ -295,32 +217,28 @@ pub trait AggregatorImplExt: ObjectSubclass { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] - fn parent_negotiate(&self, aggregator: &Self::Type) -> bool; + fn parent_negotiate(&self) -> bool; #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] - fn parent_peek_next_sample( - &self, - aggregator: &Self::Type, - pad: &AggregatorPad, - ) -> Option; + fn parent_peek_next_sample(&self, pad: &AggregatorPad) -> Option; } impl AggregatorImplExt for T { - fn parent_flush(&self, aggregator: &Self::Type) -> Result { + fn parent_flush(&self) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; (*parent_class) .flush .map(|f| { - try_from_glib(f(aggregator + try_from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -331,7 +249,6 @@ impl AggregatorImplExt for T { fn parent_clip( &self, - aggregator: &Self::Type, aggregator_pad: &AggregatorPad, buffer: gst::Buffer, ) -> Option { @@ -341,7 +258,10 @@ impl AggregatorImplExt for T { match (*parent_class).clip { None => Some(buffer), Some(ref func) => from_glib_full(func( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, aggregator_pad.to_glib_none().0, buffer.into_glib_ptr(), )), @@ -351,7 +271,6 @@ impl AggregatorImplExt for T { fn parent_finish_buffer( &self, - aggregator: &Self::Type, buffer: gst::Buffer, ) -> Result { unsafe { @@ -361,7 +280,10 @@ impl AggregatorImplExt for T { .finish_buffer .expect("Missing parent function `finish_buffer`"); try_from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer.into_glib_ptr(), )) } @@ -371,7 +293,6 @@ impl AggregatorImplExt for T { #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn parent_finish_buffer_list( &self, - aggregator: &Self::Type, buffer_list: gst::BufferList, ) -> Result { unsafe { @@ -381,18 +302,16 @@ impl AggregatorImplExt for T { .finish_buffer_list .expect("Missing parent function `finish_buffer_list`"); try_from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer_list.into_glib_ptr(), )) } } - fn parent_sink_event( - &self, - aggregator: &Self::Type, - aggregator_pad: &AggregatorPad, - event: gst::Event, - ) -> bool { + fn parent_sink_event(&self, aggregator_pad: &AggregatorPad, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -400,7 +319,10 @@ impl AggregatorImplExt for T { .sink_event .expect("Missing parent function `sink_event`"); from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, aggregator_pad.to_glib_none().0, event.into_glib_ptr(), )) @@ -411,7 +333,6 @@ impl AggregatorImplExt for T { #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn parent_sink_event_pre_queue( &self, - aggregator: &Self::Type, aggregator_pad: &AggregatorPad, event: gst::Event, ) -> Result { @@ -422,19 +343,17 @@ impl AggregatorImplExt for T { .sink_event_pre_queue .expect("Missing parent function `sink_event_pre_queue`"); try_from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, aggregator_pad.to_glib_none().0, event.into_glib_ptr(), )) } } - fn parent_sink_query( - &self, - aggregator: &Self::Type, - aggregator_pad: &AggregatorPad, - query: &mut gst::QueryRef, - ) -> bool { + fn parent_sink_query(&self, aggregator_pad: &AggregatorPad, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -442,7 +361,10 @@ impl AggregatorImplExt for T { .sink_query .expect("Missing parent function `sink_query`"); from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, aggregator_pad.to_glib_none().0, query.as_mut_ptr(), )) @@ -453,7 +375,6 @@ impl AggregatorImplExt for T { #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] fn parent_sink_query_pre_queue( &self, - aggregator: &Self::Type, aggregator_pad: &AggregatorPad, query: &mut gst::QueryRef, ) -> bool { @@ -464,14 +385,17 @@ impl AggregatorImplExt for T { .sink_query_pre_queue .expect("Missing parent function `sink_query`"); from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, aggregator_pad.to_glib_none().0, query.as_mut_ptr(), )) } } - fn parent_src_event(&self, aggregator: &Self::Type, event: gst::Event) -> bool { + fn parent_src_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -479,13 +403,16 @@ impl AggregatorImplExt for T { .src_event .expect("Missing parent function `src_event`"); from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_src_query(&self, aggregator: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -493,7 +420,10 @@ impl AggregatorImplExt for T { .src_query .expect("Missing parent function `src_query`"); from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } @@ -501,7 +431,6 @@ impl AggregatorImplExt for T { fn parent_src_activate( &self, - aggregator: &Self::Type, mode: gst::PadMode, active: bool, ) -> Result<(), gst::LoggableError> { @@ -512,7 +441,10 @@ impl AggregatorImplExt for T { None => Ok(()), Some(f) => gst::result_from_gboolean!( f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, mode.into_glib(), active.into_glib() ), @@ -523,11 +455,7 @@ impl AggregatorImplExt for T { } } - fn parent_aggregate( - &self, - aggregator: &Self::Type, - timeout: bool, - ) -> Result { + fn parent_aggregate(&self, timeout: bool) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -535,20 +463,24 @@ impl AggregatorImplExt for T { .aggregate .expect("Missing parent function `aggregate`"); try_from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, timeout.into_glib(), )) } } - fn parent_start(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; (*parent_class) .start .map(|f| { - if from_glib(f(aggregator + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -565,14 +497,15 @@ impl AggregatorImplExt for T { } } - fn parent_stop(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; (*parent_class) .stop .map(|f| { - if from_glib(f(aggregator + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -589,14 +522,15 @@ impl AggregatorImplExt for T { } } - fn parent_next_time(&self, aggregator: &Self::Type) -> Option { + fn parent_next_time(&self) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; (*parent_class) .get_next_time .map(|f| { - from_glib(f(aggregator + from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -607,7 +541,6 @@ impl AggregatorImplExt for T { fn parent_create_new_pad( &self, - aggregator: &Self::Type, templ: &gst::PadTemplate, req_name: Option<&str>, caps: Option<&gst::Caps>, @@ -619,7 +552,10 @@ impl AggregatorImplExt for T { .create_new_pad .expect("Missing parent function `create_new_pad`"); from_glib_full(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, templ.to_glib_none().0, req_name.to_glib_none().0, caps.to_glib_none().0, @@ -627,11 +563,7 @@ impl AggregatorImplExt for T { } } - fn parent_update_src_caps( - &self, - aggregator: &Self::Type, - caps: &gst::Caps, - ) -> Result { + fn parent_update_src_caps(&self, caps: &gst::Caps) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -641,7 +573,10 @@ impl AggregatorImplExt for T { let mut out_caps = ptr::null_mut(); gst::FlowSuccess::try_from_glib(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.as_mut_ptr(), &mut out_caps, )) @@ -649,7 +584,7 @@ impl AggregatorImplExt for T { } } - fn parent_fixate_src_caps(&self, aggregator: &Self::Type, caps: gst::Caps) -> gst::Caps { + fn parent_fixate_src_caps(&self, caps: gst::Caps) -> gst::Caps { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -658,17 +593,16 @@ impl AggregatorImplExt for T { .fixate_src_caps .expect("Missing parent function `fixate_src_caps`"); from_glib_full(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.into_glib_ptr(), )) } } - fn parent_negotiated_src_caps( - &self, - aggregator: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn parent_negotiated_src_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -677,7 +611,10 @@ impl AggregatorImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.to_glib_none().0 ), gst::CAT_RUST, @@ -690,7 +627,6 @@ impl AggregatorImplExt for T { fn parent_propose_allocation( &self, - element: &Self::Type, pad: &AggregatorPad, decide_query: Option<&gst::query::Allocation>, query: &mut gst::query::Allocation, @@ -703,7 +639,10 @@ impl AggregatorImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, pad.to_glib_none().0, decide_query .as_ref() @@ -721,7 +660,6 @@ impl AggregatorImplExt for T { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -732,7 +670,10 @@ impl AggregatorImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -745,14 +686,15 @@ impl AggregatorImplExt for T { #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] - fn parent_negotiate(&self, aggregator: &Self::Type) -> bool { + fn parent_negotiate(&self) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; (*parent_class) .negotiate .map(|f| { - from_glib(f(aggregator + from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -763,11 +705,7 @@ impl AggregatorImplExt for T { #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] - fn parent_peek_next_sample( - &self, - aggregator: &Self::Type, - pad: &AggregatorPad, - ) -> Option { + fn parent_peek_next_sample(&self, pad: &AggregatorPad) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass; @@ -775,7 +713,10 @@ impl AggregatorImplExt for T { .peek_next_sample .map(|f| { from_glib_full(f( - aggregator.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, pad.to_glib_none().0, )) }) @@ -822,12 +763,8 @@ unsafe extern "C" fn aggregator_flush( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.flush(wrap.unsafe_cast_ref()).into() - }) - .into_glib() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { imp.flush().into() }).into_glib() } unsafe extern "C" fn aggregator_clip( @@ -837,14 +774,9 @@ unsafe extern "C" fn aggregator_clip( ) -> *mut gst::ffi::GstBuffer { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let ret = gst::panic_to_error!(&wrap, imp.panicked(), None, { - imp.clip( - wrap.unsafe_cast_ref(), - &from_glib_borrow(aggregator_pad), - from_glib_full(buffer), - ) + let ret = gst::panic_to_error!(imp, None, { + imp.clip(&from_glib_borrow(aggregator_pad), from_glib_full(buffer)) }); ret.map(|r| r.into_glib_ptr()).unwrap_or(ptr::null_mut()) @@ -856,11 +788,9 @@ unsafe extern "C" fn aggregator_finish_buffer( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.finish_buffer(wrap.unsafe_cast_ref(), from_glib_full(buffer)) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.finish_buffer(from_glib_full(buffer)).into() }) .into_glib() } @@ -873,11 +803,9 @@ unsafe extern "C" fn aggregator_finish_buffer_list( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.finish_buffer_list(wrap.unsafe_cast_ref(), from_glib_full(buffer_list)) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.finish_buffer_list(from_glib_full(buffer_list)).into() }) .into_glib() } @@ -889,14 +817,9 @@ unsafe extern "C" fn aggregator_sink_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(wrap, imp.panicked(), false, { - imp.sink_event( - wrap.unsafe_cast_ref(), - &from_glib_borrow(aggregator_pad), - from_glib_full(event), - ) + gst::panic_to_error!(imp, false, { + imp.sink_event(&from_glib_borrow(aggregator_pad), from_glib_full(event)) }) .into_glib() } @@ -910,15 +833,10 @@ unsafe extern "C" fn aggregator_sink_event_pre_queue( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.sink_event_pre_queue( - wrap.unsafe_cast_ref(), - &from_glib_borrow(aggregator_pad), - from_glib_full(event), - ) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.sink_event_pre_queue(&from_glib_borrow(aggregator_pad), from_glib_full(event)) + .into() }) .into_glib() } @@ -930,11 +848,9 @@ unsafe extern "C" fn aggregator_sink_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { imp.sink_query( - wrap.unsafe_cast_ref(), &from_glib_borrow(aggregator_pad), gst::QueryRef::from_mut_ptr(query), ) @@ -951,11 +867,9 @@ unsafe extern "C" fn aggregator_sink_query_pre_queue( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { imp.sink_query_pre_queue( - wrap.unsafe_cast_ref(), &from_glib_borrow(aggregator_pad), gst::QueryRef::from_mut_ptr(query), ) @@ -969,12 +883,8 @@ unsafe extern "C" fn aggregator_src_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.src_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn aggregator_src_query( @@ -983,10 +893,9 @@ unsafe extern "C" fn aggregator_src_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.src_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -998,13 +907,12 @@ unsafe extern "C" fn aggregator_src_activate( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.src_activate(wrap.unsafe_cast_ref(), from_glib(mode), from_glib(active)) { + gst::panic_to_error!(imp, false, { + match imp.src_activate(from_glib(mode), from_glib(active)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1018,11 +926,9 @@ unsafe extern "C" fn aggregator_aggregate( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.aggregate(wrap.unsafe_cast_ref(), from_glib(timeout)) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.aggregate(from_glib(timeout)).into() }) .into_glib() } @@ -1032,13 +938,12 @@ unsafe extern "C" fn aggregator_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -1051,13 +956,12 @@ unsafe extern "C" fn aggregator_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -1070,12 +974,8 @@ unsafe extern "C" fn aggregator_get_next_time( ) -> gst::ffi::GstClockTime { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::ClockTime::NONE, { - imp.next_time(wrap.unsafe_cast_ref()) - }) - .into_glib() + gst::panic_to_error!(imp, gst::ClockTime::NONE, { imp.next_time() }).into_glib() } unsafe extern "C" fn aggregator_create_new_pad( @@ -1086,13 +986,11 @@ unsafe extern "C" fn aggregator_create_new_pad( ) -> *mut ffi::GstAggregatorPad { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), None, { + gst::panic_to_error!(imp, None, { let req_name: Borrowed> = from_glib_borrow(req_name); imp.create_new_pad( - wrap.unsafe_cast_ref(), &from_glib_borrow(templ), req_name.as_ref().as_ref().map(|s| s.as_str()), Option::::from_glib_borrow(caps) @@ -1110,12 +1008,11 @@ unsafe extern "C" fn aggregator_update_src_caps( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); *res = ptr::null_mut(); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.update_src_caps(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.update_src_caps(&from_glib_borrow(caps)) { Ok(res_caps) => { *res = res_caps.into_glib_ptr(); gst::FlowReturn::Ok @@ -1132,10 +1029,9 @@ unsafe extern "C" fn aggregator_fixate_src_caps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { - imp.fixate_src_caps(wrap.unsafe_cast_ref(), from_glib_full(caps)) + gst::panic_to_error!(imp, gst::Caps::new_empty(), { + imp.fixate_src_caps(from_glib_full(caps)) }) .into_glib_ptr() } @@ -1146,13 +1042,12 @@ unsafe extern "C" fn aggregator_negotiated_src_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.negotiated_src_caps(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) { + gst::panic_to_error!(imp, false, { + match imp.negotiated_src_caps(&from_glib_borrow(caps)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1168,7 +1063,6 @@ unsafe extern "C" fn aggregator_propose_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let decide_query = if decide_query.is_null() { None } else { @@ -1182,16 +1076,11 @@ unsafe extern "C" fn aggregator_propose_allocation( _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.propose_allocation( - wrap.unsafe_cast_ref(), - &from_glib_borrow(pad), - decide_query, - query, - ) { + gst::panic_to_error!(imp, false, { + match imp.propose_allocation(&from_glib_borrow(pad), decide_query, query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1205,17 +1094,16 @@ unsafe extern "C" fn aggregator_decide_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.decide_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1230,12 +1118,8 @@ unsafe extern "C" fn aggregator_negotiate( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.negotiate(wrap.unsafe_cast_ref()) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.negotiate() }).into_glib() } #[cfg(any(feature = "v1_18", feature = "dox"))] @@ -1246,10 +1130,6 @@ unsafe extern "C" fn aggregator_peek_next_sample( ) -> *mut gst::ffi::GstSample { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), None, { - imp.peek_next_sample(wrap.unsafe_cast_ref(), &from_glib_borrow(pad)) - }) - .to_glib_full() + gst::panic_to_error!(imp, None, { imp.peek_next_sample(&from_glib_borrow(pad)) }).to_glib_full() } diff --git a/gstreamer-base/src/subclass/aggregator_pad.rs b/gstreamer-base/src/subclass/aggregator_pad.rs index 25c2e3b1c..d9de1ec6f 100644 --- a/gstreamer-base/src/subclass/aggregator_pad.rs +++ b/gstreamer-base/src/subclass/aggregator_pad.rs @@ -9,45 +9,23 @@ use crate::Aggregator; use crate::AggregatorPad; pub trait AggregatorPadImpl: AggregatorPadImplExt + PadImpl { - fn flush( - &self, - aggregator_pad: &Self::Type, - aggregator: &Aggregator, - ) -> Result { - self.parent_flush(aggregator_pad, aggregator) + fn flush(&self, aggregator: &Aggregator) -> Result { + self.parent_flush(aggregator) } - fn skip_buffer( - &self, - aggregator_pad: &Self::Type, - aggregator: &Aggregator, - buffer: &gst::Buffer, - ) -> bool { - self.parent_skip_buffer(aggregator_pad, aggregator, buffer) + fn skip_buffer(&self, aggregator: &Aggregator, buffer: &gst::Buffer) -> bool { + self.parent_skip_buffer(aggregator, buffer) } } pub trait AggregatorPadImplExt: ObjectSubclass { - fn parent_flush( - &self, - aggregator_pad: &Self::Type, - aggregator: &Aggregator, - ) -> Result; + fn parent_flush(&self, aggregator: &Aggregator) -> Result; - fn parent_skip_buffer( - &self, - aggregator_pad: &Self::Type, - aggregator: &Aggregator, - buffer: &gst::Buffer, - ) -> bool; + fn parent_skip_buffer(&self, aggregator: &Aggregator, buffer: &gst::Buffer) -> bool; } impl AggregatorPadImplExt for T { - fn parent_flush( - &self, - aggregator_pad: &Self::Type, - aggregator: &Aggregator, - ) -> Result { + fn parent_flush(&self, aggregator: &Aggregator) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorPadClass; @@ -55,7 +33,7 @@ impl AggregatorPadImplExt for T { .flush .map(|f| { try_from_glib(f( - aggregator_pad + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -66,12 +44,7 @@ impl AggregatorPadImplExt for T { } } - fn parent_skip_buffer( - &self, - aggregator_pad: &Self::Type, - aggregator: &Aggregator, - buffer: &gst::Buffer, - ) -> bool { + fn parent_skip_buffer(&self, aggregator: &Aggregator, buffer: &gst::Buffer) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorPadClass; @@ -79,7 +52,7 @@ impl AggregatorPadImplExt for T { .skip_buffer .map(|f| { from_glib(f( - aggregator_pad + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -106,11 +79,8 @@ unsafe extern "C" fn aggregator_pad_flush( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let res: gst::FlowReturn = imp - .flush(wrap.unsafe_cast_ref(), &from_glib_borrow(aggregator)) - .into(); + let res: gst::FlowReturn = imp.flush(&from_glib_borrow(aggregator)).into(); res.into_glib() } @@ -121,12 +91,7 @@ unsafe extern "C" fn aggregator_pad_skip_buffer( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.skip_buffer( - wrap.unsafe_cast_ref(), - &from_glib_borrow(aggregator), - &from_glib_borrow(buffer), - ) - .into_glib() + imp.skip_buffer(&from_glib_borrow(aggregator), &from_glib_borrow(buffer)) + .into_glib() } diff --git a/gstreamer-base/src/subclass/base_parse.rs b/gstreamer-base/src/subclass/base_parse.rs index 09fea1bbb..169fa87a4 100644 --- a/gstreamer-base/src/subclass/base_parse.rs +++ b/gstreamer-base/src/subclass/base_parse.rs @@ -12,74 +12,67 @@ use crate::BaseParse; use crate::BaseParseFrame; pub trait BaseParseImpl: BaseParseImplExt + ElementImpl { - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(element) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(element) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } - fn set_sink_caps( + fn set_sink_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_set_sink_caps(caps) + } + + fn handle_frame( &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { - self.parent_set_sink_caps(element, caps) - } - - fn handle_frame<'a>( - &'a self, - element: &Self::Type, frame: BaseParseFrame, ) -> Result<(gst::FlowSuccess, u32), gst::FlowError> { - self.parent_handle_frame(element, frame) + self.parent_handle_frame(frame) } fn convert( &self, - element: &Self::Type, src_val: impl gst::FormattedValue, dest_format: gst::Format, ) -> Option { - self.parent_convert(element, src_val, dest_format) + self.parent_convert(src_val, dest_format) } } pub trait BaseParseImplExt: ObjectSubclass { - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; - fn parent_set_sink_caps( + fn parent_set_sink_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError>; + + fn parent_handle_frame( &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError>; - - fn parent_handle_frame<'a>( - &'a self, - element: &Self::Type, frame: BaseParseFrame, ) -> Result<(gst::FlowSuccess, u32), gst::FlowError>; fn parent_convert( &self, - element: &Self::Type, src_val: impl gst::FormattedValue, dest_format: gst::Format, ) -> Option; } impl BaseParseImplExt for T { - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass; (*parent_class) .start .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -92,14 +85,19 @@ impl BaseParseImplExt for T { } } - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass; (*parent_class) .stop .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -112,11 +110,7 @@ impl BaseParseImplExt for T { } } - fn parent_set_sink_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn parent_set_sink_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass; @@ -125,7 +119,10 @@ impl BaseParseImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.to_glib_none().0, ), gst::CAT_RUST, @@ -136,9 +133,8 @@ impl BaseParseImplExt for T { } } - fn parent_handle_frame<'a>( - &'a self, - element: &'a Self::Type, + fn parent_handle_frame( + &self, frame: BaseParseFrame, ) -> Result<(gst::FlowSuccess, u32), gst::FlowError> { unsafe { @@ -149,7 +145,10 @@ impl BaseParseImplExt for T { .handle_frame .map(|f| { let res = try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, frame.to_glib_none().0, &mut skipsize, )); @@ -161,7 +160,6 @@ impl BaseParseImplExt for T { fn parent_convert( &self, - element: &Self::Type, src_val: impl gst::FormattedValue, dest_format: gst::Format, ) -> Option { @@ -172,7 +170,10 @@ impl BaseParseImplExt for T { let mut dest_val = mem::MaybeUninit::uninit(); let res = from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, src_val.format().into_glib(), src_val.into_raw_value(), dest_format.into_glib(), @@ -209,13 +210,12 @@ unsafe extern "C" fn base_parse_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -228,13 +228,12 @@ unsafe extern "C" fn base_parse_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -248,14 +247,13 @@ unsafe extern "C" fn base_parse_set_sink_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let caps: Borrowed = from_glib_borrow(caps); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_sink_caps(wrap.unsafe_cast_ref(), &caps) { + gst::panic_to_error!(imp, false, { + match imp.set_sink_caps(&caps) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -270,11 +268,12 @@ unsafe extern "C" fn base_parse_handle_frame( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let wrap_frame = BaseParseFrame::new(frame, &wrap); + let instance = imp.instance(); + let instance = instance.unsafe_cast_ref::(); + let wrap_frame = BaseParseFrame::new(frame, instance); - let res = gst::panic_to_error!(&wrap, imp.panicked(), Err(gst::FlowError::Error), { - imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame) + let res = gst::panic_to_error!(imp, Err(gst::FlowError::Error), { + imp.handle_frame(wrap_frame) }); match res { @@ -296,12 +295,9 @@ unsafe extern "C" fn base_parse_convert( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let source = gst::GenericFormattedValue::new(from_glib(source_format), source_value); - let res = gst::panic_to_error!(&wrap, imp.panicked(), None, { - imp.convert(wrap.unsafe_cast_ref(), source, from_glib(dest_format)) - }); + let res = gst::panic_to_error!(imp, None, { imp.convert(source, from_glib(dest_format)) }); match res { Some(dest) => { diff --git a/gstreamer-base/src/subclass/base_sink.rs b/gstreamer-base/src/subclass/base_sink.rs index 9926b49b0..cbdcc6e13 100644 --- a/gstreamer-base/src/subclass/base_sink.rs +++ b/gstreamer-base/src/subclass/base_sink.rs @@ -10,146 +10,119 @@ use std::ptr; use crate::BaseSink; pub trait BaseSinkImpl: BaseSinkImplExt + ElementImpl { - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(element) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(element) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } - fn render( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result { - self.parent_render(element, buffer) + fn render(&self, buffer: &gst::Buffer) -> Result { + self.parent_render(buffer) } - fn prepare( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result { - self.parent_prepare(element, buffer) + fn prepare(&self, buffer: &gst::Buffer) -> Result { + self.parent_prepare(buffer) } - fn render_list( - &self, - element: &Self::Type, - list: &gst::BufferList, - ) -> Result { - self.parent_render_list(element, list) + fn render_list(&self, list: &gst::BufferList) -> Result { + self.parent_render_list(list) } - fn prepare_list( - &self, - element: &Self::Type, - list: &gst::BufferList, - ) -> Result { - self.parent_prepare_list(element, list) + fn prepare_list(&self, list: &gst::BufferList) -> Result { + self.parent_prepare_list(list) } - fn query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - BaseSinkImplExt::parent_query(self, element, query) + fn query(&self, query: &mut gst::QueryRef) -> bool { + BaseSinkImplExt::parent_query(self, query) } - fn event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_event(element, event) + fn event(&self, event: gst::Event) -> bool { + self.parent_event(event) } - fn caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> Option { - self.parent_caps(element, filter) + fn caps(&self, filter: Option<&gst::Caps>) -> Option { + self.parent_caps(filter) } - fn set_caps(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> { - self.parent_set_caps(element, caps) + fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_set_caps(caps) } - fn fixate(&self, element: &Self::Type, caps: gst::Caps) -> gst::Caps { - self.parent_fixate(element, caps) + fn fixate(&self, caps: gst::Caps) -> gst::Caps { + self.parent_fixate(caps) } - fn unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_unlock(element) + fn unlock(&self) -> Result<(), gst::ErrorMessage> { + self.parent_unlock() } - fn unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_unlock_stop(element) + fn unlock_stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_unlock_stop() } fn propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_propose_allocation(element, query) + self.parent_propose_allocation(query) } } pub trait BaseSinkImplExt: ObjectSubclass { - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; - fn parent_render( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result; + fn parent_render(&self, buffer: &gst::Buffer) -> Result; - fn parent_prepare( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result; + fn parent_prepare(&self, buffer: &gst::Buffer) -> Result; fn parent_render_list( &self, - element: &Self::Type, list: &gst::BufferList, ) -> Result; fn parent_prepare_list( &self, - element: &Self::Type, list: &gst::BufferList, ) -> Result; - fn parent_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_query(&self, query: &mut gst::QueryRef) -> bool; - fn parent_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_event(&self, event: gst::Event) -> bool; - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> Option; + fn parent_caps(&self, filter: Option<&gst::Caps>) -> Option; - fn parent_set_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError>; + fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError>; - fn parent_fixate(&self, element: &Self::Type, caps: gst::Caps) -> gst::Caps; + fn parent_fixate(&self, caps: gst::Caps) -> gst::Caps; - fn parent_unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_unlock(&self) -> Result<(), gst::ErrorMessage>; - fn parent_unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_unlock_stop(&self) -> Result<(), gst::ErrorMessage>; fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; } impl BaseSinkImplExt for T { - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; (*parent_class) .start .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -162,14 +135,19 @@ impl BaseSinkImplExt for T { } } - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; (*parent_class) .stop .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -182,11 +160,7 @@ impl BaseSinkImplExt for T { } } - fn parent_render( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result { + fn parent_render(&self, buffer: &gst::Buffer) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; @@ -194,7 +168,10 @@ impl BaseSinkImplExt for T { .render .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer.to_glib_none().0, )) }) @@ -202,11 +179,7 @@ impl BaseSinkImplExt for T { } } - fn parent_prepare( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result { + fn parent_prepare(&self, buffer: &gst::Buffer) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; @@ -214,7 +187,10 @@ impl BaseSinkImplExt for T { .prepare .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer.to_glib_none().0, )) }) @@ -224,7 +200,6 @@ impl BaseSinkImplExt for T { fn parent_render_list( &self, - element: &Self::Type, list: &gst::BufferList, ) -> Result { unsafe { @@ -234,13 +209,16 @@ impl BaseSinkImplExt for T { .render_list .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, list.to_glib_none().0, )) }) .unwrap_or_else(|| { for buffer in list.iter() { - self.render(element, &from_glib_borrow(buffer.as_ptr()))?; + self.render(&from_glib_borrow(buffer.as_ptr()))?; } Ok(gst::FlowSuccess::Ok) }) @@ -249,7 +227,6 @@ impl BaseSinkImplExt for T { fn parent_prepare_list( &self, - element: &Self::Type, list: &gst::BufferList, ) -> Result { unsafe { @@ -259,20 +236,23 @@ impl BaseSinkImplExt for T { .prepare_list .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, list.to_glib_none().0, )) }) .unwrap_or_else(|| { for buffer in list.iter() { - self.prepare(element, &from_glib_borrow(buffer.as_ptr()))?; + self.prepare(&from_glib_borrow(buffer.as_ptr()))?; } Ok(gst::FlowSuccess::Ok) }) } } - fn parent_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; @@ -280,7 +260,10 @@ impl BaseSinkImplExt for T { .query .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) }) @@ -288,7 +271,7 @@ impl BaseSinkImplExt for T { } } - fn parent_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; @@ -296,7 +279,10 @@ impl BaseSinkImplExt for T { .event .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) }) @@ -304,7 +290,7 @@ impl BaseSinkImplExt for T { } } - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> Option { + fn parent_caps(&self, filter: Option<&gst::Caps>) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; @@ -313,7 +299,10 @@ impl BaseSinkImplExt for T { .get_caps .map(|f| { from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, filter.to_glib_none().0, )) }) @@ -321,11 +310,7 @@ impl BaseSinkImplExt for T { } } - fn parent_set_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; @@ -334,7 +319,10 @@ impl BaseSinkImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.to_glib_none().0 ), gst::CAT_RUST, @@ -345,14 +333,17 @@ impl BaseSinkImplExt for T { } } - fn parent_fixate(&self, element: &Self::Type, caps: gst::Caps) -> gst::Caps { + fn parent_fixate(&self, caps: gst::Caps) -> gst::Caps { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; match (*parent_class).fixate { Some(fixate) => from_glib_full(fixate( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.into_glib_ptr(), )), None => caps, @@ -360,14 +351,19 @@ impl BaseSinkImplExt for T { } } - fn parent_unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_unlock(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; (*parent_class) .unlock .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -380,14 +376,19 @@ impl BaseSinkImplExt for T { } } - fn parent_unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_unlock_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSinkClass; (*parent_class) .unlock_stop .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -402,7 +403,6 @@ impl BaseSinkImplExt for T { fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -413,7 +413,10 @@ impl BaseSinkImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -451,13 +454,12 @@ unsafe extern "C" fn base_sink_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -470,13 +472,12 @@ unsafe extern "C" fn base_sink_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -490,13 +491,9 @@ unsafe extern "C" fn base_sink_render( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let buffer = from_glib_borrow(buffer); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.render(wrap.unsafe_cast_ref(), &buffer).into() - }) - .into_glib() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { imp.render(&buffer).into() }).into_glib() } unsafe extern "C" fn base_sink_prepare( @@ -505,13 +502,9 @@ unsafe extern "C" fn base_sink_prepare( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let buffer = from_glib_borrow(buffer); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.prepare(wrap.unsafe_cast_ref(), &buffer).into() - }) - .into_glib() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { imp.prepare(&buffer).into() }).into_glib() } unsafe extern "C" fn base_sink_render_list( @@ -520,11 +513,10 @@ unsafe extern "C" fn base_sink_render_list( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let list = from_glib_borrow(list); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.render_list(wrap.unsafe_cast_ref(), &list).into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.render_list(&list).into() }) .into_glib() } @@ -535,11 +527,10 @@ unsafe extern "C" fn base_sink_prepare_list( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let list = from_glib_borrow(list); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.prepare_list(wrap.unsafe_cast_ref(), &list).into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.prepare_list(&list).into() }) .into_glib() } @@ -550,13 +541,9 @@ unsafe extern "C" fn base_sink_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = gst::QueryRef::from_mut_ptr(query_ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - BaseSinkImpl::query(imp, wrap.unsafe_cast_ref(), query) - }) - .into_glib() + gst::panic_to_error!(imp, false, { BaseSinkImpl::query(imp, query) }).into_glib() } unsafe extern "C" fn base_sink_event( @@ -565,12 +552,8 @@ unsafe extern "C" fn base_sink_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.event(wrap.unsafe_cast_ref(), from_glib_full(event_ptr)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.event(from_glib_full(event_ptr)) }).into_glib() } unsafe extern "C" fn base_sink_get_caps( @@ -579,14 +562,11 @@ unsafe extern "C" fn base_sink_get_caps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let filter = Option::::from_glib_borrow(filter); - gst::panic_to_error!(&wrap, imp.panicked(), None, { - imp.caps(wrap.unsafe_cast_ref(), filter.as_ref().as_ref()) - }) - .map(|caps| caps.into_glib_ptr()) - .unwrap_or(ptr::null_mut()) + gst::panic_to_error!(imp, None, { imp.caps(filter.as_ref().as_ref()) }) + .map(|caps| caps.into_glib_ptr()) + .unwrap_or(ptr::null_mut()) } unsafe extern "C" fn base_sink_set_caps( @@ -595,14 +575,13 @@ unsafe extern "C" fn base_sink_set_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let caps = from_glib_borrow(caps); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_caps(wrap.unsafe_cast_ref(), &caps) { + gst::panic_to_error!(imp, false, { + match imp.set_caps(&caps) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -616,13 +595,9 @@ unsafe extern "C" fn base_sink_fixate( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let caps = from_glib_full(caps); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { - imp.fixate(wrap.unsafe_cast_ref(), caps) - }) - .into_glib_ptr() + gst::panic_to_error!(imp, gst::Caps::new_empty(), { imp.fixate(caps) }).into_glib_ptr() } unsafe extern "C" fn base_sink_unlock( @@ -630,13 +605,12 @@ unsafe extern "C" fn base_sink_unlock( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.unlock(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.unlock() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -649,13 +623,12 @@ unsafe extern "C" fn base_sink_unlock_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.unlock_stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.unlock_stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -669,17 +642,16 @@ unsafe extern "C" fn base_sink_propose_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.propose_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.propose_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer-base/src/subclass/base_src.rs b/gstreamer-base/src/subclass/base_src.rs index b62c152e3..aeb18677b 100644 --- a/gstreamer-base/src/subclass/base_src.rs +++ b/gstreamer-base/src/subclass/base_src.rs @@ -27,181 +27,161 @@ pub enum CreateSuccess { } pub trait BaseSrcImpl: BaseSrcImplExt + ElementImpl { - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(element) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(element) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } - fn is_seekable(&self, element: &Self::Type) -> bool { - self.parent_is_seekable(element) + fn is_seekable(&self) -> bool { + self.parent_is_seekable() } - fn size(&self, element: &Self::Type) -> Option { - self.parent_size(element) + fn size(&self) -> Option { + self.parent_size() } #[doc(alias = "get_times")] - fn times( - &self, - element: &Self::Type, - buffer: &gst::BufferRef, - ) -> (Option, Option) { - self.parent_times(element, buffer) + fn times(&self, buffer: &gst::BufferRef) -> (Option, Option) { + self.parent_times(buffer) } fn fill( &self, - element: &Self::Type, offset: u64, length: u32, buffer: &mut gst::BufferRef, ) -> Result { - self.parent_fill(element, offset, length, buffer) + self.parent_fill(offset, length, buffer) } - fn alloc( - &self, - element: &Self::Type, - offset: u64, - length: u32, - ) -> Result { - self.parent_alloc(element, offset, length) + fn alloc(&self, offset: u64, length: u32) -> Result { + self.parent_alloc(offset, length) } fn create( &self, - element: &Self::Type, offset: u64, buffer: Option<&mut gst::BufferRef>, length: u32, ) -> Result { - self.parent_create(element, offset, buffer, length) + self.parent_create(offset, buffer, length) } - fn do_seek(&self, element: &Self::Type, segment: &mut gst::Segment) -> bool { - self.parent_do_seek(element, segment) + fn do_seek(&self, segment: &mut gst::Segment) -> bool { + self.parent_do_seek(segment) } - fn query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - BaseSrcImplExt::parent_query(self, element, query) + fn query(&self, query: &mut gst::QueryRef) -> bool { + BaseSrcImplExt::parent_query(self, query) } - fn event(&self, element: &Self::Type, event: &gst::Event) -> bool { - self.parent_event(element, event) + fn event(&self, event: &gst::Event) -> bool { + self.parent_event(event) } - fn caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> Option { - self.parent_caps(element, filter) + fn caps(&self, filter: Option<&gst::Caps>) -> Option { + self.parent_caps(filter) } - fn negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { - self.parent_negotiate(element) + fn negotiate(&self) -> Result<(), gst::LoggableError> { + self.parent_negotiate() } - fn set_caps(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> { - self.parent_set_caps(element, caps) + fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_set_caps(caps) } - fn fixate(&self, element: &Self::Type, caps: gst::Caps) -> gst::Caps { - self.parent_fixate(element, caps) + fn fixate(&self, caps: gst::Caps) -> gst::Caps { + self.parent_fixate(caps) } - fn unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_unlock(element) + fn unlock(&self) -> Result<(), gst::ErrorMessage> { + self.parent_unlock() } - fn unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_unlock_stop(element) + fn unlock_stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_unlock_stop() } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } } pub trait BaseSrcImplExt: ObjectSubclass { - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; - fn parent_is_seekable(&self, element: &Self::Type) -> bool; + fn parent_is_seekable(&self) -> bool; - fn parent_size(&self, element: &Self::Type) -> Option; + fn parent_size(&self) -> Option; fn parent_times( &self, - element: &Self::Type, buffer: &gst::BufferRef, ) -> (Option, Option); fn parent_fill( &self, - element: &Self::Type, offset: u64, length: u32, buffer: &mut gst::BufferRef, ) -> Result; - fn parent_alloc( - &self, - element: &Self::Type, - offset: u64, - length: u32, - ) -> Result; + fn parent_alloc(&self, offset: u64, length: u32) -> Result; fn parent_create( &self, - element: &Self::Type, offset: u64, buffer: Option<&mut gst::BufferRef>, length: u32, ) -> Result; - fn parent_do_seek(&self, element: &Self::Type, segment: &mut gst::Segment) -> bool; + fn parent_do_seek(&self, segment: &mut gst::Segment) -> bool; - fn parent_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_query(&self, query: &mut gst::QueryRef) -> bool; - fn parent_event(&self, element: &Self::Type, event: &gst::Event) -> bool; + fn parent_event(&self, event: &gst::Event) -> bool; - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> Option; + fn parent_caps(&self, filter: Option<&gst::Caps>) -> Option; - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>; + fn parent_negotiate(&self) -> Result<(), gst::LoggableError>; - fn parent_set_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError>; + fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError>; - fn parent_fixate(&self, element: &Self::Type, caps: gst::Caps) -> gst::Caps; + fn parent_fixate(&self, caps: gst::Caps) -> gst::Caps; - fn parent_unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_unlock(&self) -> Result<(), gst::ErrorMessage>; - fn parent_unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_unlock_stop(&self) -> Result<(), gst::ErrorMessage>; fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; } impl BaseSrcImplExt for T { - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; (*parent_class) .start .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -214,14 +194,19 @@ impl BaseSrcImplExt for T { } } - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; (*parent_class) .stop .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -234,18 +219,24 @@ impl BaseSrcImplExt for T { } } - fn parent_is_seekable(&self, element: &Self::Type) -> bool { + fn parent_is_seekable(&self) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; (*parent_class) .is_seekable - .map(|f| from_glib(f(element.unsafe_cast_ref::().to_glib_none().0))) + .map(|f| { + from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + }) .unwrap_or(false) } } - fn parent_size(&self, element: &Self::Type) -> Option { + fn parent_size(&self) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; @@ -254,7 +245,10 @@ impl BaseSrcImplExt for T { .map(|f| { let mut size = mem::MaybeUninit::uninit(); if from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, size.as_mut_ptr(), )) { Some(size.assume_init()) @@ -268,7 +262,6 @@ impl BaseSrcImplExt for T { fn parent_times( &self, - element: &Self::Type, buffer: &gst::BufferRef, ) -> (Option, Option) { unsafe { @@ -280,7 +273,10 @@ impl BaseSrcImplExt for T { let mut start = mem::MaybeUninit::uninit(); let mut stop = mem::MaybeUninit::uninit(); f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer.as_mut_ptr(), start.as_mut_ptr(), stop.as_mut_ptr(), @@ -296,7 +292,6 @@ impl BaseSrcImplExt for T { fn parent_fill( &self, - element: &Self::Type, offset: u64, length: u32, buffer: &mut gst::BufferRef, @@ -308,7 +303,10 @@ impl BaseSrcImplExt for T { .fill .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, offset, length, buffer.as_mut_ptr(), @@ -318,12 +316,7 @@ impl BaseSrcImplExt for T { } } - fn parent_alloc( - &self, - element: &Self::Type, - offset: u64, - length: u32, - ) -> Result { + fn parent_alloc(&self, offset: u64, length: u32) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; @@ -337,7 +330,10 @@ impl BaseSrcImplExt for T { let buffer_ref = &mut buffer_ptr as *mut _ as *mut gst::ffi::GstBuffer; gst::FlowSuccess::try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, offset, length, buffer_ref, @@ -350,7 +346,6 @@ impl BaseSrcImplExt for T { fn parent_create( &self, - element: &Self::Type, offset: u64, mut buffer: Option<&mut gst::BufferRef>, length: u32, @@ -361,6 +356,8 @@ impl BaseSrcImplExt for T { (*parent_class) .create .map(|f| { + let instance = self.instance(); + let instance = instance.unsafe_cast_ref::(); let orig_buffer_ptr = buffer .as_mut() .map(|b| b.as_mut_ptr()) @@ -375,7 +372,7 @@ impl BaseSrcImplExt for T { if let Err(err) = gst::FlowSuccess::try_from_glib( f( - element.unsafe_cast_ref::().to_glib_none().0, + instance.to_glib_none().0, offset, length, buffer_ref, @@ -387,14 +384,14 @@ impl BaseSrcImplExt for T { let pending_buffer_list = instance_data.pending_buffer_list.borrow_mut().take(); if pending_buffer_list.is_some() && - (buffer.is_some() || element.unsafe_cast_ref::().src_pad().mode() == gst::PadMode::Pull) { + (buffer.is_some() || instance.src_pad().mode() == gst::PadMode::Pull) { panic!("Buffer lists can only be returned in push mode"); } if buffer_ptr.is_null() && pending_buffer_list.is_none() { gst::error!( gst::CAT_RUST, - obj: element.unsafe_cast_ref::(), + obj: instance, "No buffer and no buffer list returned" ); return Err(gst::FlowError::Error); @@ -403,7 +400,7 @@ impl BaseSrcImplExt for T { if !buffer_ptr.is_null() && pending_buffer_list.is_some() { gst::error!( gst::CAT_RUST, - obj: element.unsafe_cast_ref::(), + obj: instance, "Both buffer and buffer list returned" ); return Err(gst::FlowError::Error); @@ -415,7 +412,7 @@ impl BaseSrcImplExt for T { gst::debug!( gst::CAT_PERFORMANCE, - obj: element.unsafe_cast_ref::(), + obj: instance, "Returned new buffer from parent create function, copying into passed buffer" ); @@ -424,7 +421,7 @@ impl BaseSrcImplExt for T { Err(_) => { gst::error!( gst::CAT_RUST, - obj: element.unsafe_cast_ref::(), + obj: instance, "Failed to map passed buffer writable" ); return Err(gst::FlowError::Error); @@ -443,7 +440,7 @@ impl BaseSrcImplExt for T { Err(_) => { gst::error!( gst::CAT_RUST, - obj: element.unsafe_cast_ref::(), + obj: instance, "Failed to copy buffer metadata" ); @@ -463,7 +460,7 @@ impl BaseSrcImplExt for T { } } - fn parent_do_seek(&self, element: &Self::Type, segment: &mut gst::Segment) -> bool { + fn parent_do_seek(&self, segment: &mut gst::Segment) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; @@ -471,7 +468,10 @@ impl BaseSrcImplExt for T { .do_seek .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, segment.to_glib_none_mut().0, )) }) @@ -479,7 +479,7 @@ impl BaseSrcImplExt for T { } } - fn parent_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; @@ -487,7 +487,10 @@ impl BaseSrcImplExt for T { .query .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) }) @@ -495,7 +498,7 @@ impl BaseSrcImplExt for T { } } - fn parent_event(&self, element: &Self::Type, event: &gst::Event) -> bool { + fn parent_event(&self, event: &gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; @@ -503,7 +506,10 @@ impl BaseSrcImplExt for T { .event .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.to_glib_none().0, )) }) @@ -511,7 +517,7 @@ impl BaseSrcImplExt for T { } } - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> Option { + fn parent_caps(&self, filter: Option<&gst::Caps>) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; @@ -520,7 +526,10 @@ impl BaseSrcImplExt for T { .get_caps .map(|f| { from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, filter.to_glib_none().0, )) }) @@ -528,7 +537,7 @@ impl BaseSrcImplExt for T { } } - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { + fn parent_negotiate(&self) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; @@ -536,7 +545,11 @@ impl BaseSrcImplExt for T { .negotiate .map(|f| { gst::result_from_gboolean!( - f(element.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Parent function `negotiate` failed" ) @@ -545,11 +558,7 @@ impl BaseSrcImplExt for T { } } - fn parent_set_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; @@ -558,7 +567,10 @@ impl BaseSrcImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.to_glib_none().0 ), gst::CAT_RUST, @@ -569,14 +581,17 @@ impl BaseSrcImplExt for T { } } - fn parent_fixate(&self, element: &Self::Type, caps: gst::Caps) -> gst::Caps { + fn parent_fixate(&self, caps: gst::Caps) -> gst::Caps { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; match (*parent_class).fixate { Some(fixate) => from_glib_full(fixate( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.into_glib_ptr(), )), None => caps, @@ -584,14 +599,19 @@ impl BaseSrcImplExt for T { } } - fn parent_unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_unlock(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; (*parent_class) .unlock .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -604,14 +624,19 @@ impl BaseSrcImplExt for T { } } - fn parent_unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_unlock_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseSrcClass; (*parent_class) .unlock_stop .map(|f| { - if from_glib(f(element.unsafe_cast_ref::().to_glib_none().0)) { + if from_glib(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + { Ok(()) } else { Err(gst::error_msg!( @@ -626,7 +651,6 @@ impl BaseSrcImplExt for T { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -637,7 +661,10 @@ impl BaseSrcImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -685,13 +712,12 @@ unsafe extern "C" fn base_src_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -704,13 +730,12 @@ unsafe extern "C" fn base_src_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -723,12 +748,8 @@ unsafe extern "C" fn base_src_is_seekable( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.is_seekable(wrap.unsafe_cast_ref()) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.is_seekable() }).into_glib() } unsafe extern "C" fn base_src_get_size( @@ -737,10 +758,9 @@ unsafe extern "C" fn base_src_get_size( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.size(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.size() { Some(s) => { *size = s; true @@ -759,14 +779,13 @@ unsafe extern "C" fn base_src_get_times( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let buffer = gst::BufferRef::from_ptr(buffer); *start = gst::ffi::GST_CLOCK_TIME_NONE; *stop = gst::ffi::GST_CLOCK_TIME_NONE; - gst::panic_to_error!(&wrap, imp.panicked(), (), { - let (start_, stop_) = imp.times(wrap.unsafe_cast_ref(), buffer); + gst::panic_to_error!(imp, (), { + let (start_, stop_) = imp.times(buffer); *start = start_.into_glib(); *stop = stop_.into_glib(); }); @@ -780,12 +799,10 @@ unsafe extern "C" fn base_src_fill( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let buffer = gst::BufferRef::from_mut_ptr(buffer); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.fill(wrap.unsafe_cast_ref(), offset, length, buffer) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.fill(offset, length, buffer).into() }) .into_glib() } @@ -798,13 +815,12 @@ unsafe extern "C" fn base_src_alloc( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // FIXME: Wrong signature in -sys bindings // https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3 let buffer_ptr = buffer_ptr as *mut *mut gst::ffi::GstBuffer; - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.alloc(wrap.unsafe_cast_ref(), offset, length) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.alloc(offset, length) { Ok(buffer) => { *buffer_ptr = buffer.into_glib_ptr(); gst::FlowReturn::Ok @@ -824,7 +840,8 @@ unsafe extern "C" fn base_src_create( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); + let instance = imp.instance(); + let instance = instance.unsafe_cast_ref::(); // FIXME: Wrong signature in -sys bindings // https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3 let buffer_ptr = buffer_ptr as *mut *mut gst::ffi::GstBuffer; @@ -840,23 +857,18 @@ unsafe extern "C" fn base_src_create( .unwrap(); // If there is a pending buffer list at this point then unset it. - if wrap.type_() == T::Type::static_type() { + if instance.type_() == T::Type::static_type() { *instance_data.pending_buffer_list.borrow_mut() = None; } - let res = gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.create( - wrap.unsafe_cast_ref(), - offset, - buffer.as_deref_mut(), - length, - ) { + let res = gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.create(offset, buffer.as_deref_mut(), length) { Ok(CreateSuccess::NewBuffer(new_buffer)) => { if let Some(passed_buffer) = buffer { if passed_buffer.as_ptr() != new_buffer.as_ptr() { gst::debug!( gst::CAT_PERFORMANCE, - obj: &*wrap, + obj: instance, "Returned new buffer from create function, copying into passed buffer" ); @@ -865,7 +877,7 @@ unsafe extern "C" fn base_src_create( Err(_) => { gst::error!( gst::CAT_RUST, - obj: &*wrap, + obj: instance, "Failed to map passed buffer writable" ); return gst::FlowReturn::Error; @@ -889,7 +901,7 @@ unsafe extern "C" fn base_src_create( Err(_) => { gst::error!( gst::CAT_RUST, - obj: &*wrap, + obj: instance, "Failed to copy buffer metadata" ); @@ -905,9 +917,7 @@ unsafe extern "C" fn base_src_create( } } Ok(CreateSuccess::NewBufferList(new_buffer_list)) => { - if buffer.is_some() - || wrap.unsafe_cast_ref::().src_pad().mode() == gst::PadMode::Pull - { + if buffer.is_some() || instance.src_pad().mode() == gst::PadMode::Pull { panic!("Buffer lists can only be returned in push mode"); } @@ -916,9 +926,9 @@ unsafe extern "C" fn base_src_create( // If this is the final type then submit the buffer list. This can only be done // once so can only really be done here. // FIXME: This won't work if a non-Rust subclass of a Rust subclass is created. - if wrap.type_() == T::Type::static_type() { + if instance.type_() == T::Type::static_type() { ffi::gst_base_src_submit_buffer_list( - wrap.to_glib_none().0, + instance.to_glib_none().0, new_buffer_list.into_glib_ptr(), ); } else { @@ -934,7 +944,7 @@ unsafe extern "C" fn base_src_create( .into_glib(); // If there is a pending buffer list at this point then unset it. - if wrap.type_() == T::Type::static_type() { + if instance.type_() == T::Type::static_type() { *instance_data.pending_buffer_list.borrow_mut() = None; } @@ -947,11 +957,10 @@ unsafe extern "C" fn base_src_do_seek( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { let mut s = from_glib_none(segment); - let res = imp.do_seek(wrap.unsafe_cast_ref(), &mut s); + let res = imp.do_seek(&mut s); ptr::write(segment, *(s.to_glib_none().0)); res @@ -965,13 +974,9 @@ unsafe extern "C" fn base_src_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = gst::QueryRef::from_mut_ptr(query_ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - BaseSrcImpl::query(imp, wrap.unsafe_cast_ref(), query) - }) - .into_glib() + gst::panic_to_error!(imp, false, { BaseSrcImpl::query(imp, query) }).into_glib() } unsafe extern "C" fn base_src_event( @@ -980,12 +985,8 @@ unsafe extern "C" fn base_src_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.event(wrap.unsafe_cast_ref(), &from_glib_borrow(event_ptr)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.event(&from_glib_borrow(event_ptr)) }).into_glib() } unsafe extern "C" fn base_src_get_caps( @@ -994,14 +995,11 @@ unsafe extern "C" fn base_src_get_caps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let filter = Option::::from_glib_borrow(filter); - gst::panic_to_error!(&wrap, imp.panicked(), None, { - imp.caps(wrap.unsafe_cast_ref(), filter.as_ref().as_ref()) - }) - .map(|caps| caps.into_glib_ptr()) - .unwrap_or(ptr::null_mut()) + gst::panic_to_error!(imp, None, { imp.caps(filter.as_ref().as_ref()) }) + .map(|caps| caps.into_glib_ptr()) + .unwrap_or(ptr::null_mut()) } unsafe extern "C" fn base_src_negotiate( @@ -1009,13 +1007,12 @@ unsafe extern "C" fn base_src_negotiate( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.negotiate(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.negotiate() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1029,14 +1026,13 @@ unsafe extern "C" fn base_src_set_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let caps = from_glib_borrow(caps); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_caps(wrap.unsafe_cast_ref(), &caps) { + gst::panic_to_error!(imp, false, { + match imp.set_caps(&caps) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1050,13 +1046,9 @@ unsafe extern "C" fn base_src_fixate( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let caps = from_glib_full(caps); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { - imp.fixate(wrap.unsafe_cast_ref(), caps) - }) - .into_glib_ptr() + gst::panic_to_error!(imp, gst::Caps::new_empty(), { imp.fixate(caps) }).into_glib_ptr() } unsafe extern "C" fn base_src_unlock( @@ -1064,13 +1056,12 @@ unsafe extern "C" fn base_src_unlock( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.unlock(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.unlock() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -1083,13 +1074,12 @@ unsafe extern "C" fn base_src_unlock_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.unlock_stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.unlock_stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -1103,17 +1093,16 @@ unsafe extern "C" fn base_src_decide_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.decide_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer-base/src/subclass/base_transform.rs b/gstreamer-base/src/subclass/base_transform.rs index bcbf9631b..124b7565a 100644 --- a/gstreamer-base/src/subclass/base_transform.rs +++ b/gstreamer-base/src/subclass/base_transform.rs @@ -23,182 +23,148 @@ pub trait BaseTransformImpl: BaseTransformImplExt + ElementImpl { const PASSTHROUGH_ON_SAME_CAPS: bool; const TRANSFORM_IP_ON_PASSTHROUGH: bool; - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(element) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(element) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } fn transform_caps( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, filter: Option<&gst::Caps>, ) -> Option { - self.parent_transform_caps(element, direction, caps, filter) + self.parent_transform_caps(direction, caps, filter) } fn fixate_caps( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, othercaps: gst::Caps, ) -> gst::Caps { - self.parent_fixate_caps(element, direction, caps, othercaps) + self.parent_fixate_caps(direction, caps, othercaps) } - fn set_caps( - &self, - element: &Self::Type, - incaps: &gst::Caps, - outcaps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { - self.parent_set_caps(element, incaps, outcaps) + fn set_caps(&self, incaps: &gst::Caps, outcaps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_set_caps(incaps, outcaps) } - fn accept_caps( - &self, - element: &Self::Type, - direction: gst::PadDirection, - caps: &gst::Caps, - ) -> bool { - self.parent_accept_caps(element, direction, caps) + fn accept_caps(&self, direction: gst::PadDirection, caps: &gst::Caps) -> bool { + self.parent_accept_caps(direction, caps) } - fn query( - &self, - element: &Self::Type, - direction: gst::PadDirection, - query: &mut gst::QueryRef, - ) -> bool { - BaseTransformImplExt::parent_query(self, element, direction, query) + fn query(&self, direction: gst::PadDirection, query: &mut gst::QueryRef) -> bool { + BaseTransformImplExt::parent_query(self, direction, query) } fn transform_size( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, size: usize, othercaps: &gst::Caps, ) -> Option { - self.parent_transform_size(element, direction, caps, size, othercaps) + self.parent_transform_size(direction, caps, size, othercaps) } - fn unit_size(&self, element: &Self::Type, caps: &gst::Caps) -> Option { - self.parent_unit_size(element, caps) + fn unit_size(&self, caps: &gst::Caps) -> Option { + self.parent_unit_size(caps) } - fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_sink_event(element, event) + fn sink_event(&self, event: gst::Event) -> bool { + self.parent_sink_event(event) } - fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_src_event(element, event) + fn src_event(&self, event: gst::Event) -> bool { + self.parent_src_event(event) } fn prepare_output_buffer( &self, - element: &Self::Type, inbuf: InputBuffer, ) -> Result { - self.parent_prepare_output_buffer(element, inbuf) + self.parent_prepare_output_buffer(inbuf) } fn transform( &self, - element: &Self::Type, inbuf: &gst::Buffer, outbuf: &mut gst::BufferRef, ) -> Result { - self.parent_transform(element, inbuf, outbuf) + self.parent_transform(inbuf, outbuf) } - fn transform_ip( - &self, - element: &Self::Type, - buf: &mut gst::BufferRef, - ) -> Result { - self.parent_transform_ip(element, buf) + fn transform_ip(&self, buf: &mut gst::BufferRef) -> Result { + self.parent_transform_ip(buf) } fn transform_ip_passthrough( &self, - element: &Self::Type, buf: &gst::Buffer, ) -> Result { - self.parent_transform_ip_passthrough(element, buf) + self.parent_transform_ip_passthrough(buf) } fn propose_allocation( &self, - element: &Self::Type, decide_query: Option<&gst::query::Allocation>, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_propose_allocation(element, decide_query, query) + self.parent_propose_allocation(decide_query, query) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } fn copy_metadata( &self, - element: &Self::Type, inbuf: &gst::BufferRef, outbuf: &mut gst::BufferRef, ) -> Result<(), gst::LoggableError> { - self.parent_copy_metadata(element, inbuf, outbuf) + self.parent_copy_metadata(inbuf, outbuf) } fn transform_meta<'a>( &self, - element: &Self::Type, outbuf: &mut gst::BufferRef, meta: gst::MetaRef<'a, gst::Meta>, inbuf: &'a gst::BufferRef, ) -> bool { - self.parent_transform_meta(element, outbuf, meta, inbuf) + self.parent_transform_meta(outbuf, meta, inbuf) } - fn before_transform(&self, element: &Self::Type, inbuf: &gst::BufferRef) { - self.parent_before_transform(element, inbuf); + fn before_transform(&self, inbuf: &gst::BufferRef) { + self.parent_before_transform(inbuf); } fn submit_input_buffer( &self, - element: &Self::Type, is_discont: bool, inbuf: gst::Buffer, ) -> Result { - self.parent_submit_input_buffer(element, is_discont, inbuf) + self.parent_submit_input_buffer(is_discont, inbuf) } - fn generate_output( - &self, - element: &Self::Type, - ) -> Result { - self.parent_generate_output(element) + fn generate_output(&self) -> Result { + self.parent_generate_output() } } pub trait BaseTransformImplExt: ObjectSubclass { - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; fn parent_transform_caps( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, filter: Option<&gst::Caps>, @@ -206,7 +172,6 @@ pub trait BaseTransformImplExt: ObjectSubclass { fn parent_fixate_caps( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, othercaps: gst::Caps, @@ -214,106 +179,82 @@ pub trait BaseTransformImplExt: ObjectSubclass { fn parent_set_caps( &self, - element: &Self::Type, incaps: &gst::Caps, outcaps: &gst::Caps, ) -> Result<(), gst::LoggableError>; - fn parent_accept_caps( - &self, - element: &Self::Type, - direction: gst::PadDirection, - caps: &gst::Caps, - ) -> bool; + fn parent_accept_caps(&self, direction: gst::PadDirection, caps: &gst::Caps) -> bool; - fn parent_query( - &self, - element: &Self::Type, - direction: gst::PadDirection, - query: &mut gst::QueryRef, - ) -> bool; + fn parent_query(&self, direction: gst::PadDirection, query: &mut gst::QueryRef) -> bool; fn parent_transform_size( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, size: usize, othercaps: &gst::Caps, ) -> Option; - fn parent_unit_size(&self, element: &Self::Type, caps: &gst::Caps) -> Option; + fn parent_unit_size(&self, caps: &gst::Caps) -> Option; - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_sink_event(&self, event: gst::Event) -> bool; - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_src_event(&self, event: gst::Event) -> bool; fn parent_prepare_output_buffer( &self, - element: &Self::Type, inbuf: InputBuffer, ) -> Result; fn parent_transform( &self, - element: &Self::Type, inbuf: &gst::Buffer, outbuf: &mut gst::BufferRef, ) -> Result; fn parent_transform_ip( &self, - element: &Self::Type, buf: &mut gst::BufferRef, ) -> Result; fn parent_transform_ip_passthrough( &self, - element: &Self::Type, buf: &gst::Buffer, ) -> Result; fn parent_propose_allocation( &self, - element: &Self::Type, decide_query: Option<&gst::query::Allocation>, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; fn parent_copy_metadata( &self, - element: &Self::Type, inbuf: &gst::BufferRef, outbuf: &mut gst::BufferRef, ) -> Result<(), gst::LoggableError>; fn parent_transform_meta<'a>( &self, - element: &Self::Type, outbuf: &mut gst::BufferRef, meta: gst::MetaRef<'a, gst::Meta>, inbuf: &'a gst::BufferRef, ) -> bool; - fn parent_before_transform(&self, element: &Self::Type, inbuf: &gst::BufferRef); + fn parent_before_transform(&self, inbuf: &gst::BufferRef); fn parent_submit_input_buffer( &self, - element: &Self::Type, is_discont: bool, inbuf: gst::Buffer, ) -> Result; - fn parent_generate_output( - &self, - element: &Self::Type, - ) -> Result; + fn parent_generate_output(&self) -> Result; fn take_queued_buffer(&self) -> Option where @@ -328,14 +269,15 @@ pub trait BaseTransformImplExt: ObjectSubclass { } impl BaseTransformImplExt for T { - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; (*parent_class) .start .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -352,14 +294,15 @@ impl BaseTransformImplExt for T { } } - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; (*parent_class) .stop .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -378,7 +321,6 @@ impl BaseTransformImplExt for T { fn parent_transform_caps( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, filter: Option<&gst::Caps>, @@ -390,7 +332,10 @@ impl BaseTransformImplExt for T { .transform_caps .map(|f| { from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, direction.into_glib(), caps.to_glib_none().0, filter.to_glib_none().0, @@ -402,7 +347,6 @@ impl BaseTransformImplExt for T { fn parent_fixate_caps( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, othercaps: gst::Caps, @@ -412,7 +356,10 @@ impl BaseTransformImplExt for T { let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; match (*parent_class).fixate_caps { Some(f) => from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, direction.into_glib(), caps.to_glib_none().0, othercaps.into_glib_ptr(), @@ -424,7 +371,6 @@ impl BaseTransformImplExt for T { fn parent_set_caps( &self, - element: &Self::Type, incaps: &gst::Caps, outcaps: &gst::Caps, ) -> Result<(), gst::LoggableError> { @@ -436,7 +382,10 @@ impl BaseTransformImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, incaps.to_glib_none().0, outcaps.to_glib_none().0, ), @@ -448,12 +397,7 @@ impl BaseTransformImplExt for T { } } - fn parent_accept_caps( - &self, - element: &Self::Type, - direction: gst::PadDirection, - caps: &gst::Caps, - ) -> bool { + fn parent_accept_caps(&self, direction: gst::PadDirection, caps: &gst::Caps) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; @@ -461,7 +405,10 @@ impl BaseTransformImplExt for T { .accept_caps .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, direction.into_glib(), caps.to_glib_none().0, )) @@ -470,12 +417,7 @@ impl BaseTransformImplExt for T { } } - fn parent_query( - &self, - element: &Self::Type, - direction: gst::PadDirection, - query: &mut gst::QueryRef, - ) -> bool { + fn parent_query(&self, direction: gst::PadDirection, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; @@ -483,7 +425,10 @@ impl BaseTransformImplExt for T { .query .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, direction.into_glib(), query.as_mut_ptr(), )) @@ -494,7 +439,6 @@ impl BaseTransformImplExt for T { fn parent_transform_size( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, size: usize, @@ -508,7 +452,10 @@ impl BaseTransformImplExt for T { .map(|f| { let mut othersize = mem::MaybeUninit::uninit(); let res: bool = from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, direction.into_glib(), caps.to_glib_none().0, size, @@ -525,27 +472,33 @@ impl BaseTransformImplExt for T { } } - fn parent_unit_size(&self, element: &Self::Type, caps: &gst::Caps) -> Option { + fn parent_unit_size(&self, caps: &gst::Caps) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; let f = (*parent_class).get_unit_size.unwrap_or_else(|| { - if !element.unsafe_cast_ref::().is_in_place() { + if !self + .instance() + .unsafe_cast_ref::() + .is_in_place() + { unimplemented!(concat!( "Missing parent function `get_unit_size`. Required because ", - "transform element doesn't operate in-place" + "transform doesn't operate in-place" )) } else { unreachable!(concat!( - "parent `get_unit_size` called ", - "while transform element operates in-place" + "parent `get_unit_size` called while transform operates in-place" )) } }); let mut size = mem::MaybeUninit::uninit(); if from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.to_glib_none().0, size.as_mut_ptr(), )) { @@ -556,7 +509,7 @@ impl BaseTransformImplExt for T { } } - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_sink_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; @@ -564,7 +517,10 @@ impl BaseTransformImplExt for T { .sink_event .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) }) @@ -572,7 +528,7 @@ impl BaseTransformImplExt for T { } } - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_src_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; @@ -580,7 +536,10 @@ impl BaseTransformImplExt for T { .src_event .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) }) @@ -590,7 +549,6 @@ impl BaseTransformImplExt for T { fn parent_prepare_output_buffer( &self, - element: &Self::Type, inbuf: InputBuffer, ) -> Result { unsafe { @@ -606,7 +564,10 @@ impl BaseTransformImplExt for T { let mut outbuf: *mut gst::ffi::GstBuffer = ptr::null_mut(); // FIXME: Wrong signature in FFI gst::FlowSuccess::try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buf as *mut gst::ffi::GstBuffer, (&mut outbuf) as *mut *mut gst::ffi::GstBuffer as *mut gst::ffi::GstBuffer, )) @@ -624,7 +585,6 @@ impl BaseTransformImplExt for T { fn parent_transform( &self, - element: &Self::Type, inbuf: &gst::Buffer, outbuf: &mut gst::BufferRef, ) -> Result { @@ -635,18 +595,24 @@ impl BaseTransformImplExt for T { .transform .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, inbuf.to_glib_none().0, outbuf.as_mut_ptr(), )) }) .unwrap_or_else(|| { - if !element.unsafe_cast_ref::().is_in_place() { + if !self + .instance() + .unsafe_cast_ref::() + .is_in_place() + { Err(gst::FlowError::NotSupported) } else { unreachable!(concat!( - "parent `transform` called ", - "while transform element operates in-place" + "parent `transform` called while transform operates in-place" )); } }) @@ -655,28 +621,33 @@ impl BaseTransformImplExt for T { fn parent_transform_ip( &self, - element: &Self::Type, buf: &mut gst::BufferRef, ) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; let f = (*parent_class).transform_ip.unwrap_or_else(|| { - if element.unsafe_cast_ref::().is_in_place() { + if self + .instance() + .unsafe_cast_ref::() + .is_in_place() + { panic!(concat!( "Missing parent function `transform_ip`. Required because ", - "transform element operates in-place" + "transform operates in-place" )); } else { unreachable!(concat!( - "parent `transform` called ", - "while transform element doesn't operate in-place" + "parent `transform` called while transform doesn't operate in-place" )); } }); try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buf.as_mut_ptr() as *mut _, )) } @@ -684,22 +655,25 @@ impl BaseTransformImplExt for T { fn parent_transform_ip_passthrough( &self, - element: &Self::Type, buf: &gst::Buffer, ) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; let f = (*parent_class).transform_ip.unwrap_or_else(|| { - if element.unsafe_cast_ref::().is_in_place() { + if self + .instance() + .unsafe_cast_ref::() + .is_in_place() + { panic!(concat!( "Missing parent function `transform_ip`. Required because ", - "transform element operates in-place (passthrough mode)" + "transform operates in-place (passthrough mode)" )); } else { unreachable!(concat!( "parent `transform_ip` called ", - "while transform element doesn't operate in-place (passthrough mode)" + "while transform doesn't operate in-place (passthrough mode)" )); } }); @@ -707,7 +681,10 @@ impl BaseTransformImplExt for T { // FIXME: Wrong signature in FFI let buf: *mut gst::ffi::GstBuffer = buf.to_glib_none().0; try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buf as *mut _, )) } @@ -715,7 +692,6 @@ impl BaseTransformImplExt for T { fn parent_propose_allocation( &self, - element: &Self::Type, decide_query: Option<&gst::query::Allocation>, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { @@ -727,7 +703,10 @@ impl BaseTransformImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, decide_query .as_ref() .map(|q| q.as_mut_ptr()) @@ -744,7 +723,6 @@ impl BaseTransformImplExt for T { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -755,7 +733,10 @@ impl BaseTransformImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -768,7 +749,6 @@ impl BaseTransformImplExt for T { fn parent_copy_metadata( &self, - element: &Self::Type, inbuf: &gst::BufferRef, outbuf: &mut gst::BufferRef, ) -> Result<(), gst::LoggableError> { @@ -778,7 +758,10 @@ impl BaseTransformImplExt for T { if let Some(ref f) = (*parent_class).copy_metadata { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, inbuf.as_ptr() as *mut _, outbuf.as_mut_ptr() ), @@ -793,7 +776,6 @@ impl BaseTransformImplExt for T { fn parent_transform_meta<'a>( &self, - element: &Self::Type, outbuf: &mut gst::BufferRef, meta: gst::MetaRef<'a, gst::Meta>, inbuf: &'a gst::BufferRef, @@ -805,7 +787,10 @@ impl BaseTransformImplExt for T { .transform_meta .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, outbuf.as_mut_ptr(), meta.as_ptr() as *mut _, inbuf.as_ptr() as *mut _, @@ -815,13 +800,16 @@ impl BaseTransformImplExt for T { } } - fn parent_before_transform(&self, element: &Self::Type, inbuf: &gst::BufferRef) { + fn parent_before_transform(&self, inbuf: &gst::BufferRef) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; if let Some(ref f) = (*parent_class).before_transform { f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, inbuf.as_ptr() as *mut _, ); } @@ -830,7 +818,6 @@ impl BaseTransformImplExt for T { fn parent_submit_input_buffer( &self, - element: &Self::Type, is_discont: bool, inbuf: gst::Buffer, ) -> Result { @@ -842,17 +829,17 @@ impl BaseTransformImplExt for T { .expect("Missing parent function `submit_input_buffer`"); try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, is_discont.into_glib(), inbuf.into_glib_ptr(), )) } } - fn parent_generate_output( - &self, - element: &Self::Type, - ) -> Result { + fn parent_generate_output(&self) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseTransformClass; @@ -862,7 +849,10 @@ impl BaseTransformImplExt for T { let mut outbuf = ptr::null_mut(); gst::FlowSuccess::try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, &mut outbuf, )) .map(|res| { @@ -883,9 +873,9 @@ impl BaseTransformImplExt for T { ::ParentType: IsA, { unsafe { - let element = self.instance(); + let instance = self.instance(); let ptr: *mut ffi::GstBaseTransform = - element.unsafe_cast_ref::().to_glib_none().0; + instance.unsafe_cast_ref::().to_glib_none().0; let sinkpad: Borrowed = from_glib_borrow((*ptr).sinkpad); let _stream_lock = sinkpad.stream_lock(); let buffer = (*ptr).queued_buf; @@ -900,9 +890,9 @@ impl BaseTransformImplExt for T { ::ParentType: IsA, { unsafe { - let element = self.instance(); + let instance = self.instance(); let ptr: *mut ffi::GstBaseTransform = - element.unsafe_cast_ref::().to_glib_none().0; + instance.unsafe_cast_ref::().to_glib_none().0; let sinkpad: Borrowed = from_glib_borrow((*ptr).sinkpad); let _stream_lock = sinkpad.stream_lock(); let buffer = (*ptr).queued_buf; @@ -979,13 +969,12 @@ unsafe extern "C" fn base_transform_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -998,13 +987,12 @@ unsafe extern "C" fn base_transform_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -1020,13 +1008,11 @@ unsafe extern "C" fn base_transform_transform_caps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), None, { + gst::panic_to_error!(imp, None, { let filter: Borrowed> = from_glib_borrow(filter); imp.transform_caps( - wrap.unsafe_cast_ref(), from_glib(direction), &from_glib_borrow(caps), filter.as_ref().as_ref(), @@ -1044,11 +1030,9 @@ unsafe extern "C" fn base_transform_fixate_caps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { + gst::panic_to_error!(imp, gst::Caps::new_empty(), { imp.fixate_caps( - wrap.unsafe_cast_ref(), from_glib(direction), &from_glib_borrow(caps), from_glib_full(othercaps), @@ -1064,17 +1048,12 @@ unsafe extern "C" fn base_transform_set_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_caps( - wrap.unsafe_cast_ref(), - &from_glib_borrow(incaps), - &from_glib_borrow(outcaps), - ) { + gst::panic_to_error!(imp, false, { + match imp.set_caps(&from_glib_borrow(incaps), &from_glib_borrow(outcaps)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1089,14 +1068,9 @@ unsafe extern "C" fn base_transform_accept_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.accept_caps( - wrap.unsafe_cast_ref(), - from_glib(direction), - &from_glib_borrow(caps), - ) + gst::panic_to_error!(imp, false, { + imp.accept_caps(from_glib(direction), &from_glib_borrow(caps)) }) .into_glib() } @@ -1108,12 +1082,10 @@ unsafe extern "C" fn base_transform_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { BaseTransformImpl::query( imp, - wrap.unsafe_cast_ref(), from_glib(direction), gst::QueryRef::from_mut_ptr(query), ) @@ -1131,11 +1103,9 @@ unsafe extern "C" fn base_transform_transform_size( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { match imp.transform_size( - wrap.unsafe_cast_ref(), from_glib(direction), &from_glib_borrow(caps), size, @@ -1158,10 +1128,9 @@ unsafe extern "C" fn base_transform_get_unit_size( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.unit_size(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) { + gst::panic_to_error!(imp, false, { + match imp.unit_size(&from_glib_borrow(caps)) { Some(s) => { *size = s; true @@ -1179,7 +1148,6 @@ unsafe extern "C" fn base_transform_prepare_output_buffer( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // FIXME: Wrong signature in FFI let outbuf = outbuf as *mut *mut gst::ffi::GstBuffer; @@ -1193,8 +1161,8 @@ unsafe extern "C" fn base_transform_prepare_output_buffer( true => InputBuffer::Writable(gst::BufferRef::from_mut_ptr(inbuf)), }; - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.prepare_output_buffer(wrap.unsafe_cast_ref(), buffer) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.prepare_output_buffer(buffer) { Ok(PrepareOutputBufferSuccess::InputBuffer) => { assert!( is_passthrough || is_in_place, @@ -1223,12 +1191,8 @@ unsafe extern "C" fn base_transform_sink_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.sink_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn base_transform_src_event( @@ -1237,12 +1201,8 @@ unsafe extern "C" fn base_transform_src_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.src_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn base_transform_transform( @@ -1252,11 +1212,9 @@ unsafe extern "C" fn base_transform_transform( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { imp.transform( - wrap.unsafe_cast_ref(), &from_glib_borrow(inbuf), gst::BufferRef::from_mut_ptr(outbuf), ) @@ -1271,18 +1229,15 @@ unsafe extern "C" fn base_transform_transform_ip( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // FIXME: Wrong signature in FFI let buf = buf as *mut gst::ffi::GstBuffer; - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { if from_glib(ffi::gst_base_transform_is_passthrough(ptr)) { - imp.transform_ip_passthrough(wrap.unsafe_cast_ref(), &from_glib_borrow(buf)) - .into() + imp.transform_ip_passthrough(&from_glib_borrow(buf)).into() } else { - imp.transform_ip(wrap.unsafe_cast_ref(), gst::BufferRef::from_mut_ptr(buf)) - .into() + imp.transform_ip(gst::BufferRef::from_mut_ptr(buf)).into() } }) .into_glib() @@ -1296,13 +1251,11 @@ unsafe extern "C" fn base_transform_transform_meta( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let inbuf = gst::BufferRef::from_ptr(inbuf); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { imp.transform_meta( - wrap.unsafe_cast_ref(), gst::BufferRef::from_mut_ptr(outbuf), gst::Meta::from_ptr(inbuf, meta), inbuf, @@ -1318,7 +1271,6 @@ unsafe extern "C" fn base_transform_propose_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let decide_query = if decide_query.is_null() { None } else { @@ -1332,11 +1284,11 @@ unsafe extern "C" fn base_transform_propose_allocation( _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.propose_allocation(wrap.unsafe_cast_ref(), decide_query, query) { + gst::panic_to_error!(imp, false, { + match imp.propose_allocation(decide_query, query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1350,17 +1302,16 @@ unsafe extern "C" fn base_transform_decide_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.decide_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1375,27 +1326,25 @@ unsafe extern "C" fn base_transform_copy_metadata( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); if gst::ffi::gst_mini_object_is_writable(outbuf as *mut _) == glib::ffi::GFALSE { gst::warning!( gst::CAT_RUST, - obj: &*wrap, + obj: imp.instance().unsafe_cast_ref::(), "buffer {:?} not writable", outbuf ); return glib::ffi::GFALSE; } - gst::panic_to_error!(&wrap, imp.panicked(), true, { + gst::panic_to_error!(imp, true, { match imp.copy_metadata( - wrap.unsafe_cast_ref(), gst::BufferRef::from_ptr(inbuf), gst::BufferRef::from_mut_ptr(outbuf), ) { Ok(_) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -1409,10 +1358,9 @@ unsafe extern "C" fn base_transform_before_transform( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), (), { - imp.before_transform(wrap.unsafe_cast_ref(), gst::BufferRef::from_ptr(inbuf)); + gst::panic_to_error!(imp, (), { + imp.before_transform(gst::BufferRef::from_ptr(inbuf)); }) } @@ -1423,15 +1371,10 @@ unsafe extern "C" fn base_transform_submit_input_buffer( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.submit_input_buffer( - wrap.unsafe_cast_ref(), - from_glib(is_discont), - from_glib_full(buf), - ) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.submit_input_buffer(from_glib(is_discont), from_glib_full(buf)) + .into() }) .into_glib() } @@ -1442,12 +1385,11 @@ unsafe extern "C" fn base_transform_generate_output( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); *buf = ptr::null_mut(); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.generate_output(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.generate_output() { Ok(GenerateOutputSuccess::Dropped) => crate::BASE_TRANSFORM_FLOW_DROPPED.into(), Ok(GenerateOutputSuccess::NoOutput) => gst::FlowReturn::Ok, Ok(GenerateOutputSuccess::Buffer(outbuf)) => { diff --git a/gstreamer-base/src/subclass/push_src.rs b/gstreamer-base/src/subclass/push_src.rs index 7064b7f4c..96a721f83 100644 --- a/gstreamer-base/src/subclass/push_src.rs +++ b/gstreamer-base/src/subclass/push_src.rs @@ -12,49 +12,32 @@ use crate::prelude::BaseSrcExtManual; use crate::PushSrc; pub trait PushSrcImpl: PushSrcImplExt + BaseSrcImpl { - fn fill( - &self, - element: &Self::Type, - buffer: &mut gst::BufferRef, - ) -> Result { - PushSrcImplExt::parent_fill(self, element, buffer) + fn fill(&self, buffer: &mut gst::BufferRef) -> Result { + PushSrcImplExt::parent_fill(self, buffer) } - fn alloc(&self, element: &Self::Type) -> Result { - PushSrcImplExt::parent_alloc(self, element) + fn alloc(&self) -> Result { + PushSrcImplExt::parent_alloc(self) } - fn create( - &self, - element: &Self::Type, - buffer: Option<&mut gst::BufferRef>, - ) -> Result { - PushSrcImplExt::parent_create(self, element, buffer) + fn create(&self, buffer: Option<&mut gst::BufferRef>) -> Result { + PushSrcImplExt::parent_create(self, buffer) } } pub trait PushSrcImplExt: ObjectSubclass { - fn parent_fill( - &self, - element: &Self::Type, - buffer: &mut gst::BufferRef, - ) -> Result; + fn parent_fill(&self, buffer: &mut gst::BufferRef) -> Result; - fn parent_alloc(&self, element: &Self::Type) -> Result; + fn parent_alloc(&self) -> Result; fn parent_create( &self, - element: &Self::Type, buffer: Option<&mut gst::BufferRef>, ) -> Result; } impl PushSrcImplExt for T { - fn parent_fill( - &self, - element: &Self::Type, - buffer: &mut gst::BufferRef, - ) -> Result { + fn parent_fill(&self, buffer: &mut gst::BufferRef) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstPushSrcClass; @@ -62,7 +45,10 @@ impl PushSrcImplExt for T { .fill .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer.as_mut_ptr(), )) }) @@ -70,7 +56,7 @@ impl PushSrcImplExt for T { } } - fn parent_alloc(&self, element: &Self::Type) -> Result { + fn parent_alloc(&self) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstPushSrcClass; @@ -84,7 +70,10 @@ impl PushSrcImplExt for T { let buffer_ref = &mut buffer_ptr as *mut _ as *mut gst::ffi::GstBuffer; gst::FlowSuccess::try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer_ref, )) .map(|_| from_glib_full(buffer_ref)) @@ -95,7 +84,6 @@ impl PushSrcImplExt for T { fn parent_create( &self, - element: &Self::Type, mut buffer: Option<&mut gst::BufferRef>, ) -> Result { unsafe { @@ -104,6 +92,8 @@ impl PushSrcImplExt for T { (*parent_class) .create .map(|f| { + let instance = self.instance(); + let instance = instance.unsafe_cast_ref::(); let orig_buffer_ptr = buffer .as_mut() .map(|b| b.as_mut_ptr()) @@ -117,7 +107,7 @@ impl PushSrcImplExt for T { if let Err(err) = gst::FlowSuccess::try_from_glib( f( - element.unsafe_cast_ref::().to_glib_none().0, + instance.to_glib_none().0, buffer_ref, ) ) { @@ -127,7 +117,7 @@ impl PushSrcImplExt for T { let pending_buffer_list = instance_data.pending_buffer_list.borrow_mut().take(); if pending_buffer_list.is_some() && - (buffer.is_some() || element.unsafe_cast_ref::().src_pad().mode() == gst::PadMode::Pull) { + (buffer.is_some() || instance.src_pad().mode() == gst::PadMode::Pull) { panic!("Buffer lists can only be returned in push mode"); } @@ -135,7 +125,7 @@ impl PushSrcImplExt for T { if buffer_ptr.is_null() && pending_buffer_list.is_none() { gst::error!( gst::CAT_RUST, - obj: element.unsafe_cast_ref::(), + obj: instance, "No buffer and no buffer list returned" ); return Err(gst::FlowError::Error); @@ -144,7 +134,7 @@ impl PushSrcImplExt for T { if !buffer_ptr.is_null() && pending_buffer_list.is_some() { gst::error!( gst::CAT_RUST, - obj: element.unsafe_cast_ref::(), + obj: instance, "Both buffer and buffer list returned" ); return Err(gst::FlowError::Error); @@ -156,7 +146,7 @@ impl PushSrcImplExt for T { gst::debug!( gst::CAT_PERFORMANCE, - obj: element.unsafe_cast_ref::(), + obj: instance, "Returned new buffer from parent create function, copying into passed buffer" ); @@ -165,7 +155,7 @@ impl PushSrcImplExt for T { Err(_) => { gst::error!( gst::CAT_RUST, - obj: element.unsafe_cast_ref::(), + obj: instance, "Failed to map passed buffer writable" ); return Err(gst::FlowError::Error); @@ -184,7 +174,7 @@ impl PushSrcImplExt for T { Err(_) => { gst::error!( gst::CAT_RUST, - obj: element.unsafe_cast_ref::(), + obj: instance, "Failed to copy buffer metadata" ); @@ -221,11 +211,10 @@ unsafe extern "C" fn push_src_fill( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let buffer = gst::BufferRef::from_mut_ptr(buffer); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - PushSrcImpl::fill(imp, wrap.unsafe_cast_ref(), buffer).into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + PushSrcImpl::fill(imp, buffer).into() }) .into_glib() } @@ -236,13 +225,12 @@ unsafe extern "C" fn push_src_alloc( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // FIXME: Wrong signature in -sys bindings // https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3 let buffer_ptr = buffer_ptr as *mut *mut gst::ffi::GstBuffer; - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match PushSrcImpl::alloc(imp, wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match PushSrcImpl::alloc(imp) { Ok(buffer) => { *buffer_ptr = buffer.into_glib_ptr(); gst::FlowReturn::Ok @@ -260,7 +248,6 @@ unsafe extern "C" fn push_src_create( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // FIXME: Wrong signature in -sys bindings // https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3 let buffer_ptr = buffer_ptr as *mut *mut gst::ffi::GstBuffer; @@ -275,8 +262,8 @@ unsafe extern "C" fn push_src_create( .instance_data::(crate::BaseSrc::static_type()) .unwrap(); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match PushSrcImpl::create(imp, wrap.unsafe_cast_ref(), buffer.as_deref_mut()) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match PushSrcImpl::create(imp, buffer.as_deref_mut()) { Ok(CreateSuccess::NewBuffer(new_buffer)) => { // Clear any pending buffer list *instance_data.pending_buffer_list.borrow_mut() = None; @@ -285,7 +272,7 @@ unsafe extern "C" fn push_src_create( if passed_buffer.as_ptr() != new_buffer.as_ptr() { gst::debug!( gst::CAT_PERFORMANCE, - obj: &*wrap, + imp: imp, "Returned new buffer from create function, copying into passed buffer" ); @@ -294,7 +281,7 @@ unsafe extern "C" fn push_src_create( Err(_) => { gst::error!( gst::CAT_RUST, - obj: &*wrap, + imp: imp, "Failed to map passed buffer writable" ); return gst::FlowReturn::Error; @@ -318,7 +305,7 @@ unsafe extern "C" fn push_src_create( Err(_) => { gst::error!( gst::CAT_RUST, - obj: &*wrap, + imp: imp, "Failed to copy buffer metadata" ); @@ -335,7 +322,8 @@ unsafe extern "C" fn push_src_create( } Ok(CreateSuccess::NewBufferList(new_buffer_list)) => { if buffer.is_some() - || wrap.unsafe_cast_ref::().src_pad().mode() == gst::PadMode::Pull + || imp.instance().unsafe_cast_ref::().src_pad().mode() + == gst::PadMode::Pull { panic!("Buffer lists can only be returned in push mode"); } diff --git a/gstreamer-gl/src/subclass/gl_base_filter.rs b/gstreamer-gl/src/subclass/gl_base_filter.rs index 4e0207a6d..73c2a4c23 100644 --- a/gstreamer-gl/src/subclass/gl_base_filter.rs +++ b/gstreamer-gl/src/subclass/gl_base_filter.rs @@ -11,44 +11,29 @@ use gst_base::subclass::prelude::*; use crate::GLBaseFilter; pub trait GLBaseFilterImpl: GLBaseFilterImplExt + BaseTransformImpl { - fn gl_set_caps( - &self, - filter: &Self::Type, - incaps: &Caps, - outcaps: &Caps, - ) -> Result<(), LoggableError> { - self.parent_gl_set_caps(filter, incaps, outcaps) + fn gl_set_caps(&self, incaps: &Caps, outcaps: &Caps) -> Result<(), LoggableError> { + self.parent_gl_set_caps(incaps, outcaps) } - fn gl_start(&self, filter: &Self::Type) -> Result<(), LoggableError> { - self.parent_gl_start(filter) + fn gl_start(&self) -> Result<(), LoggableError> { + self.parent_gl_start() } - fn gl_stop(&self, filter: &Self::Type) { - self.parent_gl_stop(filter) + fn gl_stop(&self) { + self.parent_gl_stop() } } pub trait GLBaseFilterImplExt: ObjectSubclass { - fn parent_gl_set_caps( - &self, - filter: &Self::Type, - incaps: &Caps, - outcaps: &Caps, - ) -> Result<(), LoggableError>; + fn parent_gl_set_caps(&self, incaps: &Caps, outcaps: &Caps) -> Result<(), LoggableError>; - fn parent_gl_start(&self, filter: &Self::Type) -> Result<(), LoggableError>; + fn parent_gl_start(&self) -> Result<(), LoggableError>; - fn parent_gl_stop(&self, filter: &Self::Type); + fn parent_gl_stop(&self); } impl GLBaseFilterImplExt for T { - fn parent_gl_set_caps( - &self, - filter: &Self::Type, - incaps: &Caps, - outcaps: &Caps, - ) -> Result<(), LoggableError> { + fn parent_gl_set_caps(&self, incaps: &Caps, outcaps: &Caps) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstGLBaseFilterClass; @@ -58,7 +43,10 @@ impl GLBaseFilterImplExt for T { .map(|f| { result_from_gboolean!( f( - filter.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, incaps.to_glib_none().0, outcaps.to_glib_none().0, ), @@ -70,7 +58,7 @@ impl GLBaseFilterImplExt for T { } } - fn parent_gl_start(&self, filter: &Self::Type) -> Result<(), LoggableError> { + fn parent_gl_start(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstGLBaseFilterClass; @@ -79,7 +67,11 @@ impl GLBaseFilterImplExt for T { .gl_start .map(|f| { result_from_gboolean!( - f(filter.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), CAT_RUST, "Parent function `gl_start` failed", ) @@ -88,13 +80,17 @@ impl GLBaseFilterImplExt for T { } } - fn parent_gl_stop(&self, filter: &Self::Type) { + fn parent_gl_stop(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstGLBaseFilterClass; if let Some(f) = (*parent_class).gl_stop { - f(filter.unsafe_cast_ref::().to_glib_none().0) + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0) } } } @@ -117,17 +113,12 @@ unsafe extern "C" fn gl_set_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.gl_set_caps( - wrap.unsafe_cast_ref(), - &from_glib_borrow(incaps), - &from_glib_borrow(outcaps), - ) { + gst::panic_to_error!(imp, false, { + match imp.gl_set_caps(&from_glib_borrow(incaps), &from_glib_borrow(outcaps)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -140,13 +131,12 @@ unsafe extern "C" fn gl_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.gl_start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.gl_start() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -157,9 +147,6 @@ unsafe extern "C" fn gl_start( unsafe extern "C" fn gl_stop(ptr: *mut GstGLBaseFilter) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), (), { - imp.gl_stop(wrap.unsafe_cast_ref()) - }) + gst::panic_to_error!(imp, (), { imp.gl_stop() }) } diff --git a/gstreamer-gl/src/subclass/gl_base_src.rs b/gstreamer-gl/src/subclass/gl_base_src.rs index 63f776408..3db370649 100644 --- a/gstreamer-gl/src/subclass/gl_base_src.rs +++ b/gstreamer-gl/src/subclass/gl_base_src.rs @@ -12,33 +12,29 @@ use crate::{GLBaseSrc, GLMemory, GLAPI}; pub trait GLBaseSrcImpl: GLBaseSrcImplExt + PushSrcImpl { const SUPPORTED_GL_API: GLAPI; - fn gl_start(&self, element: &Self::Type) -> Result<(), LoggableError> { - self.parent_gl_start(element) + fn gl_start(&self) -> Result<(), LoggableError> { + self.parent_gl_start() } - fn gl_stop(&self, element: &Self::Type) { - self.parent_gl_stop(element) + fn gl_stop(&self) { + self.parent_gl_stop() } - fn fill_gl_memory(&self, element: &Self::Type, memory: &GLMemory) -> Result<(), LoggableError> { - self.parent_fill_gl_memory(element, memory) + fn fill_gl_memory(&self, memory: &GLMemory) -> Result<(), LoggableError> { + self.parent_fill_gl_memory(memory) } } pub trait GLBaseSrcImplExt: ObjectSubclass { - fn parent_gl_start(&self, element: &Self::Type) -> Result<(), LoggableError>; + fn parent_gl_start(&self) -> Result<(), LoggableError>; - fn parent_gl_stop(&self, element: &Self::Type); + fn parent_gl_stop(&self); - fn parent_fill_gl_memory( - &self, - element: &Self::Type, - memory: &GLMemory, - ) -> Result<(), LoggableError>; + fn parent_fill_gl_memory(&self, memory: &GLMemory) -> Result<(), LoggableError>; } impl GLBaseSrcImplExt for T { - fn parent_gl_start(&self, element: &Self::Type) -> Result<(), LoggableError> { + fn parent_gl_start(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstGLBaseSrcClass; @@ -47,7 +43,11 @@ impl GLBaseSrcImplExt for T { .gl_start .map(|f| { result_from_gboolean!( - f(element.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), CAT_RUST, "Parent function `gl_start` failed", ) @@ -56,22 +56,22 @@ impl GLBaseSrcImplExt for T { } } - fn parent_gl_stop(&self, element: &Self::Type) { + fn parent_gl_stop(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstGLBaseSrcClass; if let Some(f) = (*parent_class).gl_stop { - f(element.unsafe_cast_ref::().to_glib_none().0) + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0) } } } - fn parent_fill_gl_memory( - &self, - element: &Self::Type, - memory: &GLMemory, - ) -> Result<(), LoggableError> { + fn parent_fill_gl_memory(&self, memory: &GLMemory) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstGLBaseSrcClass; @@ -81,7 +81,10 @@ impl GLBaseSrcImplExt for T { .map(|f| { result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, mut_override(memory.to_glib_none().0), ), CAT_RUST, @@ -107,13 +110,12 @@ unsafe impl IsSubclassable for GLBaseSrc { unsafe extern "C" fn gl_start(ptr: *mut GstGLBaseSrc) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.gl_start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.gl_start() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -124,11 +126,8 @@ unsafe extern "C" fn gl_start(ptr: *mut GstGLBaseSrc) -> glib: unsafe extern "C" fn gl_stop(ptr: *mut GstGLBaseSrc) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), (), { - imp.gl_stop(wrap.unsafe_cast_ref()) - }) + gst::panic_to_error!(imp, (), { imp.gl_stop() }) } unsafe extern "C" fn fill_gl_memory( @@ -137,13 +136,12 @@ unsafe extern "C" fn fill_gl_memory( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.fill_gl_memory(wrap.unsafe_cast_ref(), &from_glib_borrow(memory)) { + gst::panic_to_error!(imp, false, { + match imp.fill_gl_memory(&from_glib_borrow(memory)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer-gl/src/subclass/gl_filter.rs b/gstreamer-gl/src/subclass/gl_filter.rs index 3ec6ee1b9..f76c4a226 100644 --- a/gstreamer-gl/src/subclass/gl_filter.rs +++ b/gstreamer-gl/src/subclass/gl_filter.rs @@ -24,75 +24,47 @@ pub trait GLFilterImpl: GLFilterImplExt + GLBaseFilterImpl { /// in [`GLFilter::class_init`] if [`true`]. const ADD_RGBA_PAD_TEMPLATES: bool = true; - fn set_caps( - &self, - filter: &Self::Type, - incaps: &Caps, - outcaps: &Caps, - ) -> Result<(), LoggableError> { - GLFilterImplExt::parent_set_caps(self, filter, incaps, outcaps) + fn set_caps(&self, incaps: &Caps, outcaps: &Caps) -> Result<(), LoggableError> { + GLFilterImplExt::parent_set_caps(self, incaps, outcaps) } - fn filter( - &self, - filter: &Self::Type, - input: &Buffer, - output: &Buffer, - ) -> Result<(), LoggableError> { - self.parent_filter(filter, input, output) + fn filter(&self, input: &Buffer, output: &Buffer) -> Result<(), LoggableError> { + self.parent_filter(input, output) } - fn filter_texture( - &self, - filter: &Self::Type, - input: &GLMemory, - output: &GLMemory, - ) -> Result<(), LoggableError> { - self.parent_filter_texture(filter, input, output) + fn filter_texture(&self, input: &GLMemory, output: &GLMemory) -> Result<(), LoggableError> { + self.parent_filter_texture(input, output) } - fn init_fbo(&self, filter: &Self::Type) -> Result<(), LoggableError> { - self.parent_init_fbo(filter) + fn init_fbo(&self) -> Result<(), LoggableError> { + self.parent_init_fbo() } fn transform_internal_caps( &self, - filter: &Self::Type, direction: PadDirection, caps: &Caps, filter_caps: Option<&Caps>, ) -> Option { - self.parent_transform_internal_caps(filter, direction, caps, filter_caps) + self.parent_transform_internal_caps(direction, caps, filter_caps) } } pub trait GLFilterImplExt: ObjectSubclass { - fn parent_set_caps( - &self, - filter: &Self::Type, - incaps: &Caps, - outcaps: &Caps, - ) -> Result<(), LoggableError>; + fn parent_set_caps(&self, incaps: &Caps, outcaps: &Caps) -> Result<(), LoggableError>; - fn parent_filter( - &self, - filter: &Self::Type, - input: &Buffer, - output: &Buffer, - ) -> Result<(), LoggableError>; + fn parent_filter(&self, input: &Buffer, output: &Buffer) -> Result<(), LoggableError>; fn parent_filter_texture( &self, - filter: &Self::Type, input: &GLMemory, output: &GLMemory, ) -> Result<(), LoggableError>; - fn parent_init_fbo(&self, filter: &Self::Type) -> Result<(), LoggableError>; + fn parent_init_fbo(&self) -> Result<(), LoggableError>; fn parent_transform_internal_caps( &self, - filter: &Self::Type, direction: PadDirection, caps: &Caps, filter_caps: Option<&Caps>, @@ -100,12 +72,7 @@ pub trait GLFilterImplExt: ObjectSubclass { } impl GLFilterImplExt for T { - fn parent_set_caps( - &self, - filter: &Self::Type, - incaps: &Caps, - outcaps: &Caps, - ) -> Result<(), LoggableError> { + fn parent_set_caps(&self, incaps: &Caps, outcaps: &Caps) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut GstGLFilterClass; @@ -115,7 +82,10 @@ impl GLFilterImplExt for T { .map(|f| { result_from_gboolean!( f( - filter.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, incaps.to_glib_none().0, outcaps.to_glib_none().0, ), @@ -127,12 +97,7 @@ impl GLFilterImplExt for T { } } - fn parent_filter( - &self, - filter: &Self::Type, - input: &Buffer, - output: &Buffer, - ) -> Result<(), LoggableError> { + fn parent_filter(&self, input: &Buffer, output: &Buffer) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut GstGLFilterClass; @@ -142,7 +107,10 @@ impl GLFilterImplExt for T { .map(|f| { result_from_gboolean!( f( - filter.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, input.to_glib_none().0, output.to_glib_none().0, ), @@ -156,7 +124,6 @@ impl GLFilterImplExt for T { fn parent_filter_texture( &self, - filter: &Self::Type, input: &GLMemory, output: &GLMemory, ) -> Result<(), LoggableError> { @@ -169,7 +136,10 @@ impl GLFilterImplExt for T { .map(|f| { result_from_gboolean!( f( - filter.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, input.to_glib_none().0, output.to_glib_none().0, ), @@ -181,7 +151,7 @@ impl GLFilterImplExt for T { } } - fn parent_init_fbo(&self, filter: &Self::Type) -> Result<(), LoggableError> { + fn parent_init_fbo(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut GstGLFilterClass; @@ -190,7 +160,11 @@ impl GLFilterImplExt for T { .init_fbo .map(|f| { result_from_gboolean!( - f(filter.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), CAT_RUST, "Parent function `init_fbo` failed" ) @@ -200,7 +174,6 @@ impl GLFilterImplExt for T { } fn parent_transform_internal_caps( &self, - filter: &Self::Type, direction: PadDirection, caps: &Caps, filter_caps: Option<&Caps>, @@ -214,7 +187,10 @@ impl GLFilterImplExt for T { .expect("Missing parent function `transform_internal_caps`"); from_glib_full(f( - filter.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, direction.into_glib(), caps.to_glib_none().0, filter_caps.to_glib_none().0, @@ -255,17 +231,12 @@ unsafe extern "C" fn filter( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.filter( - wrap.unsafe_cast_ref(), - &from_glib_borrow(input), - &from_glib_borrow(output), - ) { + gst::panic_to_error!(imp, false, { + match imp.filter(&from_glib_borrow(input), &from_glib_borrow(output)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -280,17 +251,12 @@ unsafe extern "C" fn filter_texture( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.filter_texture( - wrap.unsafe_cast_ref(), - &from_glib_borrow(input), - &from_glib_borrow(output), - ) { + gst::panic_to_error!(imp, false, { + match imp.filter_texture(&from_glib_borrow(input), &from_glib_borrow(output)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -301,13 +267,12 @@ unsafe extern "C" fn filter_texture( unsafe extern "C" fn init_fbo(ptr: *mut GstGLFilter) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.init_fbo(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.init_fbo() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -322,18 +287,12 @@ unsafe extern "C" fn set_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match GLFilterImpl::set_caps( - imp, - wrap.unsafe_cast_ref(), - &from_glib_borrow(incaps), - &from_glib_borrow(outcaps), - ) { + gst::panic_to_error!(imp, false, { + match GLFilterImpl::set_caps(imp, &from_glib_borrow(incaps), &from_glib_borrow(outcaps)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -349,13 +308,11 @@ unsafe extern "C" fn transform_internal_caps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), None, { + gst::panic_to_error!(imp, None, { let filter_caps: Borrowed> = from_glib_borrow(filter_caps); imp.transform_internal_caps( - wrap.unsafe_cast_ref(), from_glib(direction), &from_glib_borrow(caps), filter_caps.as_ref().as_ref(), diff --git a/gstreamer-pbutils/src/subclass/audio_visualizer.rs b/gstreamer-pbutils/src/subclass/audio_visualizer.rs index 6f258becc..5dbd112ef 100644 --- a/gstreamer-pbutils/src/subclass/audio_visualizer.rs +++ b/gstreamer-pbutils/src/subclass/audio_visualizer.rs @@ -10,61 +10,45 @@ use crate::AudioVisualizer; pub struct AudioVisualizerSetupToken<'a>(pub(crate) &'a AudioVisualizer); pub trait AudioVisualizerImpl: AudioVisualizerImplExt + ElementImpl { - fn setup( - &self, - element: &Self::Type, - token: &AudioVisualizerSetupToken, - ) -> Result<(), LoggableError> { - self.parent_setup(element, token) + fn setup(&self, token: &AudioVisualizerSetupToken) -> Result<(), LoggableError> { + self.parent_setup(token) } fn render( &self, - element: &Self::Type, audio_buffer: &gst::BufferRef, video_frame: &mut gst_video::VideoFrameRef<&mut gst::BufferRef>, ) -> Result<(), LoggableError> { - self.parent_render(element, audio_buffer, video_frame) + self.parent_render(audio_buffer, video_frame) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } } pub trait AudioVisualizerImplExt: ObjectSubclass { - fn parent_setup( - &self, - element: &Self::Type, - token: &AudioVisualizerSetupToken, - ) -> Result<(), LoggableError>; + fn parent_setup(&self, token: &AudioVisualizerSetupToken) -> Result<(), LoggableError>; fn parent_render( &self, - element: &Self::Type, audio_buffer: &gst::BufferRef, video_frame: &mut gst_video::VideoFrameRef<&mut gst::BufferRef>, ) -> Result<(), LoggableError>; fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; } impl AudioVisualizerImplExt for T { - fn parent_setup( - &self, - element: &Self::Type, - token: &AudioVisualizerSetupToken, - ) -> Result<(), LoggableError> { + fn parent_setup(&self, token: &AudioVisualizerSetupToken) -> Result<(), LoggableError> { assert_eq!( - element.as_ptr() as *mut ffi::GstAudioVisualizer, + self.instance().as_ptr() as *mut ffi::GstAudioVisualizer, token.0.as_ptr() as *mut ffi::GstAudioVisualizer ); @@ -75,7 +59,8 @@ impl AudioVisualizerImplExt for T { .setup .map(|f| { result_from_gboolean!( - f(element + f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0,), @@ -89,7 +74,6 @@ impl AudioVisualizerImplExt for T { fn parent_render( &self, - element: &Self::Type, audio_buffer: &gst::BufferRef, video_frame: &mut gst_video::VideoFrameRef<&mut gst::BufferRef>, ) -> Result<(), LoggableError> { @@ -101,7 +85,7 @@ impl AudioVisualizerImplExt for T { .map(|f| { result_from_gboolean!( f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -118,7 +102,6 @@ impl AudioVisualizerImplExt for T { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -129,7 +112,7 @@ impl AudioVisualizerImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -159,15 +142,16 @@ unsafe extern "C" fn audio_visualizer_setup( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - let token = AudioVisualizerSetupToken(&*wrap); + gst::panic_to_error!(imp, false, { + let instance = imp.instance(); + let instance = instance.unsafe_cast_ref::(); + let token = AudioVisualizerSetupToken(instance); - match imp.setup(wrap.unsafe_cast_ref(), &token) { + match imp.setup(&token) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -182,18 +166,16 @@ unsafe extern "C" fn audio_visualizer_render( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let buffer = gst::BufferRef::from_ptr(audio_buffer); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { match imp.render( - wrap.unsafe_cast_ref(), buffer, &mut gst_video::VideoFrameRef::from_glib_borrow_mut(video_frame), ) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -207,17 +189,16 @@ unsafe extern "C" fn audio_visualizer_decide_allocation( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.decide_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer-play/src/subclass/play_video_renderer.rs b/gstreamer-play/src/subclass/play_video_renderer.rs index 1f163c6b8..aa72d7c68 100644 --- a/gstreamer-play/src/subclass/play_video_renderer.rs +++ b/gstreamer-play/src/subclass/play_video_renderer.rs @@ -7,7 +7,7 @@ use glib::subclass::prelude::*; use glib::translate::*; pub trait PlayVideoRendererImpl: ObjectImpl { - fn create_video_sink(&self, video_renderer: &Self::Type, play: &Play) -> gst::Element; + fn create_video_sink(&self, play: &Play) -> gst::Element; } unsafe impl IsImplementable for PlayVideoRenderer { @@ -19,11 +19,11 @@ unsafe impl IsImplementable for PlayVideoRenderer { } pub trait PlayVideoRendererImplExt: ObjectSubclass { - fn parent_create_video_sink(&self, video_renderer: &Self::Type, play: &Play) -> gst::Element; + fn parent_create_video_sink(&self, play: &Play) -> gst::Element; } impl PlayVideoRendererImplExt for T { - fn parent_create_video_sink(&self, video_renderer: &Self::Type, play: &Play) -> gst::Element { + fn parent_create_video_sink(&self, play: &Play) -> gst::Element { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -33,7 +33,7 @@ impl PlayVideoRendererImplExt for T { .create_video_sink .expect("no parent \"create_video_sink\" implementation"); let ret = func( - video_renderer + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -55,10 +55,7 @@ unsafe extern "C" fn video_renderer_create_video_sink( let instance = &*(video_renderer as *mut T::Instance); let imp = instance.imp(); - let sink = imp.create_video_sink( - from_glib_borrow::<_, PlayVideoRenderer>(video_renderer).unsafe_cast_ref(), - &Play::from_glib_borrow(play), - ); + let sink = imp.create_video_sink(&Play::from_glib_borrow(play)); let sink_ptr: *mut gst::ffi::GstElement = sink.to_glib_none().0; diff --git a/gstreamer-player/src/subclass/player_video_renderer.rs b/gstreamer-player/src/subclass/player_video_renderer.rs index e67a232c7..aedb32337 100644 --- a/gstreamer-player/src/subclass/player_video_renderer.rs +++ b/gstreamer-player/src/subclass/player_video_renderer.rs @@ -7,7 +7,7 @@ use glib::subclass::prelude::*; use glib::translate::*; pub trait PlayerVideoRendererImpl: ObjectImpl { - fn create_video_sink(&self, video_renderer: &Self::Type, player: &Player) -> gst::Element; + fn create_video_sink(&self, player: &Player) -> gst::Element; } unsafe impl IsImplementable for PlayerVideoRenderer { @@ -19,19 +19,11 @@ unsafe impl IsImplementable for PlayerVideoRender } pub trait PlayerVideoRendererImplExt: ObjectSubclass { - fn parent_create_video_sink( - &self, - video_renderer: &Self::Type, - player: &Player, - ) -> gst::Element; + fn parent_create_video_sink(&self, player: &Player) -> gst::Element; } impl PlayerVideoRendererImplExt for T { - fn parent_create_video_sink( - &self, - video_renderer: &Self::Type, - player: &Player, - ) -> gst::Element { + fn parent_create_video_sink(&self, player: &Player) -> gst::Element { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -41,7 +33,7 @@ impl PlayerVideoRendererImplExt for T { .create_video_sink .expect("no parent \"create_video_sink\" implementation"); let ret = func( - video_renderer + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -63,10 +55,7 @@ unsafe extern "C" fn video_renderer_create_video_sink(video_renderer).unsafe_cast_ref(), - &Player::from_glib_borrow(player), - ); + let sink = imp.create_video_sink(&from_glib_borrow::<_, Player>(player)); let sink_ptr: *mut gst::ffi::GstElement = sink.to_glib_none().0; diff --git a/gstreamer-rtp/src/subclass/rtp_base_depayload.rs b/gstreamer-rtp/src/subclass/rtp_base_depayload.rs index 32d0b3e94..dd07ac247 100644 --- a/gstreamer-rtp/src/subclass/rtp_base_depayload.rs +++ b/gstreamer-rtp/src/subclass/rtp_base_depayload.rs @@ -9,51 +9,41 @@ use crate::RTPBaseDepayload; use std::ptr; pub trait RTPBaseDepayloadImpl: RTPBaseDepayloadImplExt + ElementImpl { - fn set_caps(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> { - self.parent_set_caps(element, caps) + fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_set_caps(caps) } - fn handle_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_handle_event(element, event) + fn handle_event(&self, event: gst::Event) -> bool { + self.parent_handle_event(event) } - fn packet_lost(&self, element: &Self::Type, event: &gst::EventRef) -> bool { - self.parent_packet_lost(element, event) + fn packet_lost(&self, event: &gst::EventRef) -> bool { + self.parent_packet_lost(event) } fn process_rtp_packet( &self, - element: &Self::Type, rtp_buffer: &crate::RTPBuffer, ) -> Option { - self.parent_process_rtp_packet(element, rtp_buffer) + self.parent_process_rtp_packet(rtp_buffer) } } pub trait RTPBaseDepayloadImplExt: ObjectSubclass { - fn parent_set_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError>; + fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError>; - fn parent_handle_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_handle_event(&self, event: gst::Event) -> bool; - fn parent_packet_lost(&self, element: &Self::Type, event: &gst::EventRef) -> bool; + fn parent_packet_lost(&self, event: &gst::EventRef) -> bool; fn parent_process_rtp_packet( &self, - element: &Self::Type, rtp_buffer: &crate::RTPBuffer, ) -> Option; } impl RTPBaseDepayloadImplExt for T { - fn parent_set_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBaseDepayloadClass; @@ -62,7 +52,7 @@ impl RTPBaseDepayloadImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -76,7 +66,7 @@ impl RTPBaseDepayloadImplExt for T { } } - fn parent_handle_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_handle_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBaseDepayloadClass; @@ -84,7 +74,7 @@ impl RTPBaseDepayloadImplExt for T { .handle_event .map(|f| { from_glib(f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -95,7 +85,7 @@ impl RTPBaseDepayloadImplExt for T { } } - fn parent_packet_lost(&self, element: &Self::Type, event: &gst::EventRef) -> bool { + fn parent_packet_lost(&self, event: &gst::EventRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBaseDepayloadClass; @@ -103,7 +93,7 @@ impl RTPBaseDepayloadImplExt for T { .packet_lost .map(|f| { from_glib(f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -116,7 +106,6 @@ impl RTPBaseDepayloadImplExt for T { fn parent_process_rtp_packet( &self, - element: &Self::Type, rtp_buffer: &crate::RTPBuffer, ) -> Option { unsafe { @@ -128,7 +117,7 @@ impl RTPBaseDepayloadImplExt for T { .expect("no parent \"process\" implementation"); from_glib_full(f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -157,14 +146,13 @@ unsafe extern "C" fn rtp_base_depayload_set_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let caps = from_glib_borrow(caps); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_caps(wrap.unsafe_cast_ref(), &caps) { + gst::panic_to_error!(imp, false, { + match imp.set_caps(&caps) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -178,12 +166,8 @@ unsafe extern "C" fn rtp_base_depayload_handle_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.handle_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.handle_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn rtp_base_depayload_packet_lost( @@ -192,10 +176,9 @@ unsafe extern "C" fn rtp_base_depayload_packet_lost( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.packet_lost(wrap.unsafe_cast_ref(), gst::EventRef::from_ptr(event)) + gst::panic_to_error!(imp, false, { + imp.packet_lost(gst::EventRef::from_ptr(event)) }) .into_glib() } @@ -206,12 +189,11 @@ unsafe extern "C" fn rtp_base_depayload_process_rtp_packet *mut gst::ffi::GstBuffer { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), ptr::null_mut(), { + gst::panic_to_error!(imp, ptr::null_mut(), { let bufwrap = crate::RTPBuffer::::from_glib_borrow(rtp_packet); - imp.process_rtp_packet(wrap.unsafe_cast_ref(), &bufwrap) + imp.process_rtp_packet(&bufwrap) .map(|buffer| buffer.into_glib_ptr()) .unwrap_or(ptr::null_mut()) }) diff --git a/gstreamer-rtp/src/subclass/rtp_base_payload.rs b/gstreamer-rtp/src/subclass/rtp_base_payload.rs index 33d8bda5d..50ffd1906 100644 --- a/gstreamer-rtp/src/subclass/rtp_base_payload.rs +++ b/gstreamer-rtp/src/subclass/rtp_base_payload.rs @@ -8,70 +8,48 @@ use crate::prelude::*; use crate::RTPBasePayload; pub trait RTPBasePayloadImpl: RTPBasePayloadImplExt + ElementImpl { - fn caps(&self, element: &Self::Type, pad: &gst::Pad, filter: Option<&gst::Caps>) -> gst::Caps { - self.parent_caps(element, pad, filter) + fn caps(&self, pad: &gst::Pad, filter: Option<&gst::Caps>) -> gst::Caps { + self.parent_caps(pad, filter) } - fn set_caps(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> { - self.parent_set_caps(element, caps) + fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_set_caps(caps) } - fn handle_buffer( - &self, - element: &Self::Type, - buffer: gst::Buffer, - ) -> Result { - self.parent_handle_buffer(element, buffer) + fn handle_buffer(&self, buffer: gst::Buffer) -> Result { + self.parent_handle_buffer(buffer) } - fn query(&self, element: &Self::Type, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { - RTPBasePayloadImplExt::parent_query(self, element, pad, query) + fn query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { + RTPBasePayloadImplExt::parent_query(self, pad, query) } - fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_sink_event(element, event) + fn sink_event(&self, event: gst::Event) -> bool { + self.parent_sink_event(event) } - fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_src_event(element, event) + fn src_event(&self, event: gst::Event) -> bool { + self.parent_src_event(event) } } pub trait RTPBasePayloadImplExt: ObjectSubclass { - fn parent_caps( - &self, - element: &Self::Type, - pad: &gst::Pad, - filter: Option<&gst::Caps>, - ) -> gst::Caps; + fn parent_caps(&self, pad: &gst::Pad, filter: Option<&gst::Caps>) -> gst::Caps; - fn parent_set_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError>; + fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError>; - fn parent_handle_buffer( - &self, - element: &Self::Type, - buffer: gst::Buffer, - ) -> Result; + fn parent_handle_buffer(&self, buffer: gst::Buffer) + -> Result; - fn parent_query(&self, element: &Self::Type, pad: &gst::Pad, query: &mut gst::QueryRef) - -> bool; + fn parent_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool; - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_sink_event(&self, event: gst::Event) -> bool; - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_src_event(&self, event: gst::Event) -> bool; } impl RTPBasePayloadImplExt for T { - fn parent_caps( - &self, - element: &Self::Type, - pad: &gst::Pad, - filter: Option<&gst::Caps>, - ) -> gst::Caps { + fn parent_caps(&self, pad: &gst::Pad, filter: Option<&gst::Caps>) -> gst::Caps { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBasePayloadClass; @@ -79,18 +57,17 @@ impl RTPBasePayloadImplExt for T { .get_caps .expect("Missing parent function `get_caps`"); from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, pad.to_glib_none().0, filter.to_glib_none().0, )) } } - fn parent_set_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBasePayloadClass; @@ -99,7 +76,10 @@ impl RTPBasePayloadImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, caps.to_glib_none().0 ), gst::CAT_RUST, @@ -108,7 +88,7 @@ impl RTPBasePayloadImplExt for T { }) .unwrap_or_else(|| { // Trigger negotiation as the base class does - element + self.instance() .unsafe_cast_ref::() .set_outcaps(None) .map_err(|_| gst::loggable_error!(gst::CAT_RUST, "Failed to negotiate")) @@ -118,7 +98,6 @@ impl RTPBasePayloadImplExt for T { fn parent_handle_buffer( &self, - element: &Self::Type, buffer: gst::Buffer, ) -> Result { unsafe { @@ -128,7 +107,10 @@ impl RTPBasePayloadImplExt for T { .handle_buffer .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer.into_glib_ptr(), )) }) @@ -136,12 +118,7 @@ impl RTPBasePayloadImplExt for T { } } - fn parent_query( - &self, - element: &Self::Type, - pad: &gst::Pad, - query: &mut gst::QueryRef, - ) -> bool { + fn parent_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBasePayloadClass; @@ -149,7 +126,10 @@ impl RTPBasePayloadImplExt for T { .query .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, pad.to_glib_none().0, query.as_mut_ptr(), )) @@ -158,7 +138,7 @@ impl RTPBasePayloadImplExt for T { } } - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_sink_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBasePayloadClass; @@ -166,7 +146,10 @@ impl RTPBasePayloadImplExt for T { .sink_event .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) }) @@ -174,7 +157,7 @@ impl RTPBasePayloadImplExt for T { } } - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_src_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBasePayloadClass; @@ -182,7 +165,10 @@ impl RTPBasePayloadImplExt for T { .src_event .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) }) @@ -211,12 +197,10 @@ unsafe extern "C" fn rtp_base_payload_get_caps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { + gst::panic_to_error!(imp, gst::Caps::new_empty(), { RTPBasePayloadImpl::caps( imp, - wrap.unsafe_cast_ref(), &from_glib_borrow(pad), Option::::from_glib_borrow(filter) .as_ref() @@ -232,14 +216,13 @@ unsafe extern "C" fn rtp_base_payload_set_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let caps = from_glib_borrow(caps); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_caps(wrap.unsafe_cast_ref(), &caps) { + gst::panic_to_error!(imp, false, { + match imp.set_caps(&caps) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -253,11 +236,9 @@ unsafe extern "C" fn rtp_base_payload_handle_buffer( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.handle_buffer(wrap.unsafe_cast_ref(), from_glib_full(buffer)) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.handle_buffer(from_glib_full(buffer)).into() }) .into_glib() } @@ -269,12 +250,10 @@ unsafe extern "C" fn rtp_base_payload_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { RTPBasePayloadImpl::query( imp, - wrap.unsafe_cast_ref(), &from_glib_borrow(pad), gst::QueryRef::from_mut_ptr(query), ) @@ -288,12 +267,8 @@ unsafe extern "C" fn rtp_base_payload_sink_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.sink_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn rtp_base_payload_src_event( @@ -302,10 +277,6 @@ unsafe extern "C" fn rtp_base_payload_src_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.src_event(from_glib_full(event)) }).into_glib() } diff --git a/gstreamer-rtp/src/subclass/rtp_header_extension.rs b/gstreamer-rtp/src/subclass/rtp_header_extension.rs index 95e4eb6e8..c7a6b0d52 100644 --- a/gstreamer-rtp/src/subclass/rtp_header_extension.rs +++ b/gstreamer-rtp/src/subclass/rtp_header_extension.rs @@ -8,75 +8,59 @@ use glib::translate::*; pub trait RTPHeaderExtensionImpl: RTPHeaderExtensionImplExt + ElementImpl { const URI: &'static str; - fn supported_flags(&self, element: &Self::Type) -> crate::RTPHeaderExtensionFlags { - self.parent_supported_flags(element) + fn supported_flags(&self) -> crate::RTPHeaderExtensionFlags { + self.parent_supported_flags() } - fn max_size(&self, element: &Self::Type, input: &gst::BufferRef) -> usize { - self.parent_max_size(element, input) + fn max_size(&self, input: &gst::BufferRef) -> usize { + self.parent_max_size(input) } fn write( &self, - element: &Self::Type, input: &gst::BufferRef, write_flags: crate::RTPHeaderExtensionFlags, output: &mut gst::BufferRef, output_data: &mut [u8], ) -> Result { - self.parent_write(element, input, write_flags, output, output_data) + self.parent_write(input, write_flags, output, output_data) } fn read( &self, - element: &Self::Type, read_flags: crate::RTPHeaderExtensionFlags, input_data: &[u8], output: &mut gst::BufferRef, ) -> Result<(), gst::LoggableError> { - self.parent_read(element, read_flags, input_data, output) + self.parent_read(read_flags, input_data, output) } - fn set_non_rtp_sink_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { - self.parent_set_non_rtp_sink_caps(element, caps) + fn set_non_rtp_sink_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + self.parent_set_non_rtp_sink_caps(caps) } - fn update_non_rtp_src_caps( - &self, - element: &Self::Type, - caps: &mut gst::CapsRef, - ) -> Result<(), gst::LoggableError> { - self.parent_update_non_rtp_src_caps(element, caps) + fn update_non_rtp_src_caps(&self, caps: &mut gst::CapsRef) -> Result<(), gst::LoggableError> { + self.parent_update_non_rtp_src_caps(caps) } fn set_attributes( &self, - element: &Self::Type, direction: crate::RTPHeaderExtensionDirection, attributes: &str, ) -> Result<(), gst::LoggableError> { - self.parent_set_attributes(element, direction, attributes) + self.parent_set_attributes(direction, attributes) } - fn set_caps_from_attributes( - &self, - element: &Self::Type, - caps: &mut gst::CapsRef, - ) -> Result<(), gst::LoggableError> { - self.parent_set_caps_from_attributes(element, caps) + fn set_caps_from_attributes(&self, caps: &mut gst::CapsRef) -> Result<(), gst::LoggableError> { + self.parent_set_caps_from_attributes(caps) } } pub trait RTPHeaderExtensionImplExt: ObjectSubclass { - fn parent_supported_flags(&self, element: &Self::Type) -> crate::RTPHeaderExtensionFlags; - fn parent_max_size(&self, element: &Self::Type, input: &gst::BufferRef) -> usize; + fn parent_supported_flags(&self) -> crate::RTPHeaderExtensionFlags; + fn parent_max_size(&self, input: &gst::BufferRef) -> usize; fn parent_write( &self, - element: &Self::Type, input: &gst::BufferRef, write_flags: crate::RTPHeaderExtensionFlags, output: &mut gst::BufferRef, @@ -84,50 +68,43 @@ pub trait RTPHeaderExtensionImplExt: ObjectSubclass { ) -> Result; fn parent_read( &self, - element: &Self::Type, read_flags: crate::RTPHeaderExtensionFlags, input_data: &[u8], output: &mut gst::BufferRef, ) -> Result<(), gst::LoggableError>; - fn parent_set_non_rtp_sink_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError>; + fn parent_set_non_rtp_sink_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError>; fn parent_update_non_rtp_src_caps( &self, - element: &Self::Type, caps: &mut gst::CapsRef, ) -> Result<(), gst::LoggableError>; fn parent_set_attributes( &self, - element: &Self::Type, direction: crate::RTPHeaderExtensionDirection, attributes: &str, ) -> Result<(), gst::LoggableError>; fn parent_set_caps_from_attributes( &self, - element: &Self::Type, caps: &mut gst::CapsRef, ) -> Result<(), gst::LoggableError>; } impl RTPHeaderExtensionImplExt for T { - fn parent_supported_flags(&self, element: &Self::Type) -> crate::RTPHeaderExtensionFlags { + fn parent_supported_flags(&self) -> crate::RTPHeaderExtensionFlags { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPHeaderExtensionClass; let f = (*parent_class) .get_supported_flags .expect("no parent \"get_supported_flags\" implementation"); - from_glib(f(element + from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) } } - fn parent_max_size(&self, element: &Self::Type, input: &gst::BufferRef) -> usize { + fn parent_max_size(&self, input: &gst::BufferRef) -> usize { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPHeaderExtensionClass; @@ -135,7 +112,7 @@ impl RTPHeaderExtensionImplExt for T { .get_max_size .expect("no parent \"get_max_size\" implementation"); f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -146,7 +123,6 @@ impl RTPHeaderExtensionImplExt for T { fn parent_write( &self, - element: &Self::Type, input: &gst::BufferRef, write_flags: crate::RTPHeaderExtensionFlags, output: &mut gst::BufferRef, @@ -160,7 +136,7 @@ impl RTPHeaderExtensionImplExt for T { .expect("no parent \"write\" implementation"); let res = f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -184,7 +160,6 @@ impl RTPHeaderExtensionImplExt for T { fn parent_read( &self, - element: &Self::Type, read_flags: crate::RTPHeaderExtensionFlags, input_data: &[u8], output: &mut gst::BufferRef, @@ -198,7 +173,7 @@ impl RTPHeaderExtensionImplExt for T { gst::result_from_gboolean!( f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -213,18 +188,14 @@ impl RTPHeaderExtensionImplExt for T { } } - fn parent_set_non_rtp_sink_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn parent_set_non_rtp_sink_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPHeaderExtensionClass; if let Some(f) = (*parent_class).set_non_rtp_sink_caps { gst::result_from_gboolean!( f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -241,7 +212,6 @@ impl RTPHeaderExtensionImplExt for T { fn parent_update_non_rtp_src_caps( &self, - element: &Self::Type, caps: &mut gst::CapsRef, ) -> Result<(), gst::LoggableError> { unsafe { @@ -250,7 +220,7 @@ impl RTPHeaderExtensionImplExt for T { if let Some(f) = (*parent_class).update_non_rtp_src_caps { gst::result_from_gboolean!( f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -267,7 +237,6 @@ impl RTPHeaderExtensionImplExt for T { fn parent_set_attributes( &self, - element: &Self::Type, direction: crate::RTPHeaderExtensionDirection, attributes: &str, ) -> Result<(), gst::LoggableError> { @@ -277,7 +246,7 @@ impl RTPHeaderExtensionImplExt for T { if let Some(f) = (*parent_class).set_attributes { gst::result_from_gboolean!( f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -295,7 +264,6 @@ impl RTPHeaderExtensionImplExt for T { fn parent_set_caps_from_attributes( &self, - element: &Self::Type, caps: &mut gst::CapsRef, ) -> Result<(), gst::LoggableError> { unsafe { @@ -307,7 +275,7 @@ impl RTPHeaderExtensionImplExt for T { gst::result_from_gboolean!( f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -344,14 +312,10 @@ unsafe extern "C" fn get_supported_flags( ) -> ffi::GstRTPHeaderExtensionFlags { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!( - &wrap, - imp.panicked(), - crate::RTPHeaderExtensionFlags::empty(), - { imp.supported_flags(wrap.unsafe_cast_ref()) } - ) + gst::panic_to_error!(imp, crate::RTPHeaderExtensionFlags::empty(), { + imp.supported_flags() + }) .into_glib() } @@ -361,11 +325,8 @@ unsafe extern "C" fn get_max_size( ) -> usize { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), 0, { - imp.max_size(wrap.unsafe_cast_ref(), gst::BufferRef::from_ptr(input)) - }) + gst::panic_to_error!(imp, 0, { imp.max_size(gst::BufferRef::from_ptr(input)) }) } unsafe extern "C" fn write( @@ -378,11 +339,9 @@ unsafe extern "C" fn write( ) -> isize { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), -1, { + gst::panic_to_error!(imp, -1, { match imp.write( - wrap.unsafe_cast_ref(), gst::BufferRef::from_ptr(input), from_glib(write_flags), gst::BufferRef::from_mut_ptr(output), @@ -394,7 +353,7 @@ unsafe extern "C" fn write( ) { Ok(len) => len as isize, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); -1 } } @@ -410,11 +369,9 @@ unsafe extern "C" fn read( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { match imp.read( - wrap.unsafe_cast_ref(), from_glib(read_flags), if input_data_len == 0 { &[] @@ -425,7 +382,7 @@ unsafe extern "C" fn read( ) { Ok(_) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -439,13 +396,12 @@ unsafe extern "C" fn set_non_rtp_sink_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_non_rtp_sink_caps(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) { + gst::panic_to_error!(imp, false, { + match imp.set_non_rtp_sink_caps(&from_glib_borrow(caps)) { Ok(_) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -459,14 +415,12 @@ unsafe extern "C" fn update_non_rtp_src_caps( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.update_non_rtp_src_caps(wrap.unsafe_cast_ref(), gst::CapsRef::from_mut_ptr(caps)) - { + gst::panic_to_error!(imp, false, { + match imp.update_non_rtp_src_caps(gst::CapsRef::from_mut_ptr(caps)) { Ok(_) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -481,17 +435,15 @@ unsafe extern "C" fn set_attributes( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { match imp.set_attributes( - wrap.unsafe_cast_ref(), from_glib(direction), &glib::GString::from_glib_borrow(attributes), ) { Ok(_) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -505,14 +457,12 @@ unsafe extern "C" fn set_caps_from_attributes( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_caps_from_attributes(wrap.unsafe_cast_ref(), gst::CapsRef::from_mut_ptr(caps)) - { + gst::panic_to_error!(imp, false, { + match imp.set_caps_from_attributes(gst::CapsRef::from_mut_ptr(caps)) { Ok(_) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer-rtsp-server/src/subclass/rtsp_client.rs b/gstreamer-rtsp-server/src/subclass/rtsp_client.rs index 2f88d0ff5..1bba5c39e 100644 --- a/gstreamer-rtsp-server/src/subclass/rtsp_client.rs +++ b/gstreamer-rtsp-server/src/subclass/rtsp_client.rs @@ -9,92 +9,83 @@ use std::mem; use crate::RTSPClient; pub trait RTSPClientImpl: RTSPClientImplExt + ObjectImpl + Send + Sync { - fn create_sdp( - &self, - client: &Self::Type, - media: &crate::RTSPMedia, - ) -> Option { - self.parent_create_sdp(client, media) + fn create_sdp(&self, media: &crate::RTSPMedia) -> Option { + self.parent_create_sdp(media) } fn configure_client_media( &self, - client: &Self::Type, media: &crate::RTSPMedia, stream: &crate::RTSPStream, ctx: &crate::RTSPContext, ) -> Result<(), gst::LoggableError> { - self.parent_configure_client_media(client, media, stream, ctx) + self.parent_configure_client_media(media, stream, ctx) } // TODO: configure_client_transport - fn params_set(&self, client: &Self::Type, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult { - self.parent_params_set(client, ctx) + fn params_set(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult { + self.parent_params_set(ctx) } - fn params_get(&self, client: &Self::Type, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult { - self.parent_params_get(client, ctx) + fn params_get(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult { + self.parent_params_get(ctx) } - fn make_path_from_uri( - &self, - client: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { - self.parent_make_path_from_uri(client, url) + fn make_path_from_uri(&self, url: &gst_rtsp::RTSPUrl) -> Option { + self.parent_make_path_from_uri(url) } - fn closed(&self, client: &Self::Type) { - self.parent_closed(client); + fn closed(&self) { + self.parent_closed(); } - fn new_session(&self, client: &Self::Type, session: &crate::RTSPSession) { - self.parent_new_session(client, session); + fn new_session(&self, session: &crate::RTSPSession) { + self.parent_new_session(session); } - fn options_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_options_request(client, ctx); + fn options_request(&self, ctx: &crate::RTSPContext) { + self.parent_options_request(ctx); } - fn describe_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_describe_request(client, ctx); + fn describe_request(&self, ctx: &crate::RTSPContext) { + self.parent_describe_request(ctx); } - fn setup_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_setup_request(client, ctx); + fn setup_request(&self, ctx: &crate::RTSPContext) { + self.parent_setup_request(ctx); } - fn play_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_play_request(client, ctx); + fn play_request(&self, ctx: &crate::RTSPContext) { + self.parent_play_request(ctx); } - fn pause_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_pause_request(client, ctx); + fn pause_request(&self, ctx: &crate::RTSPContext) { + self.parent_pause_request(ctx); } - fn teardown_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_teardown_request(client, ctx); + fn teardown_request(&self, ctx: &crate::RTSPContext) { + self.parent_teardown_request(ctx); } - fn set_parameter_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_set_parameter_request(client, ctx); + fn set_parameter_request(&self, ctx: &crate::RTSPContext) { + self.parent_set_parameter_request(ctx); } - fn parameter_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_parameter_request(client, ctx); + fn parameter_request(&self, ctx: &crate::RTSPContext) { + self.parent_parameter_request(ctx); } - fn announce_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_announce_request(client, ctx); + fn announce_request(&self, ctx: &crate::RTSPContext) { + self.parent_announce_request(ctx); } - fn record_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_record_request(client, ctx); + fn record_request(&self, ctx: &crate::RTSPContext) { + self.parent_record_request(ctx); } - fn handle_response(&self, client: &Self::Type, ctx: &crate::RTSPContext) { - self.parent_handle_response(client, ctx); + fn handle_response(&self, ctx: &crate::RTSPContext) { + self.parent_handle_response(ctx); } // TODO: tunnel_http_response @@ -102,114 +93,67 @@ pub trait RTSPClientImpl: RTSPClientImplExt + ObjectImpl + Send + Sync { fn handle_sdp( &self, - client: &Self::Type, ctx: &crate::RTSPContext, media: &crate::RTSPMedia, sdp: &gst_sdp::SDPMessageRef, ) -> Result<(), gst::LoggableError> { - self.parent_handle_sdp(client, ctx, media, sdp) + self.parent_handle_sdp(ctx, media, sdp) } fn check_requirements( &self, - client: &Self::Type, ctx: &crate::RTSPContext, arr: &[String], ) -> Option { - self.parent_check_requirements(client, ctx, arr) + self.parent_check_requirements(ctx, arr) } - fn pre_options_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_options_request(client, ctx) + fn pre_options_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_options_request(ctx) } - fn pre_describe_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_describe_request(client, ctx) + fn pre_describe_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_describe_request(ctx) } - fn pre_setup_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_setup_request(client, ctx) + fn pre_setup_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_setup_request(ctx) } - fn pre_play_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_play_request(client, ctx) + fn pre_play_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_play_request(ctx) } - fn pre_pause_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_pause_request(client, ctx) + fn pre_pause_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_pause_request(ctx) } - fn pre_teardown_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_teardown_request(client, ctx) + fn pre_teardown_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_teardown_request(ctx) } - fn pre_set_parameter_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_set_parameter_request(client, ctx) + fn pre_set_parameter_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_set_parameter_request(ctx) } - fn pre_get_parameter_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_get_parameter_request(client, ctx) + fn pre_get_parameter_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_get_parameter_request(ctx) } - fn pre_announce_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_announce_request(client, ctx) + fn pre_announce_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_announce_request(ctx) } - fn pre_record_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { - self.parent_pre_record_request(client, ctx) + fn pre_record_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { + self.parent_pre_record_request(ctx) } } pub trait RTSPClientImplExt: ObjectSubclass { - fn parent_create_sdp( - &self, - client: &Self::Type, - media: &crate::RTSPMedia, - ) -> Option; + fn parent_create_sdp(&self, media: &crate::RTSPMedia) -> Option; fn parent_configure_client_media( &self, - client: &Self::Type, media: &crate::RTSPMedia, stream: &crate::RTSPStream, ctx: &crate::RTSPContext, @@ -217,56 +161,43 @@ pub trait RTSPClientImplExt: ObjectSubclass { // TODO: configure_client_transport - fn parent_params_set( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPResult; + fn parent_params_set(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult; - fn parent_params_get( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPResult; + fn parent_params_get(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult; - fn parent_make_path_from_uri( - &self, - client: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option; + fn parent_make_path_from_uri(&self, url: &gst_rtsp::RTSPUrl) -> Option; - fn parent_closed(&self, client: &Self::Type); + fn parent_closed(&self); - fn parent_new_session(&self, client: &Self::Type, session: &crate::RTSPSession); + fn parent_new_session(&self, session: &crate::RTSPSession); - fn parent_options_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_options_request(&self, ctx: &crate::RTSPContext); - fn parent_describe_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_describe_request(&self, ctx: &crate::RTSPContext); - fn parent_setup_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_setup_request(&self, ctx: &crate::RTSPContext); - fn parent_play_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_play_request(&self, ctx: &crate::RTSPContext); - fn parent_pause_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_pause_request(&self, ctx: &crate::RTSPContext); - fn parent_teardown_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_teardown_request(&self, ctx: &crate::RTSPContext); - fn parent_set_parameter_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_set_parameter_request(&self, ctx: &crate::RTSPContext); - fn parent_parameter_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_parameter_request(&self, ctx: &crate::RTSPContext); - fn parent_announce_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_announce_request(&self, ctx: &crate::RTSPContext); - fn parent_record_request(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_record_request(&self, ctx: &crate::RTSPContext); - fn parent_handle_response(&self, client: &Self::Type, ctx: &crate::RTSPContext); + fn parent_handle_response(&self, ctx: &crate::RTSPContext); // TODO: tunnel_http_response // TODO: send_message fn parent_handle_sdp( &self, - client: &Self::Type, ctx: &crate::RTSPContext, media: &crate::RTSPMedia, sdp: &gst_sdp::SDPMessageRef, @@ -274,78 +205,39 @@ pub trait RTSPClientImplExt: ObjectSubclass { fn parent_check_requirements( &self, - client: &Self::Type, ctx: &crate::RTSPContext, arr: &[String], ) -> Option; - fn parent_pre_options_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode; + fn parent_pre_options_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode; - fn parent_pre_describe_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode; + fn parent_pre_describe_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode; - fn parent_pre_setup_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode; + fn parent_pre_setup_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode; - fn parent_pre_play_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode; + fn parent_pre_play_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode; - fn parent_pre_pause_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode; + fn parent_pre_pause_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode; - fn parent_pre_teardown_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode; + fn parent_pre_teardown_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode; fn parent_pre_set_parameter_request( &self, - client: &Self::Type, ctx: &crate::RTSPContext, ) -> gst_rtsp::RTSPStatusCode; fn parent_pre_get_parameter_request( &self, - client: &Self::Type, ctx: &crate::RTSPContext, ) -> gst_rtsp::RTSPStatusCode; - fn parent_pre_announce_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode; + fn parent_pre_announce_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode; - fn parent_pre_record_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode; + fn parent_pre_record_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode; } impl RTSPClientImplExt for T { - fn parent_create_sdp( - &self, - client: &Self::Type, - media: &crate::RTSPMedia, - ) -> Option { + fn parent_create_sdp(&self, media: &crate::RTSPMedia) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; @@ -354,7 +246,10 @@ impl RTSPClientImplExt for T { .expect("No `create_rtpbin` virtual method implementation in parent class"); from_glib_full(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, media.to_glib_none().0, )) } @@ -362,7 +257,6 @@ impl RTSPClientImplExt for T { fn parent_configure_client_media( &self, - client: &Self::Type, media: &crate::RTSPMedia, stream: &crate::RTSPStream, ctx: &crate::RTSPContext, @@ -376,7 +270,10 @@ impl RTSPClientImplExt for T { gst::result_from_gboolean!( f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, media.to_glib_none().0, stream.to_glib_none().0, ctx.to_glib_none().0 @@ -389,11 +286,7 @@ impl RTSPClientImplExt for T { // TODO: configure_client_transport - fn parent_params_set( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPResult { + fn parent_params_set(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; @@ -402,17 +295,16 @@ impl RTSPClientImplExt for T { .expect("No `params_set` virtual method implementation in parent class"); from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } } - fn parent_params_get( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPResult { + fn parent_params_get(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; @@ -421,17 +313,16 @@ impl RTSPClientImplExt for T { .expect("No `params_get` virtual method implementation in parent class"); from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } } - fn parent_make_path_from_uri( - &self, - client: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { + fn parent_make_path_from_uri(&self, url: &gst_rtsp::RTSPUrl) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; @@ -440,172 +331,215 @@ impl RTSPClientImplExt for T { .expect("No `make_path_from_uri` virtual method implementation in parent class"); from_glib_full(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, url.to_glib_none().0, )) } } - fn parent_closed(&self, client: &Self::Type) { + fn parent_closed(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).closed { - f(client.unsafe_cast_ref::().to_glib_none().0); + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0); } } } - fn parent_new_session(&self, client: &Self::Type, session: &crate::RTSPSession) { + fn parent_new_session(&self, session: &crate::RTSPSession) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).new_session { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, session.to_glib_none().0, ); } } } - fn parent_options_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_options_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).options_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_describe_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_describe_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).describe_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_setup_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_setup_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).setup_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_play_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_play_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).play_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_pause_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_pause_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pause_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_teardown_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_teardown_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).teardown_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_set_parameter_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_set_parameter_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).set_parameter_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_parameter_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_parameter_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).get_parameter_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_announce_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_announce_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).announce_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_record_request(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_record_request(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).record_request { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } } } - fn parent_handle_response(&self, client: &Self::Type, ctx: &crate::RTSPContext) { + fn parent_handle_response(&self, ctx: &crate::RTSPContext) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).handle_response { f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, ); } @@ -617,7 +551,6 @@ impl RTSPClientImplExt for T { fn parent_handle_sdp( &self, - client: &Self::Type, ctx: &crate::RTSPContext, media: &crate::RTSPMedia, sdp: &gst_sdp::SDPMessageRef, @@ -631,7 +564,10 @@ impl RTSPClientImplExt for T { gst::result_from_gboolean!( f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, media.to_glib_none().0, sdp as *const _ as *mut _ @@ -644,7 +580,6 @@ impl RTSPClientImplExt for T { fn parent_check_requirements( &self, - client: &Self::Type, ctx: &crate::RTSPContext, arr: &[String], ) -> Option { @@ -653,7 +588,10 @@ impl RTSPClientImplExt for T { let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).check_requirements { from_glib_full(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, arr.to_glib_none().0, )) @@ -663,17 +601,16 @@ impl RTSPClientImplExt for T { } } - fn parent_pre_options_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { + fn parent_pre_options_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_options_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -682,17 +619,16 @@ impl RTSPClientImplExt for T { } } - fn parent_pre_describe_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { + fn parent_pre_describe_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_describe_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -701,17 +637,16 @@ impl RTSPClientImplExt for T { } } - fn parent_pre_setup_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { + fn parent_pre_setup_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_setup_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -720,17 +655,16 @@ impl RTSPClientImplExt for T { } } - fn parent_pre_play_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { + fn parent_pre_play_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_play_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -739,17 +673,16 @@ impl RTSPClientImplExt for T { } } - fn parent_pre_pause_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { + fn parent_pre_pause_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_pause_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -758,17 +691,16 @@ impl RTSPClientImplExt for T { } } - fn parent_pre_teardown_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { + fn parent_pre_teardown_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_teardown_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -779,7 +711,6 @@ impl RTSPClientImplExt for T { fn parent_pre_set_parameter_request( &self, - client: &Self::Type, ctx: &crate::RTSPContext, ) -> gst_rtsp::RTSPStatusCode { unsafe { @@ -787,7 +718,10 @@ impl RTSPClientImplExt for T { let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_set_parameter_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -798,7 +732,6 @@ impl RTSPClientImplExt for T { fn parent_pre_get_parameter_request( &self, - client: &Self::Type, ctx: &crate::RTSPContext, ) -> gst_rtsp::RTSPStatusCode { unsafe { @@ -806,7 +739,10 @@ impl RTSPClientImplExt for T { let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_get_parameter_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -815,17 +751,16 @@ impl RTSPClientImplExt for T { } } - fn parent_pre_announce_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { + fn parent_pre_announce_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_announce_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -834,17 +769,16 @@ impl RTSPClientImplExt for T { } } - fn parent_pre_record_request( - &self, - client: &Self::Type, - ctx: &crate::RTSPContext, - ) -> gst_rtsp::RTSPStatusCode { + fn parent_pre_record_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass; if let Some(f) = (*parent_class).pre_record_request { from_glib(f( - client.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, ctx.to_glib_none().0, )) } else { @@ -896,10 +830,8 @@ unsafe extern "C" fn client_create_sdp( ) -> *mut gst_sdp::ffi::GstSDPMessage { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let sdp = - mem::ManuallyDrop::new(imp.create_sdp(wrap.unsafe_cast_ref(), &from_glib_borrow(media))); + let sdp = mem::ManuallyDrop::new(imp.create_sdp(&from_glib_borrow(media))); let ptr = sdp.to_glib_none().0; ptr as *mut _ @@ -913,17 +845,15 @@ unsafe extern "C" fn client_configure_client_media( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); match imp.configure_client_media( - wrap.unsafe_cast_ref(), &from_glib_borrow(media), &from_glib_borrow(stream), &from_glib_borrow(ctx), ) { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } } @@ -935,10 +865,8 @@ unsafe extern "C" fn client_params_set( ) -> gst_rtsp::ffi::GstRTSPResult { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.params_set(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.params_set(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_params_get( @@ -947,10 +875,8 @@ unsafe extern "C" fn client_params_get( ) -> gst_rtsp::ffi::GstRTSPResult { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.params_get(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.params_get(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_make_path_from_uri( @@ -959,18 +885,16 @@ unsafe extern "C" fn client_make_path_from_uri( ) -> *mut std::os::raw::c_char { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.make_path_from_uri(wrap.unsafe_cast_ref(), &from_glib_borrow(url)) + imp.make_path_from_uri(&from_glib_borrow(url)) .to_glib_full() } unsafe extern "C" fn client_closed(ptr: *mut ffi::GstRTSPClient) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.closed(wrap.unsafe_cast_ref()); + imp.closed(); } unsafe extern "C" fn client_new_session( @@ -979,9 +903,8 @@ unsafe extern "C" fn client_new_session( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.new_session(wrap.unsafe_cast_ref(), &from_glib_borrow(session)); + imp.new_session(&from_glib_borrow(session)); } unsafe extern "C" fn client_options_request( @@ -990,9 +913,8 @@ unsafe extern "C" fn client_options_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.options_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.options_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_describe_request( @@ -1001,9 +923,8 @@ unsafe extern "C" fn client_describe_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.describe_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.describe_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_setup_request( @@ -1012,9 +933,8 @@ unsafe extern "C" fn client_setup_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.setup_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.setup_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_play_request( @@ -1023,9 +943,8 @@ unsafe extern "C" fn client_play_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.play_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.play_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_pause_request( @@ -1034,9 +953,8 @@ unsafe extern "C" fn client_pause_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pause_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.pause_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_teardown_request( @@ -1045,9 +963,8 @@ unsafe extern "C" fn client_teardown_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.teardown_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.teardown_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_set_parameter_request( @@ -1056,9 +973,8 @@ unsafe extern "C" fn client_set_parameter_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.set_parameter_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.set_parameter_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_get_parameter_request( @@ -1067,9 +983,8 @@ unsafe extern "C" fn client_get_parameter_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.parameter_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.parameter_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_announce_request( @@ -1078,9 +993,8 @@ unsafe extern "C" fn client_announce_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.announce_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.announce_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_record_request( @@ -1089,9 +1003,8 @@ unsafe extern "C" fn client_record_request( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.record_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.record_request(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_handle_response( @@ -1100,9 +1013,8 @@ unsafe extern "C" fn client_handle_response( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.handle_response(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)); + imp.handle_response(&from_glib_borrow(ctx)); } unsafe extern "C" fn client_handle_sdp( @@ -1113,17 +1025,15 @@ unsafe extern "C" fn client_handle_sdp( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); match imp.handle_sdp( - wrap.unsafe_cast_ref(), &from_glib_borrow(ctx), &from_glib_borrow(media), &*(sdp as *mut _), ) { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } } @@ -1136,14 +1046,9 @@ unsafe extern "C" fn client_check_requirements( ) -> *mut std::os::raw::c_char { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.check_requirements( - wrap.unsafe_cast_ref(), - &from_glib_borrow(ctx), - Vec::from_glib_none(arr).as_slice(), - ) - .to_glib_full() + imp.check_requirements(&from_glib_borrow(ctx), Vec::from_glib_none(arr).as_slice()) + .to_glib_full() } unsafe extern "C" fn client_pre_options_request( @@ -1152,10 +1057,8 @@ unsafe extern "C" fn client_pre_options_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_options_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.pre_options_request(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_pre_describe_request( @@ -1164,10 +1067,8 @@ unsafe extern "C" fn client_pre_describe_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_describe_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.pre_describe_request(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_pre_setup_request( @@ -1176,10 +1077,8 @@ unsafe extern "C" fn client_pre_setup_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_setup_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.pre_setup_request(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_pre_play_request( @@ -1188,10 +1087,8 @@ unsafe extern "C" fn client_pre_play_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_play_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.pre_play_request(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_pre_pause_request( @@ -1200,10 +1097,8 @@ unsafe extern "C" fn client_pre_pause_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_pause_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.pre_pause_request(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_pre_teardown_request( @@ -1212,10 +1107,8 @@ unsafe extern "C" fn client_pre_teardown_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_teardown_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.pre_teardown_request(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_pre_set_parameter_request( @@ -1224,9 +1117,8 @@ unsafe extern "C" fn client_pre_set_parameter_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_set_parameter_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) + imp.pre_set_parameter_request(&from_glib_borrow(ctx)) .into_glib() } @@ -1236,9 +1128,8 @@ unsafe extern "C" fn client_pre_get_parameter_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_get_parameter_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) + imp.pre_get_parameter_request(&from_glib_borrow(ctx)) .into_glib() } @@ -1248,10 +1139,8 @@ unsafe extern "C" fn client_pre_announce_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_announce_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.pre_announce_request(&from_glib_borrow(ctx)).into_glib() } unsafe extern "C" fn client_pre_record_request( @@ -1260,8 +1149,6 @@ unsafe extern "C" fn client_pre_record_request( ) -> gst_rtsp::ffi::GstRTSPStatusCode { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.pre_record_request(wrap.unsafe_cast_ref(), &from_glib_borrow(ctx)) - .into_glib() + imp.pre_record_request(&from_glib_borrow(ctx)).into_glib() } diff --git a/gstreamer-rtsp-server/src/subclass/rtsp_media.rs b/gstreamer-rtsp-server/src/subclass/rtsp_media.rs index 11faa89fe..d733b2ffe 100644 --- a/gstreamer-rtsp-server/src/subclass/rtsp_media.rs +++ b/gstreamer-rtsp-server/src/subclass/rtsp_media.rs @@ -26,137 +26,118 @@ impl SDPInfo { } pub trait RTSPMediaImpl: RTSPMediaImplExt + ObjectImpl + Send + Sync { - fn handle_message(&self, media: &Self::Type, message: &gst::MessageRef) -> bool { - self.parent_handle_message(media, message) + fn handle_message(&self, message: &gst::MessageRef) -> bool { + self.parent_handle_message(message) } - fn prepare(&self, media: &Self::Type, thread: &RTSPThread) -> Result<(), gst::LoggableError> { - self.parent_prepare(media, thread) + fn prepare(&self, thread: &RTSPThread) -> Result<(), gst::LoggableError> { + self.parent_prepare(thread) } - fn unprepare(&self, media: &Self::Type) -> Result<(), gst::LoggableError> { - self.parent_unprepare(media) + fn unprepare(&self) -> Result<(), gst::LoggableError> { + self.parent_unprepare() } - fn suspend(&self, media: &Self::Type) -> Result<(), gst::LoggableError> { - self.parent_suspend(media) + fn suspend(&self) -> Result<(), gst::LoggableError> { + self.parent_suspend() } - fn unsuspend(&self, media: &Self::Type) -> Result<(), gst::LoggableError> { - self.parent_unsuspend(media) + fn unsuspend(&self) -> Result<(), gst::LoggableError> { + self.parent_unsuspend() } // TODO missing: convert_range - fn query_position(&self, media: &Self::Type) -> Option { - self.parent_query_position(media) + fn query_position(&self) -> Option { + self.parent_query_position() } - fn query_stop(&self, media: &Self::Type) -> Option { - self.parent_query_stop(media) + fn query_stop(&self) -> Option { + self.parent_query_stop() } - fn create_rtpbin(&self, media: &Self::Type) -> Option { - self.parent_create_rtpbin(media) + fn create_rtpbin(&self) -> Option { + self.parent_create_rtpbin() } - fn setup_rtpbin( - &self, - media: &Self::Type, - rtpbin: &gst::Element, - ) -> Result<(), gst::LoggableError> { - self.parent_setup_rtpbin(media, rtpbin) + fn setup_rtpbin(&self, rtpbin: &gst::Element) -> Result<(), gst::LoggableError> { + self.parent_setup_rtpbin(rtpbin) } fn setup_sdp( &self, - media: &Self::Type, sdp: &mut gst_sdp::SDPMessageRef, info: &SDPInfo, ) -> Result<(), gst::LoggableError> { - self.parent_setup_sdp(media, sdp, info) + self.parent_setup_sdp(sdp, info) } - fn new_stream(&self, media: &Self::Type, stream: &crate::RTSPStream) { - self.parent_new_stream(media, stream); + fn new_stream(&self, stream: &crate::RTSPStream) { + self.parent_new_stream(stream); } - fn removed_stream(&self, media: &Self::Type, stream: &crate::RTSPStream) { - self.parent_removed_stream(media, stream); + fn removed_stream(&self, stream: &crate::RTSPStream) { + self.parent_removed_stream(stream); } - fn prepared(&self, media: &Self::Type) { - self.parent_prepared(media); + fn prepared(&self) { + self.parent_prepared(); } - fn unprepared(&self, media: &Self::Type) { - self.parent_unprepared(media); + fn unprepared(&self) { + self.parent_unprepared(); } - fn target_state(&self, media: &Self::Type, state: gst::State) { - self.parent_target_state(media, state); + fn target_state(&self, state: gst::State) { + self.parent_target_state(state); } - fn new_state(&self, media: &Self::Type, state: gst::State) { - self.parent_new_state(media, state); + fn new_state(&self, state: gst::State) { + self.parent_new_state(state); } - fn handle_sdp( - &self, - media: &Self::Type, - sdp: &gst_sdp::SDPMessageRef, - ) -> Result<(), gst::LoggableError> { - self.parent_handle_sdp(media, sdp) + fn handle_sdp(&self, sdp: &gst_sdp::SDPMessageRef) -> Result<(), gst::LoggableError> { + self.parent_handle_sdp(sdp) } } pub trait RTSPMediaImplExt: ObjectSubclass { - fn parent_handle_message(&self, media: &Self::Type, message: &gst::MessageRef) -> bool; - fn parent_prepare( - &self, - media: &Self::Type, - thread: &RTSPThread, - ) -> Result<(), gst::LoggableError>; - fn parent_unprepare(&self, media: &Self::Type) -> Result<(), gst::LoggableError>; - fn parent_suspend(&self, media: &Self::Type) -> Result<(), gst::LoggableError>; - fn parent_unsuspend(&self, media: &Self::Type) -> Result<(), gst::LoggableError>; + fn parent_handle_message(&self, message: &gst::MessageRef) -> bool; + fn parent_prepare(&self, thread: &RTSPThread) -> Result<(), gst::LoggableError>; + fn parent_unprepare(&self) -> Result<(), gst::LoggableError>; + fn parent_suspend(&self) -> Result<(), gst::LoggableError>; + fn parent_unsuspend(&self) -> Result<(), gst::LoggableError>; // TODO missing: convert_range - fn parent_query_position(&self, media: &Self::Type) -> Option; - fn parent_query_stop(&self, media: &Self::Type) -> Option; - fn parent_create_rtpbin(&self, media: &Self::Type) -> Option; - fn parent_setup_rtpbin( - &self, - media: &Self::Type, - rtpbin: &gst::Element, - ) -> Result<(), gst::LoggableError>; + fn parent_query_position(&self) -> Option; + fn parent_query_stop(&self) -> Option; + fn parent_create_rtpbin(&self) -> Option; + fn parent_setup_rtpbin(&self, rtpbin: &gst::Element) -> Result<(), gst::LoggableError>; fn parent_setup_sdp( &self, - media: &Self::Type, sdp: &mut gst_sdp::SDPMessageRef, info: &SDPInfo, ) -> Result<(), gst::LoggableError>; - fn parent_new_stream(&self, media: &Self::Type, stream: &crate::RTSPStream); - fn parent_removed_stream(&self, media: &Self::Type, stream: &crate::RTSPStream); - fn parent_prepared(&self, media: &Self::Type); - fn parent_unprepared(&self, media: &Self::Type); - fn parent_target_state(&self, media: &Self::Type, state: gst::State); - fn parent_new_state(&self, media: &Self::Type, state: gst::State); - fn parent_handle_sdp( - &self, - media: &Self::Type, - sdp: &gst_sdp::SDPMessageRef, - ) -> Result<(), gst::LoggableError>; + fn parent_new_stream(&self, stream: &crate::RTSPStream); + fn parent_removed_stream(&self, stream: &crate::RTSPStream); + fn parent_prepared(&self); + fn parent_unprepared(&self); + fn parent_target_state(&self, state: gst::State); + fn parent_new_state(&self, state: gst::State); + fn parent_handle_sdp(&self, sdp: &gst_sdp::SDPMessageRef) -> Result<(), gst::LoggableError>; } impl RTSPMediaImplExt for T { - fn parent_handle_message(&self, media: &Self::Type, message: &gst::MessageRef) -> bool { + fn parent_handle_message(&self, message: &gst::MessageRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).handle_message { from_glib(f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, message.as_ptr() as *mut _, )) } else { @@ -165,18 +146,17 @@ impl RTSPMediaImplExt for T { } } - fn parent_prepare( - &self, - media: &Self::Type, - thread: &RTSPThread, - ) -> Result<(), gst::LoggableError> { + fn parent_prepare(&self, thread: &RTSPThread) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).prepare { gst::result_from_gboolean!( f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, thread.to_glib_none().0 ), gst::CAT_RUST, @@ -188,13 +168,17 @@ impl RTSPMediaImplExt for T { } } - fn parent_unprepare(&self, media: &Self::Type) -> Result<(), gst::LoggableError> { + fn parent_unprepare(&self) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).unprepare { gst::result_from_gboolean!( - f(media.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Parent function `unprepare` failed" ) @@ -204,13 +188,17 @@ impl RTSPMediaImplExt for T { } } - fn parent_suspend(&self, media: &Self::Type) -> Result<(), gst::LoggableError> { + fn parent_suspend(&self) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).suspend { gst::result_from_gboolean!( - f(media.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Parent function `suspend` failed" ) @@ -220,13 +208,17 @@ impl RTSPMediaImplExt for T { } } - fn parent_unsuspend(&self, media: &Self::Type) -> Result<(), gst::LoggableError> { + fn parent_unsuspend(&self) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).unsuspend { gst::result_from_gboolean!( - f(media.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Parent function `unsuspend` failed" ) @@ -238,7 +230,7 @@ impl RTSPMediaImplExt for T { // TODO missing: convert_range - fn parent_query_position(&self, media: &Self::Type) -> Option { + fn parent_query_position(&self) -> Option { unsafe { use std::mem; @@ -247,7 +239,10 @@ impl RTSPMediaImplExt for T { if let Some(f) = (*parent_class).query_position { let mut position = mem::MaybeUninit::uninit(); if f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, position.as_mut_ptr(), ) == glib::ffi::GFALSE { @@ -261,7 +256,7 @@ impl RTSPMediaImplExt for T { } } - fn parent_query_stop(&self, media: &Self::Type) -> Option { + fn parent_query_stop(&self) -> Option { unsafe { use std::mem; @@ -270,7 +265,10 @@ impl RTSPMediaImplExt for T { if let Some(f) = (*parent_class).query_stop { let mut stop = mem::MaybeUninit::uninit(); if f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, stop.as_mut_ptr(), ) == glib::ffi::GFALSE { @@ -284,7 +282,7 @@ impl RTSPMediaImplExt for T { } } - fn parent_create_rtpbin(&self, media: &Self::Type) -> Option { + fn parent_create_rtpbin(&self) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; @@ -292,15 +290,15 @@ impl RTSPMediaImplExt for T { .create_rtpbin .expect("No `create_rtpbin` virtual method implementation in parent class"); - from_glib_none(f(media.unsafe_cast_ref::().to_glib_none().0)) + from_glib_none(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) } } - fn parent_setup_rtpbin( - &self, - media: &Self::Type, - rtpbin: &gst::Element, - ) -> Result<(), gst::LoggableError> { + fn parent_setup_rtpbin(&self, rtpbin: &gst::Element) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; @@ -311,7 +309,13 @@ impl RTSPMediaImplExt for T { glib::gobject_ffi::g_object_force_floating(ptr as *mut _); let res = gst::result_from_gboolean!( - f(media.unsafe_cast_ref::().to_glib_none().0, ptr), + f( + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, + ptr + ), gst::CAT_RUST, "Parent function `setup_sdp` failed" ); @@ -332,7 +336,6 @@ impl RTSPMediaImplExt for T { fn parent_setup_sdp( &self, - media: &Self::Type, sdp: &mut gst_sdp::SDPMessageRef, info: &SDPInfo, ) -> Result<(), gst::LoggableError> { @@ -345,7 +348,10 @@ impl RTSPMediaImplExt for T { gst::result_from_gboolean!( f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, sdp as *mut _ as *mut gst_sdp::ffi::GstSDPMessage, info.0.as_ptr() ), @@ -355,83 +361,99 @@ impl RTSPMediaImplExt for T { } } - fn parent_new_stream(&self, media: &Self::Type, stream: &crate::RTSPStream) { + fn parent_new_stream(&self, stream: &crate::RTSPStream) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).new_stream { f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, stream.to_glib_none().0, ); } } } - fn parent_removed_stream(&self, media: &Self::Type, stream: &crate::RTSPStream) { + fn parent_removed_stream(&self, stream: &crate::RTSPStream) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).removed_stream { f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, stream.to_glib_none().0, ); } } } - fn parent_prepared(&self, media: &Self::Type) { + fn parent_prepared(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).prepared { - f(media.unsafe_cast_ref::().to_glib_none().0); + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0); } } } - fn parent_unprepared(&self, media: &Self::Type) { + fn parent_unprepared(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).unprepared { - f(media.unsafe_cast_ref::().to_glib_none().0); + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0); } } } - fn parent_target_state(&self, media: &Self::Type, state: gst::State) { + fn parent_target_state(&self, state: gst::State) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).target_state { f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, state.into_glib(), ); } } } - fn parent_new_state(&self, media: &Self::Type, state: gst::State) { + fn parent_new_state(&self, state: gst::State) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; if let Some(f) = (*parent_class).new_state { f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, state.into_glib(), ); } } } - fn parent_handle_sdp( - &self, - media: &Self::Type, - sdp: &gst_sdp::SDPMessageRef, - ) -> Result<(), gst::LoggableError> { + fn parent_handle_sdp(&self, sdp: &gst_sdp::SDPMessageRef) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaClass; @@ -441,7 +463,10 @@ impl RTSPMediaImplExt for T { gst::result_from_gboolean!( f( - media.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, sdp as *const _ as *mut gst_sdp::ffi::GstSDPMessage ), gst::CAT_RUST, @@ -480,9 +505,8 @@ unsafe extern "C" fn media_handle_message( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.handle_message(wrap.unsafe_cast_ref(), gst::MessageRef::from_ptr(message)) + imp.handle_message(gst::MessageRef::from_ptr(message)) .into_glib() } @@ -492,12 +516,11 @@ unsafe extern "C" fn media_prepare( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.prepare(wrap.unsafe_cast_ref(), &from_glib_borrow(thread)) { + match imp.prepare(&from_glib_borrow(thread)) { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } } @@ -508,12 +531,11 @@ unsafe extern "C" fn media_unprepare( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.unprepare(wrap.unsafe_cast_ref()) { + match imp.unprepare() { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } } @@ -524,12 +546,11 @@ unsafe extern "C" fn media_suspend( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.suspend(wrap.unsafe_cast_ref()) { + match imp.suspend() { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } } @@ -540,12 +561,11 @@ unsafe extern "C" fn media_unsuspend( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.unsuspend(wrap.unsafe_cast_ref()) { + match imp.unsuspend() { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } } @@ -557,9 +577,8 @@ unsafe extern "C" fn media_query_position( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.query_position(wrap.unsafe_cast_ref()) { + match imp.query_position() { Some(pos) => { *position = pos.into_glib() as i64; glib::ffi::GTRUE @@ -574,9 +593,8 @@ unsafe extern "C" fn media_query_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.query_stop(wrap.unsafe_cast_ref()) { + match imp.query_stop() { Some(s) => { *stop = s.into_glib() as i64; glib::ffi::GTRUE @@ -590,9 +608,8 @@ unsafe extern "C" fn media_create_rtpbin( ) -> *mut gst::ffi::GstElement { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let res: *mut gst::ffi::GstElement = imp.create_rtpbin(wrap.unsafe_cast_ref()).to_glib_full(); + let res: *mut gst::ffi::GstElement = imp.create_rtpbin().to_glib_full(); if !res.is_null() { glib::gobject_ffi::g_object_force_floating(res as *mut _); @@ -607,7 +624,6 @@ unsafe extern "C" fn media_setup_rtpbin( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // If the rtpbin was floating before make sure it is not anymore for now so // we don't accidentally take ownership of it somewhere along the line @@ -615,10 +631,10 @@ unsafe extern "C" fn media_setup_rtpbin( glib::gobject_ffi::g_object_ref_sink(rtpbin as *mut _); } - let res = match imp.setup_rtpbin(wrap.unsafe_cast_ref(), &from_glib_borrow(rtpbin)) { + let res = match imp.setup_rtpbin(&from_glib_borrow(rtpbin)) { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } }; @@ -636,16 +652,14 @@ unsafe extern "C" fn media_setup_sdp( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); match imp.setup_sdp( - wrap.unsafe_cast_ref(), &mut *(sdp as *mut gst_sdp::SDPMessageRef), &SDPInfo(ptr::NonNull::new(info).expect("NULL SDPInfo")), ) { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } } @@ -657,9 +671,8 @@ unsafe extern "C" fn media_new_stream( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.new_stream(wrap.unsafe_cast_ref(), &from_glib_borrow(stream)); + imp.new_stream(&from_glib_borrow(stream)); } unsafe extern "C" fn media_removed_stream( @@ -668,25 +681,22 @@ unsafe extern "C" fn media_removed_stream( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.removed_stream(wrap.unsafe_cast_ref(), &from_glib_borrow(stream)); + imp.removed_stream(&from_glib_borrow(stream)); } unsafe extern "C" fn media_prepared(ptr: *mut ffi::GstRTSPMedia) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.prepared(wrap.unsafe_cast_ref()); + imp.prepared(); } unsafe extern "C" fn media_unprepared(ptr: *mut ffi::GstRTSPMedia) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.unprepared(wrap.unsafe_cast_ref()); + imp.unprepared(); } unsafe extern "C" fn media_target_state( @@ -695,9 +705,8 @@ unsafe extern "C" fn media_target_state( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.target_state(wrap.unsafe_cast_ref(), from_glib(state)); + imp.target_state(from_glib(state)); } unsafe extern "C" fn media_new_state( @@ -706,9 +715,8 @@ unsafe extern "C" fn media_new_state( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.new_state(wrap.unsafe_cast_ref(), from_glib(state)); + imp.new_state(from_glib(state)); } unsafe extern "C" fn media_handle_sdp( @@ -717,15 +725,11 @@ unsafe extern "C" fn media_handle_sdp( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.handle_sdp( - wrap.unsafe_cast_ref(), - &*(sdp as *const gst_sdp::SDPMessageRef), - ) { + match imp.handle_sdp(&*(sdp as *const gst_sdp::SDPMessageRef)) { Ok(()) => glib::ffi::GTRUE, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); glib::ffi::GFALSE } } diff --git a/gstreamer-rtsp-server/src/subclass/rtsp_media_factory.rs b/gstreamer-rtsp-server/src/subclass/rtsp_media_factory.rs index cf2a92ad8..50c0c19b4 100644 --- a/gstreamer-rtsp-server/src/subclass/rtsp_media_factory.rs +++ b/gstreamer-rtsp-server/src/subclass/rtsp_media_factory.rs @@ -9,80 +9,52 @@ use crate::RTSPMediaFactory; use std::mem::transmute; pub trait RTSPMediaFactoryImpl: RTSPMediaFactoryImplExt + ObjectImpl + Send + Sync { - fn gen_key(&self, factory: &Self::Type, url: &gst_rtsp::RTSPUrl) -> Option { - self.parent_gen_key(factory, url) + fn gen_key(&self, url: &gst_rtsp::RTSPUrl) -> Option { + self.parent_gen_key(url) } - fn create_element( - &self, - factory: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { - self.parent_create_element(factory, url) + fn create_element(&self, url: &gst_rtsp::RTSPUrl) -> Option { + self.parent_create_element(url) } - fn construct(&self, factory: &Self::Type, url: &gst_rtsp::RTSPUrl) -> Option { - self.parent_construct(factory, url) + fn construct(&self, url: &gst_rtsp::RTSPUrl) -> Option { + self.parent_construct(url) } - fn create_pipeline( - &self, - factory: &Self::Type, - media: &crate::RTSPMedia, - ) -> Option { - self.parent_create_pipeline(factory, media) + fn create_pipeline(&self, media: &crate::RTSPMedia) -> Option { + self.parent_create_pipeline(media) } - fn configure(&self, factory: &Self::Type, media: &crate::RTSPMedia) { - self.parent_configure(factory, media) + fn configure(&self, media: &crate::RTSPMedia) { + self.parent_configure(media) } - fn media_constructed(&self, factory: &Self::Type, media: &crate::RTSPMedia) { - self.parent_media_constructed(factory, media) + fn media_constructed(&self, media: &crate::RTSPMedia) { + self.parent_media_constructed(media) } - fn media_configure(&self, factory: &Self::Type, media: &crate::RTSPMedia) { - self.parent_media_configure(factory, media) + fn media_configure(&self, media: &crate::RTSPMedia) { + self.parent_media_configure(media) } } pub trait RTSPMediaFactoryImplExt: ObjectSubclass { - fn parent_gen_key( - &self, - factory: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option; + fn parent_gen_key(&self, url: &gst_rtsp::RTSPUrl) -> Option; - fn parent_create_element( - &self, - factory: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option; + fn parent_create_element(&self, url: &gst_rtsp::RTSPUrl) -> Option; - fn parent_construct( - &self, - factory: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option; + fn parent_construct(&self, url: &gst_rtsp::RTSPUrl) -> Option; - fn parent_create_pipeline( - &self, - factory: &Self::Type, - media: &crate::RTSPMedia, - ) -> Option; + fn parent_create_pipeline(&self, media: &crate::RTSPMedia) -> Option; - fn parent_configure(&self, factory: &Self::Type, media: &crate::RTSPMedia); + fn parent_configure(&self, media: &crate::RTSPMedia); - fn parent_media_constructed(&self, factory: &Self::Type, media: &crate::RTSPMedia); - fn parent_media_configure(&self, factory: &Self::Type, media: &crate::RTSPMedia); + fn parent_media_constructed(&self, media: &crate::RTSPMedia); + fn parent_media_configure(&self, media: &crate::RTSPMedia); } impl RTSPMediaFactoryImplExt for T { - fn parent_gen_key( - &self, - factory: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { + fn parent_gen_key(&self, url: &gst_rtsp::RTSPUrl) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaFactoryClass; @@ -90,7 +62,7 @@ impl RTSPMediaFactoryImplExt for T { .gen_key .map(|f| { from_glib_full(f( - factory + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -101,11 +73,7 @@ impl RTSPMediaFactoryImplExt for T { } } - fn parent_create_element( - &self, - factory: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { + fn parent_create_element(&self, url: &gst_rtsp::RTSPUrl) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaFactoryClass; @@ -113,7 +81,7 @@ impl RTSPMediaFactoryImplExt for T { .create_element .map(|f| { from_glib_none(f( - factory + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -124,11 +92,7 @@ impl RTSPMediaFactoryImplExt for T { } } - fn parent_construct( - &self, - factory: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { + fn parent_construct(&self, url: &gst_rtsp::RTSPUrl) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaFactoryClass; @@ -136,7 +100,7 @@ impl RTSPMediaFactoryImplExt for T { .construct .map(|f| { from_glib_full(f( - factory + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -147,11 +111,7 @@ impl RTSPMediaFactoryImplExt for T { } } - fn parent_create_pipeline( - &self, - factory: &Self::Type, - media: &crate::RTSPMedia, - ) -> Option { + fn parent_create_pipeline(&self, media: &crate::RTSPMedia) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaFactoryClass; @@ -159,7 +119,7 @@ impl RTSPMediaFactoryImplExt for T { .create_pipeline .map(|f| { let ptr = f( - factory + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -176,13 +136,13 @@ impl RTSPMediaFactoryImplExt for T { } } - fn parent_configure(&self, factory: &Self::Type, media: &crate::RTSPMedia) { + fn parent_configure(&self, media: &crate::RTSPMedia) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaFactoryClass; if let Some(f) = (*parent_class).configure { f( - factory + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -192,13 +152,13 @@ impl RTSPMediaFactoryImplExt for T { } } - fn parent_media_constructed(&self, factory: &Self::Type, media: &crate::RTSPMedia) { + fn parent_media_constructed(&self, media: &crate::RTSPMedia) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaFactoryClass; if let Some(f) = (*parent_class).media_constructed { f( - factory + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -208,13 +168,13 @@ impl RTSPMediaFactoryImplExt for T { } } - fn parent_media_configure(&self, factory: &Self::Type, media: &crate::RTSPMedia) { + fn parent_media_configure(&self, media: &crate::RTSPMedia) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMediaFactoryClass; if let Some(f) = (*parent_class).media_configure { f( - factory + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -244,10 +204,8 @@ unsafe extern "C" fn factory_gen_key( ) -> *mut std::os::raw::c_char { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.gen_key(wrap.unsafe_cast_ref(), &from_glib_borrow(url)) - .to_glib_full() + imp.gen_key(&from_glib_borrow(url)).to_glib_full() } unsafe extern "C" fn factory_create_element( @@ -256,11 +214,8 @@ unsafe extern "C" fn factory_create_element( ) -> *mut gst::ffi::GstElement { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let element = imp - .create_element(wrap.unsafe_cast_ref(), &from_glib_borrow(url)) - .to_glib_full(); + let element = imp.create_element(&from_glib_borrow(url)).to_glib_full(); glib::gobject_ffi::g_object_force_floating(element as *mut _); element } @@ -271,10 +226,8 @@ unsafe extern "C" fn factory_construct( ) -> *mut ffi::GstRTSPMedia { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.construct(wrap.unsafe_cast_ref(), &from_glib_borrow(url)) - .to_glib_full() + imp.construct(&from_glib_borrow(url)).to_glib_full() } unsafe extern "C" fn factory_create_pipeline( @@ -288,11 +241,9 @@ unsafe extern "C" fn factory_create_pipeline( let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let pipeline: *mut gst::ffi::GstPipeline = imp - .create_pipeline(wrap.unsafe_cast_ref(), &from_glib_borrow(media)) - .to_glib_full(); + let pipeline: *mut gst::ffi::GstPipeline = + imp.create_pipeline(&from_glib_borrow(media)).to_glib_full(); // FIXME We somehow need to ensure the pipeline actually stays alive... glib::gobject_ffi::g_object_set_qdata_full( @@ -313,9 +264,8 @@ unsafe extern "C" fn factory_configure( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.configure(wrap.unsafe_cast_ref(), &from_glib_borrow(media)); + imp.configure(&from_glib_borrow(media)); } unsafe extern "C" fn factory_media_constructed( @@ -324,9 +274,8 @@ unsafe extern "C" fn factory_media_constructed( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.media_constructed(wrap.unsafe_cast_ref(), &from_glib_borrow(media)); + imp.media_constructed(&from_glib_borrow(media)); } unsafe extern "C" fn factory_media_configure( @@ -335,7 +284,6 @@ unsafe extern "C" fn factory_media_configure( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.media_configure(wrap.unsafe_cast_ref(), &from_glib_borrow(media)); + imp.media_configure(&from_glib_borrow(media)); } diff --git a/gstreamer-rtsp-server/src/subclass/rtsp_mount_points.rs b/gstreamer-rtsp-server/src/subclass/rtsp_mount_points.rs index 0a26ffe84..f81f96f76 100644 --- a/gstreamer-rtsp-server/src/subclass/rtsp_mount_points.rs +++ b/gstreamer-rtsp-server/src/subclass/rtsp_mount_points.rs @@ -8,29 +8,17 @@ use gst_rtsp::ffi::GstRTSPUrl; use crate::RTSPMountPoints; pub trait RTSPMountPointsImpl: RTSPMountPointsImplExt + ObjectImpl + Send + Sync { - fn make_path( - &self, - mount_points: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { - self.parent_make_path(mount_points, url) + fn make_path(&self, url: &gst_rtsp::RTSPUrl) -> Option { + self.parent_make_path(url) } } pub trait RTSPMountPointsImplExt: ObjectSubclass { - fn parent_make_path( - &self, - mount_points: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option; + fn parent_make_path(&self, url: &gst_rtsp::RTSPUrl) -> Option; } impl RTSPMountPointsImplExt for T { - fn parent_make_path( - &self, - mount_points: &Self::Type, - url: &gst_rtsp::RTSPUrl, - ) -> Option { + fn parent_make_path(&self, url: &gst_rtsp::RTSPUrl) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPMountPointsClass; @@ -38,7 +26,7 @@ impl RTSPMountPointsImplExt for T { .make_path .expect("No `make_path` virtual method implementation in parent class"); from_glib_full(f( - mount_points + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -62,8 +50,6 @@ unsafe extern "C" fn mount_points_make_path( ) -> *mut std::os::raw::c_char { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.make_path(wrap.unsafe_cast_ref(), &from_glib_borrow(url)) - .to_glib_full() + imp.make_path(&from_glib_borrow(url)).to_glib_full() } diff --git a/gstreamer-rtsp-server/src/subclass/rtsp_onvif_media_factory.rs b/gstreamer-rtsp-server/src/subclass/rtsp_onvif_media_factory.rs index 623915ac4..be8e08e5f 100644 --- a/gstreamer-rtsp-server/src/subclass/rtsp_onvif_media_factory.rs +++ b/gstreamer-rtsp-server/src/subclass/rtsp_onvif_media_factory.rs @@ -10,17 +10,17 @@ use crate::RTSPOnvifMediaFactory; pub trait RTSPOnvifMediaFactoryImpl: RTSPMediaFactoryImplExt + RTSPMediaFactoryImpl + Send + Sync { - fn has_backchannel_support(&self, factory: &Self::Type) -> bool { - self.parent_has_backchannel_support(factory) + fn has_backchannel_support(&self) -> bool { + self.parent_has_backchannel_support() } } pub trait RTSPOnvifMediaFactoryImplExt: ObjectSubclass { - fn parent_has_backchannel_support(&self, factory: &Self::Type) -> bool; + fn parent_has_backchannel_support(&self) -> bool; } impl RTSPOnvifMediaFactoryImplExt for T { - fn parent_has_backchannel_support(&self, factory: &Self::Type) -> bool { + fn parent_has_backchannel_support(&self) -> bool { unsafe { let data = Self::type_data(); let parent_class = @@ -28,7 +28,8 @@ impl RTSPOnvifMediaFactoryImplExt for T { (*parent_class) .has_backchannel_support .map(|f| { - from_glib(f(factory + from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -51,8 +52,6 @@ unsafe extern "C" fn factory_has_backchannel_support glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.has_backchannel_support(wrap.unsafe_cast_ref()) - .into_glib() + imp.has_backchannel_support().into_glib() } diff --git a/gstreamer-rtsp-server/src/subclass/rtsp_server.rs b/gstreamer-rtsp-server/src/subclass/rtsp_server.rs index 6206e0d03..06edd45b4 100644 --- a/gstreamer-rtsp-server/src/subclass/rtsp_server.rs +++ b/gstreamer-rtsp-server/src/subclass/rtsp_server.rs @@ -7,40 +7,47 @@ use glib::translate::*; use crate::RTSPServer; pub trait RTSPServerImpl: RTSPServerImplExt + ObjectImpl + Send + Sync { - fn create_client(&self, server: &Self::Type) -> Option { - self.parent_create_client(server) + fn create_client(&self) -> Option { + self.parent_create_client() } - fn client_connected(&self, server: &Self::Type, client: &crate::RTSPClient) { - self.parent_client_connected(server, client); + fn client_connected(&self, client: &crate::RTSPClient) { + self.parent_client_connected(client); } } pub trait RTSPServerImplExt: ObjectSubclass { - fn parent_create_client(&self, server: &Self::Type) -> Option; + fn parent_create_client(&self) -> Option; - fn parent_client_connected(&self, server: &Self::Type, client: &crate::RTSPClient); + fn parent_client_connected(&self, client: &crate::RTSPClient); } impl RTSPServerImplExt for T { - fn parent_create_client(&self, server: &Self::Type) -> Option { + fn parent_create_client(&self) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPServerClass; let f = (*parent_class) .create_client .expect("No `create_client` virtual method implementation in parent class"); - from_glib_full(f(server.unsafe_cast_ref::().to_glib_none().0)) + from_glib_full(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) } } - fn parent_client_connected(&self, server: &Self::Type, client: &crate::RTSPClient) { + fn parent_client_connected(&self, client: &crate::RTSPClient) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPServerClass; if let Some(f) = (*parent_class).client_connected { f( - server.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, client.to_glib_none().0, ) } @@ -61,9 +68,8 @@ unsafe extern "C" fn server_create_client( ) -> *mut ffi::GstRTSPClient { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.create_client(wrap.unsafe_cast_ref()).to_glib_full() + imp.create_client().to_glib_full() } unsafe extern "C" fn server_client_connected( @@ -72,7 +78,6 @@ unsafe extern "C" fn server_client_connected( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.client_connected(wrap.unsafe_cast_ref(), &from_glib_borrow(client)); + imp.client_connected(&from_glib_borrow(client)); } diff --git a/gstreamer-video/src/subclass/navigation.rs b/gstreamer-video/src/subclass/navigation.rs index 987ae0458..bcb1dfe6b 100644 --- a/gstreamer-video/src/subclass/navigation.rs +++ b/gstreamer-video/src/subclass/navigation.rs @@ -8,31 +8,31 @@ use glib::subclass::prelude::*; use crate::Navigation; pub trait NavigationImpl: ObjectImpl { - fn send_event(&self, nav: &Self::Type, structure: gst::Structure); + fn send_event(&self, structure: gst::Structure); #[cfg(any(feature = "v1_22", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))] - fn send_event_simple(&self, nav: &Self::Type, event: gst::Event) { + fn send_event_simple(&self, event: gst::Event) { if let Some(structure) = event.structure() { - self.send_event(nav, structure.to_owned()); + self.send_event(structure.to_owned()); } } } pub trait NavigationImplExt: ObjectSubclass { - fn parent_send_event(&self, nav: &Self::Type, structure: gst::Structure); + fn parent_send_event(&self, structure: gst::Structure); #[cfg(any(feature = "v1_22", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))] - fn parent_send_event_simple(&self, nav: &Self::Type, event: gst::Event) { + fn parent_send_event_simple(&self, event: gst::Event) { if let Some(structure) = event.structure() { - self.parent_send_event(nav, structure.to_owned()); + self.parent_send_event(structure.to_owned()); } } } impl NavigationImplExt for T { - fn parent_send_event(&self, nav: &Self::Type, structure: gst::Structure) { + fn parent_send_event(&self, structure: gst::Structure) { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -44,7 +44,10 @@ impl NavigationImplExt for T { }; func( - nav.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, structure.into_glib_ptr(), ); } @@ -52,7 +55,7 @@ impl NavigationImplExt for T { #[cfg(any(feature = "v1_22", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))] - fn parent_send_event_simple(&self, nav: &Self::Type, event: gst::Event) { + fn parent_send_event_simple(&self, event: gst::Event) { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -64,7 +67,10 @@ impl NavigationImplExt for T { }; func( - nav.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), ); } @@ -96,10 +102,7 @@ unsafe extern "C" fn navigation_send_event( let instance = &*(nav as *mut T::Instance); let imp = instance.imp(); - imp.send_event( - from_glib_borrow::<_, Navigation>(nav).unsafe_cast_ref(), - from_glib_full(structure), - ); + imp.send_event(from_glib_full(structure)); } #[cfg(any(feature = "v1_22", feature = "dox"))] @@ -111,8 +114,5 @@ unsafe extern "C" fn navigation_send_event_simple( let instance = &*(nav as *mut T::Instance); let imp = instance.imp(); - imp.send_event_simple( - from_glib_borrow::<_, Navigation>(nav).unsafe_cast_ref(), - from_glib_full(event), - ); + imp.send_event_simple(from_glib_full(event)); } diff --git a/gstreamer-video/src/subclass/video_aggregator.rs b/gstreamer-video/src/subclass/video_aggregator.rs index b26f96617..65b7f6122 100644 --- a/gstreamer-video/src/subclass/video_aggregator.rs +++ b/gstreamer-video/src/subclass/video_aggregator.rs @@ -13,71 +13,46 @@ use crate::VideoAggregator; pub struct AggregateFramesToken<'a>(pub(crate) &'a VideoAggregator); pub trait VideoAggregatorImpl: VideoAggregatorImplExt + AggregatorImpl { - fn update_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result { - self.parent_update_caps(element, caps) + fn update_caps(&self, caps: &gst::Caps) -> Result { + self.parent_update_caps(caps) } fn aggregate_frames( &self, - element: &Self::Type, token: &AggregateFramesToken, outbuf: &mut gst::BufferRef, ) -> Result { - self.parent_aggregate_frames(element, token, outbuf) + self.parent_aggregate_frames(token, outbuf) } - fn create_output_buffer( - &self, - element: &Self::Type, - ) -> Result, gst::FlowError> { - self.parent_create_output_buffer(element) + fn create_output_buffer(&self) -> Result, gst::FlowError> { + self.parent_create_output_buffer() } - fn find_best_format( - &self, - element: &Self::Type, - downstream_caps: &gst::Caps, - ) -> Option<(crate::VideoInfo, bool)> { - self.parent_find_best_format(element, downstream_caps) + fn find_best_format(&self, downstream_caps: &gst::Caps) -> Option<(crate::VideoInfo, bool)> { + self.parent_find_best_format(downstream_caps) } } pub trait VideoAggregatorImplExt: ObjectSubclass { - fn parent_update_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result; + fn parent_update_caps(&self, caps: &gst::Caps) -> Result; fn parent_aggregate_frames( &self, - element: &Self::Type, token: &AggregateFramesToken, outbuf: &mut gst::BufferRef, ) -> Result; - fn parent_create_output_buffer( - &self, - element: &Self::Type, - ) -> Result, gst::FlowError>; + fn parent_create_output_buffer(&self) -> Result, gst::FlowError>; fn parent_find_best_format( &self, - element: &Self::Type, downstream_caps: &gst::Caps, ) -> Option<(crate::VideoInfo, bool)>; } impl VideoAggregatorImplExt for T { - fn parent_update_caps( - &self, - element: &Self::Type, - caps: &gst::Caps, - ) -> Result { + fn parent_update_caps(&self, caps: &gst::Caps) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoAggregatorClass; @@ -86,7 +61,7 @@ impl VideoAggregatorImplExt for T { .expect("Missing parent function `update_caps`"); Option::<_>::from_glib_full(f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -100,12 +75,11 @@ impl VideoAggregatorImplExt for T { fn parent_aggregate_frames( &self, - element: &Self::Type, token: &AggregateFramesToken, outbuf: &mut gst::BufferRef, ) -> Result { assert_eq!( - element.as_ptr() as *mut ffi::GstVideoAggregator, + self.instance().as_ptr() as *mut ffi::GstVideoAggregator, token.0.as_ptr() as *mut ffi::GstVideoAggregator ); @@ -117,7 +91,7 @@ impl VideoAggregatorImplExt for T { .expect("Missing parent function `aggregate_frames`"); try_from_glib(f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -127,10 +101,7 @@ impl VideoAggregatorImplExt for T { } } - fn parent_create_output_buffer( - &self, - element: &Self::Type, - ) -> Result, gst::FlowError> { + fn parent_create_output_buffer(&self) -> Result, gst::FlowError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoAggregatorClass; @@ -140,7 +111,7 @@ impl VideoAggregatorImplExt for T { let mut buffer = ptr::null_mut(); try_from_glib(f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -152,7 +123,6 @@ impl VideoAggregatorImplExt for T { fn parent_find_best_format( &self, - element: &Self::Type, downstream_caps: &gst::Caps, ) -> Option<(crate::VideoInfo, bool)> { unsafe { @@ -166,7 +136,7 @@ impl VideoAggregatorImplExt for T { let mut at_least_one_alpha = glib::ffi::GFALSE; f( - element + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -206,13 +176,12 @@ unsafe extern "C" fn video_aggregator_update_caps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), ptr::null_mut(), { - match imp.update_caps(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) { + gst::panic_to_error!(imp, ptr::null_mut(), { + match imp.update_caps(&from_glib_borrow(caps)) { Ok(caps) => caps.into_glib_ptr(), Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); ptr::null_mut() } } @@ -225,13 +194,13 @@ unsafe extern "C" fn video_aggregator_aggregate_frames( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - let token = AggregateFramesToken(&*wrap); + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + let instance = imp.instance(); + let instance = instance.unsafe_cast_ref::(); + let token = AggregateFramesToken(instance); imp.aggregate_frames( - wrap.unsafe_cast_ref(), &token, gst::BufferRef::from_mut_ptr( // Wrong pointer type @@ -249,10 +218,9 @@ unsafe extern "C" fn video_aggregator_create_output_buffer gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - match imp.create_output_buffer(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + match imp.create_output_buffer() { Ok(buffer) => { *outbuf = buffer.map(|b| b.into_glib_ptr()).unwrap_or(ptr::null_mut()); Ok(gst::FlowSuccess::Ok) @@ -275,10 +243,9 @@ unsafe extern "C" fn video_aggregator_find_best_format( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), (), { - match imp.find_best_format(wrap.unsafe_cast_ref(), &from_glib_borrow(downstream_caps)) { + gst::panic_to_error!(imp, (), { + match imp.find_best_format(&from_glib_borrow(downstream_caps)) { None => (), Some((info, alpha)) => { *best_info = *info.to_glib_none().0; diff --git a/gstreamer-video/src/subclass/video_aggregator_pad.rs b/gstreamer-video/src/subclass/video_aggregator_pad.rs index 7b75c06d0..187f55ad9 100644 --- a/gstreamer-video/src/subclass/video_aggregator_pad.rs +++ b/gstreamer-video/src/subclass/video_aggregator_pad.rs @@ -13,37 +13,34 @@ use crate::VideoAggregator; use crate::VideoAggregatorPad; pub trait VideoAggregatorPadImpl: VideoAggregatorPadImplExt + AggregatorPadImpl { - fn update_conversion_info(&self, pad: &Self::Type) { - self.parent_update_conversion_info(pad) + fn update_conversion_info(&self) { + self.parent_update_conversion_info() } fn prepare_frame( &self, - pad: &Self::Type, aggregator: &crate::VideoAggregator, token: &AggregateFramesToken, buffer: &gst::Buffer, ) -> Option> { - self.parent_prepare_frame(pad, aggregator, token, buffer) + self.parent_prepare_frame(aggregator, token, buffer) } fn clean_frame( &self, - pad: &Self::Type, aggregator: &crate::VideoAggregator, token: &AggregateFramesToken, frame: Option>, ) { - self.parent_clean_frame(pad, aggregator, token, frame) + self.parent_clean_frame(aggregator, token, frame) } } pub trait VideoAggregatorPadImplExt: ObjectSubclass { - fn parent_update_conversion_info(&self, pad: &Self::Type); + fn parent_update_conversion_info(&self); fn parent_prepare_frame( &self, - pad: &Self::Type, aggregator: &crate::VideoAggregator, token: &AggregateFramesToken, buffer: &gst::Buffer, @@ -51,7 +48,6 @@ pub trait VideoAggregatorPadImplExt: ObjectSubclass { fn parent_clean_frame( &self, - pad: &Self::Type, aggregator: &crate::VideoAggregator, token: &AggregateFramesToken, frame: Option>, @@ -59,19 +55,22 @@ pub trait VideoAggregatorPadImplExt: ObjectSubclass { } impl VideoAggregatorPadImplExt for T { - fn parent_update_conversion_info(&self, pad: &Self::Type) { + fn parent_update_conversion_info(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoAggregatorPadClass; if let Some(f) = (*parent_class).update_conversion_info { - f(pad.unsafe_cast_ref::().to_glib_none().0); + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0); } } } fn parent_prepare_frame( &self, - pad: &Self::Type, aggregator: &crate::VideoAggregator, token: &AggregateFramesToken, buffer: &gst::Buffer, @@ -88,7 +87,10 @@ impl VideoAggregatorPadImplExt for T { let mut prepared_frame = mem::MaybeUninit::zeroed(); f( - pad.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, aggregator.to_glib_none().0, buffer.as_mut_ptr(), prepared_frame.as_mut_ptr(), @@ -108,7 +110,6 @@ impl VideoAggregatorPadImplExt for T { fn parent_clean_frame( &self, - pad: &Self::Type, aggregator: &crate::VideoAggregator, token: &AggregateFramesToken, frame: Option>, @@ -129,7 +130,10 @@ impl VideoAggregatorPadImplExt for T { }; f( - pad.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, aggregator.to_glib_none().0, &mut prepared_frame, ); @@ -154,9 +158,8 @@ unsafe extern "C" fn video_aggregator_pad_update_conversion_info = from_glib_borrow(ptr); - imp.update_conversion_info(wrap.unsafe_cast_ref()); + imp.update_conversion_info(); } unsafe extern "C" fn video_aggregator_pad_prepare_frame( @@ -167,17 +170,11 @@ unsafe extern "C" fn video_aggregator_pad_prepare_frame glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let aggregator: Borrowed = from_glib_borrow(aggregator); let token = AggregateFramesToken(&*aggregator); - match imp.prepare_frame( - wrap.unsafe_cast_ref(), - &aggregator, - &token, - &from_glib_borrow(buffer), - ) { + match imp.prepare_frame(&aggregator, &token, &from_glib_borrow(buffer)) { Some(frame) => { *prepared_frame = frame.into_raw(); } @@ -196,7 +193,6 @@ unsafe extern "C" fn video_aggregator_pad_clean_frame ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let aggregator: Borrowed = from_glib_borrow(aggregator); let token = AggregateFramesToken(&*aggregator); @@ -209,5 +205,5 @@ unsafe extern "C" fn video_aggregator_pad_clean_frame Some(frame) }; - imp.clean_frame(wrap.unsafe_cast_ref(), &aggregator, &token, frame); + imp.clean_frame(&aggregator, &token, frame); } diff --git a/gstreamer-video/src/subclass/video_decoder.rs b/gstreamer-video/src/subclass/video_decoder.rs index 1cee636f3..0bd15a688 100644 --- a/gstreamer-video/src/subclass/video_decoder.rs +++ b/gstreamer-video/src/subclass/video_decoder.rs @@ -10,134 +10,123 @@ use crate::VideoCodecFrame; use crate::VideoDecoder; pub trait VideoDecoderImpl: VideoDecoderImplExt + ElementImpl { - fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_open(element) + fn open(&self) -> Result<(), gst::ErrorMessage> { + self.parent_open() } - fn close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_close(element) + fn close(&self) -> Result<(), gst::ErrorMessage> { + self.parent_close() } - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(element) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(element) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } - fn finish(&self, element: &Self::Type) -> Result { - self.parent_finish(element) + fn finish(&self) -> Result { + self.parent_finish() } - fn drain(&self, element: &Self::Type) -> Result { - self.parent_drain(element) + fn drain(&self) -> Result { + self.parent_drain() } fn set_format( &self, - element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError> { - self.parent_set_format(element, state) + self.parent_set_format(state) } fn parse( &self, - element: &Self::Type, frame: &VideoCodecFrame, adapter: &gst_base::Adapter, at_eos: bool, ) -> Result { - self.parent_parse(element, frame, adapter, at_eos) + self.parent_parse(frame, adapter, at_eos) } - fn handle_frame( - &self, - element: &Self::Type, - frame: VideoCodecFrame, - ) -> Result { - self.parent_handle_frame(element, frame) + fn handle_frame(&self, frame: VideoCodecFrame) -> Result { + self.parent_handle_frame(frame) } - fn flush(&self, element: &Self::Type) -> bool { - self.parent_flush(element) + fn flush(&self) -> bool { + self.parent_flush() } - fn negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { - self.parent_negotiate(element) + fn negotiate(&self) -> Result<(), gst::LoggableError> { + self.parent_negotiate() } - fn caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { - self.parent_caps(element, filter) + fn caps(&self, filter: Option<&gst::Caps>) -> gst::Caps { + self.parent_caps(filter) } - fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_sink_event(element, event) + fn sink_event(&self, event: gst::Event) -> bool { + self.parent_sink_event(event) } - fn sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_sink_query(element, query) + fn sink_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_sink_query(query) } - fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_src_event(element, event) + fn src_event(&self, event: gst::Event) -> bool { + self.parent_src_event(event) } - fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_src_query(element, query) + fn src_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_src_query(query) } fn propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_propose_allocation(element, query) + self.parent_propose_allocation(query) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } #[cfg(any(feature = "v1_20", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] fn handle_missing_data( &self, - element: &Self::Type, timestamp: gst::ClockTime, duration: Option, ) -> bool { - self.parent_handle_missing_data(element, timestamp, duration) + self.parent_handle_missing_data(timestamp, duration) } } pub trait VideoDecoderImplExt: ObjectSubclass { - fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_open(&self) -> Result<(), gst::ErrorMessage>; - fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_close(&self) -> Result<(), gst::ErrorMessage>; - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; - fn parent_finish(&self, element: &Self::Type) -> Result; + fn parent_finish(&self) -> Result; - fn parent_drain(&self, element: &Self::Type) -> Result; + fn parent_drain(&self) -> Result; fn parent_set_format( &self, - element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError>; fn parent_parse( &self, - element: &Self::Type, frame: &VideoCodecFrame, adapter: &gst_base::Adapter, at_eos: bool, @@ -145,33 +134,30 @@ pub trait VideoDecoderImplExt: ObjectSubclass { fn parent_handle_frame( &self, - element: &Self::Type, frame: VideoCodecFrame, ) -> Result; - fn parent_flush(&self, element: &Self::Type) -> bool; + fn parent_flush(&self) -> bool; - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>; + fn parent_negotiate(&self) -> Result<(), gst::LoggableError>; - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps; + fn parent_caps(&self, filter: Option<&gst::Caps>) -> gst::Caps; - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_sink_event(&self, event: gst::Event) -> bool; - fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_sink_query(&self, query: &mut gst::QueryRef) -> bool; - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_src_event(&self, event: gst::Event) -> bool; - fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool; fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; @@ -179,21 +165,21 @@ pub trait VideoDecoderImplExt: ObjectSubclass { #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] fn parent_handle_missing_data( &self, - element: &Self::Type, timestamp: gst::ClockTime, duration: Option, ) -> bool; } impl VideoDecoderImplExt for T { - fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_open(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; (*parent_class) .open .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -210,14 +196,15 @@ impl VideoDecoderImplExt for T { } } - fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_close(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; (*parent_class) .close .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -234,14 +221,15 @@ impl VideoDecoderImplExt for T { } } - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; (*parent_class) .start .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -258,14 +246,15 @@ impl VideoDecoderImplExt for T { } } - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; (*parent_class) .stop .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -282,14 +271,15 @@ impl VideoDecoderImplExt for T { } } - fn parent_finish(&self, element: &Self::Type) -> Result { + fn parent_finish(&self) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; (*parent_class) .finish .map(|f| { - try_from_glib(f(element + try_from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -298,14 +288,15 @@ impl VideoDecoderImplExt for T { } } - fn parent_drain(&self, element: &Self::Type) -> Result { + fn parent_drain(&self) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; (*parent_class) .drain .map(|f| { - try_from_glib(f(element + try_from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -316,7 +307,6 @@ impl VideoDecoderImplExt for T { fn parent_set_format( &self, - element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError> { unsafe { @@ -327,7 +317,10 @@ impl VideoDecoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, state.as_mut_ptr() ), gst::CAT_RUST, @@ -340,7 +333,6 @@ impl VideoDecoderImplExt for T { fn parent_parse( &self, - element: &Self::Type, frame: &VideoCodecFrame, adapter: &gst_base::Adapter, at_eos: bool, @@ -352,7 +344,10 @@ impl VideoDecoderImplExt for T { .parse .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, frame.to_glib_none().0, adapter.to_glib_none().0, at_eos.into_glib(), @@ -364,7 +359,6 @@ impl VideoDecoderImplExt for T { fn parent_handle_frame( &self, - element: &Self::Type, frame: VideoCodecFrame, ) -> Result { unsafe { @@ -374,7 +368,10 @@ impl VideoDecoderImplExt for T { .handle_frame .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, frame.to_glib_none().0, )) }) @@ -382,14 +379,15 @@ impl VideoDecoderImplExt for T { } } - fn parent_flush(&self, element: &Self::Type) -> bool { + fn parent_flush(&self) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; (*parent_class) .flush .map(|f| { - from_glib(f(element + from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -398,7 +396,7 @@ impl VideoDecoderImplExt for T { } } - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { + fn parent_negotiate(&self) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; @@ -406,7 +404,11 @@ impl VideoDecoderImplExt for T { .negotiate .map(|f| { gst::result_from_gboolean!( - f(element.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Parent function `negotiate` failed" ) @@ -415,7 +417,7 @@ impl VideoDecoderImplExt for T { } } - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { + fn parent_caps(&self, filter: Option<&gst::Caps>) -> gst::Caps { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; @@ -423,19 +425,22 @@ impl VideoDecoderImplExt for T { .getcaps .map(|f| { from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, filter.to_glib_none().0, )) }) .unwrap_or_else(|| { - element + self.instance() .unsafe_cast_ref::() .proxy_getcaps(None, filter) }) } } - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_sink_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; @@ -443,13 +448,16 @@ impl VideoDecoderImplExt for T { .sink_event .expect("Missing parent function `sink_event`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_sink_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; @@ -457,13 +465,16 @@ impl VideoDecoderImplExt for T { .sink_query .expect("Missing parent function `sink_query`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } } - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_src_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; @@ -471,13 +482,16 @@ impl VideoDecoderImplExt for T { .src_event .expect("Missing parent function `src_event`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoDecoderClass; @@ -485,7 +499,10 @@ impl VideoDecoderImplExt for T { .src_query .expect("Missing parent function `src_query`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } @@ -493,7 +510,6 @@ impl VideoDecoderImplExt for T { fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -504,7 +520,10 @@ impl VideoDecoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -517,7 +536,6 @@ impl VideoDecoderImplExt for T { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -528,7 +546,10 @@ impl VideoDecoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -543,7 +564,6 @@ impl VideoDecoderImplExt for T { #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] fn parent_handle_missing_data( &self, - element: &Self::Type, timestamp: gst::ClockTime, duration: Option, ) -> bool { @@ -554,7 +574,10 @@ impl VideoDecoderImplExt for T { .handle_missing_data .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, timestamp.into_glib(), duration.into_glib(), )) @@ -598,13 +621,12 @@ unsafe extern "C" fn video_decoder_open( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.open(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.open() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -617,13 +639,12 @@ unsafe extern "C" fn video_decoder_close( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.close(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.close() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -636,13 +657,12 @@ unsafe extern "C" fn video_decoder_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -655,13 +675,12 @@ unsafe extern "C" fn video_decoder_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -674,12 +693,8 @@ unsafe extern "C" fn video_decoder_finish( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.finish(wrap.unsafe_cast_ref()).into() - }) - .into_glib() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { imp.finish().into() }).into_glib() } unsafe extern "C" fn video_decoder_drain( @@ -687,12 +702,8 @@ unsafe extern "C" fn video_decoder_drain( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.drain(wrap.unsafe_cast_ref()).into() - }) - .into_glib() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { imp.drain().into() }).into_glib() } unsafe extern "C" fn video_decoder_set_format( @@ -701,15 +712,14 @@ unsafe extern "C" fn video_decoder_set_format( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); ffi::gst_video_codec_state_ref(state); let wrap_state = VideoCodecState::::new(state); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) { + gst::panic_to_error!(imp, false, { + match imp.set_format(&wrap_state) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -725,15 +735,15 @@ unsafe extern "C" fn video_decoder_parse( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); ffi::gst_video_codec_frame_ref(frame); - let wrap_frame = VideoCodecFrame::new(frame, &*wrap); + let instance = imp.instance(); + let instance = instance.unsafe_cast_ref::(); + let wrap_frame = VideoCodecFrame::new(frame, instance); let wrap_adapter: Borrowed = from_glib_borrow(adapter); let at_eos: bool = from_glib(at_eos); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.parse(wrap.unsafe_cast_ref(), &wrap_frame, &wrap_adapter, at_eos) - .into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.parse(&wrap_frame, &wrap_adapter, at_eos).into() }) .into_glib() } @@ -744,11 +754,12 @@ unsafe extern "C" fn video_decoder_handle_frame( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let wrap_frame = VideoCodecFrame::new(frame, &*wrap); + let instance = imp.instance(); + let instance = instance.unsafe_cast_ref::(); + let wrap_frame = VideoCodecFrame::new(frame, instance); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.handle_frame(wrap_frame).into() }) .into_glib() } @@ -758,12 +769,8 @@ unsafe extern "C" fn video_decoder_flush( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - VideoDecoderImpl::flush(imp, wrap.unsafe_cast_ref()) - }) - .into_glib() + gst::panic_to_error!(imp, false, { VideoDecoderImpl::flush(imp) }).into_glib() } unsafe extern "C" fn video_decoder_negotiate( @@ -771,13 +778,12 @@ unsafe extern "C" fn video_decoder_negotiate( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.negotiate(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.negotiate() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -791,12 +797,10 @@ unsafe extern "C" fn video_decoder_getcaps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { + gst::panic_to_error!(imp, gst::Caps::new_empty(), { VideoDecoderImpl::caps( imp, - wrap.unsafe_cast_ref(), Option::::from_glib_borrow(filter) .as_ref() .as_ref(), @@ -811,12 +815,8 @@ unsafe extern "C" fn video_decoder_sink_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.sink_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn video_decoder_sink_query( @@ -825,10 +825,9 @@ unsafe extern "C" fn video_decoder_sink_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.sink_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -839,12 +838,8 @@ unsafe extern "C" fn video_decoder_src_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.src_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn video_decoder_src_query( @@ -853,10 +848,9 @@ unsafe extern "C" fn video_decoder_src_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.src_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -867,17 +861,16 @@ unsafe extern "C" fn video_decoder_propose_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.propose_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.propose_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -891,17 +884,16 @@ unsafe extern "C" fn video_decoder_decide_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.decide_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -917,11 +909,9 @@ unsafe extern "C" fn video_decoder_handle_missing_data( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), true, { + gst::panic_to_error!(imp, true, { imp.handle_missing_data( - wrap.unsafe_cast_ref(), Option::::from_glib(timestamp).unwrap(), from_glib(duration), ) diff --git a/gstreamer-video/src/subclass/video_encoder.rs b/gstreamer-video/src/subclass/video_encoder.rs index 255870321..76349fd33 100644 --- a/gstreamer-video/src/subclass/video_encoder.rs +++ b/gstreamer-video/src/subclass/video_encoder.rs @@ -10,146 +10,136 @@ use crate::VideoCodecFrame; use crate::VideoEncoder; pub trait VideoEncoderImpl: VideoEncoderImplExt + ElementImpl { - fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_open(element) + fn open(&self) -> Result<(), gst::ErrorMessage> { + self.parent_open() } - fn close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_close(element) + fn close(&self) -> Result<(), gst::ErrorMessage> { + self.parent_close() } - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_start(element) + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - self.parent_stop(element) + fn stop(&self) -> Result<(), gst::ErrorMessage> { + self.parent_stop() } - fn finish(&self, element: &Self::Type) -> Result { - self.parent_finish(element) + fn finish(&self) -> Result { + self.parent_finish() } fn set_format( &self, - element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError> { - self.parent_set_format(element, state) + self.parent_set_format(state) } - fn handle_frame( - &self, - element: &Self::Type, - frame: VideoCodecFrame, - ) -> Result { - self.parent_handle_frame(element, frame) + fn handle_frame(&self, frame: VideoCodecFrame) -> Result { + self.parent_handle_frame(frame) } - fn flush(&self, element: &Self::Type) -> bool { - self.parent_flush(element) + fn flush(&self) -> bool { + self.parent_flush() } - fn negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { - self.parent_negotiate(element) + fn negotiate(&self) -> Result<(), gst::LoggableError> { + self.parent_negotiate() } - fn caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { - self.parent_caps(element, filter) + fn caps(&self, filter: Option<&gst::Caps>) -> gst::Caps { + self.parent_caps(filter) } - fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_sink_event(element, event) + fn sink_event(&self, event: gst::Event) -> bool { + self.parent_sink_event(event) } - fn sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_sink_query(element, query) + fn sink_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_sink_query(query) } - fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool { - self.parent_src_event(element, event) + fn src_event(&self, event: gst::Event) -> bool { + self.parent_src_event(event) } - fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { - self.parent_src_query(element, query) + fn src_query(&self, query: &mut gst::QueryRef) -> bool { + self.parent_src_query(query) } fn propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_propose_allocation(element, query) + self.parent_propose_allocation(query) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } } pub trait VideoEncoderImplExt: ObjectSubclass { - fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_open(&self) -> Result<(), gst::ErrorMessage>; - fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_close(&self) -> Result<(), gst::ErrorMessage>; - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_start(&self) -> Result<(), gst::ErrorMessage>; - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>; + fn parent_stop(&self) -> Result<(), gst::ErrorMessage>; - fn parent_finish(&self, element: &Self::Type) -> Result; + fn parent_finish(&self) -> Result; fn parent_set_format( &self, - element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError>; fn parent_handle_frame( &self, - element: &Self::Type, frame: VideoCodecFrame, ) -> Result; - fn parent_flush(&self, element: &Self::Type) -> bool; + fn parent_flush(&self) -> bool; - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>; + fn parent_negotiate(&self) -> Result<(), gst::LoggableError>; - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps; + fn parent_caps(&self, filter: Option<&gst::Caps>) -> gst::Caps; - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_sink_event(&self, event: gst::Event) -> bool; - fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_sink_query(&self, query: &mut gst::QueryRef) -> bool; - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool; + fn parent_src_event(&self, event: gst::Event) -> bool; - fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool; + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool; fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError>; } impl VideoEncoderImplExt for T { - fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_open(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; (*parent_class) .open .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -166,14 +156,15 @@ impl VideoEncoderImplExt for T { } } - fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_close(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; (*parent_class) .close .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -190,14 +181,15 @@ impl VideoEncoderImplExt for T { } } - fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_start(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; (*parent_class) .start .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -214,14 +206,15 @@ impl VideoEncoderImplExt for T { } } - fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn parent_stop(&self) -> Result<(), gst::ErrorMessage> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; (*parent_class) .stop .map(|f| { - if from_glib(f(element + if from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -238,14 +231,15 @@ impl VideoEncoderImplExt for T { } } - fn parent_finish(&self, element: &Self::Type) -> Result { + fn parent_finish(&self) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; (*parent_class) .finish .map(|f| { - try_from_glib(f(element + try_from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -256,7 +250,6 @@ impl VideoEncoderImplExt for T { fn parent_set_format( &self, - element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError> { unsafe { @@ -267,7 +260,10 @@ impl VideoEncoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, state.as_mut_ptr() ), gst::CAT_RUST, @@ -280,7 +276,6 @@ impl VideoEncoderImplExt for T { fn parent_handle_frame( &self, - element: &Self::Type, frame: VideoCodecFrame, ) -> Result { unsafe { @@ -290,7 +285,10 @@ impl VideoEncoderImplExt for T { .handle_frame .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, frame.to_glib_none().0, )) }) @@ -298,14 +296,15 @@ impl VideoEncoderImplExt for T { } } - fn parent_flush(&self, element: &Self::Type) -> bool { + fn parent_flush(&self) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; (*parent_class) .flush .map(|f| { - from_glib(f(element + from_glib(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -314,7 +313,7 @@ impl VideoEncoderImplExt for T { } } - fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { + fn parent_negotiate(&self) -> Result<(), gst::LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; @@ -322,7 +321,11 @@ impl VideoEncoderImplExt for T { .negotiate .map(|f| { gst::result_from_gboolean!( - f(element.unsafe_cast_ref::().to_glib_none().0), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0), gst::CAT_RUST, "Parent function `negotiate` failed" ) @@ -331,7 +334,7 @@ impl VideoEncoderImplExt for T { } } - fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { + fn parent_caps(&self, filter: Option<&gst::Caps>) -> gst::Caps { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; @@ -339,19 +342,22 @@ impl VideoEncoderImplExt for T { .getcaps .map(|f| { from_glib_full(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, filter.to_glib_none().0, )) }) .unwrap_or_else(|| { - element + self.instance() .unsafe_cast_ref::() .proxy_getcaps(None, filter) }) } } - fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_sink_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; @@ -359,13 +365,16 @@ impl VideoEncoderImplExt for T { .sink_event .expect("Missing parent function `sink_event`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_sink_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; @@ -373,13 +382,16 @@ impl VideoEncoderImplExt for T { .sink_query .expect("Missing parent function `sink_query`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } } - fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn parent_src_event(&self, event: gst::Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; @@ -387,13 +399,16 @@ impl VideoEncoderImplExt for T { .src_event .expect("Missing parent function `src_event`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) } } - fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn parent_src_query(&self, query: &mut gst::QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass; @@ -401,7 +416,10 @@ impl VideoEncoderImplExt for T { .src_query .expect("Missing parent function `src_query`"); from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) } @@ -409,7 +427,6 @@ impl VideoEncoderImplExt for T { fn parent_propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -420,7 +437,10 @@ impl VideoEncoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -433,7 +453,6 @@ impl VideoEncoderImplExt for T { fn parent_decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { unsafe { @@ -444,7 +463,10 @@ impl VideoEncoderImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), ), gst::CAT_RUST, @@ -484,13 +506,12 @@ unsafe extern "C" fn video_encoder_open( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.open(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.open() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -503,13 +524,12 @@ unsafe extern "C" fn video_encoder_close( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.close(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.close() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -522,13 +542,12 @@ unsafe extern "C" fn video_encoder_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.start(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.start() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -541,13 +560,12 @@ unsafe extern "C" fn video_encoder_stop( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.stop(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.stop() { Ok(()) => true, Err(err) => { - wrap.post_error_message(err); + imp.post_error_message(err); false } } @@ -560,12 +578,8 @@ unsafe extern "C" fn video_encoder_finish( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.finish(wrap.unsafe_cast_ref()).into() - }) - .into_glib() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { imp.finish().into() }).into_glib() } unsafe extern "C" fn video_encoder_set_format( @@ -574,15 +588,14 @@ unsafe extern "C" fn video_encoder_set_format( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); ffi::gst_video_codec_state_ref(state); let wrap_state = VideoCodecState::::new(state); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) { + gst::panic_to_error!(imp, false, { + match imp.set_format(&wrap_state) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -596,11 +609,12 @@ unsafe extern "C" fn video_encoder_handle_frame( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let wrap_frame = VideoCodecFrame::new(frame, &*wrap); + let instance = imp.instance(); + let instance = instance.unsafe_cast_ref::(); + let wrap_frame = VideoCodecFrame::new(frame, instance); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.handle_frame(wrap_frame).into() }) .into_glib() } @@ -610,12 +624,8 @@ unsafe extern "C" fn video_encoder_flush( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - VideoEncoderImpl::flush(imp, wrap.unsafe_cast_ref()) - }) - .into_glib() + gst::panic_to_error!(imp, false, { VideoEncoderImpl::flush(imp) }).into_glib() } unsafe extern "C" fn video_encoder_negotiate( @@ -623,13 +633,12 @@ unsafe extern "C" fn video_encoder_negotiate( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.negotiate(wrap.unsafe_cast_ref()) { + gst::panic_to_error!(imp, false, { + match imp.negotiate() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -643,12 +652,10 @@ unsafe extern "C" fn video_encoder_getcaps( ) -> *mut gst::ffi::GstCaps { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), { + gst::panic_to_error!(imp, gst::Caps::new_empty(), { VideoEncoderImpl::caps( imp, - wrap.unsafe_cast_ref(), Option::::from_glib_borrow(filter) .as_ref() .as_ref(), @@ -663,12 +670,8 @@ unsafe extern "C" fn video_encoder_sink_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.sink_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn video_encoder_sink_query( @@ -677,10 +680,9 @@ unsafe extern "C" fn video_encoder_sink_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.sink_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -691,12 +693,8 @@ unsafe extern "C" fn video_encoder_src_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + gst::panic_to_error!(imp, false, { imp.src_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn video_encoder_src_query( @@ -705,10 +703,9 @@ unsafe extern "C" fn video_encoder_src_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { - imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) + gst::panic_to_error!(imp, false, { + imp.src_query(gst::QueryRef::from_mut_ptr(query)) }) .into_glib() } @@ -719,17 +716,16 @@ unsafe extern "C" fn video_encoder_propose_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.propose_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.propose_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -743,17 +739,16 @@ unsafe extern "C" fn video_encoder_decide_allocation( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = match gst::QueryRef::from_mut_ptr(query).view_mut() { gst::QueryViewMut::Allocation(allocation) => allocation, _ => unreachable!(), }; - gst::panic_to_error!(&wrap, imp.panicked(), false, { - match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { + gst::panic_to_error!(imp, false, { + match imp.decide_allocation(query) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer-video/src/subclass/video_filter.rs b/gstreamer-video/src/subclass/video_filter.rs index 3ed9ec2ac..8ca414459 100644 --- a/gstreamer-video/src/subclass/video_filter.rs +++ b/gstreamer-video/src/subclass/video_filter.rs @@ -12,45 +12,40 @@ use crate::VideoInfo; pub trait VideoFilterImpl: VideoFilterImplExt + BaseTransformImpl { fn set_info( &self, - element: &Self::Type, incaps: &gst::Caps, in_info: &VideoInfo, outcaps: &gst::Caps, out_info: &VideoInfo, ) -> Result<(), gst::LoggableError> { - self.parent_set_info(element, incaps, in_info, outcaps, out_info) + self.parent_set_info(incaps, in_info, outcaps, out_info) } fn transform_frame( &self, - element: &Self::Type, inframe: &VideoFrameRef<&gst::BufferRef>, outframe: &mut VideoFrameRef<&mut gst::BufferRef>, ) -> Result { - self.parent_transform_frame(element, inframe, outframe) + self.parent_transform_frame(inframe, outframe) } fn transform_frame_ip( &self, - element: &Self::Type, frame: &mut VideoFrameRef<&mut gst::BufferRef>, ) -> Result { - self.parent_transform_frame_ip(element, frame) + self.parent_transform_frame_ip(frame) } fn transform_frame_ip_passthrough( &self, - element: &Self::Type, frame: &VideoFrameRef<&gst::BufferRef>, ) -> Result { - self.parent_transform_frame_ip_passthrough(element, frame) + self.parent_transform_frame_ip_passthrough(frame) } } pub trait VideoFilterImplExt: ObjectSubclass { fn parent_set_info( &self, - element: &Self::Type, incaps: &gst::Caps, in_info: &VideoInfo, outcaps: &gst::Caps, @@ -59,20 +54,17 @@ pub trait VideoFilterImplExt: ObjectSubclass { fn parent_transform_frame( &self, - element: &Self::Type, inframe: &VideoFrameRef<&gst::BufferRef>, outframe: &mut VideoFrameRef<&mut gst::BufferRef>, ) -> Result; fn parent_transform_frame_ip( &self, - element: &Self::Type, frame: &mut VideoFrameRef<&mut gst::BufferRef>, ) -> Result; fn parent_transform_frame_ip_passthrough( &self, - element: &Self::Type, frame: &VideoFrameRef<&gst::BufferRef>, ) -> Result; } @@ -80,7 +72,6 @@ pub trait VideoFilterImplExt: ObjectSubclass { impl VideoFilterImplExt for T { fn parent_set_info( &self, - element: &Self::Type, incaps: &gst::Caps, in_info: &VideoInfo, outcaps: &gst::Caps, @@ -94,7 +85,10 @@ impl VideoFilterImplExt for T { .map(|f| { gst::result_from_gboolean!( f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, incaps.to_glib_none().0, mut_override(in_info.to_glib_none().0), outcaps.to_glib_none().0, @@ -110,7 +104,6 @@ impl VideoFilterImplExt for T { fn parent_transform_frame( &self, - element: &Self::Type, inframe: &VideoFrameRef<&gst::BufferRef>, outframe: &mut VideoFrameRef<&mut gst::BufferRef>, ) -> Result { @@ -121,21 +114,24 @@ impl VideoFilterImplExt for T { .transform_frame .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, mut_override(inframe.as_ptr()), outframe.as_mut_ptr(), )) }) .unwrap_or_else(|| { - if !element + if !self + .instance() .unsafe_cast_ref::() .is_in_place() { Err(gst::FlowError::NotSupported) } else { unreachable!(concat!( - "parent `transform_frame` called ", - "while transform element operates in-place" + "parent `transform_frame` called while transform operates in-place" )); } }) @@ -144,31 +140,33 @@ impl VideoFilterImplExt for T { fn parent_transform_frame_ip( &self, - element: &Self::Type, frame: &mut VideoFrameRef<&mut gst::BufferRef>, ) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoFilterClass; let f = (*parent_class).transform_frame_ip.unwrap_or_else(|| { - if element + if self + .instance() .unsafe_cast_ref::() .is_in_place() { panic!(concat!( "Missing parent function `transform_frame_ip`. Required because ", - "transform element operates in-place" + "transform operates in-place" )); } else { unreachable!(concat!( - "parent `transform_frame` called ", - "while transform element doesn't operate in-place" + "parent `transform_frame` called while transform doesn't operate in-place" )); } }); try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, frame.as_mut_ptr(), )) } @@ -176,31 +174,34 @@ impl VideoFilterImplExt for T { fn parent_transform_frame_ip_passthrough( &self, - element: &Self::Type, frame: &VideoFrameRef<&gst::BufferRef>, ) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoFilterClass; let f = (*parent_class).transform_frame_ip.unwrap_or_else(|| { - if element + if self + .instance() .unsafe_cast_ref::() .is_in_place() { panic!(concat!( "Missing parent function `transform_frame_ip`. Required because ", - "transform element operates in-place (passthrough mode)" + "transform operates in-place (passthrough mode)" )); } else { unreachable!(concat!( "parent `transform_frame_ip` called ", - "while transform element doesn't operate in-place (passthrough mode)" + "while transform doesn't operate in-place (passthrough mode)" )); } }); try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, mut_override(frame.as_ptr()), )) } @@ -242,11 +243,9 @@ unsafe extern "C" fn video_filter_set_info( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), false, { + gst::panic_to_error!(imp, false, { match imp.set_info( - wrap.unsafe_cast_ref(), &from_glib_borrow(incaps), &from_glib_none(in_info), &from_glib_borrow(outcaps), @@ -254,7 +253,7 @@ unsafe extern "C" fn video_filter_set_info( ) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -269,11 +268,9 @@ unsafe extern "C" fn video_filter_transform_frame( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { imp.transform_frame( - wrap.unsafe_cast_ref(), &VideoFrameRef::from_glib_borrow(inframe), &mut VideoFrameRef::from_glib_borrow_mut(outframe), ) @@ -288,23 +285,16 @@ unsafe extern "C" fn video_filter_transform_frame_ip( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { + gst::panic_to_error!(imp, gst::FlowReturn::Error, { if from_glib(gst_base::ffi::gst_base_transform_is_passthrough( ptr as *mut gst_base::ffi::GstBaseTransform, )) { - imp.transform_frame_ip_passthrough( - wrap.unsafe_cast_ref(), - &VideoFrameRef::from_glib_borrow(frame), - ) - .into() + imp.transform_frame_ip_passthrough(&VideoFrameRef::from_glib_borrow(frame)) + .into() } else { - imp.transform_frame_ip( - wrap.unsafe_cast_ref(), - &mut VideoFrameRef::from_glib_borrow_mut(frame), - ) - .into() + imp.transform_frame_ip(&mut VideoFrameRef::from_glib_borrow_mut(frame)) + .into() } }) .into_glib() diff --git a/gstreamer-video/src/subclass/video_sink.rs b/gstreamer-video/src/subclass/video_sink.rs index f7cb9cb56..2c63612e6 100644 --- a/gstreamer-video/src/subclass/video_sink.rs +++ b/gstreamer-video/src/subclass/video_sink.rs @@ -8,29 +8,17 @@ use gst_base::subclass::prelude::*; use crate::VideoSink; pub trait VideoSinkImpl: VideoSinkImplExt + BaseSinkImpl + ElementImpl { - fn show_frame( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result { - self.parent_show_frame(element, buffer) + fn show_frame(&self, buffer: &gst::Buffer) -> Result { + self.parent_show_frame(buffer) } } pub trait VideoSinkImplExt: ObjectSubclass { - fn parent_show_frame( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result; + fn parent_show_frame(&self, buffer: &gst::Buffer) -> Result; } impl VideoSinkImplExt for T { - fn parent_show_frame( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result { + fn parent_show_frame(&self, buffer: &gst::Buffer) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoSinkClass; @@ -38,7 +26,10 @@ impl VideoSinkImplExt for T { .show_frame .map(|f| { try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, buffer.to_glib_none().0, )) }) @@ -61,11 +52,10 @@ unsafe extern "C" fn video_sink_show_frame( ) -> gst::ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let buffer = from_glib_borrow(buffer); - gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, { - imp.show_frame(wrap.unsafe_cast_ref(), &buffer).into() + gst::panic_to_error!(imp, gst::FlowReturn::Error, { + imp.show_frame(&buffer).into() }) .into_glib() } diff --git a/gstreamer/src/log.rs b/gstreamer/src/log.rs index 75f0dafc7..69eb3c0cd 100644 --- a/gstreamer/src/log.rs +++ b/gstreamer/src/log.rs @@ -491,7 +491,7 @@ macro_rules! log_with_level( // Check the log level before using `format_args!` otherwise // formatted arguments are evaluated even if we end up not logging. if $level <= $cat.threshold() { - $crate::DebugCategory::log_unfiltered($cat.clone(), Some($obj), + $crate::DebugCategory::log_unfiltered($cat.clone(), Some(&*$obj), $level, file!(), module_path!(), line!(), format_args!($($args)*)) } }}; diff --git a/gstreamer/src/subclass/bin.rs b/gstreamer/src/subclass/bin.rs index d3b596f48..0a615d6ca 100644 --- a/gstreamer/src/subclass/bin.rs +++ b/gstreamer/src/subclass/bin.rs @@ -12,39 +12,35 @@ use crate::LoggableError; use crate::Message; pub trait BinImpl: BinImplExt + ElementImpl { - fn add_element(&self, bin: &Self::Type, element: &Element) -> Result<(), LoggableError> { - self.parent_add_element(bin, element) + fn add_element(&self, element: &Element) -> Result<(), LoggableError> { + self.parent_add_element(element) } - fn remove_element(&self, bin: &Self::Type, element: &Element) -> Result<(), LoggableError> { - self.parent_remove_element(bin, element) + fn remove_element(&self, element: &Element) -> Result<(), LoggableError> { + self.parent_remove_element(element) } - fn do_latency(&self, bin: &Self::Type) -> Result<(), LoggableError> { - self.parent_do_latency(bin) + fn do_latency(&self) -> Result<(), LoggableError> { + self.parent_do_latency() } - fn handle_message(&self, bin: &Self::Type, message: Message) { - self.parent_handle_message(bin, message) + fn handle_message(&self, message: Message) { + self.parent_handle_message(message) } } pub trait BinImplExt: ObjectSubclass { - fn parent_add_element(&self, bin: &Self::Type, element: &Element) -> Result<(), LoggableError>; + fn parent_add_element(&self, element: &Element) -> Result<(), LoggableError>; - fn parent_remove_element( - &self, - bin: &Self::Type, - element: &Element, - ) -> Result<(), LoggableError>; + fn parent_remove_element(&self, element: &Element) -> Result<(), LoggableError>; - fn parent_do_latency(&self, bin: &Self::Type) -> Result<(), LoggableError>; + fn parent_do_latency(&self) -> Result<(), LoggableError>; - fn parent_handle_message(&self, bin: &Self::Type, message: Message); + fn parent_handle_message(&self, message: Message); } impl BinImplExt for T { - fn parent_add_element(&self, bin: &Self::Type, element: &Element) -> Result<(), LoggableError> { + fn parent_add_element(&self, element: &Element) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBinClass; @@ -56,7 +52,10 @@ impl BinImplExt for T { })?; result_from_gboolean!( f( - bin.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, element.to_glib_none().0 ), crate::CAT_RUST, @@ -65,11 +64,7 @@ impl BinImplExt for T { } } - fn parent_remove_element( - &self, - bin: &Self::Type, - element: &Element, - ) -> Result<(), LoggableError> { + fn parent_remove_element(&self, element: &Element) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBinClass; @@ -81,7 +76,10 @@ impl BinImplExt for T { })?; result_from_gboolean!( f( - bin.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, element.to_glib_none().0 ), crate::CAT_RUST, @@ -90,7 +88,7 @@ impl BinImplExt for T { } } - fn parent_do_latency(&self, bin: &Self::Type) -> Result<(), LoggableError> { + fn parent_do_latency(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBinClass; @@ -101,20 +99,27 @@ impl BinImplExt for T { ) })?; result_from_gboolean!( - f(bin.unsafe_cast_ref::().to_glib_none().0,), + f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0,), crate::CAT_RUST, "Failed to update latency using the parent function" ) } } - fn parent_handle_message(&self, bin: &Self::Type, message: Message) { + fn parent_handle_message(&self, message: Message) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBinClass; if let Some(ref f) = (*parent_class).handle_message { f( - bin.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, message.into_glib_ptr(), ); } @@ -139,13 +144,12 @@ unsafe extern "C" fn bin_add_element( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - panic_to_error!(&wrap, imp.panicked(), false, { - match imp.add_element(wrap.unsafe_cast_ref(), &from_glib_none(element)) { + panic_to_error!(imp, false, { + match imp.add_element(&from_glib_none(element)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -159,7 +163,6 @@ unsafe extern "C" fn bin_remove_element( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // If we get a floating reference passed simply return FALSE here. It can't be // stored inside this bin, and if we continued to use it we would take ownership @@ -170,11 +173,11 @@ unsafe extern "C" fn bin_remove_element( return glib::ffi::GFALSE; } - panic_to_error!(&wrap, imp.panicked(), false, { - match imp.remove_element(wrap.unsafe_cast_ref(), &from_glib_none(element)) { + panic_to_error!(imp, false, { + match imp.remove_element(&from_glib_none(element)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -185,13 +188,12 @@ unsafe extern "C" fn bin_remove_element( unsafe extern "C" fn bin_do_latency(ptr: *mut ffi::GstBin) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - panic_to_error!(&wrap, imp.panicked(), false, { - match imp.do_latency(wrap.unsafe_cast_ref()) { + panic_to_error!(imp, false, { + match imp.do_latency() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -205,9 +207,6 @@ unsafe extern "C" fn bin_handle_message( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - panic_to_error!(&wrap, imp.panicked(), (), { - imp.handle_message(wrap.unsafe_cast_ref(), from_glib_full(message)) - }); + panic_to_error!(imp, (), { imp.handle_message(from_glib_full(message)) }); } diff --git a/gstreamer/src/subclass/buffer_pool.rs b/gstreamer/src/subclass/buffer_pool.rs index ca39891b5..12d55fe61 100644 --- a/gstreamer/src/subclass/buffer_pool.rs +++ b/gstreamer/src/subclass/buffer_pool.rs @@ -13,92 +13,86 @@ use crate::{BufferPool, BufferPoolAcquireParams, BufferPoolConfigRef}; pub trait BufferPoolImpl: BufferPoolImplExt + GstObjectImpl + Send + Sync { fn acquire_buffer( &self, - buffer_pool: &Self::Type, params: Option<&BufferPoolAcquireParams>, ) -> Result { - self.parent_acquire_buffer(buffer_pool, params) + self.parent_acquire_buffer(params) } fn alloc_buffer( &self, - buffer_pool: &Self::Type, params: Option<&BufferPoolAcquireParams>, ) -> Result { - self.parent_alloc_buffer(buffer_pool, params) + self.parent_alloc_buffer(params) } - fn flush_start(&self, buffer_pool: &Self::Type) { - self.parent_flush_start(buffer_pool) + fn flush_start(&self) { + self.parent_flush_start() } - fn flush_stop(&self, buffer_pool: &Self::Type) { - self.parent_flush_stop(buffer_pool) + fn flush_stop(&self) { + self.parent_flush_stop() } - fn free_buffer(&self, buffer_pool: &Self::Type, buffer: crate::Buffer) { - self.parent_free_buffer(buffer_pool, buffer) + fn free_buffer(&self, buffer: crate::Buffer) { + self.parent_free_buffer(buffer) } - fn release_buffer(&self, buffer_pool: &Self::Type, buffer: crate::Buffer) { - self.parent_release_buffer(buffer_pool, buffer) + fn release_buffer(&self, buffer: crate::Buffer) { + self.parent_release_buffer(buffer) } - fn reset_buffer(&self, buffer_pool: &Self::Type, buffer: &mut crate::BufferRef) { - self.parent_reset_buffer(buffer_pool, buffer) + fn reset_buffer(&self, buffer: &mut crate::BufferRef) { + self.parent_reset_buffer(buffer) } - fn start(&self, buffer_pool: &Self::Type) -> bool { - self.parent_start(buffer_pool) + fn start(&self) -> bool { + self.parent_start() } - fn stop(&self, buffer_pool: &Self::Type) -> bool { - self.parent_stop(buffer_pool) + fn stop(&self) -> bool { + self.parent_stop() } fn options() -> &'static [&'static str] { &[] } - fn set_config(&self, buffer_pool: &Self::Type, config: &mut BufferPoolConfigRef) -> bool { - self.parent_set_config(buffer_pool, config) + fn set_config(&self, config: &mut BufferPoolConfigRef) -> bool { + self.parent_set_config(config) } } pub trait BufferPoolImplExt: ObjectSubclass { fn parent_acquire_buffer( &self, - buffer_pool: &Self::Type, params: Option<&BufferPoolAcquireParams>, ) -> Result; fn parent_alloc_buffer( &self, - buffer_pool: &Self::Type, params: Option<&BufferPoolAcquireParams>, ) -> Result; - fn parent_free_buffer(&self, buffer_pool: &Self::Type, buffer: crate::Buffer); + fn parent_free_buffer(&self, buffer: crate::Buffer); - fn parent_release_buffer(&self, buffer_pool: &Self::Type, buffer: crate::Buffer); + fn parent_release_buffer(&self, buffer: crate::Buffer); - fn parent_reset_buffer(&self, buffer_pool: &Self::Type, buffer: &mut crate::BufferRef); + fn parent_reset_buffer(&self, buffer: &mut crate::BufferRef); - fn parent_start(&self, buffer_pool: &Self::Type) -> bool; + fn parent_start(&self) -> bool; - fn parent_stop(&self, buffer_pool: &Self::Type) -> bool; + fn parent_stop(&self) -> bool; - fn parent_set_config(&self, buffer_pool: &Self::Type, config: &mut BufferPoolConfigRef) - -> bool; + fn parent_set_config(&self, config: &mut BufferPoolConfigRef) -> bool; - fn parent_flush_start(&self, _buffer_pool: &Self::Type); + fn parent_flush_start(&self); - fn parent_flush_stop(&self, _buffer_pool: &Self::Type); + fn parent_flush_stop(&self); } impl BufferPoolImplExt for T { fn parent_acquire_buffer( &self, - buffer_pool: &Self::Type, params: Option<&BufferPoolAcquireParams>, ) -> Result { unsafe { @@ -109,7 +103,7 @@ impl BufferPoolImplExt for T { let mut buffer = std::ptr::null_mut(); let result = f( - buffer_pool + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -126,7 +120,6 @@ impl BufferPoolImplExt for T { fn parent_alloc_buffer( &self, - buffer_pool: &Self::Type, params: Option<&BufferPoolAcquireParams>, ) -> Result { unsafe { @@ -137,7 +130,7 @@ impl BufferPoolImplExt for T { let mut buffer = std::ptr::null_mut(); let result = f( - buffer_pool + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -152,13 +145,13 @@ impl BufferPoolImplExt for T { } } - fn parent_free_buffer(&self, buffer_pool: &Self::Type, buffer: crate::Buffer) { + fn parent_free_buffer(&self, buffer: crate::Buffer) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBufferPoolClass; if let Some(f) = (*parent_class).free_buffer { f( - buffer_pool + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -168,13 +161,13 @@ impl BufferPoolImplExt for T { } } - fn parent_release_buffer(&self, buffer_pool: &Self::Type, buffer: crate::Buffer) { + fn parent_release_buffer(&self, buffer: crate::Buffer) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBufferPoolClass; if let Some(f) = (*parent_class).release_buffer { f( - buffer_pool + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -184,13 +177,13 @@ impl BufferPoolImplExt for T { } } - fn parent_reset_buffer(&self, buffer_pool: &Self::Type, buffer: &mut crate::BufferRef) { + fn parent_reset_buffer(&self, buffer: &mut crate::BufferRef) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBufferPoolClass; if let Some(f) = (*parent_class).reset_buffer { f( - buffer_pool + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -200,12 +193,13 @@ impl BufferPoolImplExt for T { } } - fn parent_start(&self, buffer_pool: &Self::Type) -> bool { + fn parent_start(&self) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBufferPoolClass; if let Some(f) = (*parent_class).start { - let result = f(buffer_pool + let result = f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0); @@ -217,12 +211,13 @@ impl BufferPoolImplExt for T { } } - fn parent_stop(&self, buffer_pool: &Self::Type) -> bool { + fn parent_stop(&self) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBufferPoolClass; if let Some(f) = (*parent_class).stop { - let result = f(buffer_pool + let result = f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0); @@ -234,17 +229,13 @@ impl BufferPoolImplExt for T { } } - fn parent_set_config( - &self, - buffer_pool: &Self::Type, - config: &mut BufferPoolConfigRef, - ) -> bool { + fn parent_set_config(&self, config: &mut BufferPoolConfigRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBufferPoolClass; if let Some(f) = (*parent_class).set_config { let result = f( - buffer_pool + self.instance() .unsafe_cast_ref::() .to_glib_none() .0, @@ -258,12 +249,13 @@ impl BufferPoolImplExt for T { } } - fn parent_flush_start(&self, buffer_pool: &Self::Type) { + fn parent_flush_start(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBufferPoolClass; if let Some(f) = (*parent_class).flush_start { - f(buffer_pool + f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0) @@ -271,12 +263,13 @@ impl BufferPoolImplExt for T { } } - fn parent_flush_stop(&self, buffer_pool: &Self::Type) { + fn parent_flush_stop(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstBufferPoolClass; if let Some(f) = (*parent_class).flush_stop { - f(buffer_pool + f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0) @@ -331,10 +324,9 @@ unsafe extern "C" fn buffer_pool_acquire_buffer( ) -> ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let params: Option = from_glib_none(params); - match imp.acquire_buffer(wrap.unsafe_cast_ref(), params.as_ref()) { + match imp.acquire_buffer(params.as_ref()) { Ok(b) => { *buffer = b.into_glib_ptr(); ffi::GST_FLOW_OK @@ -350,10 +342,9 @@ unsafe extern "C" fn buffer_pool_alloc_buffer( ) -> ffi::GstFlowReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let params: Option = from_glib_none(params); - match imp.alloc_buffer(wrap.unsafe_cast_ref(), params.as_ref()) { + match imp.alloc_buffer(params.as_ref()) { Ok(b) => { *buffer = b.into_glib_ptr(); ffi::GST_FLOW_OK @@ -374,8 +365,7 @@ unsafe extern "C" fn buffer_pool_flush_start(ptr: *mut ffi::G let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.flush_start(wrap.unsafe_cast_ref()); + imp.flush_start(); } unsafe extern "C" fn buffer_pool_flush_stop(ptr: *mut ffi::GstBufferPool) { @@ -390,8 +380,7 @@ unsafe extern "C" fn buffer_pool_flush_stop(ptr: *mut ffi::Gs let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.flush_stop(wrap.unsafe_cast_ref()); + imp.flush_stop(); } unsafe extern "C" fn buffer_pool_free_buffer( @@ -417,8 +406,7 @@ unsafe extern "C" fn buffer_pool_free_buffer( let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.free_buffer(wrap.unsafe_cast_ref(), from_glib_full(buffer)); + imp.free_buffer(from_glib_full(buffer)); } unsafe extern "C" fn buffer_pool_release_buffer( @@ -427,8 +415,7 @@ unsafe extern "C" fn buffer_pool_release_buffer( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.release_buffer(wrap.unsafe_cast_ref(), from_glib_full(buffer)); + imp.release_buffer(from_glib_full(buffer)); } unsafe extern "C" fn buffer_pool_reset_buffer( @@ -437,11 +424,7 @@ unsafe extern "C" fn buffer_pool_reset_buffer( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.reset_buffer( - wrap.unsafe_cast_ref(), - crate::BufferRef::from_mut_ptr(buffer), - ); + imp.reset_buffer(crate::BufferRef::from_mut_ptr(buffer)); } unsafe extern "C" fn buffer_pool_start( @@ -449,8 +432,7 @@ unsafe extern "C" fn buffer_pool_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.start(wrap.unsafe_cast_ref()).into_glib() + imp.start().into_glib() } unsafe extern "C" fn buffer_pool_stop( @@ -478,8 +460,7 @@ unsafe extern "C" fn buffer_pool_stop( let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.stop(wrap.unsafe_cast_ref()).into_glib() + imp.stop().into_glib() } unsafe extern "C" fn buffer_pool_get_options( @@ -498,12 +479,8 @@ unsafe extern "C" fn buffer_pool_set_config( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.set_config( - wrap.unsafe_cast_ref(), - BufferPoolConfigRef::from_glib_borrow_mut(config), - ) - .into_glib() + imp.set_config(BufferPoolConfigRef::from_glib_borrow_mut(config)) + .into_glib() } #[cfg(test)] @@ -529,14 +506,10 @@ mod tests { &["TEST_OPTION"] } - fn set_config( - &self, - buffer_pool: &Self::Type, - config: &mut BufferPoolConfigRef, - ) -> bool { + fn set_config(&self, config: &mut BufferPoolConfigRef) -> bool { let (caps, size, min_buffers, max_buffers) = config.params().unwrap(); config.set_params(caps.as_ref(), size * 2, min_buffers, max_buffers); - self.parent_set_config(buffer_pool, config) + self.parent_set_config(config) } } diff --git a/gstreamer/src/subclass/child_proxy.rs b/gstreamer/src/subclass/child_proxy.rs index 250e0137e..e33ac335a 100644 --- a/gstreamer/src/subclass/child_proxy.rs +++ b/gstreamer/src/subclass/child_proxy.rs @@ -8,33 +8,33 @@ use glib::translate::*; use crate::ChildProxy; pub trait ChildProxyImpl: GstObjectImpl + Send + Sync { - fn child_by_name(&self, object: &Self::Type, name: &str) -> Option { - self.parent_child_by_name(object, name) + fn child_by_name(&self, name: &str) -> Option { + self.parent_child_by_name(name) } - fn child_by_index(&self, object: &Self::Type, index: u32) -> Option; - fn children_count(&self, object: &Self::Type) -> u32; + fn child_by_index(&self, index: u32) -> Option; + fn children_count(&self) -> u32; - fn child_added(&self, object: &Self::Type, child: &glib::Object, name: &str) { - self.parent_child_added(object, child, name); + fn child_added(&self, child: &glib::Object, name: &str) { + self.parent_child_added(child, name); } - fn child_removed(&self, object: &Self::Type, child: &glib::Object, name: &str) { - self.parent_child_removed(object, child, name); + fn child_removed(&self, child: &glib::Object, name: &str) { + self.parent_child_removed(child, name); } } pub trait ChildProxyImplExt: ObjectSubclass { - fn parent_child_by_name(&self, object: &Self::Type, name: &str) -> Option; + fn parent_child_by_name(&self, name: &str) -> Option; - fn parent_child_by_index(&self, object: &Self::Type, index: u32) -> Option; - fn parent_children_count(&self, object: &Self::Type) -> u32; + fn parent_child_by_index(&self, index: u32) -> Option; + fn parent_children_count(&self) -> u32; - fn parent_child_added(&self, _object: &Self::Type, _child: &glib::Object, _name: &str); - fn parent_child_removed(&self, _object: &Self::Type, _child: &glib::Object, _name: &str); + fn parent_child_added(&self, _child: &glib::Object, _name: &str); + fn parent_child_removed(&self, _child: &glib::Object, _name: &str); } impl ChildProxyImplExt for T { - fn parent_child_by_name(&self, object: &Self::Type, name: &str) -> Option { + fn parent_child_by_name(&self, name: &str) -> Option { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -44,14 +44,17 @@ impl ChildProxyImplExt for T { .get_child_by_name .expect("no parent \"child_by_name\" implementation"); let ret = func( - object.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, name.to_glib_none().0, ); from_glib_full(ret) } } - fn parent_child_by_index(&self, object: &Self::Type, index: u32) -> Option { + fn parent_child_by_index(&self, index: u32) -> Option { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -61,14 +64,17 @@ impl ChildProxyImplExt for T { .get_child_by_index .expect("no parent \"child_by_index\" implementation"); let ret = func( - object.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, index, ); from_glib_full(ret) } } - fn parent_children_count(&self, object: &Self::Type) -> u32 { + fn parent_children_count(&self) -> u32 { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -77,11 +83,16 @@ impl ChildProxyImplExt for T { let func = (*parent_iface) .get_children_count .expect("no parent \"children_count\" implementation"); - func(object.unsafe_cast_ref::().to_glib_none().0) + func( + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, + ) } } - fn parent_child_added(&self, object: &Self::Type, child: &glib::Object, name: &str) { + fn parent_child_added(&self, child: &glib::Object, name: &str) { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -89,7 +100,10 @@ impl ChildProxyImplExt for T { if let Some(func) = (*parent_iface).child_added { func( - object.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, child.to_glib_none().0, name.to_glib_none().0, ); @@ -97,7 +111,7 @@ impl ChildProxyImplExt for T { } } - fn parent_child_removed(&self, object: &Self::Type, child: &glib::Object, name: &str) { + fn parent_child_removed(&self, child: &glib::Object, name: &str) { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -105,7 +119,10 @@ impl ChildProxyImplExt for T { if let Some(func) = (*parent_iface).child_removed { func( - object.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, child.to_glib_none().0, name.to_glib_none().0, ); @@ -133,11 +150,8 @@ unsafe extern "C" fn child_proxy_get_child_by_name( let instance = &*(child_proxy as *mut T::Instance); let imp = instance.imp(); - imp.child_by_name( - from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(), - &glib::GString::from_glib_borrow(name), - ) - .to_glib_full() + imp.child_by_name(&glib::GString::from_glib_borrow(name)) + .to_glib_full() } unsafe extern "C" fn child_proxy_get_child_by_index( @@ -147,11 +161,7 @@ unsafe extern "C" fn child_proxy_get_child_by_index( let instance = &*(child_proxy as *mut T::Instance); let imp = instance.imp(); - imp.child_by_index( - from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(), - index, - ) - .to_glib_full() + imp.child_by_index(index).to_glib_full() } unsafe extern "C" fn child_proxy_get_children_count( @@ -160,7 +170,7 @@ unsafe extern "C" fn child_proxy_get_children_count( let instance = &*(child_proxy as *mut T::Instance); let imp = instance.imp(); - imp.children_count(from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref()) + imp.children_count() } unsafe extern "C" fn child_proxy_child_added( @@ -172,7 +182,6 @@ unsafe extern "C" fn child_proxy_child_added( let imp = instance.imp(); imp.child_added( - from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(), &from_glib_borrow(child), &glib::GString::from_glib_borrow(name), ) @@ -187,7 +196,6 @@ unsafe extern "C" fn child_proxy_child_removed( let imp = instance.imp(); imp.child_removed( - from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(), &from_glib_borrow(child), &glib::GString::from_glib_borrow(name), ) diff --git a/gstreamer/src/subclass/clock.rs b/gstreamer/src/subclass/clock.rs index e3f9d0a50..84678b22b 100644 --- a/gstreamer/src/subclass/clock.rs +++ b/gstreamer/src/subclass/clock.rs @@ -14,65 +14,47 @@ use crate::ClockTime; use crate::ClockTimeDiff; pub trait ClockImpl: ClockImplExt + GstObjectImpl + Send + Sync { - fn change_resolution( - &self, - clock: &Self::Type, - old_resolution: ClockTime, - new_resolution: ClockTime, - ) -> ClockTime { - self.parent_change_resolution(clock, old_resolution, new_resolution) + fn change_resolution(&self, old_resolution: ClockTime, new_resolution: ClockTime) -> ClockTime { + self.parent_change_resolution(old_resolution, new_resolution) } - fn resolution(&self, clock: &Self::Type) -> ClockTime { - self.parent_resolution(clock) + fn resolution(&self) -> ClockTime { + self.parent_resolution() } - fn internal_time(&self, clock: &Self::Type) -> ClockTime { - self.parent_internal_time(clock) + fn internal_time(&self) -> ClockTime { + self.parent_internal_time() } - fn wait( - &self, - clock: &Self::Type, - id: &ClockId, - ) -> (Result, ClockTimeDiff) { - self.parent_wait(clock, id) + fn wait(&self, id: &ClockId) -> (Result, ClockTimeDiff) { + self.parent_wait(id) } - fn wait_async(&self, clock: &Self::Type, id: &ClockId) -> Result { - self.parent_wait_async(clock, id) + fn wait_async(&self, id: &ClockId) -> Result { + self.parent_wait_async(id) } - fn unschedule(&self, clock: &Self::Type, id: &ClockId) { - self.parent_unschedule(clock, id) + fn unschedule(&self, id: &ClockId) { + self.parent_unschedule(id) } } pub trait ClockImplExt: ObjectSubclass { fn parent_change_resolution( &self, - clock: &Self::Type, old_resolution: ClockTime, new_resolution: ClockTime, ) -> ClockTime; - fn parent_resolution(&self, clock: &Self::Type) -> ClockTime; + fn parent_resolution(&self) -> ClockTime; - fn parent_internal_time(&self, clock: &Self::Type) -> ClockTime; + fn parent_internal_time(&self) -> ClockTime; - fn parent_wait( - &self, - clock: &Self::Type, - id: &ClockId, - ) -> (Result, ClockTimeDiff); + fn parent_wait(&self, id: &ClockId) -> (Result, ClockTimeDiff); - fn parent_wait_async( - &self, - clock: &Self::Type, - id: &ClockId, - ) -> Result; + fn parent_wait_async(&self, id: &ClockId) -> Result; - fn parent_unschedule(&self, clock: &Self::Type, id: &ClockId); + fn parent_unschedule(&self, id: &ClockId); fn wake_id(&self, id: &ClockId) where @@ -83,7 +65,6 @@ pub trait ClockImplExt: ObjectSubclass { impl ClockImplExt for T { fn parent_change_resolution( &self, - clock: &Self::Type, old_resolution: ClockTime, new_resolution: ClockTime, ) -> ClockTime { @@ -93,18 +74,18 @@ impl ClockImplExt for T { if let Some(func) = (*parent_class).change_resolution { try_from_glib(func( - clock.unsafe_cast_ref::().to_glib_none().0, + self.instance().unsafe_cast_ref::().to_glib_none().0, old_resolution.into_glib(), new_resolution.into_glib(), )) .expect("undefined resolution") } else { - self.resolution(clock) + self.resolution() } } } - fn parent_resolution(&self, clock: &Self::Type) -> ClockTime { + fn parent_resolution(&self) -> ClockTime { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass; @@ -112,14 +93,14 @@ impl ClockImplExt for T { try_from_glib( (*parent_class) .get_resolution - .map(|f| f(clock.unsafe_cast_ref::().to_glib_none().0)) + .map(|f| f(self.instance().unsafe_cast_ref::().to_glib_none().0)) .unwrap_or(1), ) .expect("undefined resolution") } } - fn parent_internal_time(&self, clock: &Self::Type) -> ClockTime { + fn parent_internal_time(&self) -> ClockTime { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass; @@ -127,18 +108,14 @@ impl ClockImplExt for T { try_from_glib( (*parent_class) .get_internal_time - .map(|f| f(clock.unsafe_cast_ref::().to_glib_none().0)) + .map(|f| f(self.instance().unsafe_cast_ref::().to_glib_none().0)) .unwrap_or(0), ) .expect("undefined internal_time") } } - fn parent_wait( - &self, - clock: &Self::Type, - id: &ClockId, - ) -> (Result, ClockTimeDiff) { + fn parent_wait(&self, id: &ClockId) -> (Result, ClockTimeDiff) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass; @@ -150,7 +127,7 @@ impl ClockImplExt for T { .wait .map(|f| { f( - clock.unsafe_cast_ref::().to_glib_none().0, + self.instance().unsafe_cast_ref::().to_glib_none().0, id.as_ptr() as *mut ffi::GstClockEntry, &mut jitter, ) @@ -162,11 +139,7 @@ impl ClockImplExt for T { } } - fn parent_wait_async( - &self, - clock: &Self::Type, - id: &ClockId, - ) -> Result { + fn parent_wait_async(&self, id: &ClockId) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass; @@ -175,7 +148,7 @@ impl ClockImplExt for T { .wait_async .map(|f| { f( - clock.unsafe_cast_ref::().to_glib_none().0, + self.instance().unsafe_cast_ref::().to_glib_none().0, id.as_ptr() as *mut ffi::GstClockEntry, ) }) @@ -184,13 +157,13 @@ impl ClockImplExt for T { } } - fn parent_unschedule(&self, clock: &Self::Type, id: &ClockId) { + fn parent_unschedule(&self, id: &ClockId) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass; if let Some(func) = (*parent_class).unschedule { func( - clock.unsafe_cast_ref::().to_glib_none().0, + self.instance().unsafe_cast_ref::().to_glib_none().0, id.as_ptr() as *mut ffi::GstClockEntry, ); } @@ -203,14 +176,15 @@ impl ClockImplExt for T { ::Type: IsA, { let clock = self.instance(); + let clock = unsafe { clock.unsafe_cast_ref::() }; cfg_if::cfg_if! { if #[cfg(feature = "v1_16")] { - assert!(id.uses_clock(&clock)); + assert!(id.uses_clock(clock)); } else { unsafe { let ptr = id.as_ptr() as *mut ffi::GstClockEntry; - assert_eq!((*ptr).clock, clock.as_ref().to_glib_none().0); + assert_eq!((*ptr).clock, clock.to_glib_none().0); } } } @@ -219,7 +193,7 @@ impl ClockImplExt for T { let ptr = id.as_ptr() as *mut ffi::GstClockEntry; if let Some(func) = (*ptr).func { func( - clock.as_ref().to_glib_none().0, + clock.to_glib_none().0, (*ptr).time, ptr as ffi::GstClockID, (*ptr).user_data, @@ -252,7 +226,6 @@ unsafe extern "C" fn clock_change_resolution( ) -> ffi::GstClockTime { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let old_resolution = match from_glib(old_resolution) { Some(old_resolution) => old_resolution, @@ -263,7 +236,7 @@ unsafe extern "C" fn clock_change_resolution( None => return ffi::GST_CLOCK_TIME_NONE, }; - imp.change_resolution(wrap.unsafe_cast_ref(), old_resolution, new_resolution) + imp.change_resolution(old_resolution, new_resolution) .into_glib() } @@ -272,9 +245,8 @@ unsafe extern "C" fn clock_get_resolution( ) -> ffi::GstClockTime { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.resolution(wrap.unsafe_cast_ref()).into_glib() + imp.resolution().into_glib() } unsafe extern "C" fn clock_get_internal_time( @@ -282,9 +254,8 @@ unsafe extern "C" fn clock_get_internal_time( ) -> ffi::GstClockTime { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.internal_time(wrap.unsafe_cast_ref()).into_glib() + imp.internal_time().into_glib() } unsafe extern "C" fn clock_wait( @@ -294,12 +265,8 @@ unsafe extern "C" fn clock_wait( ) -> ffi::GstClockReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - let (res, j) = imp.wait( - wrap.unsafe_cast_ref(), - &from_glib_borrow(id as ffi::GstClockID), - ); + let (res, j) = imp.wait(&from_glib_borrow(id as ffi::GstClockID)); if !jitter.is_null() { *jitter = j; } @@ -313,13 +280,8 @@ unsafe extern "C" fn clock_wait_async( ) -> ffi::GstClockReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - ClockReturn::from(imp.wait_async( - wrap.unsafe_cast_ref(), - &from_glib_borrow(id as ffi::GstClockID), - )) - .into_glib() + ClockReturn::from(imp.wait_async(&from_glib_borrow(id as ffi::GstClockID))).into_glib() } unsafe extern "C" fn clock_unschedule( @@ -328,10 +290,6 @@ unsafe extern "C" fn clock_unschedule( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.unschedule( - wrap.unsafe_cast_ref(), - &from_glib_borrow(id as ffi::GstClockID), - ); + imp.unschedule(&from_glib_borrow(id as ffi::GstClockID)); } diff --git a/gstreamer/src/subclass/device.rs b/gstreamer/src/subclass/device.rs index c2a3a6bd3..762954ea0 100644 --- a/gstreamer/src/subclass/device.rs +++ b/gstreamer/src/subclass/device.rs @@ -12,49 +12,29 @@ use crate::LoggableError; use std::ptr; pub trait DeviceImpl: DeviceImplExt + GstObjectImpl + Send + Sync { - fn create_element( - &self, - device: &Self::Type, - name: Option<&str>, - ) -> Result { - self.parent_create_element(device, name) + fn create_element(&self, name: Option<&str>) -> Result { + self.parent_create_element(name) } - fn reconfigure_element( - &self, - device: &Self::Type, - element: &Element, - ) -> Result<(), LoggableError> { - self.parent_reconfigure_element(device, element) + fn reconfigure_element(&self, element: &Element) -> Result<(), LoggableError> { + self.parent_reconfigure_element(element) } } pub trait DeviceImplExt: ObjectSubclass { - fn parent_create_element( - &self, - device: &Self::Type, - name: Option<&str>, - ) -> Result; + fn parent_create_element(&self, name: Option<&str>) -> Result; - fn parent_reconfigure_element( - &self, - device: &Self::Type, - element: &Element, - ) -> Result<(), LoggableError>; + fn parent_reconfigure_element(&self, element: &Element) -> Result<(), LoggableError>; } impl DeviceImplExt for T { - fn parent_create_element( - &self, - device: &Self::Type, - name: Option<&str>, - ) -> Result { + fn parent_create_element(&self, name: Option<&str>) -> Result { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstDeviceClass; if let Some(f) = (*parent_class).create_element { let ptr = f( - device.unsafe_cast_ref::().to_glib_none().0, + self.instance().unsafe_cast_ref::().to_glib_none().0, name.to_glib_none().0, ); @@ -74,11 +54,7 @@ impl DeviceImplExt for T { } } - fn parent_reconfigure_element( - &self, - device: &Self::Type, - element: &Element, - ) -> Result<(), LoggableError> { + fn parent_reconfigure_element(&self, element: &Element) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstDeviceClass; @@ -90,7 +66,7 @@ impl DeviceImplExt for T { })?; result_from_gboolean!( f( - device.unsafe_cast_ref::().to_glib_none().0, + self.instance().unsafe_cast_ref::().to_glib_none().0, element.to_glib_none().0 ), crate::CAT_RUST, @@ -115,10 +91,8 @@ unsafe extern "C" fn device_create_element( ) -> *mut ffi::GstElement { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); match imp.create_element( - wrap.unsafe_cast_ref(), Option::::from_glib_borrow(name) .as_ref() .as_ref() @@ -136,7 +110,7 @@ unsafe extern "C" fn device_create_element( element_ptr } Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); ptr::null_mut() } } @@ -148,12 +122,11 @@ unsafe extern "C" fn device_reconfigure_element( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.reconfigure_element(wrap.unsafe_cast_ref(), &from_glib_borrow(element)) { + match imp.reconfigure_element(&from_glib_borrow(element)) { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } diff --git a/gstreamer/src/subclass/device_provider.rs b/gstreamer/src/subclass/device_provider.rs index 74cc01500..5fcac80ee 100644 --- a/gstreamer/src/subclass/device_provider.rs +++ b/gstreamer/src/subclass/device_provider.rs @@ -73,34 +73,35 @@ pub trait DeviceProviderImpl: DeviceProviderImplExt + GstObjectImpl + Send + Syn None } - fn probe(&self, device_provider: &Self::Type) -> Vec { - self.parent_probe(device_provider) + fn probe(&self) -> Vec { + self.parent_probe() } - fn start(&self, device_provider: &Self::Type) -> Result<(), LoggableError> { - self.parent_start(device_provider) + fn start(&self) -> Result<(), LoggableError> { + self.parent_start() } - fn stop(&self, device_provider: &Self::Type) { - self.parent_stop(device_provider) + fn stop(&self) { + self.parent_stop() } } pub trait DeviceProviderImplExt: ObjectSubclass { - fn parent_probe(&self, device_provider: &Self::Type) -> Vec; + fn parent_probe(&self) -> Vec; - fn parent_start(&self, device_provider: &Self::Type) -> Result<(), LoggableError>; + fn parent_start(&self) -> Result<(), LoggableError>; - fn parent_stop(&self, device_provider: &Self::Type); + fn parent_stop(&self); } impl DeviceProviderImplExt for T { - fn parent_probe(&self, device_provider: &Self::Type) -> Vec { + fn parent_probe(&self) -> Vec { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstDeviceProviderClass; if let Some(f) = (*parent_class).probe { - FromGlibPtrContainer::from_glib_full(f(device_provider + FromGlibPtrContainer::from_glib_full(f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0)) @@ -110,7 +111,7 @@ impl DeviceProviderImplExt for T { } } - fn parent_start(&self, device_provider: &Self::Type) -> Result<(), LoggableError> { + fn parent_start(&self) -> Result<(), LoggableError> { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstDeviceProviderClass; @@ -118,7 +119,8 @@ impl DeviceProviderImplExt for T { loggable_error!(crate::CAT_RUST, "Parent function `start` is not defined") })?; result_from_gboolean!( - f(device_provider + f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0), @@ -128,12 +130,13 @@ impl DeviceProviderImplExt for T { } } - fn parent_stop(&self, device_provider: &Self::Type) { + fn parent_stop(&self) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstDeviceProviderClass; if let Some(f) = (*parent_class).stop { - f(device_provider + f(self + .instance() .unsafe_cast_ref::() .to_glib_none() .0); @@ -177,9 +180,8 @@ unsafe extern "C" fn device_provider_probe( ) -> *mut glib::ffi::GList { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.probe(wrap.unsafe_cast_ref()).to_glib_full() + imp.probe().to_glib_full() } unsafe extern "C" fn device_provider_start( @@ -187,12 +189,11 @@ unsafe extern "C" fn device_provider_start( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.start(wrap.unsafe_cast_ref()) { + match imp.start() { Ok(()) => true, Err(err) => { - err.log_with_object(&*wrap); + err.log_with_imp(imp); false } } @@ -202,7 +203,6 @@ unsafe extern "C" fn device_provider_start( unsafe extern "C" fn device_provider_stop(ptr: *mut ffi::GstDeviceProvider) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.stop(wrap.unsafe_cast_ref()); + imp.stop(); } diff --git a/gstreamer/src/subclass/element.rs b/gstreamer/src/subclass/element.rs index 6880d5e28..11245d53b 100644 --- a/gstreamer/src/subclass/element.rs +++ b/gstreamer/src/subclass/element.rs @@ -85,79 +85,75 @@ pub trait ElementImpl: ElementImplExt + GstObjectImpl + Send + Sync { fn change_state( &self, - element: &Self::Type, transition: StateChange, ) -> Result { - self.parent_change_state(element, transition) + self.parent_change_state(transition) } fn request_new_pad( &self, - element: &Self::Type, templ: &crate::PadTemplate, name: Option, caps: Option<&crate::Caps>, ) -> Option { - self.parent_request_new_pad(element, templ, name, caps) + self.parent_request_new_pad(templ, name, caps) } - fn release_pad(&self, element: &Self::Type, pad: &crate::Pad) { - self.parent_release_pad(element, pad) + fn release_pad(&self, pad: &crate::Pad) { + self.parent_release_pad(pad) } - fn send_event(&self, element: &Self::Type, event: Event) -> bool { - self.parent_send_event(element, event) + fn send_event(&self, event: Event) -> bool { + self.parent_send_event(event) } - fn query(&self, element: &Self::Type, query: &mut QueryRef) -> bool { - self.parent_query(element, query) + fn query(&self, query: &mut QueryRef) -> bool { + self.parent_query(query) } - fn set_context(&self, element: &Self::Type, context: &crate::Context) { - self.parent_set_context(element, context) + fn set_context(&self, context: &crate::Context) { + self.parent_set_context(context) } - fn set_clock(&self, element: &Self::Type, clock: Option<&crate::Clock>) -> bool { - self.parent_set_clock(element, clock) + fn set_clock(&self, clock: Option<&crate::Clock>) -> bool { + self.parent_set_clock(clock) } - fn provide_clock(&self, element: &Self::Type) -> Option { - self.parent_provide_clock(element) + fn provide_clock(&self) -> Option { + self.parent_provide_clock() } - fn post_message(&self, element: &Self::Type, msg: crate::Message) -> bool { - self.parent_post_message(element, msg) + fn post_message(&self, msg: crate::Message) -> bool { + self.parent_post_message(msg) } } pub trait ElementImplExt: ObjectSubclass { fn parent_change_state( &self, - element: &Self::Type, transition: StateChange, ) -> Result; fn parent_request_new_pad( &self, - element: &Self::Type, templ: &crate::PadTemplate, name: Option, caps: Option<&crate::Caps>, ) -> Option; - fn parent_release_pad(&self, element: &Self::Type, pad: &crate::Pad); + fn parent_release_pad(&self, pad: &crate::Pad); - fn parent_send_event(&self, element: &Self::Type, event: Event) -> bool; + fn parent_send_event(&self, event: Event) -> bool; - fn parent_query(&self, element: &Self::Type, query: &mut QueryRef) -> bool; + fn parent_query(&self, query: &mut QueryRef) -> bool; - fn parent_set_context(&self, element: &Self::Type, context: &crate::Context); + fn parent_set_context(&self, context: &crate::Context); - fn parent_set_clock(&self, element: &Self::Type, clock: Option<&crate::Clock>) -> bool; + fn parent_set_clock(&self, clock: Option<&crate::Clock>) -> bool; - fn parent_provide_clock(&self, element: &Self::Type) -> Option; + fn parent_provide_clock(&self) -> Option; - fn parent_post_message(&self, element: &Self::Type, msg: crate::Message) -> bool; + fn parent_post_message(&self, msg: crate::Message) -> bool; fn panicked(&self) -> &atomic::AtomicBool; @@ -168,7 +164,7 @@ pub trait ElementImplExt: ObjectSubclass { f: F, ) -> R; - fn catch_panic_pad_function R, G: FnOnce() -> R>( + fn catch_panic_pad_function R, G: FnOnce() -> R>( parent: Option<&crate::Object>, fallback: G, f: F, @@ -180,7 +176,6 @@ pub trait ElementImplExt: ObjectSubclass { impl ElementImplExt for T { fn parent_change_state( &self, - element: &Self::Type, transition: StateChange, ) -> Result { unsafe { @@ -191,7 +186,10 @@ impl ElementImplExt for T { .change_state .expect("Missing parent function `change_state`"); try_from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, transition.into_glib(), )) } @@ -199,7 +197,6 @@ impl ElementImplExt for T { fn parent_request_new_pad( &self, - element: &Self::Type, templ: &crate::PadTemplate, name: Option, caps: Option<&crate::Caps>, @@ -212,7 +209,10 @@ impl ElementImplExt for T { .request_new_pad .map(|f| { from_glib_none(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, templ.to_glib_none().0, name.to_glib_full(), caps.to_glib_none().0, @@ -222,7 +222,7 @@ impl ElementImplExt for T { } } - fn parent_release_pad(&self, element: &Self::Type, pad: &crate::Pad) { + fn parent_release_pad(&self, pad: &crate::Pad) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstElementClass; @@ -231,7 +231,10 @@ impl ElementImplExt for T { .release_pad .map(|f| { f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, pad.to_glib_none().0, ) }) @@ -239,7 +242,7 @@ impl ElementImplExt for T { } } - fn parent_send_event(&self, element: &Self::Type, event: Event) -> bool { + fn parent_send_event(&self, event: Event) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstElementClass; @@ -248,7 +251,10 @@ impl ElementImplExt for T { .send_event .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, event.into_glib_ptr(), )) }) @@ -256,7 +262,7 @@ impl ElementImplExt for T { } } - fn parent_query(&self, element: &Self::Type, query: &mut QueryRef) -> bool { + fn parent_query(&self, query: &mut QueryRef) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstElementClass; @@ -265,7 +271,10 @@ impl ElementImplExt for T { .query .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, query.as_mut_ptr(), )) }) @@ -273,7 +282,7 @@ impl ElementImplExt for T { } } - fn parent_set_context(&self, element: &Self::Type, context: &crate::Context) { + fn parent_set_context(&self, context: &crate::Context) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstElementClass; @@ -282,7 +291,10 @@ impl ElementImplExt for T { .set_context .map(|f| { f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, context.to_glib_none().0, ) }) @@ -290,7 +302,7 @@ impl ElementImplExt for T { } } - fn parent_set_clock(&self, element: &Self::Type, clock: Option<&crate::Clock>) -> bool { + fn parent_set_clock(&self, clock: Option<&crate::Clock>) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstElementClass; @@ -299,7 +311,10 @@ impl ElementImplExt for T { .set_clock .map(|f| { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, clock.to_glib_none().0, )) }) @@ -307,26 +322,35 @@ impl ElementImplExt for T { } } - fn parent_provide_clock(&self, element: &Self::Type) -> Option { + fn parent_provide_clock(&self) -> Option { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstElementClass; (*parent_class) .provide_clock - .map(|f| from_glib_none(f(element.unsafe_cast_ref::().to_glib_none().0))) + .map(|f| { + from_glib_none(f(self + .instance() + .unsafe_cast_ref::() + .to_glib_none() + .0)) + }) .unwrap_or(None) } } - fn parent_post_message(&self, element: &Self::Type, msg: crate::Message) -> bool { + fn parent_post_message(&self, msg: crate::Message) -> bool { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstElementClass; if let Some(f) = (*parent_class).post_message { from_glib(f( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, msg.into_glib_ptr(), )) } else { @@ -352,11 +376,11 @@ impl ElementImplExt for T { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - panic_to_error!(element, imp.panicked(), fallback(), { f(imp) }) + panic_to_error!(imp, fallback(), { f(imp) }) } } - fn catch_panic_pad_function R, G: FnOnce() -> R>( + fn catch_panic_pad_function R, G: FnOnce() -> R>( parent: Option<&crate::Object>, fallback: G, f: F, @@ -368,9 +392,7 @@ impl ElementImplExt for T { let instance = &*(ptr as *mut Self::Instance); let imp = instance.imp(); - panic_to_error!(wrap, imp.panicked(), fallback(), { - f(imp, wrap.unsafe_cast_ref()) - }) + panic_to_error!(imp, fallback(), { f(imp) }) } } @@ -435,7 +457,6 @@ unsafe extern "C" fn element_change_state( ) -> ffi::GstStateChangeReturn { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // *Never* fail downwards state changes, this causes bugs in GStreamer // and leads to crashes and deadlocks. @@ -447,10 +468,7 @@ unsafe extern "C" fn element_change_state( _ => StateChangeReturn::Failure, }; - panic_to_error!(&wrap, imp.panicked(), fallback, { - imp.change_state(wrap.unsafe_cast_ref(), transition).into() - }) - .into_glib() + panic_to_error!(imp, fallback, { imp.change_state(transition).into() }).into_glib() } unsafe extern "C" fn element_request_new_pad( @@ -461,15 +479,13 @@ unsafe extern "C" fn element_request_new_pad( ) -> *mut ffi::GstPad { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let caps = Option::::from_glib_borrow(caps); // XXX: This is effectively unsafe but the best we can do // See https://bugzilla.gnome.org/show_bug.cgi?id=791193 - let pad = panic_to_error!(&wrap, imp.panicked(), None, { + let pad = panic_to_error!(imp, None, { imp.request_new_pad( - wrap.unsafe_cast_ref(), &from_glib_borrow(templ), from_glib_none(name), caps.as_ref().as_ref(), @@ -495,7 +511,6 @@ unsafe extern "C" fn element_release_pad( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // If we get a floating reference passed simply return here. It can't be stored inside this // element, and if we continued to use it we would take ownership of this floating reference. @@ -505,9 +520,7 @@ unsafe extern "C" fn element_release_pad( return; } - panic_to_error!(&wrap, imp.panicked(), (), { - imp.release_pad(wrap.unsafe_cast_ref(), &from_glib_none(pad)) - }) + panic_to_error!(imp, (), { imp.release_pad(&from_glib_none(pad)) }) } unsafe extern "C" fn element_send_event( @@ -516,12 +529,8 @@ unsafe extern "C" fn element_send_event( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - panic_to_error!(&wrap, imp.panicked(), false, { - imp.send_event(wrap.unsafe_cast_ref(), from_glib_full(event)) - }) - .into_glib() + panic_to_error!(imp, false, { imp.send_event(from_glib_full(event)) }).into_glib() } unsafe extern "C" fn element_query( @@ -530,13 +539,9 @@ unsafe extern "C" fn element_query( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let query = QueryRef::from_mut_ptr(query); - panic_to_error!(&wrap, imp.panicked(), false, { - imp.query(wrap.unsafe_cast_ref(), query) - }) - .into_glib() + panic_to_error!(imp, false, { imp.query(query) }).into_glib() } unsafe extern "C" fn element_set_context( @@ -545,11 +550,8 @@ unsafe extern "C" fn element_set_context( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - panic_to_error!(&wrap, imp.panicked(), (), { - imp.set_context(wrap.unsafe_cast_ref(), &from_glib_borrow(context)) - }) + panic_to_error!(imp, (), { imp.set_context(&from_glib_borrow(context)) }) } unsafe extern "C" fn element_set_clock( @@ -558,14 +560,10 @@ unsafe extern "C" fn element_set_clock( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let clock = Option::::from_glib_borrow(clock); - panic_to_error!(&wrap, imp.panicked(), false, { - imp.set_clock(wrap.unsafe_cast_ref(), clock.as_ref().as_ref()) - }) - .into_glib() + panic_to_error!(imp, false, { imp.set_clock(clock.as_ref().as_ref()) }).into_glib() } unsafe extern "C" fn element_provide_clock( @@ -573,12 +571,8 @@ unsafe extern "C" fn element_provide_clock( ) -> *mut ffi::GstClock { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - panic_to_error!(&wrap, imp.panicked(), None, { - imp.provide_clock(wrap.unsafe_cast_ref()) - }) - .to_glib_full() + panic_to_error!(imp, None, { imp.provide_clock() }).to_glib_full() } unsafe extern "C" fn element_post_message( @@ -587,12 +581,10 @@ unsafe extern "C" fn element_post_message( ) -> glib::ffi::gboolean { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); // Can't catch panics here as posting the error message would cause // this code to be called again recursively forever. - imp.post_message(wrap.unsafe_cast_ref(), from_glib_full(msg)) - .into_glib() + imp.post_message(from_glib_full(msg)).into_glib() } #[cfg(test)] @@ -616,46 +608,25 @@ mod tests { fn sink_chain( &self, _pad: &crate::Pad, - _element: &super::TestElement, buffer: crate::Buffer, ) -> Result { self.n_buffers.fetch_add(1, atomic::Ordering::SeqCst); self.srcpad.push(buffer) } - fn sink_event( - &self, - _pad: &crate::Pad, - _element: &super::TestElement, - event: crate::Event, - ) -> bool { + fn sink_event(&self, _pad: &crate::Pad, event: crate::Event) -> bool { self.srcpad.push_event(event) } - fn sink_query( - &self, - _pad: &crate::Pad, - _element: &super::TestElement, - query: &mut crate::QueryRef, - ) -> bool { + fn sink_query(&self, _pad: &crate::Pad, query: &mut crate::QueryRef) -> bool { self.srcpad.peer_query(query) } - fn src_event( - &self, - _pad: &crate::Pad, - _element: &super::TestElement, - event: crate::Event, - ) -> bool { + fn src_event(&self, _pad: &crate::Pad, event: crate::Event) -> bool { self.sinkpad.push_event(event) } - fn src_query( - &self, - _pad: &crate::Pad, - _element: &super::TestElement, - query: &mut crate::QueryRef, - ) -> bool { + fn src_query(&self, _pad: &crate::Pad, query: &mut crate::QueryRef) -> bool { self.sinkpad.peer_query(query) } } @@ -673,21 +644,21 @@ mod tests { TestElement::catch_panic_pad_function( parent, || Err(crate::FlowError::Error), - |identity, element| identity.sink_chain(pad, element, buffer), + |identity| identity.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { TestElement::catch_panic_pad_function( parent, || false, - |identity, element| identity.sink_event(pad, element, event), + |identity| identity.sink_event(pad, event), ) }) .query_function(|pad, parent, query| { TestElement::catch_panic_pad_function( parent, || false, - |identity, element| identity.sink_query(pad, element, query), + |identity| identity.sink_query(pad, query), ) }) .build(); @@ -698,14 +669,14 @@ mod tests { TestElement::catch_panic_pad_function( parent, || false, - |identity, element| identity.src_event(pad, element, event), + |identity| identity.src_event(pad, event), ) }) .query_function(|pad, parent, query| { TestElement::catch_panic_pad_function( parent, || false, - |identity, element| identity.src_query(pad, element, query), + |identity| identity.src_query(pad, query), ) }) .build(); @@ -720,9 +691,10 @@ mod tests { } impl ObjectImpl for TestElement { - fn constructed(&self, element: &Self::Type) { - self.parent_constructed(element); + fn constructed(&self) { + self.parent_constructed(); + let element = self.instance(); element.add_pad(&self.sinkpad).unwrap(); element.add_pad(&self.srcpad).unwrap(); } @@ -772,10 +744,9 @@ mod tests { fn change_state( &self, - element: &Self::Type, transition: crate::StateChange, ) -> Result { - let res = self.parent_change_state(element, transition)?; + let res = self.parent_change_state(transition)?; if transition == crate::StateChange::PausedToPlaying { self.reached_playing.store(true, atomic::Ordering::SeqCst); diff --git a/gstreamer/src/subclass/error.rs b/gstreamer/src/subclass/error.rs index c14bb9203..20d864b64 100644 --- a/gstreamer/src/subclass/error.rs +++ b/gstreamer/src/subclass/error.rs @@ -7,15 +7,14 @@ use crate::FlowReturn; #[macro_export] macro_rules! panic_to_error( - ($element:expr, $panicked:expr, $ret:expr, $code:block) => {{ + ($imp:expr, $ret:expr, $code:block) => {{ use std::panic::{self, AssertUnwindSafe}; use std::sync::atomic::Ordering; - use $crate::prelude::ElementExtManual; #[allow(clippy::unused_unit)] { - if $panicked.load(Ordering::Relaxed) { - $element.post_error_message($crate::error_msg!($crate::LibraryError::Failed, ["Panicked"])); + if $imp.panicked().load(Ordering::Relaxed) { + $imp.post_error_message($crate::error_msg!($crate::LibraryError::Failed, ["Panicked"])); $ret } else { let result = panic::catch_unwind(AssertUnwindSafe(|| $code)); @@ -23,13 +22,13 @@ macro_rules! panic_to_error( match result { Ok(result) => result, Err(err) => { - $panicked.store(true, Ordering::Relaxed); + $imp.panicked().store(true, Ordering::Relaxed); if let Some(cause) = err.downcast_ref::<&str>() { - $element.post_error_message($crate::error_msg!($crate::LibraryError::Failed, ["Panicked: {}", cause])); + $imp.post_error_message($crate::error_msg!($crate::LibraryError::Failed, ["Panicked: {}", cause])); } else if let Some(cause) = err.downcast_ref::() { - $element.post_error_message($crate::error_msg!($crate::LibraryError::Failed, ["Panicked: {}", cause])); + $imp.post_error_message($crate::error_msg!($crate::LibraryError::Failed, ["Panicked: {}", cause])); } else { - $element.post_error_message($crate::error_msg!($crate::LibraryError::Failed, ["Panicked"])); + $imp.post_error_message($crate::error_msg!($crate::LibraryError::Failed, ["Panicked"])); } $ret } diff --git a/gstreamer/src/subclass/pad.rs b/gstreamer/src/subclass/pad.rs index 0b0d24b9a..823bc6d9b 100644 --- a/gstreamer/src/subclass/pad.rs +++ b/gstreamer/src/subclass/pad.rs @@ -8,23 +8,23 @@ use glib::translate::*; use crate::Pad; pub trait PadImpl: PadImplExt + GstObjectImpl + Send + Sync { - fn linked(&self, pad: &Self::Type, peer: &Pad) { - self.parent_linked(pad, peer) + fn linked(&self, peer: &Pad) { + self.parent_linked(peer) } - fn unlinked(&self, pad: &Self::Type, peer: &Pad) { - self.parent_unlinked(pad, peer) + fn unlinked(&self, peer: &Pad) { + self.parent_unlinked(peer) } } pub trait PadImplExt: ObjectSubclass { - fn parent_linked(&self, pad: &Self::Type, peer: &Pad); + fn parent_linked(&self, peer: &Pad); - fn parent_unlinked(&self, pad: &Self::Type, peer: &Pad); + fn parent_unlinked(&self, peer: &Pad); } impl PadImplExt for T { - fn parent_linked(&self, pad: &Self::Type, peer: &Pad) { + fn parent_linked(&self, peer: &Pad) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstPadClass; @@ -33,7 +33,7 @@ impl PadImplExt for T { .linked .map(|f| { f( - pad.unsafe_cast_ref::().to_glib_none().0, + self.instance().unsafe_cast_ref::().to_glib_none().0, peer.to_glib_none().0, ) }) @@ -41,7 +41,7 @@ impl PadImplExt for T { } } - fn parent_unlinked(&self, pad: &Self::Type, peer: &Pad) { + fn parent_unlinked(&self, peer: &Pad) { unsafe { let data = Self::type_data(); let parent_class = data.as_ref().parent_class() as *mut ffi::GstPadClass; @@ -50,7 +50,7 @@ impl PadImplExt for T { .unlinked .map(|f| { f( - pad.unsafe_cast_ref::().to_glib_none().0, + self.instance().unsafe_cast_ref::().to_glib_none().0, peer.to_glib_none().0, ) }) @@ -71,17 +71,15 @@ unsafe impl IsSubclassable for Pad { unsafe extern "C" fn pad_linked(ptr: *mut ffi::GstPad, peer: *mut ffi::GstPad) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.linked(wrap.unsafe_cast_ref(), &from_glib_borrow(peer)) + imp.linked(&from_glib_borrow(peer)) } unsafe extern "C" fn pad_unlinked(ptr: *mut ffi::GstPad, peer: *mut ffi::GstPad) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.unlinked(wrap.unsafe_cast_ref(), &from_glib_borrow(peer)) + imp.unlinked(&from_glib_borrow(peer)) } #[cfg(test)] @@ -113,14 +111,14 @@ mod tests { impl GstObjectImpl for TestPad {} impl PadImpl for TestPad { - fn linked(&self, pad: &Self::Type, peer: &Pad) { + fn linked(&self, peer: &Pad) { self.linked.store(true, atomic::Ordering::SeqCst); - self.parent_linked(pad, peer) + self.parent_linked(peer) } - fn unlinked(&self, pad: &Self::Type, peer: &Pad) { + fn unlinked(&self, peer: &Pad) { self.unlinked.store(true, atomic::Ordering::SeqCst); - self.parent_unlinked(pad, peer) + self.parent_unlinked(peer) } } } diff --git a/gstreamer/src/subclass/task_pool.rs b/gstreamer/src/subclass/task_pool.rs index e8bc31b91..c4e0d48f5 100644 --- a/gstreamer/src/subclass/task_pool.rs +++ b/gstreamer/src/subclass/task_pool.rs @@ -8,7 +8,6 @@ use std::ptr; use std::sync::{Arc, Mutex}; use glib::ffi::gpointer; -use glib::prelude::*; use glib::subclass::prelude::*; use glib::translate::*; @@ -25,7 +24,7 @@ pub trait TaskPoolImpl: GstObjectImpl + Send + Sync { /// Prepare the task pool to accept tasks. /// /// This defaults to doing nothing. - fn prepare(&self, _task_pool: &Self::Type) -> Result<(), glib::Error> { + fn prepare(&self) -> Result<(), glib::Error> { Ok(()) } @@ -34,7 +33,7 @@ pub trait TaskPoolImpl: GstObjectImpl + Send + Sync { /// /// This is mainly used internally to ensure proper cleanup of internal data structures in test /// suites. - fn cleanup(&self, _task_pool: &Self::Type) {} + fn cleanup(&self) {} // rustdoc-stripper-ignore-next /// Deliver a task to the pool. @@ -42,11 +41,7 @@ pub trait TaskPoolImpl: GstObjectImpl + Send + Sync { /// If returning `Ok`, you need to call the `func` eventually. /// /// If returning `Err`, the `func` must be dropped without calling it. - fn push( - &self, - task_pool: &Self::Type, - func: TaskPoolFunction, - ) -> Result, glib::Error>; + fn push(&self, func: TaskPoolFunction) -> Result, glib::Error>; } unsafe impl IsSubclassable for TaskPool { @@ -71,9 +66,8 @@ unsafe extern "C" fn task_pool_prepare( ) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - match imp.prepare(wrap.unsafe_cast_ref()) { + match imp.prepare() { Ok(()) => {} Err(err) => { if !error.is_null() { @@ -86,9 +80,8 @@ unsafe extern "C" fn task_pool_prepare( unsafe extern "C" fn task_pool_cleanup(ptr: *mut ffi::GstTaskPool) { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); - imp.cleanup(wrap.unsafe_cast_ref()); + imp.cleanup(); } unsafe extern "C" fn task_pool_push( @@ -99,11 +92,10 @@ unsafe extern "C" fn task_pool_push( ) -> gpointer { let instance = &*(ptr as *mut T::Instance); let imp = instance.imp(); - let wrap: Borrowed = from_glib_borrow(ptr); let func = TaskPoolFunction::new(func.expect("Tried to push null func"), user_data); - match imp.push(wrap.unsafe_cast_ref(), func.clone()) { + match imp.push(func.clone()) { Ok(None) => ptr::null_mut(), Ok(Some(handle)) => Box::into_raw(Box::new(handle)) as gpointer, Err(err) => { @@ -117,9 +109,8 @@ unsafe extern "C" fn task_pool_push( } unsafe extern "C" fn task_pool_join(ptr: *mut ffi::GstTaskPool, id: gpointer) { - let wrap: Borrowed = from_glib_borrow(ptr); - if id.is_null() { + let wrap: Borrowed = from_glib_borrow(ptr); crate::warning!(crate::CAT_RUST, obj: wrap.as_ref(), "Tried to join null handle"); return; } @@ -134,9 +125,8 @@ unsafe extern "C" fn task_pool_dispose_handle( ptr: *mut ffi::GstTaskPool, id: gpointer, ) { - let wrap: Borrowed = from_glib_borrow(ptr); - if id.is_null() { + let wrap: Borrowed = from_glib_borrow(ptr); crate::warning!(crate::CAT_RUST, obj: wrap.as_ref(), "Tried to dispose null handle"); return; } @@ -270,20 +260,16 @@ mod tests { impl TaskPoolImpl for TestPool { type Handle = TestHandle; - fn prepare(&self, _task_pool: &Self::Type) -> Result<(), glib::Error> { + fn prepare(&self) -> Result<(), glib::Error> { self.prepared.store(true, atomic::Ordering::SeqCst); Ok(()) } - fn cleanup(&self, _task_pool: &Self::Type) { + fn cleanup(&self) { self.cleaned_up.store(true, atomic::Ordering::SeqCst); } - fn push( - &self, - _task_pool: &Self::Type, - func: TaskPoolFunction, - ) -> Result, glib::Error> { + fn push(&self, func: TaskPoolFunction) -> Result, glib::Error> { let handle = thread::spawn(move || func.call()); Ok(Some(TestHandle(handle))) } diff --git a/gstreamer/src/subclass/uri_handler.rs b/gstreamer/src/subclass/uri_handler.rs index e650d59d6..f9ac05a72 100644 --- a/gstreamer/src/subclass/uri_handler.rs +++ b/gstreamer/src/subclass/uri_handler.rs @@ -13,14 +13,14 @@ use std::ptr; pub trait URIHandlerImpl: super::element::ElementImpl { const URI_TYPE: URIType; fn protocols() -> &'static [&'static str]; - fn uri(&self, element: &Self::Type) -> Option; - fn set_uri(&self, element: &Self::Type, uri: &str) -> Result<(), glib::Error>; + fn uri(&self) -> Option; + fn set_uri(&self, uri: &str) -> Result<(), glib::Error>; } pub trait URIHandlerImplExt: ObjectSubclass { fn parent_protocols() -> Vec; - fn parent_uri(&self, element: &Self::Type) -> Option; - fn parent_set_uri(&self, element: &Self::Type, uri: &str) -> Result<(), glib::Error>; + fn parent_uri(&self) -> Option; + fn parent_set_uri(&self, uri: &str) -> Result<(), glib::Error>; } impl URIHandlerImplExt for T { @@ -38,7 +38,7 @@ impl URIHandlerImplExt for T { } } - fn parent_uri(&self, element: &Self::Type) -> Option { + fn parent_uri(&self) -> Option { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -47,12 +47,17 @@ impl URIHandlerImplExt for T { let func = (*parent_iface) .get_uri .expect("no parent \"uri\" implementation"); - let ret = func(element.unsafe_cast_ref::().to_glib_none().0); + let ret = func( + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, + ); from_glib_full(ret) } } - fn parent_set_uri(&self, element: &Self::Type, uri: &str) -> Result<(), glib::Error> { + fn parent_set_uri(&self, uri: &str) -> Result<(), glib::Error> { unsafe { let type_data = Self::type_data(); let parent_iface = type_data.as_ref().parent_interface::() @@ -64,7 +69,10 @@ impl URIHandlerImplExt for T { let mut err = ptr::null_mut(); func( - element.unsafe_cast_ref::().to_glib_none().0, + self.instance() + .unsafe_cast_ref::() + .to_glib_none() + .0, uri.to_glib_none().0, &mut err, ); @@ -126,8 +134,7 @@ unsafe extern "C" fn uri_handler_get_uri( let instance = &*(uri_handler as *mut T::Instance); let imp = instance.imp(); - imp.uri(from_glib_borrow::<_, URIHandler>(uri_handler).unsafe_cast_ref()) - .to_glib_full() + imp.uri().to_glib_full() } unsafe extern "C" fn uri_handler_set_uri( @@ -138,10 +145,7 @@ unsafe extern "C" fn uri_handler_set_uri( let instance = &*(uri_handler as *mut T::Instance); let imp = instance.imp(); - match imp.set_uri( - from_glib_borrow::<_, URIHandler>(uri_handler).unsafe_cast_ref(), - glib::GString::from_glib_borrow(uri).as_str(), - ) { + match imp.set_uri(glib::GString::from_glib_borrow(uri).as_str()) { Ok(()) => true.into_glib(), Err(error) => { if !err.is_null() {