diff options
author | Sebastian Dröge <sebastian@centricular.com> | 2022-10-09 16:06:59 +0300 |
---|---|---|
committer | Sebastian Dröge <sebastian@centricular.com> | 2022-10-10 15:03:25 +0300 |
commit | 7ee4afacf413b2e3c386bb1070994ed4325994e6 (patch) | |
tree | eddcc0e047ab4704e5a459dd551a55196e8a1848 /video | |
parent | 7818ac658b02417fda071ce025b6d6a7fdb54a76 (diff) |
Change *Impl trait methods to only take &self and not Self::Type in addition
Diffstat (limited to 'video')
29 files changed, 991 insertions, 1456 deletions
diff --git a/video/cdg/src/cdgdec/imp.rs b/video/cdg/src/cdgdec/imp.rs index 5e4f3cc38..469c09767 100644 --- a/video/cdg/src/cdgdec/imp.rs +++ b/video/cdg/src/cdgdec/imp.rs @@ -88,39 +88,39 @@ impl ElementImpl for CdgDec { } impl VideoDecoderImpl for CdgDec { - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn start(&self) -> Result<(), gst::ErrorMessage> { let mut out_info = self.output_info.lock().unwrap(); *out_info = None; - self.parent_start(element) + self.parent_start() } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { { let mut cdg_inter = self.cdg_inter.lock().unwrap(); cdg_inter.reset(true); } - self.parent_stop(element) + self.parent_stop() } fn handle_frame( &self, - element: &Self::Type, mut frame: gst_video::VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError> { { let mut out_info = self.output_info.lock().unwrap(); if out_info.is_none() { - let output_state = element.set_output_state( + let instance = self.instance(); + let output_state = instance.set_output_state( gst_video::VideoFormat::Rgba, CDG_WIDTH, CDG_HEIGHT, None, )?; - element.negotiate(output_state)?; + instance.negotiate(output_state)?; - let out_state = element.output_state().unwrap(); + let out_state = instance.output_state().unwrap(); *out_info = Some(out_state.info()); } } @@ -128,8 +128,8 @@ impl VideoDecoderImpl for CdgDec { let cmd = { let input = frame.input_buffer().unwrap(); let map = input.map_readable().map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["Failed to map input buffer readable"] ); @@ -144,7 +144,7 @@ impl VideoDecoderImpl for CdgDec { Some(cmd) => cmd, None => { // Not a CDG command - element.release_frame(frame); + self.instance().release_frame(frame); return Ok(gst::FlowSuccess::Ok); } }; @@ -152,7 +152,7 @@ impl VideoDecoderImpl for CdgDec { let mut cdg_inter = self.cdg_inter.lock().unwrap(); cdg_inter.handle_cmd(cmd); - element.allocate_output_frame(&mut frame, None)?; + self.instance().allocate_output_frame(&mut frame, None)?; { let output = frame.output_buffer_mut().unwrap(); let info = self.output_info.lock().unwrap(); @@ -160,8 +160,8 @@ impl VideoDecoderImpl for CdgDec { let mut out_frame = gst_video::VideoFrameRef::from_buffer_ref_writable(output, info.as_ref().unwrap()) .map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["Failed to map output buffer writable"] ); @@ -188,19 +188,13 @@ impl VideoDecoderImpl for CdgDec { } } - gst::debug!( - CAT, - obj: element, - "Finish frame pts={}", - frame.pts().display() - ); + gst::debug!(CAT, imp: self, "Finish frame pts={}", frame.pts().display()); - element.finish_frame(frame) + self.instance().finish_frame(frame) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { if query @@ -216,11 +210,11 @@ impl VideoDecoderImpl for CdgDec { } } - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } - fn flush(&self, element: &Self::Type) -> bool { - gst::debug!(CAT, obj: element, "flushing, reset CDG interpreter"); + fn flush(&self) -> bool { + gst::debug!(CAT, imp: self, "flushing, reset CDG interpreter"); let mut cdg_inter = self.cdg_inter.lock().unwrap(); cdg_inter.reset(false); diff --git a/video/cdg/src/cdgparse/imp.rs b/video/cdg/src/cdgparse/imp.rs index d3869d417..8ebf1e007 100644 --- a/video/cdg/src/cdgparse/imp.rs +++ b/video/cdg/src/cdgparse/imp.rs @@ -111,16 +111,15 @@ fn time_to_bytes(time: gst::ClockTime) -> Bytes { } impl BaseParseImpl for CdgParse { - fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { - element.set_min_frame_size(CDG_PACKET_SIZE as u32); + fn start(&self) -> Result<(), gst::ErrorMessage> { + self.instance().set_min_frame_size(CDG_PACKET_SIZE as u32); /* Set duration */ let mut query = gst::query::Duration::new(gst::Format::Bytes); - let pad = element.src_pad(); - if pad.query(&mut query) { + if self.instance().src_pad().query(&mut query) { let size = query.result(); let bytes: Option<Bytes> = size.try_into().unwrap(); - element.set_duration(bytes.map(bytes_to_time), 0); + self.instance().set_duration(bytes.map(bytes_to_time), 0); } Ok(()) @@ -128,11 +127,9 @@ impl BaseParseImpl for CdgParse { fn handle_frame( &self, - element: &Self::Type, mut frame: gst_base::BaseParseFrame, ) -> Result<(gst::FlowSuccess, u32), gst::FlowError> { - let pad = element.src_pad(); - if pad.current_caps().is_none() { + if self.instance().src_pad().current_caps().is_none() { // Set src pad caps let src_caps = gst::Caps::builder("video/x-cdg") .field("width", CDG_WIDTH as i32) @@ -141,15 +138,17 @@ impl BaseParseImpl for CdgParse { .field("parsed", true) .build(); - pad.push_event(gst::event::Caps::new(&src_caps)); + self.instance() + .src_pad() + .push_event(gst::event::Caps::new(&src_caps)); } // Scan for CDG instruction let input = frame.buffer().unwrap(); let skip = { let map = input.map_readable().map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["Failed to map input buffer readable"] ); @@ -172,8 +171,8 @@ impl BaseParseImpl for CdgParse { let (keyframe, header) = { let map = input.map_readable().map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["Failed to map input buffer readable"] ); @@ -203,16 +202,16 @@ impl BaseParseImpl for CdgParse { buffer.set_flags(gst::BufferFlags::HEADER); } - gst::debug!(CAT, obj: element, "Found frame pts={}", pts); + gst::debug!(CAT, imp: self, "Found frame pts={}", pts); - element.finish_frame(frame, CDG_PACKET_SIZE as u32)?; + self.instance() + .finish_frame(frame, CDG_PACKET_SIZE as u32)?; Ok((gst::FlowSuccess::Ok, skip)) } fn convert( &self, - _element: &Self::Type, src_val: impl FormattedValue, dest_format: gst::Format, ) -> Option<gst::GenericFormattedValue> { diff --git a/video/closedcaption/src/ccdetect/imp.rs b/video/closedcaption/src/ccdetect/imp.rs index e2b1f6150..b6691dd4b 100644 --- a/video/closedcaption/src/ccdetect/imp.rs +++ b/video/closedcaption/src/ccdetect/imp.rs @@ -72,9 +72,13 @@ struct CCPacketContents { } impl CCDetect { - fn detect_cc_data(data: &[u8]) -> Result<CCPacketContents, ParseError> { + fn detect_cc_data(&self, data: &[u8]) -> Result<CCPacketContents, ParseError> { if data.len() % 3 != 0 { - gst::warning!(CAT, "cc_data length is not a multiple of 3, truncating"); + gst::warning!( + CAT, + imp: self, + "cc_data length is not a multiple of 3, truncating" + ); } /* logic from ccconverter */ @@ -86,6 +90,7 @@ impl CCDetect { let cc_type = triple[0] & 0x03; gst::trace!( CAT, + imp: self, "triple:{} have ccp:{} 608:{} 708:{} data:{:02x},{:02x},{:02x} cc_valid:{} cc_type:{:02b}", i * 3, started_ccp, @@ -130,22 +135,21 @@ impl CCDetect { }) } - fn detect_cdp(data: &[u8]) -> Result<CCPacketContents, ParseError> { + fn detect_cdp(&self, data: &[u8]) -> Result<CCPacketContents, ParseError> { let data = extract_cdp(data)?; - Self::detect_cc_data(data) + self.detect_cc_data(data) } - fn detect(format: CCFormat, data: &[u8]) -> Result<CCPacketContents, ParseError> { + fn detect(&self, format: CCFormat, data: &[u8]) -> Result<CCPacketContents, ParseError> { match format { - CCFormat::Cc708CcData => Self::detect_cc_data(data), - CCFormat::Cc708Cdp => Self::detect_cdp(data), + CCFormat::Cc708CcData => self.detect_cc_data(data), + CCFormat::Cc708Cdp => self.detect_cdp(data), } } fn maybe_update_properties( &self, - element: &super::CCDetect, ts: gst::ClockTime, cc_packet: CCPacketContents, ) -> Result<(), gst::FlowError> { @@ -160,6 +164,7 @@ impl CCDetect { gst::trace!( CAT, + imp: self, "packet contains {:?} current settings {:?} and state {:?}", cc_packet, settings, @@ -193,14 +198,20 @@ impl CCDetect { state.last_cc708_change = Some(ts); } - gst::trace!(CAT, "changed to settings {:?} state {:?}", settings, state); + gst::trace!( + CAT, + imp: self, + "changed to settings {:?} state {:?}", + settings, + state + ); } if notify_cc608 { - element.notify("cc608"); + self.instance().notify("cc608"); } if notify_cc708 { - element.notify("cc708"); + self.instance().notify("cc708"); } Ok(()) @@ -243,13 +254,7 @@ impl ObjectImpl for CCDetect { PROPERTIES.as_ref() } - 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) { match pspec.name() { "window" => { let mut settings = self.settings.lock().unwrap(); @@ -260,7 +265,7 @@ impl ObjectImpl for CCDetect { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "window" => { let settings = self.settings.lock().unwrap(); @@ -337,14 +342,13 @@ impl BaseTransformImpl for CCDetect { fn transform_ip_passthrough( &self, - element: &Self::Type, buf: &gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { let map = buf.map_readable().map_err(|_| gst::FlowError::Error)?; let pts = buf.pts().ok_or_else(|| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::ResourceError::Read, ["Input buffers must have valid timestamps"] ); @@ -357,11 +361,11 @@ impl BaseTransformImpl for CCDetect { state.format }; - let cc_packet = match Self::detect(format, map.as_slice()) { + let cc_packet = match self.detect(format, map.as_slice()) { Ok(v) => v, Err(e) => { - gst::warning!(CAT, "{}", &e.to_string()); - gst::element_warning!(element, gst::StreamError::Decode, [&e.to_string()]); + gst::warning!(CAT, imp: self, "{}", &e.to_string()); + gst::element_imp_warning!(self, gst::StreamError::Decode, [&e.to_string()]); CCPacketContents { cc608: false, cc708: false, @@ -369,35 +373,29 @@ impl BaseTransformImpl for CCDetect { } }; - self.maybe_update_properties(element, pts, cc_packet) + self.maybe_update_properties(pts, cc_packet) .map_err(|_| gst::FlowError::Error)?; Ok(gst::FlowSuccess::Ok) } - fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { + fn sink_event(&self, event: gst::Event) -> bool { match event.view() { gst::event::EventView::Gap(gap) => { let _ = self.maybe_update_properties( - element, gap.get().0, CCPacketContents { cc608: false, cc708: false, }, ); - self.parent_sink_event(element, event) + self.parent_sink_event(event) } - _ => self.parent_sink_event(element, event), + _ => self.parent_sink_event(event), } } - fn set_caps( - &self, - _element: &Self::Type, - incaps: &gst::Caps, - outcaps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn set_caps(&self, incaps: &gst::Caps, outcaps: &gst::Caps) -> Result<(), gst::LoggableError> { if incaps != outcaps { return Err(gst::loggable_error!( CAT, @@ -427,7 +425,7 @@ impl BaseTransformImpl for CCDetect { Ok(()) } - fn stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { // Drop state let _ = self.state.lock().unwrap().take(); diff --git a/video/closedcaption/src/cea608overlay/imp.rs b/video/closedcaption/src/cea608overlay/imp.rs index 4f0fbf44d..e52eb6904 100644 --- a/video/closedcaption/src/cea608overlay/imp.rs +++ b/video/closedcaption/src/cea608overlay/imp.rs @@ -96,17 +96,13 @@ impl Cea608Overlay { // https://blogs.gnome.org/mclasen/2019/07/27/more-text-rendering-updates/ // // TODO: switch to the API presented in this post once it's been exposed - fn recalculate_layout( - &self, - element: &super::Cea608Overlay, - state: &mut State, - ) -> Result<gst::FlowSuccess, gst::FlowError> { + fn recalculate_layout(&self, state: &mut State) -> Result<gst::FlowSuccess, gst::FlowError> { let video_info = state.video_info.as_ref().unwrap(); let fontmap = match pangocairo::FontMap::new() { Some(fontmap) => Ok(fontmap), None => { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::LibraryError::Failed, ["Failed to create pangocairo font map"] ); @@ -116,8 +112,8 @@ impl Cea608Overlay { let context = match fontmap.create_context() { Some(context) => Ok(context), None => { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::LibraryError::Failed, ["Failed to create font map context"] ); @@ -163,7 +159,7 @@ impl Cea608Overlay { Ok(gst::FlowSuccess::Ok) } - fn overlay_text(&self, element: &super::Cea608Overlay, text: &str, state: &mut State) { + fn overlay_text(&self, text: &str, state: &mut State) { let video_info = state.video_info.as_ref().unwrap(); let layout = state.layout.as_ref().unwrap(); layout.set_text(text); @@ -251,7 +247,7 @@ impl Cea608Overlay { let buffer = match render_buffer() { Some(buffer) => buffer, None => { - gst::error!(CAT, obj: element, "Failed to render buffer"); + gst::error!(CAT, imp: self, "Failed to render buffer"); state.composition = None; return; } @@ -272,16 +268,12 @@ impl Cea608Overlay { }; } - fn negotiate( - &self, - element: &super::Cea608Overlay, - state: &mut State, - ) -> Result<gst::FlowSuccess, gst::FlowError> { + fn negotiate(&self, state: &mut State) -> Result<gst::FlowSuccess, gst::FlowError> { let video_info = match state.video_info.as_ref() { Some(video_info) => Ok(video_info), None => { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Negotiation, ["Element hasn't received valid video caps at negotiation time"] ); @@ -322,14 +314,7 @@ impl Cea608Overlay { } } - fn decode_cc_data( - &self, - pad: &gst::Pad, - element: &super::Cea608Overlay, - state: &mut State, - data: &[u8], - pts: gst::ClockTime, - ) { + fn decode_cc_data(&self, pad: &gst::Pad, state: &mut State, data: &[u8], pts: gst::ClockTime) { if data.len() % 3 != 0 { gst::warning!(CAT, "cc_data length is not a multiple of 3, truncating"); } @@ -342,12 +327,7 @@ impl Cea608Overlay { if cc_type == 0x00 || cc_type == 0x01 { if state.selected_field.is_none() { state.selected_field = Some(cc_type); - gst::info!( - CAT, - obj: element, - "Selected field {} automatically", - cc_type - ); + gst::info!(CAT, imp: self, "Selected field {} automatically", cc_type); } if Some(cc_type) == state.selected_field { @@ -368,10 +348,10 @@ impl Cea608Overlay { } }; - self.overlay_text(element, &text, state); + self.overlay_text(&text, state); } Ok(Status::Clear) => { - self.overlay_text(element, "", state); + self.overlay_text("", state); } Ok(Status::Ok) => (), Err(err) => { @@ -393,14 +373,7 @@ impl Cea608Overlay { } } - fn decode_s334_1a( - &self, - pad: &gst::Pad, - element: &super::Cea608Overlay, - state: &mut State, - data: &[u8], - pts: gst::ClockTime, - ) { + fn decode_s334_1a(&self, pad: &gst::Pad, state: &mut State, data: &[u8], pts: gst::ClockTime) { if data.len() % 3 != 0 { gst::warning!(CAT, "cc_data length is not a multiple of 3, truncating"); } @@ -409,12 +382,7 @@ impl Cea608Overlay { let cc_type = triple[0] & 0x01; if state.selected_field.is_none() { state.selected_field = Some(cc_type); - gst::info!( - CAT, - obj: element, - "Selected field {} automatically", - cc_type - ); + gst::info!(CAT, imp: self, "Selected field {} automatically", cc_type); } if Some(cc_type) == state.selected_field { @@ -430,7 +398,7 @@ impl Cea608Overlay { } }; - self.overlay_text(element, &text, state); + self.overlay_text(&text, state); } self.reset_timeout(state, pts); @@ -445,7 +413,6 @@ impl Cea608Overlay { fn sink_chain( &self, pad: &gst::Pad, - element: &super::Cea608Overlay, mut buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); @@ -458,28 +425,28 @@ impl Cea608Overlay { let mut state = self.state.lock().unwrap(); if self.srcpad.check_reconfigure() { - self.negotiate(element, &mut state)?; + self.negotiate(&mut state)?; } if state.layout.is_none() { - self.recalculate_layout(element, &mut state)?; + self.recalculate_layout(&mut state)?; } for meta in buffer.iter_meta::<gst_video::VideoCaptionMeta>() { if meta.caption_type() == gst_video::VideoCaptionType::Cea708Cdp { match extract_cdp(meta.data()) { Ok(data) => { - self.decode_cc_data(pad, element, &mut state, data, pts); + self.decode_cc_data(pad, &mut state, data, pts); } Err(e) => { gst::warning!(CAT, "{}", &e.to_string()); - gst::element_warning!(element, gst::StreamError::Decode, [&e.to_string()]); + gst::element_imp_warning!(self, gst::StreamError::Decode, [&e.to_string()]); } } } else if meta.caption_type() == gst_video::VideoCaptionType::Cea708Raw { - self.decode_cc_data(pad, element, &mut state, meta.data(), pts); + self.decode_cc_data(pad, &mut state, meta.data(), pts); } else if meta.caption_type() == gst_video::VideoCaptionType::Cea608S3341a { - self.decode_s334_1a(pad, element, &mut state, meta.data(), pts); + self.decode_s334_1a(pad, &mut state, meta.data(), pts); } else if meta.caption_type() == gst_video::VideoCaptionType::Cea608Raw { let data = meta.data(); assert!(data.len() % 2 == 0); @@ -500,7 +467,7 @@ impl Cea608Overlay { } }; - self.overlay_text(element, &text, &mut state); + self.overlay_text(&text, &mut state); } self.reset_timeout(&mut state, pts); @@ -511,7 +478,7 @@ impl Cea608Overlay { if let Some(timeout) = self.settings.lock().unwrap().timeout { if let Some(interval) = pts.opt_saturating_sub(state.last_cc_pts) { if interval > timeout { - gst::info!(CAT, obj: element, "Reached timeout, clearing overlay"); + gst::info!(CAT, imp: self, "Reached timeout, clearing overlay"); state.composition.take(); state.last_cc_pts.take(); } @@ -539,12 +506,7 @@ impl Cea608Overlay { self.srcpad.push(buffer) } - fn sink_event( - &self, - pad: &gst::Pad, - element: &super::Cea608Overlay, - event: gst::Event, - ) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -553,7 +515,7 @@ impl Cea608Overlay { let mut state = self.state.lock().unwrap(); state.video_info = gst_video::VideoInfo::from_caps(c.caps()).ok(); self.srcpad.check_reconfigure(); - match self.negotiate(element, &mut state) { + match self.negotiate(&mut state) { Ok(_) => true, Err(_) => { self.srcpad.mark_reconfigure(); @@ -565,9 +527,9 @@ impl Cea608Overlay { let mut state = self.state.lock().unwrap(); state.caption_frame = CaptionFrame::default(); state.composition = None; - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } } @@ -585,14 +547,14 @@ impl ObjectSubclass for Cea608Overlay { Cea608Overlay::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |overlay, element| overlay.sink_chain(pad, element, buffer), + |overlay| overlay.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { Cea608Overlay::catch_panic_pad_function( parent, || false, - |overlay, element| overlay.sink_event(pad, element, event), + |overlay| overlay.sink_event(pad, event), ) }) .flags(gst::PadFlags::PROXY_CAPS) @@ -645,13 +607,7 @@ impl ObjectImpl for Cea608Overlay { PROPERTIES.as_ref() } - 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) { match pspec.name() { "field" => { let mut settings = self.settings.lock().unwrap(); @@ -684,7 +640,7 @@ impl ObjectImpl for Cea608Overlay { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "field" => { let settings = self.settings.lock().unwrap(); @@ -705,9 +661,10 @@ impl ObjectImpl for Cea608Overlay { _ => unimplemented!(), } } - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -760,10 +717,9 @@ impl ElementImpl for Cea608Overlay { fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { @@ -779,6 +735,6 @@ impl ElementImpl for Cea608Overlay { _ => (), } - self.parent_change_state(element, transition) + self.parent_change_state(transition) } } diff --git a/video/closedcaption/src/cea608tojson/imp.rs b/video/closedcaption/src/cea608tojson/imp.rs index a9c41aad3..633982ae6 100644 --- a/video/closedcaption/src/cea608tojson/imp.rs +++ b/video/closedcaption/src/cea608tojson/imp.rs @@ -393,7 +393,7 @@ fn eia608_to_text(cc_data: u16) -> String { } fn dump( - element: &super::Cea608ToJson, + imp: &Cea608ToJson, cc_data: u16, pts: impl Into<Option<gst::ClockTime>>, duration: impl Into<Option<gst::ClockTime>>, @@ -404,7 +404,7 @@ fn dump( if cc_data != 0x8080 { gst::debug!( CAT, - obj: element, + imp: imp, "{} -> {}: {}", pts.display(), end.display(), @@ -413,7 +413,7 @@ fn dump( } else { gst::trace!( CAT, - obj: element, + imp: imp, "{} -> {}: padding", pts.display(), end.display() @@ -422,21 +422,17 @@ fn dump( } impl State { - fn update_mode( - &mut self, - element: &super::Cea608ToJson, - mode: Cea608Mode, - ) -> Option<TimestampedLines> { + fn update_mode(&mut self, imp: &Cea608ToJson, mode: Cea608Mode) -> Option<TimestampedLines> { if mode.is_rollup() && self.mode == Some(Cea608Mode::PopOn) { // https://www.law.cornell.edu/cfr/text/47/79.101 (f)(2)(v) - let _ = self.drain(element, true); + let _ = self.drain(imp, true); } let ret = if Some(mode) != self.mode { if self.mode == Some(Cea608Mode::PopOn) { - self.drain_pending(element) + self.drain_pending(imp) } else { - self.drain(element, true) + self.drain(imp, true) } } else { None @@ -459,8 +455,8 @@ impl State { ret } - fn drain(&mut self, element: &super::Cea608ToJson, flush: bool) -> Option<TimestampedLines> { - gst::log!(CAT, obj: element, "Draining"); + fn drain(&mut self, imp: &Cea608ToJson, flush: bool) -> Option<TimestampedLines> { + gst::log!(CAT, imp: imp, "Draining"); let pts = if self.settings.unbuffered { self.current_pts @@ -533,9 +529,9 @@ impl State { } } - fn drain_pending(&mut self, element: &super::Cea608ToJson) -> Option<TimestampedLines> { + fn drain_pending(&mut self, imp: &Cea608ToJson) -> Option<TimestampedLines> { if let Some(mut pending) = self.pending_lines.take() { - gst::log!(CAT, obj: element, "Draining pending"); + gst::log!(CAT, imp: imp, "Draining pending"); pending.duration = self .current_pts .opt_add(self.current_duration) @@ -548,18 +544,14 @@ impl State { } } - fn decode_preamble( - &mut self, - element: &super::Cea608ToJson, - cc_data: u16, - ) -> Option<TimestampedLines> { + fn decode_preamble(&mut self, imp: &Cea608ToJson, cc_data: u16) -> Option<TimestampedLines> { let preamble = parse_preamble(cc_data); if preamble.chan != 0 { return None; } - gst::log!(CAT, obj: element, "preamble: {:?}", preamble); + gst::log!(CAT, imp: imp, "preamble: {:?}", preamble); let drain_roll_up = self.cursor.row != preamble.row as u32; @@ -606,7 +598,7 @@ impl State { if self.settings.unbuffered { /* We only need to drain when the roll-up window was relocated */ let ret = if drain_roll_up { - self.drain(element, true) + self.drain(imp, true) } else { None }; @@ -620,7 +612,7 @@ impl State { ret // The relocation is potentially destructive, let us drain } else { - let ret = self.drain(element, true); + let ret = self.drain(imp, true); self.rows.insert(self.cursor.row, Row::new(self.cursor.row)); ret @@ -638,14 +630,10 @@ impl State { } } - fn decode_control( - &mut self, - element: &super::Cea608ToJson, - cc_data: u16, - ) -> Option<TimestampedLines> { + fn decode_control(&mut self, imp: &Cea608ToJson, cc_data: u16) -> Option<TimestampedLines> { let (cmd, chan) = parse_control(cc_data); - gst::log!(CAT, obj: element, "Command for CC {}", chan); + gst::log!(CAT, imp: imp, "Command for CC {}", chan); if chan != 0 { return None; @@ -653,32 +641,32 @@ impl State { match cmd { ffi::eia608_control_t_eia608_control_resume_direct_captioning => { - return self.update_mode(element, Cea608Mode::PaintOn); + return self.update_mode(imp, Cea608Mode::PaintOn); } ffi::eia608_control_t_eia608_control_erase_display_memory => { return match self.mode { Some(Cea608Mode::PopOn) => { self.clear = Some(true); - self.drain_pending(element) + self.drain_pending(imp) } _ => { - let ret = self.drain(element, true); + let ret = self.drain(imp, true); self.clear = Some(true); ret } }; } ffi::eia608_control_t_eia608_control_roll_up_2 => { - return self.update_mode(element, Cea608Mode::RollUp2); + return self.update_mode(imp, Cea608Mode::RollUp2); } ffi::eia608_control_t_eia608_control_roll_up_3 => { - return self.update_mode(element, Cea608Mode::RollUp3); + return self.update_mode(imp, Cea608Mode::RollUp3); } ffi::eia608_control_t_eia608_control_roll_up_4 => { - return self.update_mode(element, Cea608Mode::RollUp4); + return self.update_mode(imp, Cea608Mode::RollUp4); } ffi::eia608_control_t_eia608_control_carriage_return => { - gst::log!(CAT, obj: element, "carriage return"); + gst::log!(CAT, imp: imp, "carriage return"); if let Some(mode) = self.mode { // https://www.law.cornell.edu/cfr/text/47/79.101 (f)(2)(i) (f)(3)(i) @@ -704,9 +692,9 @@ impl State { } self.rows.insert(self.cursor.row, Row::new(self.cursor.row)); - self.drain(element, false) + self.drain(imp, false) } else { - let ret = self.drain(element, true); + let ret = self.drain(imp, true); self.carriage_return = Some(true); ret }; @@ -721,7 +709,7 @@ impl State { } } ffi::eia608_control_t_eia608_control_resume_caption_loading => { - return self.update_mode(element, Cea608Mode::PopOn); + return self.update_mode(imp, Cea608Mode::PopOn); } ffi::eia608_control_t_eia608_control_erase_non_displayed_memory => { if self.mode == Some(Cea608Mode::PopOn) { @@ -730,13 +718,13 @@ impl State { } ffi::eia608_control_t_eia608_control_end_of_caption => { // https://www.law.cornell.edu/cfr/text/47/79.101 (f)(2) - self.update_mode(element, Cea608Mode::PopOn); + self.update_mode(imp, Cea608Mode::PopOn); self.first_pts = self.current_pts; let ret = if self.settings.unbuffered { - self.drain(element, true) + self.drain(imp, true) } else { - let ret = self.drain_pending(element); - self.pending_lines = self.drain(element, true); + let ret = self.drain_pending(imp); + self.pending_lines = self.drain(imp, true); ret }; return ret; @@ -756,14 +744,14 @@ impl State { | ffi::eia608_control_t_eia608_control_text_restart | ffi::eia608_control_t_eia608_control_text_resume_text_display => {} _ => { - gst::warning!(CAT, obj: element, "Unknown command {}!", cmd); + gst::warning!(CAT, imp: imp, "Unknown command {}!", cmd); } } None } - fn decode_text(&mut self, element: &super::Cea608ToJson, cc_data: u16) { + fn decode_text(&mut self, imp: &Cea608ToJson, cc_data: u16) { let (char1, char2, chan) = eia608_to_utf8(cc_data); if chan != 0 { @@ -791,7 +779,7 @@ impl State { row.push(&mut self.cursor, c); } } else { - gst::warning!(CAT, obj: element, "No row to append decoded text to!"); + gst::warning!(CAT, imp: imp, "No row to append decoded text to!"); } } @@ -807,13 +795,13 @@ impl State { fn handle_cc_data( &mut self, - element: &super::Cea608ToJson, + imp: &Cea608ToJson, pts: Option<gst::ClockTime>, duration: Option<gst::ClockTime>, cc_data: u16, ) -> Option<TimestampedLines> { if (is_specialna(cc_data) || is_control(cc_data)) && Some(cc_data) == self.last_cc_data { - gst::log!(CAT, obj: element, "Skipping duplicate"); + gst::log!(CAT, imp: imp, "Skipping duplicate"); return None; } @@ -822,25 +810,25 @@ impl State { self.current_duration = duration; if is_xds(cc_data) { - gst::log!(CAT, obj: element, "XDS, ignoring"); + gst::log!(CAT, imp: imp, "XDS, ignoring"); } else if is_control(cc_data) { - gst::log!(CAT, obj: element, "control!"); - return self.decode_control(element, cc_data); + gst::log!(CAT, imp: imp, "control!"); + return self.decode_control(imp, cc_data); } else if is_basicna(cc_data) || is_specialna(cc_data) || is_westeu(cc_data) { if let Some(mode) = self.mode { self.mode?; - gst::log!(CAT, obj: element, "text"); - self.decode_text(element, cc_data); + gst::log!(CAT, imp: imp, "text"); + self.decode_text(imp, cc_data); if mode.is_rollup() && self.settings.unbuffered { - return self.drain(element, false); + return self.drain(imp, false); } } } else if is_preamble(cc_data) { - gst::log!(CAT, obj: element, "preamble"); - return self.decode_preamble(element, cc_data); + gst::log!(CAT, imp: imp, "preamble"); + return self.decode_preamble(imp, cc_data); } else if is_midrowchange(cc_data) { - gst::log!(CAT, obj: element, "midrowchange"); + gst::log!(CAT, imp: imp, "midrowchange"); self.decode_midrowchange(cc_data); } None @@ -848,16 +836,12 @@ impl State { } impl Cea608ToJson { - fn output( - &self, - element: &super::Cea608ToJson, - lines: TimestampedLines, - ) -> Result<gst::FlowSuccess, gst::FlowError> { - gst::debug!(CAT, obj: element, "outputting: {:?}", lines); + fn output(&self, lines: TimestampedLines) -> Result<gst::FlowSuccess, gst::FlowError> { + gst::debug!(CAT, imp: self, "outputting: {:?}", lines); let json = serde_json::to_string(&lines.lines).map_err(|err| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::ResourceError::Write, ["Failed to serialize as json {}", err] ); @@ -872,7 +856,7 @@ impl Cea608ToJson { buf_mut.set_duration(lines.duration); } - gst::log!(CAT, obj: element, "Pushing {:?}", buf); + gst::log!(CAT, imp: self, "Pushing {:?}", buf); self.srcpad.push(buf) } @@ -880,7 +864,6 @@ impl Cea608ToJson { fn sink_chain( &self, pad: &gst::Pad, - element: &super::Cea608ToJson, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::trace!(CAT, obj: pad, "Handling buffer {:?}", buffer); @@ -913,11 +896,11 @@ impl Cea608ToJson { let cc_data = (data[0] as u16) << 8 | data[1] as u16; - dump(element, cc_data, pts, duration); + dump(self, cc_data, pts, duration); - if let Some(lines) = state.handle_cc_data(element, pts, duration, cc_data) { + if let Some(lines) = state.handle_cc_data(self, pts, duration, cc_data) { drop(state); - self.output(element, lines) + self.output(lines) } else if state.settings.unbuffered { drop(state); self.srcpad.push_event( @@ -931,7 +914,7 @@ impl Cea608ToJson { } } - fn sink_event(&self, pad: &gst::Pad, element: &super::Cea608ToJson, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -949,19 +932,19 @@ impl Cea608ToJson { *state = State::default(); state.settings = old_settings; drop(state); - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::Eos(..) => { - if let Some(lines) = self.state.borrow_mut().drain_pending(element) { - let _ = self.output(element, lines); + if let Some(lines) = self.state.borrow_mut().drain_pending(self) { + let _ = self.output(lines); } - if let Some(lines) = self.state.borrow_mut().drain(element, true) { - let _ = self.output(element, lines); + if let Some(lines) = self.state.borrow_mut().drain(self, true) { + let _ = self.output(lines); } - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } } @@ -979,14 +962,14 @@ impl ObjectSubclass for Cea608ToJson { Cea608ToJson::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |this, element| this.sink_chain(pad, element, buffer), + |this| this.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { Cea608ToJson::catch_panic_pad_function( parent, || false, - |this, element| this.sink_event(pad, element, event), + |this| this.sink_event(pad, event), ) }) .flags(gst::PadFlags::FIXED_CAPS) @@ -1007,9 +990,10 @@ impl ObjectSubclass for Cea608ToJson { } impl ObjectImpl for Cea608ToJson { - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -1030,13 +1014,7 @@ impl ObjectImpl for Cea608ToJson { PROPERTIES.as_ref() } - 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) { match pspec.name() { "unbuffered" => { self.settings.lock().unwrap().unbuffered = @@ -1046,7 +1024,7 @@ impl ObjectImpl for Cea608ToJson { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "unbuffered" => { let settings = self.settings.lock().unwrap(); @@ -1106,10 +1084,9 @@ impl ElementImpl for Cea608ToJson { #[allow(clippy::single_match)] fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused => { @@ -1120,7 +1097,7 @@ impl ElementImpl for Cea608ToJson { _ => (), } - let ret = self.parent_change_state(element, transition)?; + let ret = self.parent_change_state(transition)?; match transition { gst::StateChange::PausedToReady => { diff --git a/video/closedcaption/src/cea608tott/imp.rs b/video/closedcaption/src/cea608tott/imp.rs index 622ea9150..f0dcdccf2 100644 --- a/video/closedcaption/src/cea608tott/imp.rs +++ b/video/closedcaption/src/cea608tott/imp.rs @@ -61,7 +61,6 @@ impl Cea608ToTt { fn sink_chain( &self, pad: &gst::Pad, - _element: &super::Cea608ToTt, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); @@ -267,7 +266,7 @@ impl Cea608ToTt { buffer } - fn sink_event(&self, pad: &gst::Pad, element: &super::Cea608ToTt, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -368,7 +367,7 @@ impl Cea608ToTt { _ => (), } - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } } @@ -385,14 +384,14 @@ impl ObjectSubclass for Cea608ToTt { Cea608ToTt::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |this, element| this.sink_chain(pad, element, buffer), + |this| this.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { Cea608ToTt::catch_panic_pad_function( parent, || false, - |this, element| this.sink_event(pad, element, event), + |this| this.sink_event(pad, event), ) }) .flags(gst::PadFlags::FIXED_CAPS) @@ -412,9 +411,10 @@ impl ObjectSubclass for Cea608ToTt { } impl ObjectImpl for Cea608ToTt { - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -486,10 +486,9 @@ impl ElementImpl for Cea608ToTt { #[allow(clippy::single_match)] fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused => { @@ -499,7 +498,7 @@ impl ElementImpl for Cea608ToTt { _ => (), } - let ret = self.parent_change_state(element, transition)?; + let ret = self.parent_change_state(transition)?; match transition { gst::StateChange::PausedToReady => { diff --git a/video/closedcaption/src/jsontovtt/imp.rs b/video/closedcaption/src/jsontovtt/imp.rs index 199e4269e..abdbb8651 100644 --- a/video/closedcaption/src/jsontovtt/imp.rs +++ b/video/closedcaption/src/jsontovtt/imp.rs @@ -7,7 +7,6 @@ // // SPDX-License-Identifier: MPL-2.0 -use gst::element_error; use gst::glib; use gst::prelude::*; use gst::subclass::prelude::*; @@ -351,7 +350,6 @@ impl JsonToVtt { fn sink_chain( &self, pad: &gst::Pad, - _element: &super::JsonToVtt, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::trace!(CAT, obj: pad, "Handling buffer {:?}", buffer); @@ -370,7 +368,7 @@ impl JsonToVtt { state.keyunit_requests.push(fku); } - fn src_event(&self, pad: &gst::Pad, element: &super::JsonToVtt, event: gst::Event) -> bool { + fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -388,20 +386,20 @@ impl JsonToVtt { } Err(_) => gst::warning!( CAT, - obj: element, + imp: self, "Invalid force-key-unit event received from downstream: {:?}", &ev ), } } - pad.event_default(Some(element), event); + pad.event_default(Some(&*self.instance()), event); true } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn sink_event(&self, pad: &gst::Pad, element: &super::JsonToVtt, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -412,7 +410,7 @@ impl JsonToVtt { let buffers = state.handle_eos(); drop(state); let _ = self.output(buffers); - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::Caps(..) => { let mut downstream_caps = match self.srcpad.allowed_caps() { @@ -455,8 +453,8 @@ impl JsonToVtt { state.segment = s; } Err(err) => { - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Failed, ["Time segment needed: {:?}", err] ); @@ -465,7 +463,7 @@ impl JsonToVtt { }; /* FIXME: Handle segment updates by draining? */ - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::Gap(ev) => { gst::log!(CAT, obj: pad, "Handling gap {:?}", ev); @@ -475,7 +473,7 @@ impl JsonToVtt { let _ = self.output(buffers); true } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } @@ -501,14 +499,14 @@ impl ObjectSubclass for JsonToVtt { JsonToVtt::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |this, element| this.sink_chain(pad, element, buffer), + |this| this.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { JsonToVtt::catch_panic_pad_function( parent, || false, - |this, element| this.sink_event(pad, element, event), + |this| this.sink_event(pad, event), ) }) .flags(gst::PadFlags::FIXED_CAPS) @@ -521,7 +519,7 @@ impl ObjectSubclass for JsonToVtt { JsonToVtt::catch_panic_pad_function( parent, || false, - |this, element| this.src_event(pad, element, event), + |this| this.src_event(pad, event), ) }) .build(); @@ -535,9 +533,10 @@ impl ObjectSubclass for JsonToVtt { } impl ObjectImpl for JsonToVtt { - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -593,17 +592,16 @@ impl ElementImpl for JsonToVtt { fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); if transition == gst::StateChange::ReadyToPaused { let mut state = self.state.lock().unwrap(); *state = State::default(); } - self.parent_change_state(element, transition) + self.parent_change_state(transition) } } diff --git a/video/closedcaption/src/mcc_enc/imp.rs b/video/closedcaption/src/mcc_enc/imp.rs index 54c4f9180..36a664343 100644 --- a/video/closedcaption/src/mcc_enc/imp.rs +++ b/video/closedcaption/src/mcc_enc/imp.rs @@ -246,7 +246,6 @@ impl MccEnc { fn generate_caption( &self, - element: &super::MccEnc, state: &State, buffer: &gst::Buffer, outbuf: &mut Vec<u8>, @@ -254,8 +253,8 @@ impl MccEnc { let meta = buffer .meta::<gst_video::VideoTimeCodeMeta>() .ok_or_else(|| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Format, ["Stream with timecodes on each buffer required"] ); @@ -266,8 +265,8 @@ impl MccEnc { let _ = write!(outbuf, "{}\t", meta.tc()); let map = buffer.map_readable().map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Format, ["Failed to map buffer readable"] ); @@ -277,8 +276,8 @@ impl MccEnc { let len = map.len(); if len >= 256 { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Format, ["Too big buffer: {}", map.len()] ); @@ -314,7 +313,6 @@ impl MccEnc { fn sink_chain( &self, pad: &gst::Pad, - element: &super::MccEnc, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); @@ -327,7 +325,7 @@ impl MccEnc { self.generate_headers(&*state, &mut outbuf)?; } - self.generate_caption(element, &*state, &buffer, &mut outbuf)?; + self.generate_caption(&*state, &buffer, &mut outbuf)?; let mut buf = gst::Buffer::from_mut_slice(outbuf); buffer @@ -338,7 +336,7 @@ impl MccEnc { self.srcpad.push(buf) } - fn sink_event(&self, pad: &gst::Pad, element: &super::MccEnc, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -377,11 +375,11 @@ impl MccEnc { .build(); self.srcpad.push_event(gst::event::Caps::new(&caps)) } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn src_event(&self, pad: &gst::Pad, element: &super::MccEnc, event: gst::Event) -> bool { + fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -390,16 +388,11 @@ impl MccEnc { gst::log!(CAT, obj: pad, "Dropping seek event"); false } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn src_query( - &self, - pad: &gst::Pad, - element: &super::MccEnc, - query: &mut gst::QueryRef, - ) -> bool { + fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { use gst::QueryViewMut; gst::log!(CAT, obj: pad, "Handling query {:?}", query); @@ -415,7 +408,7 @@ impl MccEnc { ); true } - _ => pad.query_default(Some(element), query), + _ => pad.query_default(Some(&*self.instance()), query), } } } @@ -433,33 +426,21 @@ impl ObjectSubclass for MccEnc { MccEnc::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |enc, element| enc.sink_chain(pad, element, buffer), + |enc| enc.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { - MccEnc::catch_panic_pad_function( - parent, - || false, - |enc, element| enc.sink_event(pad, element, event), - ) + MccEnc::catch_panic_pad_function(parent, || false, |enc| enc.sink_event(pad, event)) }) .build(); let templ = klass.pad_template("src").unwrap(); let srcpad = gst::Pad::builder_with_template(&templ, Some("src")) .event_function(|pad, parent, event| { - MccEnc::catch_panic_pad_function( - parent, - || false, - |enc, element| enc.src_event(pad, element, event), - ) + MccEnc::catch_panic_pad_function(parent, || false, |enc| enc.src_event(pad, event)) }) .query_function(|pad, parent, query| { - MccEnc::catch_panic_pad_function( - parent, - || false, - |enc, element| enc.src_query(pad, element, query), - ) + MccEnc::catch_panic_pad_function(parent, || false, |enc| enc.src_query(pad, query)) }) .build(); @@ -492,13 +473,7 @@ impl ObjectImpl for MccEnc { PROPERTIES.as_ref() } - 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) { match pspec.name() { "uuid" => { let mut settings = self.settings.lock().unwrap(); @@ -512,7 +487,7 @@ impl ObjectImpl for MccEnc { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "uuid" => { let settings = self.settings.lock().unwrap(); @@ -526,9 +501,10 @@ impl ObjectImpl for MccEnc { } } - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -603,10 +579,9 @@ impl ElementImpl for MccEnc { fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { @@ -617,6 +592,6 @@ impl ElementImpl for MccEnc { _ => (), } - self.parent_change_state(element, transition) + self.parent_change_state(transition) } } diff --git a/video/closedcaption/src/mcc_parse/imp.rs b/video/closedcaption/src/mcc_parse/imp.rs index 30292b233..911ef21b4 100644 --- a/video/closedcaption/src/mcc_parse/imp.rs +++ b/video/closedcaption/src/mcc_parse/imp.rs @@ -9,7 +9,6 @@ use gst::glib; use gst::prelude::*; use gst::subclass::prelude::*; -use gst::{element_error, loggable_error}; use gst_video::ValidVideoTimeCode; use std::cmp; @@ -44,10 +43,12 @@ struct PullState { } impl PullState { - fn new(element: &super::MccParse, pad: &gst::Pad) -> Self { + fn new(imp: &MccParse, pad: &gst::Pad) -> Self { Self { need_stream_start: true, - stream_id: pad.create_stream_id(element, Some("src")).to_string(), + stream_id: pad + .create_stream_id(&*imp.instance(), Some("src")) + .to_string(), offset: 0, duration: gst::ClockTime::NONE, } @@ -166,7 +167,7 @@ impl State { fn handle_timecode( &mut self, - element: &super::MccParse, + imp: &MccParse, framerate: gst::Fraction, drop_frame: bool, tc: TimeCode, @@ -179,8 +180,8 @@ impl State { .as_ref() .map(Clone::clone) .ok_or_else(|| { - element_error!( - element, + gst::element_imp_error!( + imp, gst::StreamError::Decode, ["Invalid first timecode {:?}", timecode] ); @@ -190,7 +191,7 @@ impl State { gst::warning!( CAT, - obj: element, + imp: imp, "Invalid timecode {:?}, using previous {:?}", timecode, last_timecode @@ -203,11 +204,7 @@ impl State { /// Calculate a timestamp from the timecode and make sure to /// not produce timestamps jumping backwards - fn update_timestamp( - &mut self, - element: &super::MccParse, - timecode: &gst_video::ValidVideoTimeCode, - ) { + fn update_timestamp(&mut self, imp: &MccParse, timecode: &gst_video::ValidVideoTimeCode) { let nsecs = timecode.time_since_daily_jam(); if self.start_position.is_none() { self.start_position = Some(nsecs); @@ -217,7 +214,7 @@ impl State { let nsecs = nsecs.checked_sub(start_position).unwrap_or_else(|| { gst::fixme!( CAT, - obj: element, + imp: imp, "New position {} < start position {}", nsecs, start_position, @@ -233,7 +230,7 @@ impl State { } else { gst::fixme!( CAT, - obj: element, + imp: imp, "New position {} < last position {}", nsecs, self.last_position.display(), @@ -243,7 +240,7 @@ impl State { fn add_buffer_metadata( &mut self, - element: &super::MccParse, + imp: &MccParse, buffer: &mut gst::buffer::Buffer, timecode: &gst_video::ValidVideoTimeCode, framerate: gst::Fraction, @@ -251,7 +248,7 @@ impl State { let buffer = buffer.get_mut().unwrap(); gst_video::VideoTimeCodeMeta::add(buffer, timecode); - self.update_timestamp(element, timecode); + self.update_timestamp(imp, timecode); buffer.set_pts(self.last_position); @@ -267,7 +264,7 @@ impl State { fn create_events( &mut self, - element: &super::MccParse, + imp: &MccParse, format: Option<Format>, framerate: gst::Fraction, ) -> Vec<gst::Event> { @@ -307,7 +304,7 @@ impl State { }; events.push(gst::event::Caps::new(&caps)); - gst::info!(CAT, obj: element, "Caps changed to {:?}", &caps); + gst::info!(CAT, imp: imp, "Caps changed to {:?}", &caps); } } @@ -355,7 +352,6 @@ impl AsMut<[u8]> for OffsetVec { impl MccParse { fn handle_buffer( &self, - element: &super::MccParse, buffer: Option<gst::Buffer>, scan_tc_rate: bool, ) -> Result<gst::FlowSuccess, gst::FlowError> { @@ -363,8 +359,8 @@ impl MccParse { let drain = if let Some(buffer) = buffer { let buffer = buffer.into_mapped_buffer_readable().map_err(|_| { - element_error!( - element, + gst::element_imp_error!( + self, gst::ResourceError::Read, ["Failed to map buffer readable"] ); @@ -386,15 +382,15 @@ impl MccParse { gst::debug!( CAT, - obj: element, + imp: self, "Got caption buffer with timecode {:?} and size {}", tc, data.len() ); if scan_tc_rate { - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Decode, ["Found caption line while scanning for timecode rate"] ); @@ -403,12 +399,7 @@ impl MccParse { } if data.len() < 3 { - gst::debug!( - CAT, - obj: element, - "Too small caption packet: {}", - data.len(), - ); + gst::debug!(CAT, imp: self, "Too small caption packet: {}", data.len(),); continue; } @@ -416,7 +407,7 @@ impl MccParse { (0x61, 0x01) => Format::Cea708Cdp, (0x61, 0x02) => Format::Cea608, (did, sdid) => { - gst::debug!(CAT, obj: element, "Unknown DID {:x} SDID {:x}", did, sdid); + gst::debug!(CAT, imp: self, "Unknown DID {:x} SDID {:x}", did, sdid); continue; } }; @@ -425,7 +416,7 @@ impl MccParse { if data.len() < 3 + len as usize { gst::debug!( CAT, - obj: element, + imp: self, "Too small caption packet: {} < {}", data.len(), 3 + len, @@ -433,14 +424,14 @@ impl MccParse { continue; } - state = self.handle_line(element, tc, data, format, state)?; + state = self.handle_line(tc, data, format, state)?; } Ok(Some(MccLine::Caption(tc, None))) => { assert!(state.seeking); if scan_tc_rate { - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Decode, ["Found caption line while scanning for timecode rate"] ); @@ -448,12 +439,12 @@ impl MccParse { break Err(gst::FlowError::Error); } - state = self.handle_skipped_line(element, tc, state)?; + state = self.handle_skipped_line(tc, state)?; } Ok(Some(MccLine::TimeCodeRate(rate, df))) => { gst::debug!( CAT, - obj: element, + imp: self, "Got timecode rate {} (drop frame {})", rate, df @@ -465,11 +456,11 @@ impl MccParse { } } Ok(Some(line)) => { - gst::debug!(CAT, obj: element, "Got line '{:?}'", line); + gst::debug!(CAT, imp: self, "Got line '{:?}'", line); } Err((line, err)) => { - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Decode, ["Couldn't parse line '{:?}': {:?}", line, err] ); @@ -478,8 +469,8 @@ impl MccParse { } Ok(None) => { if scan_tc_rate { - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Decode, ["Found end of input while scanning for timecode rate"] ); @@ -498,12 +489,11 @@ impl MccParse { fn handle_skipped_line( &self, - element: &super::MccParse, tc: TimeCode, mut state: MutexGuard<State>, ) -> Result<MutexGuard<State>, gst::FlowError> { let (framerate, drop_frame) = parse_timecode_rate(state.timecode_rate)?; - let timecode = state.handle_timecode(element, framerate, drop_frame, tc)?; + let timecode = state.handle_timecode(self, framerate, drop_frame, tc)?; let nsecs = timecode.time_since_daily_jam(); state.last_timecode = Some(timecode); @@ -526,15 +516,14 @@ impl MccParse { fn handle_line( &self, - element: &super::MccParse, tc: TimeCode, data: Vec<u8>, format: Format, mut state: MutexGuard<State>, ) -> Result<MutexGuard<State>, gst::FlowError> { let (framerate, drop_frame) = parse_timecode_rate(state.timecode_rate)?; - let events = state.create_events(element, Some(format), framerate); - let timecode = state.handle_timecode(element, framerate, drop_frame, tc)?; + let events = state.create_events(self, Some(format), framerate); + let timecode = state.handle_timecode(self, framerate, drop_frame, tc)?; let len = data[2] as usize; let mut buffer = gst::Buffer::from_mut_slice(OffsetVec { @@ -543,7 +532,7 @@ impl MccParse { len, }); - state.add_buffer_metadata(element, &mut buffer, &timecode, framerate); + state.add_buffer_metadata(self, &mut buffer, &timecode, framerate); // Update the last_timecode to the current one state.last_timecode = Some(timecode); @@ -558,13 +547,13 @@ impl MccParse { drop(state); for event in events { - gst::debug!(CAT, obj: element, "Pushing event {:?}", event); + gst::debug!(CAT, imp: self, "Pushing event {:?}", event); self.srcpad.push_event(event); } self.srcpad.push(buffer).map_err(|err| { if err != gst::FlowError::Flushing && err != gst::FlowError::Eos { - gst::error!(CAT, obj: element, "Pushing buffer returned {:?}", err); + gst::error!(CAT, imp: self, "Pushing buffer returned {:?}", err); } err })?; @@ -576,11 +565,7 @@ impl MccParse { Ok(self.state.lock().unwrap()) } - fn sink_activate( - &self, - pad: &gst::Pad, - element: &super::MccParse, - ) -> Result<(), gst::LoggableError> { + fn sink_activate(&self, pad: &gst::Pad) -> Result<(), gst::LoggableError> { let mode = { let mut query = gst::query::Scheduling::new(); let mut state = self.state.lock().unwrap(); @@ -595,7 +580,7 @@ impl MccParse { { gst::debug!(CAT, obj: pad, "Activating in Pull mode"); - state.pull = Some(PullState::new(element, &self.srcpad)); + state.pull = Some(PullState::new(self, &self.srcpad)); gst::PadMode::Pull } else { @@ -608,25 +593,13 @@ impl MccParse { Ok(()) } - fn start_task(&self, element: &super::MccParse) -> Result<(), gst::LoggableError> { - let element_weak = element.downgrade(); - let pad_weak = self.sinkpad.downgrade(); + fn start_task(&self) -> Result<(), gst::LoggableError> { + let imp = self.ref_counted(); let res = self.sinkpad.start_task(move || { - let element = match element_weak.upgrade() { - Some(element) => element, - None => { - if let Some(pad) = pad_weak.upgrade() { - let _ = pad.pause_task(); - } - return; - } - }; - - let parse = element.imp(); - parse.loop_fn(&element); + imp.loop_fn(); }); if res.is_err() { - return Err(loggable_error!(CAT, "Failed to start pad task")); + return Err(gst::loggable_error!(CAT, "Failed to start pad task")); } Ok(()) } @@ -634,13 +607,12 @@ impl MccParse { fn sink_activatemode( &self, _pad: &gst::Pad, - element: &super::MccParse, mode: gst::PadMode, active: bool, ) -> Result<(), gst::LoggableError> { if mode == gst::PadMode::Pull { if active { - self.start_task(element)?; + self.start_task()?; } else { let _ = self.sinkpad.stop_task(); } @@ -649,23 +621,26 @@ impl MccParse { Ok(()) } - fn scan_duration( - &self, - element: &super::MccParse, - ) -> Result<Option<ValidVideoTimeCode>, gst::LoggableError> { - gst::debug!(CAT, obj: element, "Scanning duration"); + fn scan_duration(&self) -> Result<Option<ValidVideoTimeCode>, gst::LoggableError> { + gst::debug!(CAT, imp: self, "Scanning duration"); /* First let's query the bytes duration upstream */ let mut q = gst::query::Duration::new(gst::Format::Bytes); if !self.sinkpad.peer_query(&mut q) { - return Err(loggable_error!(CAT, "Failed to query upstream duration")); + return Err(gst::loggable_error!( + CAT, + "Failed to query upstream duration" + )); } let size = match q.result().try_into().unwrap() { Some(gst::format::Bytes(size)) => size, None => { - return Err(loggable_error!(CAT, "Failed to query upstream duration")); + return Err(gst::loggable_error!( + CAT, + "Failed to query upstream duration" + )); } }; @@ -683,7 +658,7 @@ impl MccParse { buffers.push(buffer); } Err(flow) => { - return Err(loggable_error!( + return Err(gst::loggable_error!( CAT, "Failed to pull buffer while scanning duration: {:?}", flow @@ -698,7 +673,7 @@ impl MccParse { let buf = buf .clone() .into_mapped_buffer_readable() - .map_err(|_| loggable_error!(CAT, "Failed to map buffer readable"))?; + .map_err(|_| gst::loggable_error!(CAT, "Failed to map buffer readable"))?; reader.push(buf); } @@ -709,7 +684,7 @@ impl MccParse { { let state = self.state.lock().unwrap(); let (framerate, drop_frame) = parse_timecode_rate(state.timecode_rate) - .map_err(|_| loggable_error!(CAT, "Failed to parse timecode rate"))?; + .map_err(|_| gst::loggable_error!(CAT, "Failed to parse timecode rate"))?; if let Ok(mut timecode) = parse_timecode(framerate, drop_frame, tc) { /* We're looking for the total duration */ timecode.increment_frame(); @@ -720,18 +695,13 @@ impl MccParse { } if last_tc.is_some() || offset == 0 { - gst::debug!( - CAT, - obj: element, - "Duration scan done, last_tc: {:?}", - last_tc - ); + gst::debug!(CAT, imp: self, "Duration scan done, last_tc: {:?}", last_tc); break (Ok(last_tc)); } } } - fn push_eos(&self, element: &super::MccParse) { + fn push_eos(&self) { let mut state = self.state.lock().unwrap(); if state.seeking { @@ -740,7 +710,7 @@ impl MccParse { match parse_timecode_rate(state.timecode_rate) { Ok((framerate, _)) => { - let mut events = state.create_events(element, None, framerate); + let mut events = state.create_events(self, None, framerate); let mut eos_event = gst::event::Eos::builder(); if let Some(seek_seqnum) = state.seek_seqnum { @@ -753,13 +723,13 @@ impl MccParse { drop(state); for event in events { - gst::debug!(CAT, obj: element, "Pushing event {:?}", event); + gst::debug!(CAT, imp: self, "Pushing event {:?}", event); self.srcpad.push_event(event); } } Err(_) => { - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Failed, ["Streaming stopped, failed to parse timecode rate"] ); @@ -767,7 +737,7 @@ impl MccParse { } } - fn loop_fn(&self, element: &super::MccParse) { + fn loop_fn(&self) { let mut state = self.state.lock().unwrap(); let State { timecode_rate: ref tc_rate, @@ -794,8 +764,8 @@ impl MccParse { Err(flow) => { gst::error!(CAT, obj: &self.sinkpad, "Failed to pull, reason: {:?}", flow); - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Failed, ["Streaming stopped, failed to pull buffer"] ); @@ -805,11 +775,11 @@ impl MccParse { } }; - match self.handle_buffer(element, buffer, scan_tc_rate) { + match self.handle_buffer(buffer, scan_tc_rate) { Ok(_) => { let tc_rate = self.state.lock().unwrap().timecode_rate; if scan_tc_rate && tc_rate.is_some() { - match self.scan_duration(element) { + match self.scan_duration() { Ok(Some(tc)) => { let mut state = self.state.lock().unwrap(); let mut pull = state.pull.as_mut().unwrap(); @@ -823,8 +793,8 @@ impl MccParse { Err(err) => { err.log(); - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Decode, ["Failed to scan duration"] ); @@ -837,20 +807,20 @@ impl MccParse { Err(flow) => { match flow { gst::FlowError::Flushing => { - gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::debug!(CAT, imp: self, "Pausing after flow {:?}", flow); } gst::FlowError::Eos => { - self.push_eos(element); + self.push_eos(); - gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::debug!(CAT, imp: self, "Pausing after flow {:?}", flow); } _ => { - self.push_eos(element); + self.push_eos(); - gst::error!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::error!(CAT, imp: self, "Pausing after flow {:?}", flow); - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Failed, ["Streaming stopped, reason: {:?}", flow] ); @@ -865,12 +835,11 @@ impl MccParse { fn sink_chain( &self, pad: &gst::Pad, - element: &super::MccParse, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); - self.handle_buffer(element, Some(buffer), false) + self.handle_buffer(Some(buffer), false) } fn flush(&self, mut state: MutexGuard<State>) -> MutexGuard<State> { @@ -893,7 +862,7 @@ impl MccParse { self.state.lock().unwrap() } - fn sink_event(&self, pad: &gst::Pad, element: &super::MccParse, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -914,14 +883,14 @@ impl MccParse { let state = self.flush(state); drop(state); - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::Eos(_) => { gst::log!(CAT, obj: pad, "Draining"); - if let Err(err) = self.handle_buffer(element, None, false) { + if let Err(err) = self.handle_buffer(None, false) { gst::error!(CAT, obj: pad, "Failed to drain parser: {:?}", err); } - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } _ => { if event.is_sticky() @@ -933,15 +902,15 @@ impl MccParse { state.pending_events.push(event); true } else { - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } } } } - fn perform_seek(&self, event: &gst::event::Seek, element: &super::MccParse) -> bool { + fn perform_seek(&self, event: &gst::event::Seek) -> bool { if self.state.lock().unwrap().pull.is_none() { - gst::error!(CAT, obj: element, "seeking is only supported in pull mode"); + gst::error!(CAT, imp: self, "seeking is only supported in pull mode"); return false; } @@ -950,7 +919,7 @@ impl MccParse { let mut start: Option<gst::ClockTime> = match start.try_into() { Ok(start) => start, Err(_) => { - gst::error!(CAT, obj: element, "seek has invalid format"); + gst::error!(CAT, imp: self, "seek has invalid format"); return false; } }; @@ -958,18 +927,18 @@ impl MccParse { let mut stop: Option<gst::ClockTime> = match stop.try_into() { Ok(stop) => stop, Err(_) => { - gst::error!(CAT, obj: element, "seek has invalid format"); + gst::error!(CAT, imp: self, "seek has invalid format"); return false; } }; if !flags.contains(gst::SeekFlags::FLUSH) { - gst::error!(CAT, obj: element, "only flushing seeks are supported"); + gst::error!(CAT, imp: self, "only flushing seeks are supported"); return false; } if start_type == gst::SeekType::End || stop_type == gst::SeekType::End { - gst::error!(CAT, obj: element, "Relative seeks are not supported"); + gst::error!(CAT, imp: self, "Relative seeks are not supported"); return false; } @@ -979,14 +948,14 @@ impl MccParse { .seqnum(seek_seqnum) .build(); - gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event); + gst::debug!(CAT, imp: self, "Sending event {:?} upstream", event); self.sinkpad.push_event(event); let event = gst::event::FlushStart::builder() .seqnum(seek_seqnum) .build(); - gst::debug!(CAT, obj: element, "Pushing event {:?}", event); + gst::debug!(CAT, imp: self, "Pushing event {:?}", event); self.srcpad.push_event(event); let _ = self.sinkpad.pause_task(); @@ -1014,7 +983,7 @@ impl MccParse { /* Drop our state while we push a serialized event upstream */ drop(state); - gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event); + gst::debug!(CAT, imp: self, "Sending event {:?} upstream", event); self.sinkpad.push_event(event); state = self.state.lock().unwrap(); @@ -1023,7 +992,7 @@ impl MccParse { .segment .do_seek(rate, flags, start_type, start, stop_type, stop); - match self.start_task(element) { + match self.start_task() { Err(error) => { error.log(); false @@ -1032,22 +1001,17 @@ impl MccParse { } } - fn src_event(&self, pad: &gst::Pad, element: &super::MccParse, event: gst::Event) -> bool { + fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); match event.view() { - EventView::Seek(e) => self.perform_seek(e, element), - _ => pad.event_default(Some(element), event), + EventView::Seek(e) => self.perform_seek(e), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn src_query( - &self, - pad: &gst::Pad, - element: &super::MccParse, - query: &mut gst::QueryRef, - ) -> bool { + fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { use gst::QueryViewMut; gst::log!(CAT, obj: pad, "Handling query {:?}", query); @@ -1097,7 +1061,7 @@ impl MccParse { self.sinkpad.peer_query(query) } } - _ => pad.query_default(Some(element), query), + _ => pad.query_default(Some(&*self.instance()), query), } } } @@ -1114,29 +1078,34 @@ impl ObjectSubclass for MccParse { .activate_function(|pad, parent| { MccParse::catch_panic_pad_function( parent, - || Err(loggable_error!(CAT, "Panic activating sink pad")), - |parse, element| parse.sink_activate(pad, element), + || Err(gst::loggable_error!(CAT, "Panic activating sink pad")), + |parse| parse.sink_activate(pad), ) }) .activatemode_function(|pad, parent, mode, active| { MccParse::catch_panic_pad_function( parent, - || Err(loggable_error!(CAT, "Panic activating sink pad with mode")), - |parse, element| parse.sink_activatemode(pad, element, mode, active), + || { + Err(gst::loggable_error!( + CAT, + "Panic activating sink pad with mode" + )) + }, + |parse| parse.sink_activatemode(pad, mode, active), ) }) .chain_function(|pad, parent, buffer| { MccParse::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |parse, element| parse.sink_chain(pad, element, buffer), + |parse| parse.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { MccParse::catch_panic_pad_function( parent, || false, - |parse, element| parse.sink_event(pad, element, event), + |parse| parse.sink_event(pad, event), ) }) .build(); @@ -1147,14 +1116,14 @@ impl ObjectSubclass for MccParse { MccParse::catch_panic_pad_function( parent, || false, - |parse, element| parse.src_event(pad, element, event), + |parse| parse.src_event(pad, event), ) }) .query_function(|pad, parent, query| { MccParse::catch_panic_pad_function( parent, || false, - |parse, element| parse.src_query(pad, element, query), + |parse| parse.src_query(pad, query), ) }) .build(); @@ -1168,9 +1137,10 @@ impl ObjectSubclass for MccParse { } impl ObjectImpl for MccParse { - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -1241,10 +1211,9 @@ impl ElementImpl for MccParse { fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { @@ -1255,6 +1224,6 @@ impl ElementImpl for MccParse { _ => (), } - self.parent_change_state(element, transition) + self.parent_change_state(transition) } } diff --git a/video/closedcaption/src/scc_enc/imp.rs b/video/closedcaption/src/scc_enc/imp.rs index 93f5d79af..2b37a4f64 100644 --- a/video/closedcaption/src/scc_enc/imp.rs +++ b/video/closedcaption/src/scc_enc/imp.rs @@ -76,7 +76,7 @@ impl State { fn generate_caption( &mut self, - element: &super::SccEnc, + imp: &SccEnc, buffer: gst::Buffer, ) -> Result<Option<gst::Buffer>, gst::FlowError> { // Arbitrary number that was chosen to keep in order @@ -86,8 +86,8 @@ impl State { assert!(self.internal_buffer.len() < MAXIMUM_PACKETES_PER_LINE); if buffer.size() != 2 { - gst::element_error!( - element, + gst::element_imp_error!( + imp, gst::StreamError::Format, ["Wrongly sized CEA608 packet: {}", buffer.size()] ); @@ -97,8 +97,8 @@ impl State { if !self.settings.output_padding { let map = buffer.map_readable().map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + imp, gst::StreamError::Format, ["Failed to map buffer readable"] ); @@ -116,8 +116,8 @@ impl State { let mut timecode = buffer .meta::<gst_video::VideoTimeCodeMeta>() .ok_or_else(|| { - gst::element_error!( - element, + gst::element_imp_error!( + imp, gst::StreamError::Format, ["Stream with timecodes on each buffer required"] ); @@ -140,7 +140,7 @@ impl State { // flush the previous line into the buffer, and push // the new packet to the, now empty, internal buffer if Some(&timecode) != self.expected_timecode.as_ref() { - let outbuf = self.write_line(element)?; + let outbuf = self.write_line(imp)?; assert!(self.internal_buffer.is_empty()); self.internal_buffer.push(buffer); @@ -156,17 +156,14 @@ impl State { self.internal_buffer.push(buffer); if self.internal_buffer.len() == MAXIMUM_PACKETES_PER_LINE { - return self.write_line(element); + return self.write_line(imp); } Ok(None) } // Flush the internal buffers into a line - fn write_line( - &mut self, - element: &super::SccEnc, - ) -> Result<Option<gst::Buffer>, gst::FlowError> { + fn write_line(&mut self, imp: &SccEnc) -> Result<Option<gst::Buffer>, gst::FlowError> { let mut outbuf = Vec::new(); let mut line_start = true; @@ -181,8 +178,8 @@ impl State { let first_buf = self.internal_buffer.first().unwrap(); for buffer in self.internal_buffer.iter() { let map = buffer.map_readable().map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + imp, gst::StreamError::Format, ["Failed to map buffer readable"] ); @@ -251,13 +248,12 @@ impl SccEnc { fn sink_chain( &self, pad: &gst::Pad, - element: &super::SccEnc, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); let mut state = self.state.lock().unwrap(); - let res = state.generate_caption(element, buffer)?; + let res = state.generate_caption(self, buffer)?; if let Some(outbuf) = res { gst::trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &outbuf); @@ -269,7 +265,7 @@ impl SccEnc { Ok(gst::FlowSuccess::Ok) } - fn sink_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -297,7 +293,7 @@ impl SccEnc { EventView::Eos(_) => { let mut state = self.state.lock().unwrap(); - let outbuf = state.write_line(element); + let outbuf = state.write_line(self); if let Ok(Some(buffer)) = outbuf { gst::trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &buffer); @@ -311,13 +307,13 @@ impl SccEnc { gst::error!(CAT, obj: pad, "Failed to write a line after EOS: {:?}", err); return false; } - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn src_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool { + fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -326,16 +322,11 @@ impl SccEnc { gst::log!(CAT, obj: pad, "Dropping seek event"); false } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn src_query( - &self, - pad: &gst::Pad, - element: &super::SccEnc, - query: &mut gst::QueryRef, - ) -> bool { + fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { use gst::QueryViewMut; gst::log!(CAT, obj: pad, "Handling query {:?}", query); @@ -351,7 +342,7 @@ impl SccEnc { ); true } - _ => pad.query_default(Some(element), query), + _ => pad.query_default(Some(&*self.instance()), query), } } } @@ -369,33 +360,21 @@ impl ObjectSubclass for SccEnc { SccEnc::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |enc, element| enc.sink_chain(pad, element, buffer), + |enc| enc.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { - SccEnc::catch_panic_pad_function( - parent, - || false, - |enc, element| enc.sink_event(pad, element, event), - ) + SccEnc::catch_panic_pad_function(parent, || false, |enc| enc.sink_event(pad, event)) }) .build(); let templ = klass.pad_template("src").unwrap(); let srcpad = gst::Pad::builder_with_template(&templ, Some("src")) .event_function(|pad, parent, event| { - SccEnc::catch_panic_pad_function( - parent, - || false, - |enc, element| enc.src_event(pad, element, event), - ) + SccEnc::catch_panic_pad_function(parent, || false, |enc| enc.src_event(pad, event)) }) .query_function(|pad, parent, query| { - SccEnc::catch_panic_pad_function( - parent, - || false, - |enc, element| enc.src_query(pad, element, query), - ) + SccEnc::catch_panic_pad_function(parent, || false, |enc| enc.src_query(pad, query)) }) .build(); @@ -409,9 +388,10 @@ impl ObjectSubclass for SccEnc { } impl ObjectImpl for SccEnc { - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -433,13 +413,7 @@ impl ObjectImpl for SccEnc { PROPERTIES.as_ref() } - 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) { match pspec.name() { "output-padding" => { self.settings.lock().unwrap().output_padding = @@ -449,7 +423,7 @@ impl ObjectImpl for SccEnc { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "output-padding" => { let settings = self.settings.lock().unwrap(); @@ -509,10 +483,9 @@ impl ElementImpl for SccEnc { fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused => { @@ -529,6 +502,6 @@ impl ElementImpl for SccEnc { _ => (), } - self.parent_change_state(element, transition) + self.parent_change_state(transition) } } diff --git a/video/closedcaption/src/scc_parse/imp.rs b/video/closedcaption/src/scc_parse/imp.rs index 2a90ba432..5581f31a6 100644 --- a/video/closedcaption/src/scc_parse/imp.rs +++ b/video/closedcaption/src/scc_parse/imp.rs @@ -10,7 +10,6 @@ use gst::glib; use gst::prelude::*; use gst::subclass::prelude::*; -use gst::{element_error, loggable_error}; use std::cmp; use std::sync::{Mutex, MutexGuard}; @@ -38,10 +37,12 @@ struct PullState { } impl PullState { - fn new(element: &super::SccParse, pad: &gst::Pad) -> Self { + fn new(imp: &SccParse, pad: &gst::Pad) -> Self { Self { need_stream_start: true, - stream_id: pad.create_stream_id(element, Some("src")).to_string(), + stream_id: pad + .create_stream_id(&*imp.instance(), Some("src")) + .to_string(), offset: 0, duration: gst::ClockTime::NONE, } @@ -142,7 +143,7 @@ impl State { &mut self, tc: &TimeCode, framerate: gst::Fraction, - element: &super::SccParse, + imp: &SccParse, ) -> Result<gst_video::ValidVideoTimeCode, gst::FlowError> { match parse_timecode(framerate, tc) { Ok(timecode) => Ok(timecode), @@ -152,8 +153,8 @@ impl State { .as_ref() .map(Clone::clone) .ok_or_else(|| { - element_error!( - element, + gst::element_imp_error!( + imp, gst::StreamError::Decode, ["Invalid first timecode {:?}", err] ); @@ -163,7 +164,7 @@ impl State { gst::warning!( CAT, - obj: element, + imp: imp, "Invalid timecode {:?}, using previous {:?}", err, last_timecode @@ -176,11 +177,7 @@ impl State { /// Calculate a timestamp from the timecode and make sure to /// not produce timestamps jumping backwards - fn update_timestamp( - &mut self, - timecode: &gst_video::ValidVideoTimeCode, - element: &super::SccParse, - ) { + fn update_timestamp(&mut self, timecode: &gst_video::ValidVideoTimeCode, imp: &SccParse) { let nsecs = timecode.time_since_daily_jam(); if self @@ -191,7 +188,7 @@ impl State { } else { gst::fixme!( CAT, - obj: element, + imp: imp, "New position {} < last position {}", nsecs, self.last_position.display(), @@ -204,12 +201,12 @@ impl State { buffer: &mut gst::buffer::Buffer, timecode: &gst_video::ValidVideoTimeCode, framerate: gst::Fraction, - element: &super::SccParse, + imp: &SccParse, ) { let buffer = buffer.get_mut().unwrap(); gst_video::VideoTimeCodeMeta::add(buffer, timecode); - self.update_timestamp(timecode, element); + self.update_timestamp(timecode, imp); buffer.set_pts(self.last_position); buffer.set_duration( @@ -219,7 +216,7 @@ impl State { fn create_events( &mut self, - element: &super::SccParse, + imp: &SccParse, framerate: Option<gst::Fraction>, ) -> Vec<gst::Event> { let mut events = Vec::new(); @@ -253,7 +250,7 @@ impl State { self.framerate = Some(framerate); events.push(gst::event::Caps::new(&caps)); - gst::info!(CAT, obj: element, "Caps changed to {:?}", &caps); + gst::info!(CAT, imp: imp, "Caps changed to {:?}", &caps); } } @@ -282,15 +279,14 @@ pub struct SccParse { impl SccParse { fn handle_buffer( &self, - element: &super::SccParse, buffer: Option<gst::Buffer>, ) -> Result<gst::FlowSuccess, gst::FlowError> { let mut state = self.state.lock().unwrap(); let drain = if let Some(buffer) = buffer { let buffer = buffer.into_mapped_buffer_readable().map_err(|_| { - element_error!( - element, + gst::element_imp_error!( + self, gst::ResourceError::Read, ["Failed to map buffer readable"] ); @@ -308,14 +304,14 @@ impl SccParse { let line = state.line(drain); match line { Ok(Some(SccLine::Caption(tc, data))) => { - state = self.handle_line(tc, data, element, state)?; + state = self.handle_line(tc, data, state)?; } Ok(Some(line)) => { - gst::debug!(CAT, obj: element, "Got line '{:?}'", line); + gst::debug!(CAT, imp: self, "Got line '{:?}'", line); } Err((line, err)) => { - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Decode, ["Couldn't parse line '{:?}': {:?}", line, err] ); @@ -336,12 +332,11 @@ impl SccParse { &self, tc: TimeCode, data: Vec<u8>, - element: &super::SccParse, mut state: MutexGuard<State>, ) -> Result<MutexGuard<State>, gst::FlowError> { gst::trace!( CAT, - obj: element, + imp: self, "Got caption buffer with timecode {:?} and size {}", tc, data.len() @@ -355,7 +350,7 @@ impl SccParse { gst::Fraction::new(30, 1) }; - let mut timecode = state.handle_timecode(&tc, framerate, element)?; + let mut timecode = state.handle_timecode(&tc, framerate, self)?; let start_time = timecode.time_since_daily_jam(); let segment_start = state.segment.start(); let clip_buffers = if state.seeking { @@ -369,7 +364,7 @@ impl SccParse { gst::trace!( CAT, - obj: element, + imp: self, "Checking inside of segment, line start {} line stop {} segment start {} num bufs {}", start_time, stop_time, @@ -408,18 +403,13 @@ impl SccParse { buf_mut.copy_from_slice(0, d).unwrap(); } - state.add_buffer_metadata(&mut buffer, &timecode, framerate, element); + state.add_buffer_metadata(&mut buffer, &timecode, framerate, self); timecode.increment_frame(); if clip_buffers { let end_time = buffer.pts().opt_add(buffer.duration()); if end_time.opt_lt(segment_start).unwrap_or(false) { - gst::trace!( - CAT, - obj: element, - "Skip segment clipped buffer {:?}", - buffer, - ); + gst::trace!(CAT, imp: self, "Skip segment clipped buffer {:?}", buffer,); continue; } @@ -443,19 +433,19 @@ impl SccParse { // Update the last_timecode to the current one state.last_timecode = Some(timecode); - let events = state.create_events(element, Some(framerate)); + let events = state.create_events(self, Some(framerate)); // Drop our state mutex while we push out buffers or events drop(state); for event in events { - gst::debug!(CAT, obj: element, "Pushing event {:?}", event); + gst::debug!(CAT, imp: self, "Pushing event {:?}", event); self.srcpad.push_event(event); } self.srcpad.push_list(buffers).map_err(|err| { if err != gst::FlowError::Flushing && err != gst::FlowError::Eos { - gst::error!(CAT, obj: element, "Pushing buffer returned {:?}", err); + gst::error!(CAT, imp: self, "Pushing buffer returned {:?}", err); } err })?; @@ -467,11 +457,7 @@ impl SccParse { Ok(self.state.lock().unwrap()) } - fn sink_activate( - &self, - pad: &gst::Pad, - element: &super::SccParse, - ) -> Result<(), gst::LoggableError> { + fn sink_activate(&self, pad: &gst::Pad) -> Result<(), gst::LoggableError> { let mode = { let mut query = gst::query::Scheduling::new(); let mut state = self.state.lock().unwrap(); @@ -486,7 +472,7 @@ impl SccParse { { gst::debug!(CAT, obj: pad, "Activating in Pull mode"); - state.pull = Some(PullState::new(element, &self.srcpad)); + state.pull = Some(PullState::new(self, &self.srcpad)); gst::PadMode::Pull } else { @@ -499,25 +485,13 @@ impl SccParse { Ok(()) } - fn start_task(&self, element: &super::SccParse) -> Result<(), gst::LoggableError> { - let element_weak = element.downgrade(); - let pad_weak = self.sinkpad.downgrade(); + fn start_task(&self) -> Result<(), gst::LoggableError> { + let imp = self.ref_counted(); let res = self.sinkpad.start_task(move || { - let element = match element_weak.upgrade() { - Some(element) => element, - None => { - if let Some(pad) = pad_weak.upgrade() { - let _ = pad.pause_task(); - } - return; - } - }; - - let parse = element.imp(); - parse.loop_fn(&element); + imp.loop_fn(); }); if res.is_err() { - return Err(loggable_error!(CAT, "Failed to start pad task")); + return Err(gst::loggable_error!(CAT, "Failed to start pad task")); } Ok(()) } @@ -525,13 +499,12 @@ impl SccParse { fn sink_activatemode( &self, _pad: &gst::Pad, - element: &super::SccParse, mode: gst::PadMode, active: bool, ) -> Result<(), gst::LoggableError> { if mode == gst::PadMode::Pull { if active { - self.start_task(element)?; + self.start_task()?; } else { let _ = self.sinkpad.stop_task(); } @@ -540,23 +513,26 @@ impl SccParse { Ok(()) } - fn scan_duration( - &self, - element: &super::SccParse, - ) -> Result<Option<gst_video::ValidVideoTimeCode>, gst::LoggableError> { - gst::debug!(CAT, obj: element, "Scanning duration"); + fn scan_duration(&self) -> Result<Option<gst_video::ValidVideoTimeCode>, gst::LoggableError> { + gst::debug!(CAT, imp: self, "Scanning duration"); /* First let's query the bytes duration upstream */ let mut q = gst::query::Duration::new(gst::Format::Bytes); if !self.sinkpad.peer_query(&mut q) { - return Err(loggable_error!(CAT, "Failed to query upstream duration")); + return Err(gst::loggable_error!( + CAT, + "Failed to query upstream duration" + )); } let size = match q.result().try_into().unwrap() { Some(gst::format::Bytes(size)) => size, None => { - return Err(loggable_error!(CAT, "Failed to query upstream duration")); + return Err(gst::loggable_error!( + CAT, + "Failed to query upstream duration" + )); } }; @@ -574,7 +550,7 @@ impl SccParse { buffers.push(buffer); } Err(flow) => { - return Err(loggable_error!( + return Err(gst::loggable_error!( CAT, "Failed to pull buffer while scanning duration: {:?}", flow @@ -589,7 +565,7 @@ impl SccParse { let buf = buf .clone() .into_mapped_buffer_readable() - .map_err(|_| loggable_error!(CAT, "Failed to map buffer readable"))?; + .map_err(|_| gst::loggable_error!(CAT, "Failed to map buffer readable"))?; reader.push(buf); } @@ -613,25 +589,20 @@ impl SccParse { } if last_tc.is_some() || offset == 0 { - gst::debug!( - CAT, - obj: element, - "Duration scan done, last_tc: {:?}", - last_tc - ); + gst::debug!(CAT, imp: self, "Duration scan done, last_tc: {:?}", last_tc); break (Ok(last_tc)); } } } - fn push_eos(&self, element: &super::SccParse) { + fn push_eos(&self) { let mut state = self.state.lock().unwrap(); if state.seeking { state.need_flush_stop = true; } - let mut events = state.create_events(element, None); + let mut events = state.create_events(self, None); let mut eos_event = gst::event::Eos::builder(); if let Some(seek_seqnum) = state.seek_seqnum { @@ -644,12 +615,12 @@ impl SccParse { drop(state); for event in events { - gst::debug!(CAT, obj: element, "Pushing event {:?}", event); + gst::debug!(CAT, imp: self, "Pushing event {:?}", event); self.srcpad.push_event(event); } } - fn loop_fn(&self, element: &super::SccParse) { + fn loop_fn(&self) { let mut state = self.state.lock().unwrap(); let State { ref framerate, @@ -676,8 +647,8 @@ impl SccParse { Err(flow) => { gst::error!(CAT, obj: &self.sinkpad, "Failed to pull, reason: {:?}", flow); - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Failed, ["Streaming stopped, failed to pull buffer"] ); @@ -687,10 +658,10 @@ impl SccParse { } }; - match self.handle_buffer(element, buffer) { + match self.handle_buffer(buffer) { Ok(_) => { if scan_duration { - match self.scan_duration(element) { + match self.scan_duration() { Ok(Some(tc)) => { let mut state = self.state.lock().unwrap(); let mut pull = state.pull.as_mut().unwrap(); @@ -704,8 +675,8 @@ impl SccParse { Err(err) => { err.log(); - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Decode, ["Failed to scan duration"] ); @@ -718,20 +689,20 @@ impl SccParse { Err(flow) => { match flow { gst::FlowError::Flushing => { - gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::debug!(CAT, imp: self, "Pausing after flow {:?}", flow); } gst::FlowError::Eos => { - self.push_eos(element); + self.push_eos(); - gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::debug!(CAT, imp: self, "Pausing after flow {:?}", flow); } _ => { - self.push_eos(element); + self.push_eos(); - gst::error!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::error!(CAT, imp: self, "Pausing after flow {:?}", flow); - element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Failed, ["Streaming stopped, reason: {:?}", flow] ); @@ -746,12 +717,11 @@ impl SccParse { fn sink_chain( &self, pad: &gst::Pad, - element: &super::SccParse, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); - self.handle_buffer(element, Some(buffer)) + self.handle_buffer(Some(buffer)) } fn flush(&self, mut state: MutexGuard<State>) -> MutexGuard<State> { @@ -771,7 +741,7 @@ impl SccParse { self.state.lock().unwrap() } - fn sink_event(&self, pad: &gst::Pad, element: &super::SccParse, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -792,14 +762,14 @@ impl SccParse { let state = self.flush(state); drop(state); - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::Eos(_) => { gst::log!(CAT, obj: pad, "Draining"); - if let Err(err) = self.handle_buffer(element, None) { + if let Err(err) = self.handle_buffer(None) { gst::error!(CAT, obj: pad, "Failed to drain parser: {:?}", err); } - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } _ => { if event.is_sticky() @@ -811,15 +781,15 @@ impl SccParse { state.pending_events.push(event); true } else { - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } } } } - fn perform_seek(&self, event: &gst::event::Seek, element: &super::SccParse) -> bool { + fn perform_seek(&self, event: &gst::event::Seek) -> bool { if self.state.lock().unwrap().pull.is_none() { - gst::error!(CAT, obj: element, "seeking is only supported in pull mode"); + gst::error!(CAT, imp: self, "seeking is only supported in pull mode"); return false; } @@ -828,7 +798,7 @@ impl SccParse { let mut start: Option<gst::ClockTime> = match start.try_into() { Ok(start) => start, Err(_) => { - gst::error!(CAT, obj: element, "seek has invalid format"); + gst::error!(CAT, imp: self, "seek has invalid format"); return false; } }; @@ -836,18 +806,18 @@ impl SccParse { let mut stop: Option<gst::ClockTime> = match stop.try_into() { Ok(stop) => stop, Err(_) => { - gst::error!(CAT, obj: element, "seek has invalid format"); + gst::error!(CAT, imp: self, "seek has invalid format"); return false; } }; if !flags.contains(gst::SeekFlags::FLUSH) { - gst::error!(CAT, obj: element, "only flushing seeks are supported"); + gst::error!(CAT, imp: self, "only flushing seeks are supported"); return false; } if start_type == gst::SeekType::End || stop_type == gst::SeekType::End { - gst::error!(CAT, obj: element, "Relative seeks are not supported"); + gst::error!(CAT, imp: self, "Relative seeks are not supported"); return false; } @@ -857,14 +827,14 @@ impl SccParse { .seqnum(seek_seqnum) .build(); - gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event); + gst::debug!(CAT, imp: self, "Sending event {:?} upstream", event); self.sinkpad.push_event(event); let event = gst::event::FlushStart::builder() .seqnum(seek_seqnum) .build(); - gst::debug!(CAT, obj: element, "Pushing event {:?}", event); + gst::debug!(CAT, imp: self, "Pushing event {:?}", event); self.srcpad.push_event(event); let _ = self.sinkpad.pause_task(); @@ -892,7 +862,7 @@ impl SccParse { /* Drop our state while we push a serialized event upstream */ drop(state); - gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event); + gst::debug!(CAT, imp: self, "Sending event {:?} upstream", event); self.sinkpad.push_event(event); state = self.state.lock().unwrap(); @@ -901,7 +871,7 @@ impl SccParse { .segment .do_seek(rate, flags, start_type, start, stop_type, stop); - match self.start_task(element) { + match self.start_task() { Err(error) => { error.log(); false @@ -910,22 +880,17 @@ impl SccParse { } } - fn src_event(&self, pad: &gst::Pad, element: &super::SccParse, event: gst::Event) -> bool { + fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); match event.view() { - EventView::Seek(e) => self.perform_seek(e, element), - _ => pad.event_default(Some(element), event), + EventView::Seek(e) => self.perform_seek(e), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn src_query( - &self, - pad: &gst::Pad, - element: &super::SccParse, - query: &mut gst::QueryRef, - ) -> bool { + fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { use gst::QueryViewMut; gst::log!(CAT, obj: pad, "Handling query {:?}", query); @@ -975,7 +940,7 @@ impl SccParse { self.sinkpad.peer_query(query) } } - _ => pad.query_default(Some(element), query), + _ => pad.query_default(Some(&*self.instance()), query), } } } @@ -992,29 +957,34 @@ impl ObjectSubclass for SccParse { .activate_function(|pad, parent| { SccParse::catch_panic_pad_function( parent, - || Err(loggable_error!(CAT, "Panic activating sink pad")), - |parse, element| parse.sink_activate(pad, element), + || Err(gst::loggable_error!(CAT, "Panic activating sink pad")), + |parse| parse.sink_activate(pad), ) }) .activatemode_function(|pad, parent, mode, active| { SccParse::catch_panic_pad_function( parent, - || Err(loggable_error!(CAT, "Panic activating sink pad with mode")), - |parse, element| parse.sink_activatemode(pad, element, mode, active), + || { + Err(gst::loggable_error!( + CAT, + "Panic activating sink pad with mode" + )) + }, + |parse| parse.sink_activatemode(pad, mode, active), ) }) .chain_function(|pad, parent, buffer| { SccParse::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |parse, element| parse.sink_chain(pad, element, buffer), + |parse| parse.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { SccParse::catch_panic_pad_function( parent, || false, - |parse, element| parse.sink_event(pad, element, event), + |parse| parse.sink_event(pad, event), ) }) .build(); @@ -1025,14 +995,14 @@ impl ObjectSubclass for SccParse { SccParse::catch_panic_pad_function( parent, || false, - |parse, element| parse.src_event(pad, element, event), + |parse| parse.src_event(pad, event), ) }) .query_function(|pad, parent, query| { SccParse::catch_panic_pad_function( parent, || false, - |parse, element| parse.src_query(pad, element, query), + |parse| parse.src_query(pad, query), ) }) .build(); @@ -1046,9 +1016,10 @@ impl ObjectSubclass for SccParse { } impl ObjectImpl for SccParse { - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -1104,10 +1075,9 @@ impl ElementImpl for SccParse { fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { @@ -1118,6 +1088,6 @@ impl ElementImpl for SccParse { _ => (), } - self.parent_change_state(element, transition) + self.parent_change_state(transition) } } diff --git a/video/closedcaption/src/transcriberbin/imp.rs b/video/closedcaption/src/transcriberbin/imp.rs index fa4c275f6..5bb928e9b 100644 --- a/video/closedcaption/src/transcriberbin/imp.rs +++ b/video/closedcaption/src/transcriberbin/imp.rs @@ -85,12 +85,8 @@ pub struct TranscriberBin { } impl TranscriberBin { - fn construct_transcription_bin( - &self, - element: &super::TranscriberBin, - state: &mut State, - ) -> Result<(), Error> { - gst::debug!(CAT, obj: element, "Building transcription bin"); + fn construct_transcription_bin(&self, state: &mut State) -> Result<(), Error> { + gst::debug!(CAT, imp: self, "Building transcription bin"); let aqueue_transcription = gst::ElementFactory::make("queue", Some("transqueue"))?; aqueue_transcription.set_property("max-size-buffers", 0u32); @@ -153,11 +149,7 @@ impl TranscriberBin { Ok(()) } - fn construct_internal_bin( - &self, - element: &super::TranscriberBin, - state: &mut State, - ) -> Result<(), Error> { + fn construct_internal_bin(&self, state: &mut State) -> Result<(), Error> { let aclocksync = gst::ElementFactory::make("clocksync", None)?; let vclocksync = gst::ElementFactory::make("clocksync", None)?; @@ -202,17 +194,16 @@ impl TranscriberBin { state.internal_bin.add_pad(&internal_video_sinkpad)?; state.internal_bin.add_pad(&internal_video_srcpad)?; - let element_weak = element.downgrade(); + let imp_weak = self.downgrade(); let comp_sinkpad = &state.cccombiner.static_pad("sink").unwrap(); // Drop caption meta from video buffer if user preference is transcription comp_sinkpad.add_probe(gst::PadProbeType::BUFFER, move |_, probe_info| { - let element = match element_weak.upgrade() { + let imp = match imp_weak.upgrade() { None => return gst::PadProbeReturn::Remove, - Some(element) => element, + Some(imp) => imp, }; - let trans = TranscriberBin::from_instance(&element); - let settings = trans.settings.lock().unwrap(); + let settings = imp.settings.lock().unwrap(); if settings.caption_source != CaptionSource::Transcription { return gst::PadProbeReturn::Pass; } @@ -227,7 +218,7 @@ impl TranscriberBin { gst::PadProbeReturn::Ok }); - element.add(&state.internal_bin)?; + self.instance().add(&state.internal_bin)?; state .cccombiner @@ -242,12 +233,12 @@ impl TranscriberBin { self.video_srcpad .set_target(Some(&state.internal_bin.static_pad("video_src").unwrap()))?; - self.construct_transcription_bin(element, state)?; + self.construct_transcription_bin(state)?; Ok(()) } - fn setup_transcription(&self, element: &super::TranscriberBin, state: &State) { + fn setup_transcription(&self, state: &State) { let settings = self.settings.lock().unwrap(); let mut cc_caps = settings.cc_caps.clone(); @@ -285,10 +276,10 @@ impl TranscriberBin { drop(settings); - self.setup_cc_mode(element, state); + self.setup_cc_mode(state); } - fn disable_transcription_bin(&self, element: &super::TranscriberBin) { + fn disable_transcription_bin(&self) { let mut state = self.state.lock().unwrap(); if let Some(ref mut state) = state.as_mut() { @@ -299,7 +290,7 @@ impl TranscriberBin { let passthrough = self.settings.lock().unwrap().passthrough; if passthrough { - gst::debug!(CAT, obj: element, "disabling transcription bin"); + gst::debug!(CAT, imp: self, "disabling transcription bin"); let bin_sink_pad = state.transcription_bin.static_pad("sink").unwrap(); if let Some(audio_tee_pad) = bin_sink_pad.peer() { @@ -319,13 +310,13 @@ impl TranscriberBin { } } - fn block_and_update(&self, element: &super::TranscriberBin, passthrough: bool) { + fn block_and_update(&self, passthrough: bool) { let mut s = self.state.lock().unwrap(); if let Some(ref mut state) = s.as_mut() { if passthrough { let sinkpad = state.transcription_bin.static_pad("sink").unwrap(); - let element_weak = element.downgrade(); + let imp_weak = self.downgrade(); state.tearing_down = true; drop(s); let _ = sinkpad.add_probe( @@ -333,14 +324,12 @@ impl TranscriberBin { | gst::PadProbeType::BUFFER | gst::PadProbeType::EVENT_DOWNSTREAM, move |_pad, _info| { - let element = match element_weak.upgrade() { + let imp = match imp_weak.upgrade() { None => return gst::PadProbeReturn::Pass, - Some(element) => element, + Some(imp) => imp, }; - let this = element.imp(); - - this.disable_transcription_bin(&element); + imp.disable_transcription_bin(); gst::PadProbeReturn::Remove }, @@ -363,10 +352,10 @@ impl TranscriberBin { } } - fn setup_cc_mode(&self, element: &super::TranscriberBin, state: &State) { + fn setup_cc_mode(&self, state: &State) { let mode = self.settings.lock().unwrap().mode; - gst::debug!(CAT, obj: element, "setting CC mode {:?}", mode); + gst::debug!(CAT, imp: self, "setting CC mode {:?}", mode); state.tttocea608.set_property("mode", mode); @@ -386,12 +375,11 @@ impl TranscriberBin { fn relink_transcriber( &self, state: &mut State, - element: &super::TranscriberBin, old_transcriber: &gst::Element, ) -> Result<(), Error> { gst::error!( CAT, - obj: element, + imp: self, "Relinking transcriber, old: {:?}, new: {:?}", old_transcriber, state.transcriber @@ -414,12 +402,7 @@ impl TranscriberBin { } #[allow(clippy::single_match)] - fn src_query( - &self, - pad: &gst::Pad, - element: &super::TranscriberBin, - query: &mut gst::QueryRef, - ) -> bool { + fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { use gst::QueryViewMut; gst::log!(CAT, obj: pad, "Handling query {:?}", query); @@ -428,7 +411,7 @@ impl TranscriberBin { QueryViewMut::Latency(q) => { let mut upstream_query = gst::query::Latency::new(); - let ret = pad.query_default(Some(element), &mut upstream_query); + let ret = pad.query_default(Some(&*self.instance()), &mut upstream_query); if ret { let (_, mut min, _) = upstream_query.result(); @@ -453,7 +436,7 @@ impl TranscriberBin { ret } - _ => pad.query_default(Some(element), query), + _ => pad.query_default(Some(&*self.instance()), query), } } @@ -497,12 +480,7 @@ impl TranscriberBin { } #[allow(clippy::single_match)] - fn video_sink_event( - &self, - pad: &gst::Pad, - element: &super::TranscriberBin, - event: gst::Event, - ) -> bool { + fn video_sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -525,16 +503,16 @@ impl TranscriberBin { if !had_framerate { gst::info!( CAT, - obj: element, + imp: self, "Received video caps, setting up transcription" ); - self.setup_transcription(element, state); + self.setup_transcription(state); } } - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } } @@ -554,7 +532,7 @@ impl ObjectSubclass for TranscriberBin { TranscriberBin::catch_panic_pad_function( parent, || false, - |transcriber, element| transcriber.src_query(pad.upcast_ref(), element, query), + |transcriber| transcriber.src_query(pad.upcast_ref(), query), ) }) .build(); @@ -565,9 +543,7 @@ impl ObjectSubclass for TranscriberBin { TranscriberBin::catch_panic_pad_function( parent, || false, - |transcriber, element| { - transcriber.video_sink_event(pad.upcast_ref(), element, event) - }, + |transcriber| transcriber.video_sink_event(pad.upcast_ref(), event), ) }) .build(); @@ -577,7 +553,7 @@ impl ObjectSubclass for TranscriberBin { TranscriberBin::catch_panic_pad_function( parent, || false, - |transcriber, element| transcriber.src_query(pad.upcast_ref(), element, query), + |transcriber| transcriber.src_query(pad.upcast_ref(), query), ) }) .build(); @@ -644,13 +620,7 @@ impl ObjectImpl for TranscriberBin { PROPERTIES.as_ref() } - 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) { match pspec.name() { "passthrough" => { let mut settings = self.settings.lock().unwrap(); @@ -661,7 +631,7 @@ impl ObjectImpl for TranscriberBin { if old_passthrough != new_passthrough { drop(settings); - self.block_and_update(obj, new_passthrough); + self.block_and_update(new_passthrough); } } "latency" => { @@ -685,7 +655,7 @@ impl ObjectImpl for TranscriberBin { if old_mode != new_mode { drop(settings); - self.setup_cc_mode(obj, self.state.lock().unwrap().as_ref().unwrap()); + self.setup_cc_mode(self.state.lock().unwrap().as_ref().unwrap()); } } "cc-caps" => { @@ -698,7 +668,7 @@ impl ObjectImpl for TranscriberBin { let old_transcriber = state.transcriber.clone(); state.transcriber = value.get().expect("type checked upstream"); if old_transcriber != state.transcriber { - match self.relink_transcriber(state, obj, &old_transcriber) { + match self.relink_transcriber(state, &old_transcriber) { Ok(()) => (), Err(err) => { gst::error!(CAT, "invalid transcriber: {}", err); @@ -716,10 +686,10 @@ impl ObjectImpl for TranscriberBin { let s = self.state.lock().unwrap(); if let Some(state) = s.as_ref() { if settings.caption_source == CaptionSource::Inband { - gst::debug!(CAT, obj: obj, "Use inband caption, dropping transcription"); + gst::debug!(CAT, imp: self, "Use inband caption, dropping transcription"); state.transcription_valve.set_property("drop", true); } else { - gst::debug!(CAT, obj: obj, "Stop dropping transcription"); + gst::debug!(CAT, imp: self, "Stop dropping transcription"); state.transcription_valve.set_property("drop", false); } } @@ -728,7 +698,7 @@ impl ObjectImpl for TranscriberBin { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "passthrough" => { let settings = self.settings.lock().unwrap(); @@ -767,16 +737,17 @@ impl ObjectImpl for TranscriberBin { } } - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.audio_srcpad).unwrap(); obj.add_pad(&self.audio_sinkpad).unwrap(); obj.add_pad(&self.video_srcpad).unwrap(); obj.add_pad(&self.video_sinkpad).unwrap(); *self.state.lock().unwrap() = match self.build_state() { - Ok(mut state) => match self.construct_internal_bin(obj, &mut state) { + Ok(mut state) => match self.construct_internal_bin(&mut state) { Ok(()) => Some(state), Err(err) => { gst::error!(CAT, "Failed to build internal bin: {}", err); @@ -855,10 +826,9 @@ impl ElementImpl for TranscriberBin { #[allow(clippy::single_match)] fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused => { @@ -868,14 +838,14 @@ impl ElementImpl for TranscriberBin { if state.framerate.is_some() { gst::info!( CAT, - obj: element, + imp: self, "Received video caps, setting up transcription" ); - self.setup_transcription(element, state); + self.setup_transcription(state); } } else { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Failed, ["Can't change state with no state"] ); @@ -885,12 +855,12 @@ impl ElementImpl for TranscriberBin { _ => (), } - self.parent_change_state(element, transition) + self.parent_change_state(transition) } } impl BinImpl for TranscriberBin { - fn handle_message(&self, bin: &Self::Type, msg: gst::Message) { + fn handle_message(&self, msg: gst::Message) { use gst::MessageView; match msg.view() { @@ -902,7 +872,7 @@ impl BinImpl for TranscriberBin { if msg.src().as_ref() == Some(state.transcriber.upcast_ref()) { gst::error!( CAT, - obj: bin, + imp: self, "Transcriber has posted an error ({:?}), going back to passthrough", m ); @@ -910,21 +880,21 @@ impl BinImpl for TranscriberBin { let mut settings = self.settings.lock().unwrap(); settings.passthrough = true; drop(settings); - bin.notify("passthrough"); - bin.call_async(move |bin| { + self.instance().notify("passthrough"); + self.instance().call_async(move |bin| { let thiz = bin.imp(); - thiz.block_and_update(bin, true); + thiz.block_and_update(true); }); } else { drop(s); - self.parent_handle_message(bin, msg); + self.parent_handle_message(msg); } } else { drop(s); - self.parent_handle_message(bin, msg); + self.parent_handle_message(msg); } } - _ => self.parent_handle_message(bin, msg), + _ => self.parent_handle_message(msg), } } } diff --git a/video/closedcaption/src/tttocea608/imp.rs b/video/closedcaption/src/tttocea608/imp.rs index c20ff2fb5..22ca651bb 100644 --- a/video/closedcaption/src/tttocea608/imp.rs +++ b/video/closedcaption/src/tttocea608/imp.rs @@ -151,7 +151,7 @@ static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| { static SPACE: Lazy<u16> = Lazy::new(|| eia608_from_utf8_1(&[0x20, 0, 0, 0, 0])); fn cc_data_buffer( - element: &super::TtToCea608, + imp: &TtToCea608, cc_data: u16, pts: gst::ClockTime, duration: gst::ClockTime, @@ -163,14 +163,14 @@ fn cc_data_buffer( if cc_data != 0x8080 { gst::log!( CAT, - obj: element, + imp: imp, "{} -> {}: {}", pts, pts + duration, eia608_to_text(cc_data) ); } else { - gst::trace!(CAT, obj: element, "{} -> {}: padding", pts, pts + duration); + gst::trace!(CAT, imp: imp, "{} -> {}: padding", pts, pts + duration); } buf_mut.copy_from_slice(0, &data).unwrap(); @@ -183,7 +183,7 @@ fn cc_data_buffer( impl State { fn check_erase_display( &mut self, - element: &super::TtToCea608, + imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, ) -> bool { if let Some(erase_display_frame_no) = self.erase_display_frame_no { @@ -191,7 +191,7 @@ impl State { self.erase_display_frame_no = None; self.column = 0; self.send_roll_up_preamble = true; - self.erase_display_memory(element, bufferlist); + self.erase_display_memory(imp, bufferlist); return true; } } @@ -199,13 +199,8 @@ impl State { false } - fn cc_data( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - cc_data: u16, - ) { - self.check_erase_display(element, bufferlist); + fn cc_data(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, cc_data: u16) { + self.check_erase_display(imp, bufferlist); let (fps_n, fps_d) = (self.framerate.numer() as u64, self.framerate.denom() as u64); @@ -216,7 +211,7 @@ impl State { if self.last_frame_no < self.max_frame_no { self.last_frame_no += 1; } else { - gst::debug!(CAT, obj: element, "More text than bandwidth!"); + gst::debug!(CAT, imp: imp, "More text than bandwidth!"); } let next_pts = (self.last_frame_no * gst::ClockTime::SECOND) @@ -225,122 +220,96 @@ impl State { let duration = next_pts - pts; - bufferlist.insert(-1, cc_data_buffer(element, cc_data, pts, duration)); + bufferlist.insert(-1, cc_data_buffer(imp, cc_data, pts, duration)); } - fn pad( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - frame_no: u64, - ) { + fn pad(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, frame_no: u64) { while self.last_frame_no < frame_no { - if !self.check_erase_display(element, bufferlist) { - self.cc_data(element, bufferlist, 0x8080); + if !self.check_erase_display(imp, bufferlist) { + self.cc_data(imp, bufferlist, 0x8080); } } } - fn resume_caption_loading( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - ) { + fn resume_caption_loading(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_resume_caption_loading), ) } - fn resume_direct_captioning( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - ) { + fn resume_direct_captioning(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_resume_direct_captioning), ) } - fn delete_to_end_of_row( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - ) { + fn delete_to_end_of_row(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_delete_to_end_of_row), ) } - fn roll_up_2(&mut self, element: &super::TtToCea608, bufferlist: &mut gst::BufferListRef) { + fn roll_up_2(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_roll_up_2), ) } - fn roll_up_3(&mut self, element: &super::TtToCea608, bufferlist: &mut gst::BufferListRef) { + fn roll_up_3(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_roll_up_3), ) } - fn roll_up_4(&mut self, element: &super::TtToCea608, bufferlist: &mut gst::BufferListRef) { + fn roll_up_4(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_roll_up_4), ) } - fn carriage_return( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - ) { + fn carriage_return(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_carriage_return), ) } - fn end_of_caption(&mut self, element: &super::TtToCea608, bufferlist: &mut gst::BufferListRef) { + fn end_of_caption(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_end_of_caption), ) } - fn tab_offset( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - offset: u32, - ) { + fn tab_offset(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, offset: u32) { match offset { 0 => (), 1 => self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_tab_offset_1), ), 2 => self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_tab_offset_2), ), 3 => self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_tab_offset_3), ), @@ -350,14 +319,14 @@ impl State { fn preamble_indent( &mut self, - element: &super::TtToCea608, + imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, row: i32, col: i32, underline: bool, ) { self.cc_data( - element, + imp, bufferlist, eia608_row_column_preamble(row, col, underline), ) @@ -365,14 +334,14 @@ impl State { fn preamble_style( &mut self, - element: &super::TtToCea608, + imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, row: i32, style: u32, underline: bool, ) { self.cc_data( - element, + imp, bufferlist, eia608_row_style_preamble(row, style, underline), ) @@ -380,31 +349,21 @@ impl State { fn midrow_change( &mut self, - element: &super::TtToCea608, + imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, style: u32, underline: bool, ) { - self.cc_data(element, bufferlist, eia608_midrow_change(style, underline)) + self.cc_data(imp, bufferlist, eia608_midrow_change(style, underline)) } - fn bna( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - bna1: u16, - bna2: u16, - ) { - self.cc_data(element, bufferlist, eia608_from_basicna(bna1, bna2)) + fn bna(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, bna1: u16, bna2: u16) { + self.cc_data(imp, bufferlist, eia608_from_basicna(bna1, bna2)) } - fn erase_display_memory( - &mut self, - element: &super::TtToCea608, - bufferlist: &mut gst::BufferListRef, - ) { + fn erase_display_memory(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) { self.cc_data( - element, + imp, bufferlist, eia608_control_command(ffi::eia608_control_t_eia608_control_erase_display_memory), ) @@ -423,14 +382,13 @@ pub struct TtToCea608 { impl TtToCea608 { fn open_chunk( &self, - element: &super::TtToCea608, state: &mut State, chunk: &Chunk, bufferlist: &mut gst::BufferListRef, col: u32, ) -> bool { if (chunk.style != state.style || chunk.underline != state.underline) && col < 31 { - state.midrow_change(element, bufferlist, chunk.style as u32, chunk.underline); + state.midrow_change(self, bufferlist, chunk.style as u32, chunk.underline); state.style = chunk.style; state.underline = chunk.underline; true @@ -442,7 +400,6 @@ impl TtToCea608 { #[allow(clippy::too_many_arguments)] fn open_line( &self, - element: &super::TtToCea608, state: &mut State, settings: &Settings, chunk: &Chunk, @@ -459,7 +416,7 @@ impl TtToCea608 { if let Some(carriage_return) = carriage_return { if carriage_return { *col = settings.origin_column; - state.carriage_return(element, bufferlist); + state.carriage_return(self, bufferlist); true } else { state.send_roll_up_preamble @@ -475,20 +432,14 @@ impl TtToCea608 { if do_preamble { match state.mode { - Cea608Mode::RollUp2 => state.roll_up_2(element, bufferlist), - Cea608Mode::RollUp3 => state.roll_up_3(element, bufferlist), - Cea608Mode::RollUp4 => state.roll_up_4(element, bufferlist), + Cea608Mode::RollUp2 => state.roll_up_2(self, bufferlist), + Cea608Mode::RollUp3 => state.roll_up_3(self, bufferlist), + Cea608Mode::RollUp4 => state.roll_up_4(self, bufferlist), _ => (), } if chunk.style != TextStyle::White && indent == 0 { - state.preamble_style( - element, - bufferlist, - row, - chunk.style as u32, - chunk.underline, - ); + state.preamble_style(self, bufferlist, row, chunk.style as u32, chunk.underline); state.style = chunk.style; } else { if chunk.style != TextStyle::White { @@ -502,20 +453,14 @@ impl TtToCea608 { } state.style = TextStyle::White; - state.preamble_indent( - element, - bufferlist, - row, - (indent * 4) as i32, - chunk.underline, - ); + state.preamble_indent(self, bufferlist, row, (indent * 4) as i32, chunk.underline); } if state.mode == Cea608Mode::PaintOn { - state.delete_to_end_of_row(element, bufferlist); + state.delete_to_end_of_row(self, bufferlist); } - state.tab_offset(element, bufferlist, offset); + state.tab_offset(self, bufferlist, offset); state.underline = chunk.underline; state.send_roll_up_preamble = false; @@ -524,7 +469,7 @@ impl TtToCea608 { ret = false; } - if self.open_chunk(element, state, chunk, bufferlist, *col) { + if self.open_chunk(state, chunk, bufferlist, *col) { *col += 1; ret = false } @@ -540,7 +485,6 @@ impl TtToCea608 { &self, mut state: &mut State, settings: &Settings, - element: &super::TtToCea608, pts: gst::ClockTime, duration: gst::ClockTime, lines: Lines, @@ -564,7 +508,7 @@ impl TtToCea608 { let frame_no = pts.mul_div_round(fps_n, fps_d).unwrap().seconds(); if state.last_frame_no == 0 { - gst::debug!(CAT, obj: element, "Initial skip to frame no {}", frame_no); + gst::debug!(CAT, imp: self, "Initial skip to frame no {}", frame_no); state.last_frame_no = pts.mul_div_floor(fps_n, fps_d).unwrap().seconds(); } @@ -573,7 +517,7 @@ impl TtToCea608 { .unwrap() .seconds(); - state.pad(element, mut_list, frame_no); + state.pad(self, mut_list, frame_no); let mut cleared = false; if let Some(mode) = lines.mode { @@ -581,7 +525,7 @@ impl TtToCea608 { /* Always erase the display when going to or from pop-on */ if state.mode == Cea608Mode::PopOn || mode == Cea608Mode::PopOn { state.erase_display_frame_no = None; - state.erase_display_memory(element, mut_list); + state.erase_display_memory(self, mut_list); cleared = true; } @@ -598,7 +542,7 @@ impl TtToCea608 { if let Some(clear) = lines.clear { if clear && !cleared { state.erase_display_frame_no = None; - state.erase_display_memory(element, mut_list); + state.erase_display_memory(self, mut_list); if state.mode != Cea608Mode::PopOn && state.mode != Cea608Mode::PaintOn { state.send_roll_up_preamble = true; } @@ -607,28 +551,23 @@ impl TtToCea608 { } if state.mode == Cea608Mode::PopOn { - state.resume_caption_loading(element, mut_list); - state.cc_data(element, mut_list, erase_non_displayed_memory()); + state.resume_caption_loading(self, mut_list); + state.cc_data(self, mut_list, erase_non_displayed_memory()); } else if state.mode == Cea608Mode::PaintOn { - state.resume_direct_captioning(element, mut_list); + state.resume_direct_captioning(self, mut_list); } let mut prev_char = 0; for line in &lines.lines { - gst::log!(CAT, obj: element, "Processing {:?}", line); + gst::log!(CAT, imp: self, "Processing {:?}", line); if let Some(line_row) = line.row { row = line_row; } if row > 14 { - gst::warning!( - CAT, - obj: element, - "Dropping line after 15th row: {:?}", - line - ); + gst::warning!(CAT, imp: self, "Dropping line after 15th row: {:?}", line); continue; } @@ -644,13 +583,12 @@ impl TtToCea608 { for (j, chunk) in line.chunks.iter().enumerate() { let mut prepend_space = true; if prev_char != 0 { - state.cc_data(element, mut_list, prev_char); + state.cc_data(self, mut_list, prev_char); prev_char = 0; } if j == 0 { prepend_space = self.open_line( - element, state, settings, chunk, @@ -659,7 +597,7 @@ impl TtToCea608 { row as i32, line.carriage_return, ); - } else if self.open_chunk(element, state, chunk, mut_list, col) { + } else if self.open_chunk(state, chunk, mut_list, col) { prepend_space = false; col += 1; } @@ -690,36 +628,36 @@ impl TtToCea608 { let mut cc_data = eia608_from_utf8_1(&encoded); if cc_data == 0 { - gst::warning!(CAT, obj: element, "Not translating UTF8: {}", c); + gst::warning!(CAT, imp: self, "Not translating UTF8: {}", c); cc_data = *SPACE; } if is_basicna(prev_char) { if is_basicna(cc_data) { - state.bna(element, mut_list, prev_char, cc_data); + state.bna(self, mut_list, prev_char, cc_data); } else if is_westeu(cc_data) { // extended characters overwrite the previous character, // so insert a dummy char then write the extended char - state.bna(element, mut_list, prev_char, *SPACE); - state.cc_data(element, mut_list, cc_data); + state.bna(self, mut_list, prev_char, *SPACE); + state.cc_data(self, mut_list, cc_data); } else { - state.cc_data(element, mut_list, prev_char); - state.cc_data(element, mut_list, cc_data); + state.cc_data(self, mut_list, prev_char); + state.cc_data(self, mut_list, cc_data); } prev_char = 0; } else if is_westeu(cc_data) { // extended characters overwrite the previous character, // so insert a dummy char then write the extended char - state.cc_data(element, mut_list, *SPACE); - state.cc_data(element, mut_list, cc_data); + state.cc_data(self, mut_list, *SPACE); + state.cc_data(self, mut_list, cc_data); } else if is_basicna(cc_data) { prev_char = cc_data; } else { - state.cc_data(element, mut_list, cc_data); + state.cc_data(self, mut_list, cc_data); } if is_specialna(cc_data) { - state.resume_caption_loading(element, mut_list); + state.resume_caption_loading(self, mut_list); } col += 1; @@ -742,12 +680,11 @@ impl TtToCea608 { || col > 31 { if prev_char != 0 { - state.cc_data(element, mut_list, prev_char); + state.cc_data(self, mut_list, prev_char); prev_char = 0; } self.open_line( - element, state, settings, chunk, @@ -761,7 +698,7 @@ impl TtToCea608 { if chars.peek().is_some() { gst::warning!( CAT, - obj: element, + imp: self, "Dropping characters after 32nd column: {}", c ); @@ -773,7 +710,7 @@ impl TtToCea608 { if state.mode == Cea608Mode::PopOn || state.mode == Cea608Mode::PaintOn { if prev_char != 0 { - state.cc_data(element, mut_list, prev_char); + state.cc_data(self, mut_list, prev_char); prev_char = 0; } row += 1; @@ -781,13 +718,13 @@ impl TtToCea608 { } if prev_char != 0 { - state.cc_data(element, mut_list, prev_char); + state.cc_data(self, mut_list, prev_char); } if state.mode == Cea608Mode::PopOn { /* No need to erase the display at this point, end_of_caption will be equivalent */ state.erase_display_frame_no = None; - state.end_of_caption(element, mut_list); + state.end_of_caption(self, mut_list); } state.column = col; @@ -800,7 +737,7 @@ impl TtToCea608 { Some(state.last_frame_no + timeout.mul_div_round(fps_n, fps_d).unwrap().seconds()); } - state.pad(element, mut_list, state.max_frame_no); + state.pad(self, mut_list, state.max_frame_no); Ok(bufferlist) } @@ -808,14 +745,13 @@ impl TtToCea608 { fn sink_chain( &self, pad: &gst::Pad, - element: &super::TtToCea608, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { - gst::log!(CAT, obj: element, "Handling {:?}", buffer); + gst::log!(CAT, imp: self, "Handling {:?}", buffer); let pts = buffer.pts().ok_or_else(|| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Format, ["Stream with timestamped buffers required"] ); @@ -823,8 +759,8 @@ impl TtToCea608 { })?; let duration = buffer.duration().ok_or_else(|| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::StreamError::Format, ["Buffers of stream need to have a duration"] ); @@ -890,7 +826,7 @@ impl TtToCea608 { } } - let bufferlist = self.generate(&mut state, &settings, element, pts, duration, lines)?; + let bufferlist = self.generate(&mut state, &settings, pts, duration, lines)?; drop(settings); drop(state); @@ -898,7 +834,7 @@ impl TtToCea608 { self.srcpad.push_list(bufferlist) } - fn sink_event(&self, pad: &gst::Pad, element: &super::TtToCea608, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { gst::log!(CAT, obj: pad, "Handling event {:?}", event); use gst::EventView; @@ -954,7 +890,7 @@ impl TtToCea608 { gst::debug!( CAT, - obj: element, + imp: self, "Initial skip to frame no {}", state.last_frame_no ); @@ -969,7 +905,7 @@ impl TtToCea608 { let mut bufferlist = gst::BufferList::new(); let mut_list = bufferlist.get_mut().unwrap(); - state.pad(element, mut_list, frame_no); + state.pad(self, mut_list, frame_no); drop(state); @@ -984,7 +920,7 @@ impl TtToCea608 { let mut_list = bufferlist.get_mut().unwrap(); state.max_frame_no = erase_display_frame_no; - state.pad(element, mut_list, erase_display_frame_no); + state.pad(self, mut_list, erase_display_frame_no); drop(state); @@ -993,7 +929,7 @@ impl TtToCea608 { drop(state); } - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::FlushStop(_) => { let mut state = self.state.lock().unwrap(); @@ -1010,9 +946,9 @@ impl TtToCea608 { drop(settings); drop(state); - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } } @@ -1030,14 +966,14 @@ impl ObjectSubclass for TtToCea608 { TtToCea608::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |this, element| this.sink_chain(pad, element, buffer), + |this| this.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { TtToCea608::catch_panic_pad_function( parent, || false, - |this, element| this.sink_event(pad, element, event), + |this| this.sink_event(pad, event), ) }) .flags(gst::PadFlags::FIXED_CAPS) @@ -1093,20 +1029,15 @@ impl ObjectImpl for TtToCea608 { PROPERTIES.as_ref() } - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } - 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) { match pspec.name() { "mode" => { let mut state = self.state.lock().unwrap(); @@ -1141,7 +1072,7 @@ impl ObjectImpl for TtToCea608 { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "mode" => { let settings = self.settings.lock().unwrap(); @@ -1235,10 +1166,9 @@ impl ElementImpl for TtToCea608 { #[allow(clippy::single_match)] fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused => { @@ -1255,7 +1185,7 @@ impl ElementImpl for TtToCea608 { _ => (), } - let ret = self.parent_change_state(element, transition)?; + let ret = self.parent_change_state(transition)?; match transition { gst::StateChange::PausedToReady => { diff --git a/video/closedcaption/src/tttojson/imp.rs b/video/closedcaption/src/tttojson/imp.rs index 4efc494fa..030efe631 100644 --- a/video/closedcaption/src/tttojson/imp.rs +++ b/video/closedcaption/src/tttojson/imp.rs @@ -48,15 +48,14 @@ impl TtToJson { fn sink_chain( &self, _pad: &gst::Pad, - element: &super::TtToJson, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { let pts = buffer.pts(); let duration = buffer.duration(); let buffer = buffer.into_mapped_buffer_readable().map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::ResourceError::Read, ["Failed to map buffer readable"] ); @@ -65,8 +64,8 @@ impl TtToJson { })?; let text = std::str::from_utf8(buffer.as_slice()).map_err(|err| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::ResourceError::Read, ["Failed to map decode as utf8: {}", err] ); @@ -101,8 +100,8 @@ impl TtToJson { } let json = serde_json::to_string(&lines).map_err(|err| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::ResourceError::Write, ["Failed to serialize as json {}", err] ); @@ -120,7 +119,7 @@ impl TtToJson { self.srcpad.push(buf) } - fn sink_event(&self, pad: &gst::Pad, element: &super::TtToJson, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -133,8 +132,8 @@ impl TtToJson { .build(); self.srcpad.push_event(gst::event::Caps::new(&caps)) } - EventView::Eos(_) => pad.event_default(Some(element), event), - _ => pad.event_default(Some(element), event), + EventView::Eos(_) => pad.event_default(Some(&*self.instance()), event), + _ => pad.event_default(Some(&*self.instance()), event), } } } @@ -197,14 +196,14 @@ impl ObjectSubclass for TtToJson { TtToJson::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |enc, element| enc.sink_chain(pad, element, buffer), + |enc| enc.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { TtToJson::catch_panic_pad_function( parent, || false, - |enc, element| enc.sink_event(pad, element, event), + |enc| enc.sink_event(pad, event), ) }) .build(); @@ -235,20 +234,15 @@ impl ObjectImpl for TtToJson { PROPERTIES.as_ref() } - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } - 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) { match pspec.name() { "mode" => { let mut settings = self.settings.lock().unwrap(); @@ -258,7 +252,7 @@ impl ObjectImpl for TtToJson { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "mode" => { let settings = self.settings.lock().unwrap(); diff --git a/video/dav1d/src/dav1ddec/imp.rs b/video/dav1d/src/dav1ddec/imp.rs index 02eb10fd9..211158687 100644 --- a/video/dav1d/src/dav1ddec/imp.rs +++ b/video/dav1d/src/dav1ddec/imp.rs @@ -71,11 +71,7 @@ impl Dav1dDec { } } - fn gst_video_format_from_dav1d_picture( - &self, - element: &super::Dav1dDec, - pic: &dav1d::Picture, - ) -> gst_video::VideoFormat { + fn gst_video_format_from_dav1d_picture(&self, pic: &dav1d::Picture) -> gst_video::VideoFormat { let bpc = pic.bits_per_component(); let format_desc = match (pic.pixel_layout(), bpc) { (dav1d::PixelLayout::I400, Some(dav1d::BitsPerComponent(8))) => "GRAY8", @@ -91,7 +87,7 @@ impl Dav1dDec { (layout, bpc) => { gst::warning!( CAT, - obj: element, + imp: self, "Unsupported dav1d format {:?}/{:?}", layout, bpc @@ -119,20 +115,19 @@ impl Dav1dDec { } }; f.parse::<gst_video::VideoFormat>().unwrap_or_else(|_| { - gst::warning!(CAT, obj: element, "Unsupported dav1d format: {}", f); + gst::warning!(CAT, imp: self, "Unsupported dav1d format: {}", f); gst_video::VideoFormat::Unknown }) } fn handle_resolution_change<'s>( &'s self, - element: &super::Dav1dDec, mut state_guard: MutexGuard<'s, Option<State>>, pic: &dav1d::Picture, ) -> Result<MutexGuard<'s, Option<State>>, gst::FlowError> { let state = state_guard.as_ref().unwrap(); - let format = self.gst_video_format_from_dav1d_picture(element, pic); + let format = self.gst_video_format_from_dav1d_picture(pic); if format == gst_video::VideoFormat::Unknown { return Err(gst::FlowError::NotNegotiated); } @@ -152,7 +147,7 @@ impl Dav1dDec { gst::info!( CAT, - obj: element, + imp: self, "Negotiating format {:?} picture dimensions {}x{}", format, pic.width(), @@ -162,10 +157,11 @@ impl Dav1dDec { let input_state = state.input_state.clone(); drop(state_guard); + let instance = self.instance(); let output_state = - element.set_output_state(format, pic.width(), pic.height(), Some(&input_state))?; - element.negotiate(output_state)?; - let out_state = element.output_state().unwrap(); + instance.set_output_state(format, pic.width(), pic.height(), Some(&input_state))?; + instance.negotiate(output_state)?; + let out_state = instance.output_state().unwrap(); state_guard = self.state.lock().unwrap(); let state = state_guard.as_mut().unwrap(); @@ -174,22 +170,21 @@ impl Dav1dDec { Ok(state_guard) } - fn flush_decoder(&self, element: &super::Dav1dDec, state: &mut State) { - gst::info!(CAT, obj: element, "Flushing decoder"); + fn flush_decoder(&self, state: &mut State) { + gst::info!(CAT, imp: self, "Flushing decoder"); state.decoder.flush(); } fn send_data( &self, - element: &super::Dav1dDec, state_guard: &mut MutexGuard<Option<State>>, input_buffer: gst::Buffer, frame: gst_video::VideoCodecFrame, ) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> { gst::trace!( CAT, - obj: element, + imp: self, "Sending data to decoder for frame {}", frame.system_frame_number() ); @@ -210,18 +205,18 @@ impl Dav1dDec { .send_data(input_data, frame_number, timestamp, duration) { Ok(()) => { - gst::trace!(CAT, obj: element, "Decoder returned OK"); + gst::trace!(CAT, imp: self, "Decoder returned OK"); Ok(std::ops::ControlFlow::Break(())) } Err(err) if err.is_again() => { - gst::trace!(CAT, obj: element, "Decoder returned EAGAIN"); + gst::trace!(CAT, imp: self, "Decoder returned EAGAIN"); Ok(std::ops::ControlFlow::Continue(())) } Err(err) => { gst::error!(CAT, "Sending data failed (error code: {})", err); - element.release_frame(frame); + self.instance().release_frame(frame); gst_video::video_decoder_error!( - element, + &*self.instance(), 1, gst::StreamError::Decode, ["Sending data failed (error code {})", err] @@ -233,26 +228,25 @@ impl Dav1dDec { fn send_pending_data( &self, - element: &super::Dav1dDec, state_guard: &mut MutexGuard<Option<State>>, ) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> { - gst::trace!(CAT, obj: element, "Sending pending data to decoder"); + gst::trace!(CAT, imp: self, "Sending pending data to decoder"); let state = state_guard.as_mut().unwrap(); match state.decoder.send_pending_data() { Ok(()) => { - gst::trace!(CAT, obj: element, "Decoder returned OK"); + gst::trace!(CAT, imp: self, "Decoder returned OK"); Ok(std::ops::ControlFlow::Break(())) } Err(err) if err.is_again() => { - gst::trace!(CAT, obj: element, "Decoder returned EAGAIN"); + gst::trace!(CAT, imp: self, "Decoder returned EAGAIN"); Ok(std::ops::ControlFlow::Continue(())) } Err(err) => { gst::error!(CAT, "Sending data failed (error code: {})", err); gst_video::video_decoder_error!( - element, + &*self.instance(), 1, gst::StreamError::Decode, ["Sending data failed (error code {})", err] @@ -264,7 +258,6 @@ impl Dav1dDec { fn decoded_picture_as_buffer( &self, - element: &super::Dav1dDec, state_guard: &mut MutexGuard<Option<State>>, pic: &dav1d::Picture, output_state: gst_video::VideoCodecState<gst_video::video_codec_state::Readable>, @@ -304,7 +297,7 @@ impl Dav1dDec { } else { gst::trace!( gst::CAT_PERFORMANCE, - obj: element, + imp: self, "Copying decoded video frame component {:?}", component ); @@ -359,71 +352,67 @@ impl Dav1dDec { fn handle_picture<'s>( &'s self, - element: &super::Dav1dDec, mut state_guard: MutexGuard<'s, Option<State>>, pic: &dav1d::Picture, ) -> Result<MutexGuard<'s, Option<State>>, gst::FlowError> { - gst::trace!(CAT, obj: element, "Handling picture {}", pic.offset()); + gst::trace!(CAT, imp: self, "Handling picture {}", pic.offset()); - state_guard = self.handle_resolution_change(element, state_guard, pic)?; + state_guard = self.handle_resolution_change(state_guard, pic)?; - let output_state = element + let instance = self.instance(); + let output_state = instance .output_state() .expect("Output state not set. Shouldn't happen!"); let offset = pic.offset() as i32; - if let Some(mut frame) = element.frame(offset) { + let frame = instance.frame(offset); + if let Some(mut frame) = frame { let output_buffer = - self.decoded_picture_as_buffer(element, &mut state_guard, pic, output_state)?; + self.decoded_picture_as_buffer(&mut state_guard, pic, output_state)?; frame.set_output_buffer(output_buffer); drop(state_guard); - element.finish_frame(frame)?; + instance.finish_frame(frame)?; Ok(self.state.lock().unwrap()) } else { - gst::warning!(CAT, obj: element, "No frame found for offset {}", offset); + gst::warning!(CAT, imp: self, "No frame found for offset {}", offset); Ok(state_guard) } } - fn drop_decoded_pictures( - &self, - element: &super::Dav1dDec, - state_guard: &mut MutexGuard<Option<State>>, - ) { - while let Ok(Some(pic)) = self.pending_pictures(element, state_guard) { - gst::debug!(CAT, obj: element, "Dropping picture {}", pic.offset()); + fn drop_decoded_pictures(&self, state_guard: &mut MutexGuard<Option<State>>) { + while let Ok(Some(pic)) = self.pending_pictures(state_guard) { + gst::debug!(CAT, imp: self, "Dropping picture {}", pic.offset()); drop(pic); } } fn pending_pictures( &self, - element: &super::Dav1dDec, state_guard: &mut MutexGuard<Option<State>>, ) -> Result<Option<dav1d::Picture>, gst::FlowError> { - gst::trace!(CAT, obj: element, "Retrieving pending picture"); + gst::trace!(CAT, imp: self, "Retrieving pending picture"); let state = state_guard.as_mut().unwrap(); match state.decoder.get_picture() { Ok(pic) => { - gst::trace!(CAT, obj: element, "Retrieved picture {}", pic.offset()); + gst::trace!(CAT, imp: self, "Retrieved picture {}", pic.offset()); Ok(Some(pic)) } Err(err) if err.is_again() => { - gst::trace!(CAT, obj: element, "Decoder needs more data"); + gst::trace!(CAT, imp: self, "Decoder needs more data"); Ok(None) } Err(err) => { gst::error!( CAT, - obj: element, + imp: self, "Retrieving decoded picture failed (error code {})", err ); gst_video::video_decoder_error!( - element, + &*self.instance(), 1, gst::StreamError::Decode, ["Retrieving decoded picture failed (error code {})", err] @@ -435,11 +424,10 @@ impl Dav1dDec { fn forward_pending_pictures<'s>( &'s self, - element: &super::Dav1dDec, mut state_guard: MutexGuard<'s, Option<State>>, ) -> Result<MutexGuard<Option<State>>, gst::FlowError> { - while let Some(pic) = self.pending_pictures(element, &mut state_guard)? { - state_guard = self.handle_picture(element, state_guard, &pic)?; + while let Some(pic) = self.pending_pictures(&mut state_guard)? { + state_guard = self.handle_picture(state_guard, &pic)?; } Ok(state_guard) @@ -516,13 +504,7 @@ impl ObjectImpl for Dav1dDec { PROPERTIES.as_ref() } - 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() { @@ -536,7 +518,7 @@ impl ObjectImpl for Dav1dDec { } } - 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() { @@ -600,7 +582,7 @@ impl ElementImpl for Dav1dDec { } impl VideoDecoderImpl for Dav1dDec { - fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { + fn src_query(&self, query: &mut gst::QueryRef) -> bool { match query.view_mut() { gst::QueryViewMut::Latency(q) => { let state_guard = self.state.lock().unwrap(); @@ -613,9 +595,8 @@ impl VideoDecoderImpl for Dav1dDec { Some(ref state) => match state.output_info { Some(ref info) => { let mut upstream_latency = gst::query::Latency::new(); - let sinkpad = element.sink_pad(); - if sinkpad.peer_query(&mut upstream_latency) { + if self.instance().sink_pad().peer_query(&mut upstream_latency) { let (live, mut min, mut max) = upstream_latency.result(); // For autodetection: 1 if live, else whatever dav1d gives us let frame_latency: u64 = if max_frame_delay < 0 && live { @@ -638,7 +619,7 @@ impl VideoDecoderImpl for Dav1dDec { * gst::ClockTime::SECOND / (fps_n as u64); - gst::debug!(CAT, obj: element, "Reporting latency of {}", latency); + gst::debug!(CAT, imp: self, "Reporting latency of {}", latency); min += latency; max = max.opt_add(latency); @@ -657,22 +638,21 @@ impl VideoDecoderImpl for Dav1dDec { None => false, } } - _ => VideoDecoderImplExt::parent_src_query(self, element, query), + _ => VideoDecoderImplExt::parent_src_query(self, query), } } - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { { let mut state_guard = self.state.lock().unwrap(); *state_guard = None; } - self.parent_stop(element) + self.parent_stop() } fn set_format( &self, - element: &Self::Type, input_state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>, ) -> Result<(), gst::LoggableError> { let mut state_guard = self.state.lock().unwrap(); @@ -681,14 +661,13 @@ impl VideoDecoderImpl for Dav1dDec { let max_frame_delay: u32; let n_cpus = num_cpus::get(); - gst::info!(CAT, obj: element, "Detected {} logical CPUs", n_cpus); + gst::info!(CAT, imp: self, "Detected {} logical CPUs", n_cpus); if settings.max_frame_delay == -1 { let mut latency_query = gst::query::Latency::new(); let mut is_live = false; - let sinkpad = element.sink_pad(); - if sinkpad.peer_query(&mut latency_query) { + if self.instance().sink_pad().peer_query(&mut latency_query) { is_live = latency_query.result().0; } @@ -699,7 +678,7 @@ impl VideoDecoderImpl for Dav1dDec { gst::info!( CAT, - obj: element, + imp: self, "Creating decoder with n-threads={} and max-frame-delay={}", settings.n_threads, max_frame_delay @@ -719,12 +698,11 @@ impl VideoDecoderImpl for Dav1dDec { n_cpus, }); - self.parent_set_format(element, input_state) + self.parent_set_format(input_state) } fn handle_frame( &self, - element: &Self::Type, frame: gst_video::VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError> { let input_buffer = frame @@ -733,73 +711,71 @@ impl VideoDecoderImpl for Dav1dDec { { let mut state_guard = self.state.lock().unwrap(); - state_guard = self.forward_pending_pictures(element, state_guard)?; - if self.send_data(element, &mut state_guard, input_buffer, frame)? + state_guard = self.forward_pending_pictures(state_guard)?; + if self.send_data(&mut state_guard, input_buffer, frame)? == std::ops::ControlFlow::Continue(()) { loop { - state_guard = self.forward_pending_pictures(element, state_guard)?; - if self.send_pending_data(element, &mut state_guard)? - == std::ops::ControlFlow::Break(()) + state_guard = self.forward_pending_pictures(state_guard)?; + if self.send_pending_data(&mut state_guard)? == std::ops::ControlFlow::Break(()) { break; } } } - let _state_guard = self.forward_pending_pictures(element, state_guard)?; + let _state_guard = self.forward_pending_pictures(state_guard)?; } Ok(gst::FlowSuccess::Ok) } - fn flush(&self, element: &Self::Type) -> bool { - gst::info!(CAT, obj: element, "Flushing"); + fn flush(&self) -> bool { + gst::info!(CAT, imp: self, "Flushing"); { let mut state_guard = self.state.lock().unwrap(); if state_guard.is_some() { let state = state_guard.as_mut().unwrap(); - self.flush_decoder(element, state); - self.drop_decoded_pictures(element, &mut state_guard); + self.flush_decoder(state); + self.drop_decoded_pictures(&mut state_guard); } } true } - fn drain(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> { - gst::info!(CAT, obj: element, "Draining"); + fn drain(&self) -> Result<gst::FlowSuccess, gst::FlowError> { + gst::info!(CAT, imp: self, "Draining"); { let mut state_guard = self.state.lock().unwrap(); if state_guard.is_some() { let state = state_guard.as_mut().unwrap(); - self.flush_decoder(element, state); - let _state_guard = self.forward_pending_pictures(element, state_guard)?; + self.flush_decoder(state); + let _state_guard = self.forward_pending_pictures(state_guard)?; } } - self.parent_drain(element) + self.parent_drain() } - fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> { - gst::info!(CAT, obj: element, "Finishing"); + fn finish(&self) -> Result<gst::FlowSuccess, gst::FlowError> { + gst::info!(CAT, imp: self, "Finishing"); { let mut state_guard = self.state.lock().unwrap(); if state_guard.is_some() { let state = state_guard.as_mut().unwrap(); - self.flush_decoder(element, state); - let _state_guard = self.forward_pending_pictures(element, state_guard)?; + self.flush_decoder(state); + let _state_guard = self.forward_pending_pictures(state_guard)?; } } - self.parent_finish(element) + self.parent_finish() } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { { @@ -810,6 +786,6 @@ impl VideoDecoderImpl for Dav1dDec { .is_some(); } - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } } diff --git a/video/ffv1/src/ffv1dec/imp.rs b/video/ffv1/src/ffv1dec/imp.rs index 6d6372fe0..6fcfd6b4f 100644 --- a/video/ffv1/src/ffv1dec/imp.rs +++ b/video/ffv1/src/ffv1dec/imp.rs @@ -358,7 +358,6 @@ impl VideoDecoderImpl for Ffv1Dec { /* We allocate the decoder here rather than start() because we need the sink caps */ fn set_format( &self, - element: &super::Ffv1Dec, state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>, ) -> Result<(), gst::LoggableError> { let info = state.info(); @@ -372,7 +371,8 @@ impl VideoDecoderImpl for Ffv1Dec { let format = get_output_format(decoder.config_record()) .ok_or_else(|| gst::loggable_error!(CAT, "Unsupported format"))?; - let output_state = element + let instance = self.instance(); + let output_state = instance .set_output_state(format, info.width(), info.height(), Some(state)) .map_err(|err| gst::loggable_error!(CAT, "Failed to set output params: {}", err))?; @@ -386,23 +386,22 @@ impl VideoDecoderImpl for Ffv1Dec { }; drop(decoder_state); - element + instance .negotiate(output_state) .map_err(|err| gst::loggable_error!(CAT, "Negotiation failed: {}", err))?; - self.parent_set_format(element, state) + self.parent_set_format(state) } - fn stop(&self, element: &super::Ffv1Dec) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { let mut decoder_state = self.state.lock().unwrap(); *decoder_state = DecoderState::Stopped; - self.parent_stop(element) + self.parent_stop() } fn handle_frame( &self, - element: &super::Ffv1Dec, mut frame: gst_video::VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError> { let mut state = self.state.lock().unwrap(); @@ -438,14 +437,13 @@ impl VideoDecoderImpl for Ffv1Dec { drop(state); frame.set_output_buffer(buf); - element.finish_frame(frame)?; + self.instance().finish_frame(frame)?; Ok(gst::FlowSuccess::Ok) } fn decide_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { let supported = query @@ -461,6 +459,6 @@ impl VideoDecoderImpl for Ffv1Dec { *video_meta_supported = supported; } - self.parent_decide_allocation(element, query) + self.parent_decide_allocation(query) } } diff --git a/video/flavors/src/flvdemux/imp.rs b/video/flavors/src/flvdemux/imp.rs index b2a42a83d..80c683d14 100644 --- a/video/flavors/src/flvdemux/imp.rs +++ b/video/flavors/src/flvdemux/imp.rs @@ -134,7 +134,7 @@ impl ObjectSubclass for FlvDemux { FlvDemux::catch_panic_pad_function( parent, || Err(gst::loggable_error!(CAT, "Panic activating sink pad")), - |demux, element| demux.sink_activate(pad, element), + |demux| demux.sink_activate(pad), ) }) .activatemode_function(|pad, parent, mode, active| { @@ -146,8 +146,8 @@ impl ObjectSubclass for FlvDemux { "Panic activating sink pad with mode" )) }, - |demux, element| { - demux.sink_activatemode(pad, element, mode, active); + |demux| { + demux.sink_activatemode(pad, mode, active); Ok(()) }, ) @@ -156,14 +156,14 @@ impl ObjectSubclass for FlvDemux { FlvDemux::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |demux, element| demux.sink_chain(pad, element, buffer), + |demux| demux.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { FlvDemux::catch_panic_pad_function( parent, || false, - |demux, element| demux.sink_event(pad, element, event), + |demux| demux.sink_event(pad, event), ) }) .build(); @@ -180,10 +180,10 @@ impl ObjectSubclass for FlvDemux { } impl ObjectImpl for FlvDemux { - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); - obj.add_pad(&self.sinkpad).unwrap(); + self.instance().add_pad(&self.sinkpad).unwrap(); } } @@ -298,11 +298,7 @@ impl ElementImpl for FlvDemux { } impl FlvDemux { - fn sink_activate( - &self, - pad: &gst::Pad, - _element: &super::FlvDemux, - ) -> Result<(), gst::LoggableError> { + fn sink_activate(&self, pad: &gst::Pad) -> Result<(), gst::LoggableError> { let mode = { let mut query = gst::query::Scheduling::new(); if !pad.peer_query(&mut query) { @@ -327,15 +323,9 @@ impl FlvDemux { Ok(()) } - fn sink_activatemode( - &self, - _pad: &gst::Pad, - element: &super::FlvDemux, - mode: gst::PadMode, - active: bool, - ) { + fn sink_activatemode(&self, _pad: &gst::Pad, mode: gst::PadMode, active: bool) { if active { - self.start(element, mode); + self.start(mode); if mode == gst::PadMode::Pull { // TODO implement pull mode @@ -347,63 +337,58 @@ impl FlvDemux { let _ = self.sinkpad.stop_task(); } - self.stop(element); + self.stop(); } } - fn start(&self, _element: &super::FlvDemux, _mode: gst::PadMode) { + fn start(&self, _mode: gst::PadMode) { *self.state.lock().unwrap() = State::NeedHeader; } - fn stop(&self, element: &super::FlvDemux) { + fn stop(&self) { *self.state.lock().unwrap() = State::Stopped; self.adapter.lock().unwrap().clear(); let mut flow_combiner = self.flow_combiner.lock().unwrap(); if let Some(pad) = self.audio_srcpad.lock().unwrap().take() { - element.remove_pad(&pad).unwrap(); + self.instance().remove_pad(&pad).unwrap(); flow_combiner.remove_pad(&pad); } if let Some(pad) = self.video_srcpad.lock().unwrap().take() { - element.remove_pad(&pad).unwrap(); + self.instance().remove_pad(&pad).unwrap(); flow_combiner.remove_pad(&pad); } flow_combiner.reset(); } - fn sink_event(&self, pad: &gst::Pad, element: &super::FlvDemux, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); match event.view() { EventView::Eos(..) => { // TODO implement - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::Segment(..) => { // TODO implement - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::FlushStart(..) => { // TODO implement - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::FlushStop(..) => { // TODO implement - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn src_query( - &self, - pad: &gst::Pad, - element: &super::FlvDemux, - query: &mut gst::QueryRef, - ) -> bool { + fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool { use gst::QueryViewMut; match query.view_mut() { @@ -447,11 +432,11 @@ impl FlvDemux { false } } - _ => pad.query_default(Some(element), query), + _ => pad.query_default(Some(&*self.instance()), query), } } - fn src_event(&self, pad: &gst::Pad, element: &super::FlvDemux, event: gst::Event) -> bool { + fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; match event.view() { @@ -459,14 +444,13 @@ impl FlvDemux { // TODO: Implement false } - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } fn sink_chain( &self, pad: &gst::Pad, - element: &super::FlvDemux, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); @@ -479,10 +463,10 @@ impl FlvDemux { match *state { State::Stopped => unreachable!(), State::NeedHeader => { - let header = match self.find_header(element, &mut *adapter) { + let header = match self.find_header(&mut *adapter) { Ok(header) => header, Err(_) => { - gst::trace!(CAT, obj: element, "Need more data"); + gst::trace!(CAT, imp: self, "Need more data"); return Ok(gst::FlowSuccess::Ok); } }; @@ -511,7 +495,7 @@ impl FlvDemux { } => { let avail = adapter.available(); if avail == 0 { - gst::trace!(CAT, obj: element, "Need more data"); + gst::trace!(CAT, imp: self, "Need more data"); return Ok(gst::FlowSuccess::Ok); } let skip = cmp::min(avail, *skip_left as usize); @@ -519,24 +503,24 @@ impl FlvDemux { *skip_left -= skip as u32; } State::Streaming(ref mut sstate) => { - let res = sstate.handle_tag(element, &mut *adapter); + let res = sstate.handle_tag(self, &mut *adapter); match res { Ok(None) => { - gst::trace!(CAT, obj: element, "Need more data"); + gst::trace!(CAT, imp: self, "Need more data"); return Ok(gst::FlowSuccess::Ok); } Ok(Some(events)) => { drop(state); drop(adapter); - self.handle_events(element, events)?; + self.handle_events(events)?; adapter = self.adapter.lock().unwrap(); state = self.state.lock().unwrap(); } Err(err) => { - element.post_error_message(err); + self.post_error_message(err); return Err(gst::FlowError::Error); } } @@ -545,16 +529,12 @@ impl FlvDemux { } } - fn find_header( - &self, - element: &super::FlvDemux, - adapter: &mut gst_base::UniqueAdapter, - ) -> Result<flavors::Header, ()> { + fn find_header(&self, adapter: &mut gst_base::UniqueAdapter) -> Result<flavors::Header, ()> { while adapter.available() >= 9 { let data = adapter.map(9).unwrap(); if let Ok((_, header)) = flavors::header(&*data) { - gst::debug!(CAT, obj: element, "Found FLV header: {:?}", header); + gst::debug!(CAT, imp: self, "Found FLV header: {:?}", header); drop(data); adapter.flush(9); @@ -570,7 +550,6 @@ impl FlvDemux { fn handle_events( &self, - element: &super::FlvDemux, events: SmallVec<[Event; 4]>, ) -> Result<gst::FlowSuccess, gst::FlowError> { for event in events { @@ -582,7 +561,7 @@ impl FlvDemux { if let Some(ref srcpad) = *audio_srcpad { srcpad.clone() } else { - let srcpad = self.create_srcpad(element, "audio", &caps); + let srcpad = self.create_srcpad("audio", &caps); *audio_srcpad = Some(srcpad.clone()); srcpad @@ -593,7 +572,7 @@ impl FlvDemux { if let Some(ref srcpad) = *video_srcpad { srcpad.clone() } else { - let srcpad = self.create_srcpad(element, "video", &caps); + let srcpad = self.create_srcpad("video", &caps); *video_srcpad = Some(srcpad.clone()); @@ -618,7 +597,7 @@ impl FlvDemux { let res = pad.push(buffer); gst::trace!( CAT, - obj: element, + imp: self, "Pushing buffer for stream {:?} returned {:?}", stream, res @@ -631,7 +610,7 @@ impl FlvDemux { } } Event::HaveAllStreams => { - element.no_more_pads(); + self.instance().no_more_pads(); } } } @@ -639,28 +618,28 @@ impl FlvDemux { Ok(gst::FlowSuccess::Ok) } - fn create_srcpad(&self, element: &super::FlvDemux, name: &str, caps: &gst::Caps) -> gst::Pad { - let templ = element.element_class().pad_template(name).unwrap(); + fn create_srcpad(&self, name: &str, caps: &gst::Caps) -> gst::Pad { + let templ = self.instance().element_class().pad_template(name).unwrap(); let srcpad = gst::Pad::builder_with_template(&templ, Some(name)) .event_function(|pad, parent, event| { FlvDemux::catch_panic_pad_function( parent, || false, - |demux, element| demux.src_event(pad, element, event), + |demux| demux.src_event(pad, event), ) }) .query_function(|pad, parent, query| { FlvDemux::catch_panic_pad_function( parent, || false, - |demux, element| demux.src_query(pad, element, query), + |demux| demux.src_query(pad, query), ) }) .build(); srcpad.set_active(true).unwrap(); - let full_stream_id = srcpad.create_stream_id(element, Some(name)); + let full_stream_id = srcpad.create_stream_id(&*self.instance(), Some(name)); // FIXME group id srcpad.push_event(gst::event::StreamStart::new(&full_stream_id)); srcpad.push_event(gst::event::Caps::new(caps)); @@ -671,7 +650,7 @@ impl FlvDemux { self.flow_combiner.lock().unwrap().add_pad(&srcpad); - element.add_pad(&srcpad).unwrap(); + self.instance().add_pad(&srcpad).unwrap(); srcpad } @@ -694,7 +673,7 @@ impl StreamingState { fn handle_tag( &mut self, - element: &super::FlvDemux, + imp: &FlvDemux, adapter: &mut gst_base::UniqueAdapter, ) -> Result<Option<SmallVec<[Event; 4]>>, gst::ErrorMessage> { use nom::number::complete::be_u32; @@ -708,7 +687,7 @@ impl StreamingState { match be_u32::<_, (_, nom::error::ErrorKind)>(&data[0..4]) { Err(_) => unreachable!(), Ok((_, previous_size)) => { - gst::trace!(CAT, obj: element, "Previous tag size {}", previous_size); + gst::trace!(CAT, imp: imp, "Previous tag size {}", previous_size); // Nothing to do here, we just consume it for now } } @@ -724,7 +703,7 @@ impl StreamingState { Ok((_, tag_header)) => tag_header, }; - gst::trace!(CAT, obj: element, "Parsed tag header {:?}", tag_header); + gst::trace!(CAT, imp: imp, "Parsed tag header {:?}", tag_header); drop(data); @@ -736,19 +715,19 @@ impl StreamingState { match tag_header.tag_type { flavors::TagType::Script => { - gst::trace!(CAT, obj: element, "Found script tag"); + gst::trace!(CAT, imp: imp, "Found script tag"); - Ok(self.handle_script_tag(element, &tag_header, adapter)) + Ok(self.handle_script_tag(imp, &tag_header, adapter)) } flavors::TagType::Audio => { - gst::trace!(CAT, obj: element, "Found audio tag"); + gst::trace!(CAT, imp: imp, "Found audio tag"); - self.handle_audio_tag(element, &tag_header, adapter) + self.handle_audio_tag(imp, &tag_header, adapter) } flavors::TagType::Video => { - gst::trace!(CAT, obj: element, "Found video tag"); + gst::trace!(CAT, imp: imp, "Found video tag"); - self.handle_video_tag(element, &tag_header, adapter) + self.handle_video_tag(imp, &tag_header, adapter) } } .map(Option::Some) @@ -756,7 +735,7 @@ impl StreamingState { fn handle_script_tag( &mut self, - element: &super::FlvDemux, + imp: &FlvDemux, tag_header: &flavors::TagHeader, adapter: &mut gst_base::UniqueAdapter, ) -> SmallVec<[Event; 4]> { @@ -768,10 +747,10 @@ impl StreamingState { match flavors::script_data(&*data) { Ok((_, ref script_data)) if script_data.name == "onMetaData" => { - gst::trace!(CAT, obj: element, "Got script tag: {:?}", script_data); + gst::trace!(CAT, imp: imp, "Got script tag: {:?}", script_data); let metadata = Metadata::new(script_data); - gst::debug!(CAT, obj: element, "Got metadata: {:?}", metadata); + gst::debug!(CAT, imp: imp, "Got metadata: {:?}", metadata); let audio_changed = self .audio @@ -799,10 +778,10 @@ impl StreamingState { } } Ok((_, ref script_data)) => { - gst::trace!(CAT, obj: element, "Got script tag: {:?}", script_data); + gst::trace!(CAT, imp: imp, "Got script tag: {:?}", script_data); } Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { - gst::error!(CAT, obj: element, "Error parsing script tag: {:?}", err); + gst::error!(CAT, imp: imp, "Error parsing script tag: {:?}", err); } Err(nom::Err::Incomplete(_)) => { // ignore @@ -817,17 +796,12 @@ impl StreamingState { fn update_audio_stream( &mut self, - element: &super::FlvDemux, + imp: &FlvDemux, data_header: &flavors::AudioDataHeader, ) -> SmallVec<[Event; 4]> { let mut events = SmallVec::new(); - gst::trace!( - CAT, - obj: element, - "Got audio data header: {:?}", - data_header - ); + gst::trace!(CAT, imp: imp, "Got audio data header: {:?}", data_header); let new_audio_format = AudioFormat::new(data_header, &self.metadata, &self.aac_sequence_header); @@ -835,7 +809,7 @@ impl StreamingState { if self.audio.as_ref() != Some(&new_audio_format) { gst::debug!( CAT, - obj: element, + imp: imp, "Got new audio format: {:?}", new_audio_format ); @@ -851,7 +825,7 @@ impl StreamingState { if (!self.expect_video || self.video != None) && self.audio != None && !self.got_all_streams { - gst::debug!(CAT, obj: element, "Have all expected streams now"); + gst::debug!(CAT, imp: imp, "Have all expected streams now"); self.got_all_streams = true; events.push(Event::HaveAllStreams); } @@ -861,7 +835,7 @@ impl StreamingState { fn handle_aac_audio_packet_header( &mut self, - element: &super::FlvDemux, + imp: &FlvDemux, tag_header: &flavors::TagHeader, adapter: &mut gst_base::UniqueAdapter, ) -> Result<bool, gst::ErrorMessage> { @@ -870,7 +844,7 @@ impl StreamingState { adapter.flush((tag_header.data_size - 1) as usize); gst::warning!( CAT, - obj: element, + imp: imp, "Too small packet for AAC packet header {}", tag_header.data_size ); @@ -881,19 +855,14 @@ impl StreamingState { match flavors::aac_audio_packet_header(&*data) { Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { - gst::error!( - CAT, - obj: element, - "Invalid AAC audio packet header: {:?}", - err - ); + gst::error!(CAT, imp: imp, "Invalid AAC audio packet header: {:?}", err); drop(data); adapter.flush((tag_header.data_size - 1) as usize); Ok(true) } Err(nom::Err::Incomplete(_)) => unreachable!(), Ok((_, header)) => { - gst::trace!(CAT, obj: element, "Got AAC packet header {:?}", header); + gst::trace!(CAT, imp: imp, "Got AAC packet header {:?}", header); match header.packet_type { flavors::AACPacketType::SequenceHeader => { drop(data); @@ -901,7 +870,7 @@ impl StreamingState { let buffer = adapter .take_buffer((tag_header.data_size - 1 - 1) as usize) .unwrap(); - gst::debug!(CAT, obj: element, "Got AAC sequence header {:?}", buffer,); + gst::debug!(CAT, imp: imp, "Got AAC sequence header {:?}", buffer,); self.aac_sequence_header = Some(buffer); Ok(true) @@ -918,7 +887,7 @@ impl StreamingState { fn handle_audio_tag( &mut self, - element: &super::FlvDemux, + imp: &FlvDemux, tag_header: &flavors::TagHeader, adapter: &mut gst_base::UniqueAdapter, ) -> Result<SmallVec<[Event; 4]>, gst::ErrorMessage> { @@ -927,7 +896,7 @@ impl StreamingState { let data = adapter.map(1).unwrap(); let data_header = match flavors::audio_data_header(&*data) { Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { - gst::error!(CAT, obj: element, "Invalid audio data header: {:?}", err); + gst::error!(CAT, imp: imp, "Invalid audio data header: {:?}", err); drop(data); adapter.flush(tag_header.data_size as usize); return Ok(SmallVec::new()); @@ -938,11 +907,11 @@ impl StreamingState { drop(data); adapter.flush(1); - let mut events = self.update_audio_stream(element, &data_header); + let mut events = self.update_audio_stream(imp, &data_header); // AAC special case if data_header.sound_format == flavors::SoundFormat::AAC - && self.handle_aac_audio_packet_header(element, tag_header, adapter)? + && self.handle_aac_audio_packet_header(imp, tag_header, adapter)? { return Ok(events); } @@ -972,7 +941,7 @@ impl StreamingState { gst::trace!( CAT, - obj: element, + imp: imp, "Outputting audio buffer {:?} for tag {:?}", buffer, tag_header, @@ -987,17 +956,12 @@ impl StreamingState { fn update_video_stream( &mut self, - element: &super::FlvDemux, + imp: &FlvDemux, data_header: &flavors::VideoDataHeader, ) -> SmallVec<[Event; 4]> { let mut events = SmallVec::new(); - gst::trace!( - CAT, - obj: element, - "Got video data header: {:?}", - data_header - ); + gst::trace!(CAT, imp: imp, "Got video data header: {:?}", data_header); let new_video_format = VideoFormat::new(data_header, &self.metadata, &self.avc_sequence_header); @@ -1005,7 +969,7 @@ impl StreamingState { if self.video.as_ref() != Some(&new_video_format) { gst::debug!( CAT, - obj: element, + imp: imp, "Got new video format: {:?}", new_video_format ); @@ -1021,7 +985,7 @@ impl StreamingState { if (!self.expect_audio || self.audio != None) && self.video != None && !self.got_all_streams { - gst::debug!(CAT, obj: element, "Have all expected streams now"); + gst::debug!(CAT, imp: imp, "Have all expected streams now"); self.got_all_streams = true; events.push(Event::HaveAllStreams); } @@ -1031,7 +995,7 @@ impl StreamingState { fn handle_avc_video_packet_header( &mut self, - element: &super::FlvDemux, + imp: &FlvDemux, tag_header: &flavors::TagHeader, adapter: &mut gst_base::UniqueAdapter, ) -> Result<Option<i32>, gst::ErrorMessage> { @@ -1040,7 +1004,7 @@ impl StreamingState { adapter.flush((tag_header.data_size - 1) as usize); gst::warning!( CAT, - obj: element, + imp: imp, "Too small packet for AVC packet header {}", tag_header.data_size ); @@ -1050,19 +1014,14 @@ impl StreamingState { let data = adapter.map(4).unwrap(); match flavors::avc_video_packet_header(&*data) { Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { - gst::error!( - CAT, - obj: element, - "Invalid AVC video packet header: {:?}", - err - ); + gst::error!(CAT, imp: imp, "Invalid AVC video packet header: {:?}", err); drop(data); adapter.flush((tag_header.data_size - 1) as usize); Ok(None) } Err(nom::Err::Incomplete(_)) => unreachable!(), Ok((_, header)) => { - gst::trace!(CAT, obj: element, "Got AVC packet header {:?}", header); + gst::trace!(CAT, imp: imp, "Got AVC packet header {:?}", header); match header.packet_type { flavors::AVCPacketType::SequenceHeader => { drop(data); @@ -1072,7 +1031,7 @@ impl StreamingState { .unwrap(); gst::debug!( CAT, - obj: element, + imp: imp, "Got AVC sequence header {:?} of size {}", buffer, tag_header.data_size - 1 - 4 @@ -1099,7 +1058,7 @@ impl StreamingState { fn handle_video_tag( &mut self, - element: &super::FlvDemux, + imp: &FlvDemux, tag_header: &flavors::TagHeader, adapter: &mut gst_base::UniqueAdapter, ) -> Result<SmallVec<[Event; 4]>, gst::ErrorMessage> { @@ -1108,7 +1067,7 @@ impl StreamingState { let data = adapter.map(1).unwrap(); let data_header = match flavors::video_data_header(&*data) { Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { - gst::error!(CAT, obj: element, "Invalid video data header: {:?}", err); + gst::error!(CAT, imp: imp, "Invalid video data header: {:?}", err); drop(data); adapter.flush(tag_header.data_size as usize); return Ok(SmallVec::new()); @@ -1119,11 +1078,11 @@ impl StreamingState { drop(data); adapter.flush(1); - let mut events = self.update_video_stream(element, &data_header); + let mut events = self.update_video_stream(imp, &data_header); // AVC/H264 special case let cts = if data_header.codec_id == flavors::CodecId::H264 { - match self.handle_avc_video_packet_header(element, tag_header, adapter)? { + match self.handle_avc_video_packet_header(imp, tag_header, adapter)? { Some(cts) => cts, None => { return Ok(events); @@ -1184,7 +1143,7 @@ impl StreamingState { gst::trace!( CAT, - obj: element, + imp: imp, "Outputting video buffer {:?} for tag {:?}, keyframe: {}", buffer, tag_header, diff --git a/video/gif/src/gifenc/imp.rs b/video/gif/src/gifenc/imp.rs index 68786dfb1..c7a6617ce 100644 --- a/video/gif/src/gifenc/imp.rs +++ b/video/gif/src/gifenc/imp.rs @@ -168,13 +168,7 @@ impl ObjectImpl for GifEnc { PROPERTIES.as_ref() } - 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) { match pspec.name() { "repeat" => { let mut settings = self.settings.lock().unwrap(); @@ -188,7 +182,7 @@ impl ObjectImpl for GifEnc { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "repeat" => { let settings = self.settings.lock().unwrap(); @@ -251,30 +245,28 @@ impl ElementImpl for GifEnc { } impl VideoEncoderImpl for GifEnc { - fn stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { *self.state.borrow_mut() = None; Ok(()) } fn propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { query.add_allocation_meta::<gst_video::VideoMeta>(None); - self.parent_propose_allocation(element, query) + self.parent_propose_allocation(query) } fn set_format( &self, - element: &Self::Type, state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>, ) -> Result<(), gst::LoggableError> { - self.flush_encoder(element) + self.flush_encoder() .map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?; let video_info = state.info(); - gst::debug!(CAT, obj: element, "Setting format {:?}", video_info); + gst::debug!(CAT, imp: self, "Setting format {:?}", video_info); { let mut state = State::new(video_info); @@ -283,23 +275,23 @@ impl VideoEncoderImpl for GifEnc { *self.state.borrow_mut() = Some(state); } - let output_state = element + let instance = self.instance(); + let output_state = instance .set_output_state(gst::Caps::builder("image/gif").build(), Some(state)) .map_err(|_| gst::loggable_error!(CAT, "Failed to set output state"))?; - element + instance .negotiate(output_state) .map_err(|_| gst::loggable_error!(CAT, "Failed to negotiate"))?; - self.parent_set_format(element, state) + self.parent_set_format(state) } - fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> { - self.flush_encoder(element) + fn finish(&self) -> Result<gst::FlowSuccess, gst::FlowError> { + self.flush_encoder() } fn handle_frame( &self, - element: &Self::Type, mut frame: gst_video::VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError> { let mut state_guard = self.state.borrow_mut(); @@ -307,7 +299,7 @@ impl VideoEncoderImpl for GifEnc { gst::debug!( CAT, - obj: element, + imp: self, "Sending frame {}", frame.system_frame_number() ); @@ -318,8 +310,8 @@ impl VideoEncoderImpl for GifEnc { let in_frame = gst_video::VideoFrameRef::from_buffer_ref_readable(input_buffer, &state.video_info) .map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["Failed to map output buffer readable"] ); @@ -339,8 +331,8 @@ impl VideoEncoderImpl for GifEnc { state.gif_pts = pts; } let pts = pts.ok_or_else(|| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["No PTS set on input frame. Unable to calculate proper frame timing."] ); @@ -349,8 +341,8 @@ impl VideoEncoderImpl for GifEnc { let frame_delay = pts .checked_sub(state.gif_pts.expect("checked above")) .ok_or_else(|| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["Input frame PTS is greater than gif_pts. Unable to calculate proper frame timing."] ); @@ -388,7 +380,7 @@ impl VideoEncoderImpl for GifEnc { // encode new frame let context = state.context.as_mut().unwrap(); if let Err(e) = context.write_frame(&gif_frame) { - gst::element_error!(element, gst::CoreError::Failed, [&e.to_string()]); + gst::element_imp_error!(self, gst::CoreError::Failed, [&e.to_string()]); return Err(gst::FlowError::Error); } } @@ -405,13 +397,13 @@ impl VideoEncoderImpl for GifEnc { // Currently not using incremental frames -> every frame is a keyframe frame.set_flags(gst_video::VideoCodecFrameFlags::SYNC_POINT); frame.set_output_buffer(output_buffer); - element.finish_frame(Some(frame)) + self.instance().finish_frame(Some(frame)) } } impl GifEnc { - fn flush_encoder(&self, element: &super::GifEnc) -> Result<gst::FlowSuccess, gst::FlowError> { - gst::debug!(CAT, obj: element, "Flushing"); + fn flush_encoder(&self) -> Result<gst::FlowSuccess, gst::FlowError> { + gst::debug!(CAT, imp: self, "Flushing"); let trailer_buffer = self.state.borrow_mut().as_mut().map(|state| { // Drop encoder to flush and take flushed data (gif trailer) @@ -433,8 +425,7 @@ impl GifEnc { }); if let Some(trailer_buffer) = trailer_buffer { // manually push GIF trailer to the encoder's src pad - let srcpad = element.static_pad("src").unwrap(); - srcpad.push(trailer_buffer)?; + self.instance().src_pad().push(trailer_buffer)?; } Ok(gst::FlowSuccess::Ok) diff --git a/video/gtk4/src/sink/imp.rs b/video/gtk4/src/sink/imp.rs index 054c3e721..ee65609df 100644 --- a/video/gtk4/src/sink/imp.rs +++ b/video/gtk4/src/sink/imp.rs @@ -80,18 +80,18 @@ impl ObjectImpl for PaintableSink { PROPERTIES.as_ref() } - fn property(&self, obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "paintable" => { let mut paintable = self.paintable.lock().unwrap(); if paintable.is_none() { - obj.initialize_paintable(&mut paintable); + self.instance().initialize_paintable(&mut paintable); } let paintable = match &*paintable { Some(ref paintable) => paintable, None => { - gst::error!(CAT, obj: obj, "Failed to create paintable"); + gst::error!(CAT, imp: self, "Failed to create paintable"); return None::<>k::gdk::Paintable>.to_value(); } }; @@ -102,7 +102,7 @@ impl ObjectImpl for PaintableSink { Err(_) => { gst::error!( CAT, - obj: obj, + imp: self, "Can't retrieve Paintable from non-main thread" ); None::<>k::gdk::Paintable>.to_value() @@ -177,25 +177,24 @@ impl ElementImpl for PaintableSink { #[allow(clippy::single_match)] fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { match transition { gst::StateChange::NullToReady => { let mut paintable = self.paintable.lock().unwrap(); if paintable.is_none() { - element.initialize_paintable(&mut paintable); + self.instance().initialize_paintable(&mut paintable); } if paintable.is_none() { - gst::error!(CAT, obj: element, "Failed to create paintable"); + gst::error!(CAT, imp: self, "Failed to create paintable"); return Err(gst::StateChangeError); } } _ => (), } - let res = self.parent_change_state(element, transition); + let res = self.parent_change_state(transition); match transition { gst::StateChange::PausedToReady => { @@ -210,8 +209,8 @@ impl ElementImpl for PaintableSink { } impl BaseSinkImpl for PaintableSink { - fn set_caps(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> { - gst::debug!(CAT, obj: element, "Setting caps {:?}", caps); + fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> { + gst::debug!(CAT, imp: self, "Setting caps {:?}", caps); let video_info = gst_video::VideoInfo::from_caps(caps) .map_err(|_| gst::loggable_error!(CAT, "Invalid caps"))?; @@ -223,7 +222,6 @@ impl BaseSinkImpl for PaintableSink { fn propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { query.add_allocation_meta::<gst_video::VideoMeta>(None); @@ -231,38 +229,34 @@ impl BaseSinkImpl for PaintableSink { // TODO: Provide a preferred "window size" here for higher-resolution rendering query.add_allocation_meta::<gst_video::VideoOverlayCompositionMeta>(None); - self.parent_propose_allocation(element, query) + self.parent_propose_allocation(query) } } impl VideoSinkImpl for PaintableSink { - fn show_frame( - &self, - element: &Self::Type, - buffer: &gst::Buffer, - ) -> Result<gst::FlowSuccess, gst::FlowError> { - gst::trace!(CAT, obj: element, "Rendering buffer {:?}", buffer); + fn show_frame(&self, buffer: &gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError> { + gst::trace!(CAT, imp: self, "Rendering buffer {:?}", buffer); let info = self.info.lock().unwrap(); let info = info.as_ref().ok_or_else(|| { - gst::error!(CAT, obj: element, "Received no caps yet"); + gst::error!(CAT, imp: self, "Received no caps yet"); gst::FlowError::NotNegotiated })?; let frame = Frame::new(buffer, info).map_err(|err| { - gst::error!(CAT, obj: element, "Failed to map video frame"); + gst::error!(CAT, imp: self, "Failed to map video frame"); err })?; self.pending_frame.lock().unwrap().replace(frame); let sender = self.sender.lock().unwrap(); let sender = sender.as_ref().ok_or_else(|| { - gst::error!(CAT, obj: element, "Have no main thread sender"); + gst::error!(CAT, imp: self, "Have no main thread sender"); gst::FlowError::Error })?; sender.send(SinkEvent::FrameChanged).map_err(|_| { - gst::error!(CAT, obj: element, "Have main thread receiver shut down"); + gst::error!(CAT, imp: self, "Have main thread receiver shut down"); gst::FlowError::Error })?; diff --git a/video/gtk4/src/sink/paintable/imp.rs b/video/gtk4/src/sink/paintable/imp.rs index c33cd9b5a..ce1b3f554 100644 --- a/video/gtk4/src/sink/paintable/imp.rs +++ b/video/gtk4/src/sink/paintable/imp.rs @@ -45,7 +45,7 @@ impl ObjectSubclass for SinkPaintable { impl ObjectImpl for SinkPaintable {} impl PaintableImpl for SinkPaintable { - fn intrinsic_height(&self, _paintable: &Self::Type) -> i32 { + fn intrinsic_height(&self) -> i32 { if let Some(paintable) = self.paintables.borrow().first() { f32::round(paintable.height) as i32 } else { @@ -53,7 +53,7 @@ impl PaintableImpl for SinkPaintable { } } - fn intrinsic_width(&self, _paintable: &Self::Type) -> i32 { + fn intrinsic_width(&self) -> i32 { if let Some(paintable) = self.paintables.borrow().first() { f32::round(paintable.width) as i32 } else { @@ -61,7 +61,7 @@ impl PaintableImpl for SinkPaintable { } } - fn intrinsic_aspect_ratio(&self, _paintable: &Self::Type) -> f64 { + fn intrinsic_aspect_ratio(&self) -> f64 { if let Some(paintable) = self.paintables.borrow().first() { paintable.width as f64 / paintable.height as f64 } else { @@ -69,13 +69,13 @@ impl PaintableImpl for SinkPaintable { } } - fn snapshot(&self, paintable: &Self::Type, snapshot: &gdk::Snapshot, width: f64, height: f64) { + fn snapshot(&self, snapshot: &gdk::Snapshot, width: f64, height: f64) { let snapshot = snapshot.downcast_ref::<gtk::Snapshot>().unwrap(); let paintables = self.paintables.borrow(); if !paintables.is_empty() { - gst::trace!(CAT, obj: paintable, "Snapshotting frame"); + gst::trace!(CAT, imp: self, "Snapshotting frame"); let (frame_width, frame_height) = paintables.first().map(|p| (p.width, p.height)).unwrap(); @@ -125,7 +125,7 @@ impl PaintableImpl for SinkPaintable { snapshot.pop(); } } else { - gst::trace!(CAT, obj: paintable, "Snapshotting black frame"); + gst::trace!(CAT, imp: self, "Snapshotting black frame"); snapshot.append_color( &gdk::RGBA::BLACK, &graphene::Rect::new(0f32, 0f32, width as f32, height as f32), @@ -135,9 +135,9 @@ impl PaintableImpl for SinkPaintable { } impl SinkPaintable { - pub(super) fn handle_frame_changed(&self, obj: &super::SinkPaintable, frame: Option<Frame>) { + pub(super) fn handle_frame_changed(&self, frame: Option<Frame>) { if let Some(frame) = frame { - gst::trace!(CAT, obj: obj, "Received new frame"); + gst::trace!(CAT, imp: self, "Received new frame"); let new_paintables = frame.into_textures(&mut *self.cached_textures.borrow_mut()); let new_size = new_paintables @@ -153,15 +153,15 @@ impl SinkPaintable { if Some(new_size) != old_size { gst::debug!( CAT, - obj: obj, + imp: self, "Size changed from {:?} to {:?}", old_size, new_size, ); - obj.invalidate_size(); + self.instance().invalidate_size(); } - obj.invalidate_contents(); + self.instance().invalidate_contents(); } } } diff --git a/video/gtk4/src/sink/paintable/mod.rs b/video/gtk4/src/sink/paintable/mod.rs index da66360ff..60459533e 100644 --- a/video/gtk4/src/sink/paintable/mod.rs +++ b/video/gtk4/src/sink/paintable/mod.rs @@ -36,6 +36,6 @@ impl Default for SinkPaintable { impl SinkPaintable { pub(crate) fn handle_frame_changed(&self, frame: Option<Frame>) { let imp = self.imp(); - imp.handle_frame_changed(self, frame); + imp.handle_frame_changed(frame); } } diff --git a/video/hsv/src/hsvdetector/imp.rs b/video/hsv/src/hsvdetector/imp.rs index 7653b7ee0..5386a22f4 100644 --- a/video/hsv/src/hsvdetector/imp.rs +++ b/video/hsv/src/hsvdetector/imp.rs @@ -215,20 +215,14 @@ impl ObjectImpl for HsvDetector { PROPERTIES.as_ref() } - 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) { match pspec.name() { "hue-ref" => { let mut settings = self.settings.lock().unwrap(); let hue_ref = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing hue-ref from {} to {}", settings.hue_ref, hue_ref @@ -240,7 +234,7 @@ impl ObjectImpl for HsvDetector { let hue_var = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing hue-var from {} to {}", settings.hue_var, hue_var @@ -252,7 +246,7 @@ impl ObjectImpl for HsvDetector { let saturation_ref = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing saturation-ref from {} to {}", settings.saturation_ref, saturation_ref @@ -264,7 +258,7 @@ impl ObjectImpl for HsvDetector { let saturation_var = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing saturation-var from {} to {}", settings.saturation_var, saturation_var @@ -276,7 +270,7 @@ impl ObjectImpl for HsvDetector { let value_ref = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing value-ref from {} to {}", settings.value_ref, value_ref @@ -288,7 +282,7 @@ impl ObjectImpl for HsvDetector { let value_var = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing value-var from {} to {}", settings.value_var, value_var @@ -301,7 +295,7 @@ impl ObjectImpl for HsvDetector { // Called whenever a value of a property is read. It can be called // at any time from any thread. - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "hue-ref" => { let settings = self.settings.lock().unwrap(); @@ -390,7 +384,6 @@ impl BaseTransformImpl for HsvDetector { fn transform_caps( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, filter: Option<&gst::Caps>, @@ -408,7 +401,7 @@ impl BaseTransformImpl for HsvDetector { gst::debug!( CAT, - obj: element, + imp: self, "Transformed caps from {} to {} in direction {:?}", caps, other_caps, @@ -428,7 +421,6 @@ impl BaseTransformImpl for HsvDetector { impl VideoFilterImpl for HsvDetector { fn transform_frame( &self, - _element: &Self::Type, in_frame: &gst_video::VideoFrameRef<&gst::BufferRef>, out_frame: &mut gst_video::VideoFrameRef<&mut gst::BufferRef>, ) -> Result<gst::FlowSuccess, gst::FlowError> { diff --git a/video/hsv/src/hsvfilter/imp.rs b/video/hsv/src/hsvfilter/imp.rs index 2b1542ae6..f198f5a05 100644 --- a/video/hsv/src/hsvfilter/imp.rs +++ b/video/hsv/src/hsvfilter/imp.rs @@ -159,20 +159,14 @@ impl ObjectImpl for HsvFilter { PROPERTIES.as_ref() } - 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) { match pspec.name() { "hue-shift" => { let mut settings = self.settings.lock().unwrap(); let hue_shift = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing hue-shift from {} to {}", settings.hue_shift, hue_shift @@ -184,7 +178,7 @@ impl ObjectImpl for HsvFilter { let saturation_mul = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing saturation-mul from {} to {}", settings.saturation_mul, saturation_mul @@ -196,7 +190,7 @@ impl ObjectImpl for HsvFilter { let saturation_off = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing saturation-off from {} to {}", settings.saturation_off, saturation_off @@ -208,7 +202,7 @@ impl ObjectImpl for HsvFilter { let value_mul = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing value-mul from {} to {}", settings.value_mul, value_mul @@ -220,7 +214,7 @@ impl ObjectImpl for HsvFilter { let value_off = value.get().expect("type checked upstream"); gst::info!( CAT, - obj: obj, + imp: self, "Changing value-off from {} to {}", settings.value_off, value_off @@ -233,7 +227,7 @@ impl ObjectImpl for HsvFilter { // Called whenever a value of a property is read. It can be called // at any time from any thread. - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "hue-shift" => { let settings = self.settings.lock().unwrap(); @@ -327,7 +321,6 @@ impl BaseTransformImpl for HsvFilter { impl VideoFilterImpl for HsvFilter { fn transform_frame_ip( &self, - _element: &Self::Type, frame: &mut gst_video::VideoFrameRef<&mut gst::BufferRef>, ) -> Result<gst::FlowSuccess, gst::FlowError> { match frame.format() { diff --git a/video/rav1e/src/rav1enc/imp.rs b/video/rav1e/src/rav1enc/imp.rs index ce459dccb..cefa894e4 100644 --- a/video/rav1e/src/rav1enc/imp.rs +++ b/video/rav1e/src/rav1enc/imp.rs @@ -348,13 +348,7 @@ impl ObjectImpl for Rav1Enc { PROPERTIES.as_ref() } - 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) { match pspec.name() { "speed-preset" => { let mut settings = self.settings.lock().unwrap(); @@ -424,7 +418,7 @@ impl ObjectImpl for Rav1Enc { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "speed-preset" => { let settings = self.settings.lock().unwrap(); @@ -555,7 +549,7 @@ impl ElementImpl for Rav1Enc { } impl VideoEncoderImpl for Rav1Enc { - fn stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { *self.state.borrow_mut() = None; Ok(()) @@ -563,25 +557,23 @@ impl VideoEncoderImpl for Rav1Enc { fn propose_allocation( &self, - element: &Self::Type, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { query.add_allocation_meta::<gst_video::VideoMeta>(None); - self.parent_propose_allocation(element, query) + self.parent_propose_allocation(query) } // For the colorimetry mapping below #[allow(clippy::wildcard_in_or_patterns)] fn set_format( &self, - element: &Self::Type, state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>, ) -> Result<(), gst::LoggableError> { - self.finish(element) + self.finish() .map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?; let video_info = state.info(); - gst::debug!(CAT, obj: element, "Setting format {:?}", video_info); + gst::debug!(CAT, imp: self, "Setting format {:?}", video_info); let settings = self.settings.lock().unwrap(); @@ -813,7 +805,8 @@ impl VideoEncoderImpl for Rav1Enc { video_info, }); - let output_state = element + let instance = self.instance(); + let output_state = instance .set_output_state( gst::Caps::builder("video/x-av1") .field("stream-format", "obu-stream") @@ -823,34 +816,34 @@ impl VideoEncoderImpl for Rav1Enc { Some(state), ) .map_err(|_| gst::loggable_error!(CAT, "Failed to set output state"))?; - element + instance .negotiate(output_state) .map_err(|_| gst::loggable_error!(CAT, "Failed to negotiate"))?; - self.parent_set_format(element, state) + self.parent_set_format(state) } - fn flush(&self, element: &Self::Type) -> bool { - gst::debug!(CAT, obj: element, "Flushing"); + fn flush(&self) -> bool { + gst::debug!(CAT, imp: self, "Flushing"); let mut state_guard = self.state.borrow_mut(); if let Some(ref mut state) = *state_guard { state.context.flush(); while let Ok(_) | Err(data::EncoderStatus::Encoded) = state.context.receive_packet() { - gst::debug!(CAT, obj: element, "Dropping packet on flush",); + gst::debug!(CAT, imp: self, "Dropping packet on flush",); } } true } - fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> { - gst::debug!(CAT, obj: element, "Finishing"); + fn finish(&self) -> Result<gst::FlowSuccess, gst::FlowError> { + gst::debug!(CAT, imp: self, "Finishing"); let mut state_guard = self.state.borrow_mut(); if let Some(ref mut state) = *state_guard { state.context.flush(); - self.output_frames(element, state)?; + self.output_frames(state)?; } Ok(gst::FlowSuccess::Ok) @@ -858,17 +851,16 @@ impl VideoEncoderImpl for Rav1Enc { fn handle_frame( &self, - element: &Self::Type, frame: gst_video::VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError> { let mut state_guard = self.state.borrow_mut(); let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?; - self.output_frames(element, state)?; + self.output_frames(state)?; gst::debug!( CAT, - obj: element, + imp: self, "Sending frame {}", frame.system_frame_number() ); @@ -878,8 +870,8 @@ impl VideoEncoderImpl for Rav1Enc { let in_frame = gst_video::VideoFrameRef::from_buffer_ref_readable(input_buffer, &state.video_info) .map_err(|_| { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["Failed to map output buffer readable"] ); @@ -894,73 +886,62 @@ impl VideoEncoderImpl for Rav1Enc { .contains(gst_video::VideoCodecFrameFlags::FORCE_KEYFRAME), ) { Ok(_) => { - gst::debug!( - CAT, - obj: element, - "Sent frame {}", - frame.system_frame_number() - ); + gst::debug!(CAT, imp: self, "Sent frame {}", frame.system_frame_number()); } Err(data::EncoderStatus::Failure) => { - gst::element_error!(element, gst::CoreError::Failed, ["Failed to send frame"]); + gst::element_imp_error!(self, gst::CoreError::Failed, ["Failed to send frame"]); return Err(gst::FlowError::Error); } Err(_) => (), } - self.output_frames(element, state) + self.output_frames(state) } } impl Rav1Enc { - fn output_frames( - &self, - element: &super::Rav1Enc, - state: &mut State, - ) -> Result<gst::FlowSuccess, gst::FlowError> { + fn output_frames(&self, state: &mut State) -> Result<gst::FlowSuccess, gst::FlowError> { loop { match state.context.receive_packet() { Ok((packet_type, packet_number, frame_number, packet_data)) => { gst::debug!( CAT, - obj: element, + imp: self, "Received packet {} of size {}, frame type {:?}", packet_number, packet_data.len(), packet_type ); - let mut frame = element.frame(frame_number as i32).expect("frame not found"); + let instance = self.instance(); + let mut frame = instance + .frame(frame_number as i32) + .expect("frame not found"); if packet_type == data::FrameType::KEY { frame.set_flags(gst_video::VideoCodecFrameFlags::SYNC_POINT); } let output_buffer = gst::Buffer::from_mut_slice(packet_data); frame.set_output_buffer(output_buffer); - element.finish_frame(Some(frame))?; + instance.finish_frame(Some(frame))?; } Err(data::EncoderStatus::Encoded) => { - gst::debug!(CAT, obj: element, "Encoded but not output frame yet",); + gst::debug!(CAT, imp: self, "Encoded but not output frame yet",); } Err(data::EncoderStatus::NeedMoreData) => { - gst::debug!(CAT, obj: element, "Encoded but need more data",); + gst::debug!(CAT, imp: self, "Encoded but need more data",); return Ok(gst::FlowSuccess::Ok); } Err(data::EncoderStatus::Failure) => { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Failed, ["Failed to receive frame"] ); return Err(gst::FlowError::Error); } Err(err) => { - gst::debug!( - CAT, - obj: element, - "Soft error when receiving frame: {:?}", - err - ); + gst::debug!(CAT, imp: self, "Soft error when receiving frame: {:?}", err); return Ok(gst::FlowSuccess::Ok); } } diff --git a/video/rspng/src/pngenc/imp.rs b/video/rspng/src/pngenc/imp.rs index 04b82ec3e..851677d86 100644 --- a/video/rspng/src/pngenc/imp.rs +++ b/video/rspng/src/pngenc/imp.rs @@ -195,13 +195,7 @@ impl ObjectImpl for PngEncoder { PROPERTIES.as_ref() } - 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) { match pspec.name() { "compression-level" => { let mut settings = self.settings.lock(); @@ -217,7 +211,7 @@ impl ObjectImpl for PngEncoder { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "compression-level" => { let settings = self.settings.lock(); @@ -283,18 +277,17 @@ impl ElementImpl for PngEncoder { } impl VideoEncoderImpl for PngEncoder { - fn stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { *self.state.lock() = None; Ok(()) } fn set_format( &self, - element: &Self::Type, state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>, ) -> Result<(), gst::LoggableError> { let video_info = state.info(); - gst::debug!(CAT, obj: element, "Setting format {:?}", video_info); + gst::debug!(CAT, imp: self, "Setting format {:?}", video_info); { let settings = self.settings.lock(); let mut state = State::new(video_info); @@ -302,17 +295,17 @@ impl VideoEncoderImpl for PngEncoder { *self.state.lock() = Some(state); } - let output_state = element + let instance = self.instance(); + let output_state = instance .set_output_state(gst::Caps::builder("image/png").build(), Some(state)) .map_err(|_| gst::loggable_error!(CAT, "Failed to set output state"))?; - element + instance .negotiate(output_state) .map_err(|_| gst::loggable_error!(CAT, "Failed to negotiate")) } fn handle_frame( &self, - element: &Self::Type, mut frame: gst_video::VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError> { let mut state_guard = self.state.lock(); @@ -320,7 +313,7 @@ impl VideoEncoderImpl for PngEncoder { gst::debug!( CAT, - obj: element, + imp: self, "Sending frame {}", frame.system_frame_number() ); @@ -330,7 +323,7 @@ impl VideoEncoderImpl for PngEncoder { let input_map = input_buffer.map_readable().unwrap(); let data = input_map.as_slice(); state.write_data(data).map_err(|e| { - gst::element_error!(element, gst::CoreError::Failed, [&e.to_string()]); + gst::element_imp_error!(self, gst::CoreError::Failed, [&e.to_string()]); gst::FlowError::Error })?; } @@ -342,6 +335,6 @@ impl VideoEncoderImpl for PngEncoder { // There are no such incremental frames in the png format frame.set_flags(gst_video::VideoCodecFrameFlags::SYNC_POINT); frame.set_output_buffer(output_buffer); - element.finish_frame(Some(frame)) + self.instance().finish_frame(Some(frame)) } } diff --git a/video/videofx/src/border/roundedcorners.rs b/video/videofx/src/border/imp.rs index c1a192e18..f3fb220ea 100644 --- a/video/videofx/src/border/roundedcorners.rs +++ b/video/videofx/src/border/imp.rs @@ -289,13 +289,7 @@ impl ObjectImpl for RoundedCorners { PROPERTIES.as_ref() } - 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) { match pspec.name() { "border-radius-px" => { let mut settings = self.settings.lock().unwrap(); @@ -304,20 +298,20 @@ impl ObjectImpl for RoundedCorners { settings.changed = true; gst::info!( CAT, - obj: obj, + imp: self, "Changing border radius from {} to {}", settings.border_radius_px, border_radius ); settings.border_radius_px = border_radius; - obj.reconfigure_src(); + self.instance().reconfigure_src(); } } _ => unimplemented!(), } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "border-radius-px" => { let settings = self.settings.lock().unwrap(); @@ -381,17 +375,16 @@ impl BaseTransformImpl for RoundedCorners { const PASSTHROUGH_ON_SAME_CAPS: bool = false; const TRANSFORM_IP_ON_PASSTHROUGH: bool = false; - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { let _ = self.state.lock().unwrap().take(); - gst::info!(CAT, obj: element, "Stopped"); + gst::info!(CAT, imp: self, "Stopped"); Ok(()) } fn transform_caps( &self, - element: &Self::Type, direction: gst::PadDirection, caps: &gst::Caps, filter: Option<&gst::Caps>, @@ -438,7 +431,7 @@ impl BaseTransformImpl for RoundedCorners { gst::debug!( CAT, - obj: element, + imp: self, "Transformed caps from {} to {} in direction {:?}", caps, other_caps, @@ -452,12 +445,7 @@ impl BaseTransformImpl for RoundedCorners { } } - fn set_caps( - &self, - element: &Self::Type, - incaps: &gst::Caps, - outcaps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn set_caps(&self, incaps: &gst::Caps, outcaps: &gst::Caps) -> Result<(), gst::LoggableError> { let mut settings = self.settings.lock().unwrap(); let out_info = match gst_video::VideoInfo::from_caps(outcaps) { @@ -467,17 +455,17 @@ impl BaseTransformImpl for RoundedCorners { gst::debug!( CAT, - obj: element, + imp: self, "Configured for caps {} to {}", incaps, outcaps ); if out_info.format() == VideoFormat::I420 { - element.set_passthrough(true); + self.instance().set_passthrough(true); return Ok(()); } else { - element.set_passthrough(false); + self.instance().set_passthrough(false); } // See "A420" planar 4:4:2:0 AYUV section @@ -497,10 +485,9 @@ impl BaseTransformImpl for RoundedCorners { fn prepare_output_buffer( &self, - element: &Self::Type, inbuf: InputBuffer, ) -> Result<PrepareOutputBufferSuccess, gst::FlowError> { - if element.is_passthrough() { + if self.instance().is_passthrough() { return Ok(PrepareOutputBufferSuccess::InputBuffer); } @@ -509,12 +496,12 @@ impl BaseTransformImpl for RoundedCorners { settings.changed = false; gst::debug!( CAT, - obj: element, + imp: self, "Caps or border radius changed, generating alpha mask" ); let state_guard = self.state.lock().unwrap(); let state = state_guard.as_ref().ok_or_else(|| { - gst::element_error!(element, gst::CoreError::Negotiation, ["Have no state yet"]); + gst::element_imp_error!(self, gst::CoreError::Negotiation, ["Have no state yet"]); gst::FlowError::NotNegotiated })?; @@ -523,8 +510,8 @@ impl BaseTransformImpl for RoundedCorners { VideoFormat::A420 => { drop(state_guard); if self.generate_alpha_mask(settings.border_radius_px).is_err() { - gst::element_error!( - element, + gst::element_imp_error!( + self, gst::CoreError::Negotiation, ["Failed to generate alpha mask"] ); @@ -537,7 +524,7 @@ impl BaseTransformImpl for RoundedCorners { let mut state_guard = self.state.lock().unwrap(); let state = state_guard.as_mut().ok_or_else(|| { - gst::element_error!(element, gst::CoreError::Negotiation, ["Have no state yet"]); + gst::element_imp_error!(self, gst::CoreError::Negotiation, ["Have no state yet"]); gst::FlowError::NotNegotiated })?; @@ -549,7 +536,7 @@ impl BaseTransformImpl for RoundedCorners { InputBuffer::Writable(outbuf) => { gst::log!( CAT, - obj: element, + imp: self, "Received writable input buffer of size: {}", outbuf.size() ); @@ -561,7 +548,7 @@ impl BaseTransformImpl for RoundedCorners { InputBuffer::Readable(buf) => { gst::log!( CAT, - obj: element, + imp: self, "Received readable input buffer of size: {}", buf.size() ); @@ -575,21 +562,16 @@ impl BaseTransformImpl for RoundedCorners { } } - fn transform_ip( - &self, - _element: &Self::Type, - _buf: &mut gst::BufferRef, - ) -> Result<gst::FlowSuccess, gst::FlowError> { + fn transform_ip(&self, _buf: &mut gst::BufferRef) -> Result<gst::FlowSuccess, gst::FlowError> { Ok(gst::FlowSuccess::Ok) } fn propose_allocation( &self, - element: &Self::Type, decide_query: Option<&gst::query::Allocation>, query: &mut gst::query::Allocation, ) -> Result<(), gst::LoggableError> { query.add_allocation_meta::<gst_video::VideoMeta>(None); - self.parent_propose_allocation(element, decide_query, query) + self.parent_propose_allocation(decide_query, query) } } diff --git a/video/videofx/src/border/mod.rs b/video/videofx/src/border/mod.rs index 6d612eda2..d81fcfa80 100644 --- a/video/videofx/src/border/mod.rs +++ b/video/videofx/src/border/mod.rs @@ -10,10 +10,10 @@ use gst::glib; use gst::prelude::*; -pub mod roundedcorners; +mod imp; glib::wrapper! { - pub struct RoundedCorners(ObjectSubclass<roundedcorners::RoundedCorners>) @extends gst_base::BaseTransform, gst::Element, gst::Object; + pub struct RoundedCorners(ObjectSubclass<imp::RoundedCorners>) @extends gst_base::BaseTransform, gst::Element, gst::Object; } pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> { diff --git a/video/videofx/src/colordetect/imp.rs b/video/videofx/src/colordetect/imp.rs index 2152ab775..b321d1503 100644 --- a/video/videofx/src/colordetect/imp.rs +++ b/video/videofx/src/colordetect/imp.rs @@ -57,12 +57,11 @@ pub struct ColorDetect { impl ColorDetect { fn detect_color( &self, - element: &super::ColorDetect, buf: &mut gst::BufferRef, ) -> Result<Option<(String, Vec<Color>)>, gst::FlowError> { let mut state_guard = self.state.borrow_mut(); let state = state_guard.as_mut().ok_or_else(|| { - gst::element_error!(element, gst::CoreError::Negotiation, ["Have no state yet"]); + gst::element_imp_error!(self, gst::CoreError::Negotiation, ["Have no state yet"]); gst::FlowError::NotNegotiated })?; @@ -93,15 +92,10 @@ impl ColorDetect { Ok(None) } - fn color_changed( - &self, - element: &super::ColorDetect, - dominant_color_name: &str, - palette: Vec<Color>, - ) { + fn color_changed(&self, dominant_color_name: &str, palette: Vec<Color>) { gst::debug!( CAT, - obj: element, + imp: self, "Dominant color changed to {}", dominant_color_name ); @@ -111,7 +105,7 @@ impl ColorDetect { .map(|c| ((c.r as u32) << 16) | ((c.g as u32) << 8) | (c.b as u32)), ); - element + self.instance() .post_message( gst::message::Element::builder( gst::structure::Structure::builder("colordetect") @@ -157,13 +151,7 @@ impl ObjectImpl for ColorDetect { PROPERTIES.as_ref() } - 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) { match pspec.name() { "quality" => { let mut settings = self.settings.lock().unwrap(); @@ -171,7 +159,7 @@ impl ObjectImpl for ColorDetect { if settings.quality != quality { gst::info!( CAT, - obj: obj, + imp: self, "Changing quality from {} to {}", settings.quality, quality @@ -185,7 +173,7 @@ impl ObjectImpl for ColorDetect { if settings.max_colors != max_colors { gst::info!( CAT, - obj: obj, + imp: self, "Changing max_colors from {} to {}", settings.max_colors, max_colors @@ -197,7 +185,7 @@ impl ObjectImpl for ColorDetect { } } - fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { + fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { match pspec.name() { "quality" => { let settings = self.settings.lock().unwrap(); @@ -268,18 +256,13 @@ impl BaseTransformImpl for ColorDetect { const PASSTHROUGH_ON_SAME_CAPS: bool = false; const TRANSFORM_IP_ON_PASSTHROUGH: bool = false; - fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { + fn stop(&self) -> Result<(), gst::ErrorMessage> { *self.state.borrow_mut() = None; - gst::info!(CAT, obj: element, "Stopped"); + gst::info!(CAT, imp: self, "Stopped"); Ok(()) } - fn set_caps( - &self, - element: &Self::Type, - incaps: &gst::Caps, - outcaps: &gst::Caps, - ) -> Result<(), gst::LoggableError> { + fn set_caps(&self, incaps: &gst::Caps, outcaps: &gst::Caps) -> Result<(), gst::LoggableError> { let in_info = match gst_video::VideoInfo::from_caps(incaps) { Err(_) => return Err(gst::loggable_error!(CAT, "Failed to parse input caps")), Ok(info) => info, @@ -292,7 +275,7 @@ impl BaseTransformImpl for ColorDetect { gst::debug!( CAT, - obj: element, + imp: self, "Configured for caps {} to {}", incaps, outcaps @@ -320,13 +303,9 @@ impl BaseTransformImpl for ColorDetect { Ok(()) } - fn transform_ip( - &self, - element: &Self::Type, - buf: &mut gst::BufferRef, - ) -> Result<gst::FlowSuccess, gst::FlowError> { - if let Some((dominant_color_name, palette)) = self.detect_color(element, buf)? { - self.color_changed(element, &dominant_color_name, palette); + fn transform_ip(&self, buf: &mut gst::BufferRef) -> Result<gst::FlowSuccess, gst::FlowError> { + if let Some((dominant_color_name, palette)) = self.detect_color(buf)? { + self.color_changed(&dominant_color_name, palette); } Ok(gst::FlowSuccess::Ok) diff --git a/video/webp/src/dec/imp.rs b/video/webp/src/dec/imp.rs index a19100674..8c90375a3 100644 --- a/video/webp/src/dec/imp.rs +++ b/video/webp/src/dec/imp.rs @@ -136,7 +136,6 @@ impl WebPDec { fn sink_chain( &self, pad: &gst::Pad, - _element: &super::WebPDec, buffer: gst::Buffer, ) -> Result<gst::FlowSuccess, gst::FlowError> { gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); @@ -149,7 +148,7 @@ impl WebPDec { Ok(gst::FlowSuccess::Ok) } - fn decode(&self, _element: &super::WebPDec) -> Result<(), gst::ErrorMessage> { + fn decode(&self) -> Result<(), gst::ErrorMessage> { let mut prev_timestamp: Option<gst::ClockTime> = Some(gst::ClockTime::ZERO); let mut state = self.state.lock().unwrap(); @@ -234,7 +233,7 @@ impl WebPDec { Ok(()) } - fn sink_event(&self, pad: &gst::Pad, element: &super::WebPDec, event: gst::Event) -> bool { + fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); @@ -242,26 +241,26 @@ impl WebPDec { EventView::FlushStop(..) => { let mut state = self.state.lock().unwrap(); *state = State::default(); - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::Eos(..) => { - if let Err(err) = self.decode(element) { - element.post_error_message(err); + if let Err(err) = self.decode() { + self.post_error_message(err); } - pad.event_default(Some(element), event) + pad.event_default(Some(&*self.instance()), event) } EventView::Segment(..) => true, - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } - fn src_event(&self, pad: &gst::Pad, element: &super::WebPDec, event: gst::Event) -> bool { + fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool { use gst::EventView; gst::log!(CAT, obj: pad, "Handling event {:?}", event); match event.view() { EventView::Seek(..) => false, - _ => pad.event_default(Some(element), event), + _ => pad.event_default(Some(&*self.instance()), event), } } } @@ -279,14 +278,14 @@ impl ObjectSubclass for WebPDec { WebPDec::catch_panic_pad_function( parent, || Err(gst::FlowError::Error), - |dec, element| dec.sink_chain(pad, element, buffer), + |dec| dec.sink_chain(pad, buffer), ) }) .event_function(|pad, parent, event| { WebPDec::catch_panic_pad_function( parent, || false, - |dec, element| dec.sink_event(pad, element, event), + |dec| dec.sink_event(pad, event), ) }) .build(); @@ -294,11 +293,7 @@ impl ObjectSubclass for WebPDec { let templ = klass.pad_template("src").unwrap(); let srcpad = gst::Pad::builder_with_template(&templ, Some("src")) .event_function(|pad, parent, event| { - WebPDec::catch_panic_pad_function( - parent, - || false, - |dec, element| dec.src_event(pad, element, event), - ) + WebPDec::catch_panic_pad_function(parent, || false, |dec| dec.src_event(pad, event)) }) .build(); @@ -311,9 +306,10 @@ impl ObjectSubclass for WebPDec { } impl ObjectImpl for WebPDec { - fn constructed(&self, obj: &Self::Type) { - self.parent_constructed(obj); + fn constructed(&self) { + self.parent_constructed(); + let obj = self.instance(); obj.add_pad(&self.sinkpad).unwrap(); obj.add_pad(&self.srcpad).unwrap(); } @@ -367,15 +363,14 @@ impl ElementImpl for WebPDec { fn change_state( &self, - element: &Self::Type, transition: gst::StateChange, ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { - gst::trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, imp: self, "Changing state {:?}", transition); if transition == gst::StateChange::PausedToReady { *self.state.lock().unwrap() = State::default(); } - self.parent_change_state(element, transition) + self.parent_change_state(transition) } } |