Update to gst::_log_macro_

See the details:
https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/980

5 files changed, 60 insertions, 65 deletions

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<gst::DebugCategory> = 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::StateChangeSuccess, gst::StateChangeError> {
-        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<Option<gst::ClockTime>, 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::FlowSuccess, gst::FlowError> {
-        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<gst::ClockTime> = 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<gst::ClockTime> = 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::StateChangeSuccess, gst::StateChangeError> {
-        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<gst::FlowSuccess, gst::FlowError> {
         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::<Option<String>>("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::<Option<String>>("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::<Vec<String>>()
                             .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::StateChangeSuccess, gst::StateChangeError> {
-        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();