From 422ea740ca937c3d669b7c961a67a09d9b1baed0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Laignel?= Date: Mon, 21 Feb 2022 18:43:46 +0100 Subject: Update to gst::_log_macro_ See the details: https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/980 --- text/ahead/src/textahead/imp.rs | 7 ++-- text/json/src/jsongstenc/imp.rs | 5 ++- text/json/src/jsongstparse/imp.rs | 73 +++++++++++++++++++-------------------- text/regex/src/gstregex/imp.rs | 13 ++++--- text/wrap/src/gsttextwrap/imp.rs | 27 +++++++-------- 5 files changed, 60 insertions(+), 65 deletions(-) (limited to 'text') diff --git a/text/ahead/src/textahead/imp.rs b/text/ahead/src/textahead/imp.rs index 0da703171..48ed011ab 100644 --- a/text/ahead/src/textahead/imp.rs +++ b/text/ahead/src/textahead/imp.rs @@ -13,7 +13,6 @@ use once_cell::sync::Lazy; use gst::glib; use gst::prelude::*; use gst::subclass::prelude::*; -use gst::{gst_debug, gst_log}; static CAT: Lazy = Lazy::new(|| { gst::DebugCategory::new( @@ -272,7 +271,7 @@ impl TextAhead { // queue buffer let mut state = self.state.lock().unwrap(); - gst_log!(CAT, obj: element, "input {:?}: {}", pts, text); + gst::log!(CAT, obj: element, "input {:?}: {}", pts, text); state.pending.push(Input { text, @@ -299,7 +298,7 @@ impl TextAhead { gst::EventView::Eos(_) => { let mut state = self.state.lock().unwrap(); - gst_debug!(CAT, obj: element, "eos"); + gst::debug!(CAT, obj: element, "eos"); while !state.pending.is_empty() { let _ = self.push_pending(element, &mut state); @@ -354,7 +353,7 @@ impl TextAhead { } } - gst_log!(CAT, obj: element, "output {:?}: {}", first.pts, text); + gst::log!(CAT, obj: element, "output {:?}: {}", first.pts, text); let mut output = gst::Buffer::from_mut_slice(text.into_bytes()); { diff --git a/text/json/src/jsongstenc/imp.rs b/text/json/src/jsongstenc/imp.rs index eee814969..cfb2e877d 100644 --- a/text/json/src/jsongstenc/imp.rs +++ b/text/json/src/jsongstenc/imp.rs @@ -9,7 +9,6 @@ use gst::glib; use gst::prelude::*; use gst::subclass::prelude::*; -use gst::{gst_log, gst_trace}; use once_cell::sync::Lazy; @@ -153,7 +152,7 @@ impl JsonGstEnc { fn sink_event(&self, pad: &gst::Pad, element: &super::JsonGstEnc, event: gst::Event) -> bool { use gst::EventView; - gst_log!(CAT, obj: pad, "Handling event {:?}", event); + gst::log!(CAT, obj: pad, "Handling event {:?}", event); match event.view() { EventView::Caps(e) => { @@ -270,7 +269,7 @@ impl ElementImpl for JsonGstEnc { element: &Self::Type, transition: gst::StateChange, ) -> Result { - gst_trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, obj: element, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { diff --git a/text/json/src/jsongstparse/imp.rs b/text/json/src/jsongstparse/imp.rs index 3139ba9f9..f561223ad 100644 --- a/text/json/src/jsongstparse/imp.rs +++ b/text/json/src/jsongstparse/imp.rs @@ -9,7 +9,6 @@ use gst::glib; use gst::prelude::*; use gst::subclass::prelude::*; -use gst::{gst_debug, gst_error, gst_info, gst_log, gst_trace, gst_warning}; use once_cell::sync::Lazy; @@ -156,7 +155,7 @@ impl State { let caps = caps_builder.build(); events.push(gst::event::Caps::new(&caps)); - gst_info!(CAT, obj: element, "Caps changed to {:?}", &caps); + gst::info!(CAT, obj: element, "Caps changed to {:?}", &caps); self.need_caps = false; } @@ -237,7 +236,7 @@ impl JsonGstParse { duration, data, })) => { - gst_debug!( + gst::debug!( CAT, obj: element, "Got buffer with timestamp {} and duration {}", @@ -273,13 +272,13 @@ impl JsonGstParse { drop(state); for event in events { - gst_debug!(CAT, obj: element, "Pushing event {:?}", event); + gst::debug!(CAT, obj: element, "Pushing event {:?}", event); self.srcpad.push_event(event); } self.srcpad.push(buffer).map_err(|err| { if err != gst::FlowError::Flushing { - gst_error!(CAT, obj: element, "Pushing buffer returned {:?}", err); + gst::error!(CAT, obj: element, "Pushing buffer returned {:?}", err); } err })?; @@ -297,11 +296,11 @@ impl JsonGstParse { if state.format.is_none() { state.format = Some(format); } else { - gst_warning!(CAT, obj: element, "Ignoring format change",); + gst::warning!(CAT, obj: element, "Ignoring format change",); } } Err((line, err)) => { - gst_error!( + gst::error!( CAT, obj: element, "Couldn't parse line '{:?}': {:?}", @@ -340,7 +339,7 @@ impl JsonGstParse { state.replay_last_line = true; state.need_flush_stop = true; - gst_debug!(CAT, obj: element, "Done seeking"); + gst::debug!(CAT, obj: element, "Done seeking"); } drop(state); @@ -360,18 +359,18 @@ impl JsonGstParse { state.pull = None; if !pad.peer_query(&mut query) { - gst_debug!(CAT, obj: pad, "Scheduling query failed on peer"); + gst::debug!(CAT, obj: pad, "Scheduling query failed on peer"); gst::PadMode::Push } else if query .has_scheduling_mode_with_flags(gst::PadMode::Pull, gst::SchedulingFlags::SEEKABLE) { - gst_debug!(CAT, obj: pad, "Activating in Pull mode"); + gst::debug!(CAT, obj: pad, "Activating in Pull mode"); state.pull = Some(PullState::new(element, &self.srcpad)); gst::PadMode::Pull } else { - gst_debug!(CAT, obj: pad, "Activating in Push mode"); + gst::debug!(CAT, obj: pad, "Activating in Push mode"); gst::PadMode::Push } }; @@ -425,7 +424,7 @@ impl JsonGstParse { &self, element: &super::JsonGstParse, ) -> Result, gst::LoggableError> { - gst_debug!(CAT, obj: element, "Scanning duration"); + gst::debug!(CAT, obj: element, "Scanning duration"); /* First let's query the bytes duration upstream */ let mut q = gst::query::Duration::new(gst::Format::Bytes); @@ -492,7 +491,7 @@ impl JsonGstParse { } if last_pts.is_some() || offset == 0 { - gst_debug!( + gst::debug!( CAT, obj: element, "Duration scan done, last_pts: {:?}", @@ -523,7 +522,7 @@ impl JsonGstParse { drop(state); for event in events { - gst_debug!(CAT, obj: element, "Pushing event {:?}", event); + gst::debug!(CAT, obj: element, "Pushing event {:?}", event); self.srcpad.push_event(event); } } @@ -564,13 +563,13 @@ impl JsonGstParse { Ok(buffer) => Some(buffer), Err(gst::FlowError::Eos) => None, Err(gst::FlowError::Flushing) => { - gst_debug!(CAT, obj: &self.sinkpad, "Pausing after pulling buffer, reason: flushing"); + gst::debug!(CAT, obj: &self.sinkpad, "Pausing after pulling buffer, reason: flushing"); self.sinkpad.pause_task().unwrap(); return; } Err(flow) => { - gst_error!(CAT, obj: &self.sinkpad, "Failed to pull, reason: {:?}", flow); + gst::error!(CAT, obj: &self.sinkpad, "Failed to pull, reason: {:?}", flow); gst::element_error!( element, @@ -586,17 +585,17 @@ impl JsonGstParse { if let Err(flow) = self.handle_buffer(element, buffer) { match flow { gst::FlowError::Flushing => { - gst_debug!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow); } gst::FlowError::Eos => { self.push_eos(element); - gst_debug!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow); } _ => { self.push_eos(element); - gst_error!(CAT, obj: element, "Pausing after flow {:?}", flow); + gst::error!(CAT, obj: element, "Pausing after flow {:?}", flow); gst::element_error!( element, @@ -616,7 +615,7 @@ impl JsonGstParse { element: &super::JsonGstParse, buffer: gst::Buffer, ) -> Result { - gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer); + gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer); self.handle_buffer(element, Some(buffer)) } @@ -638,17 +637,17 @@ impl JsonGstParse { fn sink_event(&self, pad: &gst::Pad, element: &super::JsonGstParse, event: gst::Event) -> bool { use gst::EventView; - gst_log!(CAT, obj: pad, "Handling event {:?}", event); + gst::log!(CAT, obj: pad, "Handling event {:?}", event); match event.view() { EventView::Caps(_) => { // We send a proper caps event from the chain function later - gst_log!(CAT, obj: pad, "Dropping caps event"); + gst::log!(CAT, obj: pad, "Dropping caps event"); true } EventView::Segment(_) => { // We send a gst::Format::Time segment event later when needed - gst_log!(CAT, obj: pad, "Dropping segment event"); + gst::log!(CAT, obj: pad, "Dropping segment event"); true } EventView::FlushStop(_) => { @@ -659,9 +658,9 @@ impl JsonGstParse { pad.event_default(Some(element), event) } EventView::Eos(_) => { - gst_log!(CAT, obj: pad, "Draining"); + gst::log!(CAT, obj: pad, "Draining"); if let Err(err) = self.handle_buffer(element, None) { - gst_error!(CAT, obj: pad, "Failed to drain parser: {:?}", err); + gst::error!(CAT, obj: pad, "Failed to drain parser: {:?}", err); } pad.event_default(Some(element), event) } @@ -670,7 +669,7 @@ impl JsonGstParse { && !self.srcpad.has_current_caps() && event.type_() > gst::EventType::Caps { - gst_log!(CAT, obj: pad, "Deferring sticky event until we have caps"); + gst::log!(CAT, obj: pad, "Deferring sticky event until we have caps"); let mut state = self.state.lock().unwrap(); state.pending_events.push(event); true @@ -683,7 +682,7 @@ impl JsonGstParse { fn perform_seek(&self, event: &gst::event::Seek, element: &super::JsonGstParse) -> bool { if self.state.lock().unwrap().pull.is_none() { - gst_error!(CAT, obj: element, "seeking is only supported in pull mode"); + gst::error!(CAT, obj: element, "seeking is only supported in pull mode"); return false; } @@ -692,7 +691,7 @@ impl JsonGstParse { let mut start: Option = match start.try_into() { Ok(start) => start, Err(_) => { - gst_error!(CAT, obj: element, "seek has invalid format"); + gst::error!(CAT, obj: element, "seek has invalid format"); return false; } }; @@ -700,18 +699,18 @@ impl JsonGstParse { let mut stop: Option = match stop.try_into() { Ok(stop) => stop, Err(_) => { - gst_error!(CAT, obj: element, "seek has invalid format"); + gst::error!(CAT, obj: element, "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, obj: element, "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, obj: element, "Relative seeks are not supported"); return false; } @@ -721,14 +720,14 @@ impl JsonGstParse { .seqnum(seek_seqnum) .build(); - gst_debug!(CAT, obj: element, "Sending event {:?} upstream", event); + gst::debug!(CAT, obj: element, "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, obj: element, "Pushing event {:?}", event); self.srcpad.push_event(event); self.sinkpad.pause_task().unwrap(); @@ -756,7 +755,7 @@ impl JsonGstParse { /* Drop our state while we push a serialized event upstream */ drop(state); - gst_debug!(CAT, obj: element, "Sending event {:?} upstream", event); + gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event); self.sinkpad.push_event(event); state = self.state.lock().unwrap(); @@ -777,7 +776,7 @@ impl JsonGstParse { fn src_event(&self, pad: &gst::Pad, element: &super::JsonGstParse, event: gst::Event) -> bool { use gst::EventView; - gst_log!(CAT, obj: pad, "Handling event {:?}", event); + 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), @@ -792,7 +791,7 @@ impl JsonGstParse { ) -> bool { use gst::QueryViewMut; - gst_log!(CAT, obj: pad, "Handling query {:?}", query); + gst::log!(CAT, obj: pad, "Handling query {:?}", query); match query.view_mut() { QueryViewMut::Seeking(q) => { @@ -974,7 +973,7 @@ impl ElementImpl for JsonGstParse { element: &Self::Type, transition: gst::StateChange, ) -> Result { - gst_trace!(CAT, obj: element, "Changing state {:?}", transition); + gst::trace!(CAT, obj: element, "Changing state {:?}", transition); match transition { gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { diff --git a/text/regex/src/gstregex/imp.rs b/text/regex/src/gstregex/imp.rs index 9535db26b..2ef24c1e6 100644 --- a/text/regex/src/gstregex/imp.rs +++ b/text/regex/src/gstregex/imp.rs @@ -7,7 +7,6 @@ // SPDX-License-Identifier: MPL-2.0 use gst::glib; -use gst::gst_error; use gst::prelude::*; use gst::subclass::prelude::*; @@ -54,14 +53,14 @@ impl RegEx { buffer: gst::Buffer, ) -> Result { let data = buffer.map_readable().map_err(|_| { - gst_error!(CAT, obj: element, "Can't map buffer readable"); + gst::error!(CAT, obj: element, "Can't map buffer readable"); gst::element_error!(element, gst::CoreError::Failed, ["Failed to map buffer"]); gst::FlowError::Error })?; let mut data = std::str::from_utf8(&data) .map_err(|err| { - gst_error!(CAT, obj: element, "Can't decode utf8: {}", err); + gst::error!(CAT, obj: element, "Can't decode utf8: {}", err); gst::element_error!( element, gst::StreamError::Decode, @@ -194,7 +193,7 @@ impl ObjectImpl for RegEx { let pattern = match s.get::>("pattern") { Ok(Some(pattern)) => pattern, Ok(None) | Err(_) => { - gst_error!(CAT, "All commands require a pattern field as a string"); + gst::error!(CAT, "All commands require a pattern field as a string"); continue; } }; @@ -202,7 +201,7 @@ impl ObjectImpl for RegEx { let regex = match Regex::new(&pattern) { Ok(regex) => regex, Err(err) => { - gst_error!(CAT, "Failed to compile regex: {:?}", err); + gst::error!(CAT, "Failed to compile regex: {:?}", err); continue; } }; @@ -212,7 +211,7 @@ impl ObjectImpl for RegEx { let replacement = match s.get::>("replacement") { Ok(Some(pattern)) => pattern, Ok(None) | Err(_) => { - gst_error!( + gst::error!( CAT, "Replace operations require a replacement field as a string" ); @@ -226,7 +225,7 @@ impl ObjectImpl for RegEx { }); } val => { - gst_error!(CAT, "Unknown operation {}", val); + gst::error!(CAT, "Unknown operation {}", val); } } } diff --git a/text/wrap/src/gsttextwrap/imp.rs b/text/wrap/src/gsttextwrap/imp.rs index 2c8423232..7572f3ad9 100644 --- a/text/wrap/src/gsttextwrap/imp.rs +++ b/text/wrap/src/gsttextwrap/imp.rs @@ -9,7 +9,6 @@ use gst::glib; use gst::prelude::*; use gst::subclass::prelude::*; -use gst::{gst_debug, gst_error, gst_info, gst_log}; use std::default::Default; use std::fs::File; @@ -124,7 +123,7 @@ impl TextWrap { state.options = if let Some(dictionary) = &settings.dictionary { let dict_file = match File::open(dictionary) { Err(err) => { - gst_error!(CAT, obj: element, "Failed to open dictionary file: {}", err); + gst::error!(CAT, obj: element, "Failed to open dictionary file: {}", err); return; } Ok(dict_file) => dict_file, @@ -133,7 +132,7 @@ impl TextWrap { let mut reader = io::BufReader::new(dict_file); let standard = match Standard::any_from_reader(&mut reader) { Err(err) => { - gst_error!( + gst::error!( CAT, obj: element, "Failed to load standard from file: {}", @@ -165,22 +164,22 @@ impl TextWrap { self.update_wrapper(element); let mut pts = buffer.pts().ok_or_else(|| { - gst_error!(CAT, obj: element, "Need timestamped buffers"); + gst::error!(CAT, obj: element, "Need timestamped buffers"); gst::FlowError::Error })?; let duration = buffer.duration().ok_or_else(|| { - gst_error!(CAT, obj: element, "Need buffers with duration"); + gst::error!(CAT, obj: element, "Need buffers with duration"); gst::FlowError::Error })?; let data = buffer.map_readable().map_err(|_| { - gst_error!(CAT, obj: element, "Can't map buffer readable"); + gst::error!(CAT, obj: element, "Can't map buffer readable"); gst::FlowError::Error })?; let data = std::str::from_utf8(&data).map_err(|err| { - gst_error!(CAT, obj: element, "Can't decode utf8: {}", err); + gst::error!(CAT, obj: element, "Can't decode utf8: {}", err); gst::FlowError::Error })?; @@ -254,7 +253,7 @@ impl TextWrap { .map(|l| l.to_string()) .collect::>() .join("\n"); - gst_info!( + gst::info!( CAT, obj: element, "Outputting contents {}, ts: {}, duration: {}", @@ -315,7 +314,7 @@ impl TextWrap { let data = chunk.join("\n"); let duration: gst::ClockTime = duration_per_word * data.split_whitespace().count() as u64; - gst_info!(CAT, "Pushing lines {}", data); + gst::info!(CAT, "Pushing lines {}", data); let mut buf = gst::Buffer::from_mut_slice(data.into_bytes()); { @@ -350,7 +349,7 @@ impl TextWrap { } fn sink_event(&self, pad: &gst::Pad, element: &super::TextWrap, event: gst::Event) -> bool { - gst_log!(CAT, obj: pad, "Handling event {:?}", event); + gst::log!(CAT, obj: pad, "Handling event {:?}", event); use gst::EventView; @@ -408,7 +407,7 @@ impl TextWrap { ) -> bool { use gst::QueryViewMut; - gst_log!(CAT, obj: pad, "Handling query {:?}", query); + gst::log!(CAT, obj: pad, "Handling query {:?}", query); match query.view_mut() { QueryViewMut::Latency(q) => { @@ -419,7 +418,7 @@ impl TextWrap { if ret { let (live, min, _) = peer_query.result(); let our_latency: gst::ClockTime = self.settings.lock().unwrap().accumulate_time; - gst_info!( + gst::info!( CAT, obj: element, "Reporting our latency {} + {}", @@ -567,7 +566,7 @@ impl ObjectImpl for TextWrap { settings.accumulate_time = gst::ClockTime::from_nseconds(value.get().expect("type checked upstream")); if settings.accumulate_time != old_accumulate_time { - gst_debug!( + gst::debug!( CAT, obj: obj, "Accumulate time changed: {}", @@ -652,7 +651,7 @@ impl ElementImpl for TextWrap { element: &Self::Type, transition: gst::StateChange, ) -> Result { - gst_info!(CAT, obj: element, "Changing state {:?}", transition); + gst::info!(CAT, obj: element, "Changing state {:?}", transition); if let gst::StateChange::PausedToReady = transition { let mut state = self.state.lock().unwrap(); -- cgit v1.2.3