Update to gst::_log_macro_

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

8 files changed, 121 insertions, 125 deletions

diff --git a/audio/audiofx/src/audioloudnorm/imp.rs b/audio/audiofx/src/audioloudnorm/imp.rs
index e08d3231..93b5a5dc 100644
--- a/audio/audiofx/src/audioloudnorm/imp.rs
+++ b/audio/audiofx/src/audioloudnorm/imp.rs
@@ -15,7 +15,6 @@
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{gst_debug, gst_error, gst_info, gst_log};
 
 use std::mem;
 use std::sync::Mutex;
@@ -265,7 +264,7 @@ impl State {
 
     // Drains everything
     fn drain(&mut self, element: &super::AudioLoudNorm) -> Result<gst::Buffer, gst::FlowError> {
-        gst_debug!(CAT, obj: element, "Draining");
+        gst::debug!(CAT, obj: element, "Draining");
 
         let (pts, distance) = self.adapter.prev_pts();
         let distance_samples = distance / self.info.bpf() as u64;
@@ -300,7 +299,7 @@ impl State {
             self.frame_type = FrameType::Final;
         } else if src.is_empty() {
             // Nothing to drain at all
-            gst_debug!(CAT, obj: element, "No data to drain");
+            gst::debug!(CAT, obj: element, "No data to drain");
             return Err(gst::FlowError::Eos);
         }
 
@@ -344,7 +343,7 @@ impl State {
             }
         }
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Calculated global loudness for first frame {} with peak {}",
@@ -398,7 +397,7 @@ impl State {
             *delta = f64::powf(10.0, env_shortterm / 20.);
         }
         self.prev_delta = self.delta[self.index];
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Initializing for first frame with gain adjustment of {}",
@@ -460,7 +459,7 @@ impl State {
             self.index + 11 - 30
         });
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Applying gain adjustment {}-{}",
@@ -534,7 +533,7 @@ impl State {
             .relative_threshold()
             .map_err(|_| gst::FlowError::Error)?;
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Calculated global loudness {}, short term loudness {} and relative threshold {}",
@@ -557,7 +556,7 @@ impl State {
                 .map_err(|_| gst::FlowError::Error)?;
             if shortterm_out >= self.target_i {
                 self.above_threshold = true;
-                gst_debug!(
+                gst::debug!(
                     CAT,
                     obj: element,
                     "Above threshold now ({} >= {}, {} > -70)",
@@ -585,7 +584,7 @@ impl State {
         }
 
         self.prev_delta = self.delta[self.index];
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Calculated new gain adjustment {}",
@@ -789,7 +788,7 @@ impl State {
     ) -> Result<(gst::Buffer, Option<gst::ClockTime>), gst::FlowError> {
         // Apply a linear scale factor to the whole buffer
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Applying linear gain adjustment of {}",
@@ -868,7 +867,7 @@ impl State {
             // LIMITER_ATTACK_WINDOW before the peak position.
             smp_cnt += LIMITER_LOOKAHEAD + peak_delta - LIMITER_ATTACK_WINDOW;
 
-            gst_debug!(
+            gst::debug!(
                            CAT,
                            obj: element,
                            "Found peak {} at sample {}, going to attack state at sample {} (gain reduction {}-{})",
@@ -1005,7 +1004,7 @@ impl State {
                     self.env_cnt = 0;
                     self.sustain_cnt = None;
 
-                    gst_debug!(
+                    gst::debug!(
                                     CAT,
                                     obj: element,
                                     "Found new peak {} at sample {}, restarting attack state at sample {} (gain reduction {}-{})",
@@ -1054,7 +1053,7 @@ impl State {
                     // reach the new peak
                     self.sustain_cnt = Some(self.env_cnt);
 
-                    gst_debug!(
+                    gst::debug!(
                                     CAT,
                                     obj: element,
                                     "Found new peak {} at sample {}, adjusting attack state at sample {} (gain reduction {}-{})",
@@ -1069,7 +1068,7 @@ impl State {
             } else {
                 // We're ending the attack state this much before the new peak so need
                 // to ensure that we at least sustain it for that long afterwards.
-                gst_debug!(
+                gst::debug!(
                     CAT,
                     obj: element,
                     "Found new low peak {} at sample {} in attack state at sample {}",
@@ -1085,7 +1084,7 @@ impl State {
 
         if self.env_cnt == LIMITER_ATTACK_WINDOW && smp_cnt < nb_samples {
             // If we reached the target gain reduction, go into sustain state.
-            gst_debug!(
+            gst::debug!(
                 CAT,
                 obj: element,
                 "Going to sustain state at sample {} (gain reduction {})",
@@ -1164,7 +1163,7 @@ impl State {
                     self.gain_reduction[0] = self.gain_reduction[1];
                     self.gain_reduction[1] = gain_reduction;
 
-                    gst_debug!(
+                    gst::debug!(
                                     CAT,
                                     obj: element,
                                     "Found new peak {} at sample {}, going back to attack state at sample {} (gain reduction {}-{})",
@@ -1175,7 +1174,7 @@ impl State {
                                     self.gain_reduction[1],
                                 );
                 } else {
-                    gst_debug!(
+                    gst::debug!(
                                     CAT,
                                     obj: element,
                                     "Found new peak {} at sample {}, going sustain further at sample {} (gain reduction {})",
@@ -1202,7 +1201,7 @@ impl State {
             self.gain_reduction[1] = 1.;
             self.env_cnt = 0;
 
-            gst_debug!(
+            gst::debug!(
                 CAT,
                 obj: element,
                 "Going to release state for sample {} at sample {} (gain reduction {}-1.0)",
@@ -1272,7 +1271,7 @@ impl State {
                 self.gain_reduction[0] = current_gain_reduction;
                 self.gain_reduction[1] = gain_reduction;
 
-                gst_debug!(
+                gst::debug!(
                                CAT,
                                obj: element,
                                "Found new peak {} at sample {}, going back to attack state at sample {} (gain reduction {}-{})",
@@ -1284,7 +1283,7 @@ impl State {
                             );
             } else {
                 self.gain_reduction[1] = current_gain_reduction;
-                gst_debug!(
+                gst::debug!(
                                 CAT,
                                 obj: element,
                                 "Going from release to sustain state at sample {} because of low peak {} at sample {} (gain reduction {})",
@@ -1325,7 +1324,7 @@ impl State {
         // If we're done with the release, go to out state
         if smp_cnt < nb_samples {
             self.limiter_state = LimiterState::Out;
-            gst_debug!(
+            gst::debug!(
                 CAT,
                 obj: element,
                 "Leaving release state and going to out state at sample {}",
@@ -1363,7 +1362,7 @@ impl State {
             self.limiter_state = LimiterState::Sustain;
             self.sustain_cnt = Some(LIMITER_LOOKAHEAD);
             self.gain_reduction[1] = self.target_tp / max;
-            gst_debug!(
+            gst::debug!(
                 CAT,
                 obj: element,
                 "Reducing gain for start of first frame by {} ({} > {}) and going to sustain state",
@@ -1381,7 +1380,7 @@ impl State {
         let channels = self.info.channels() as usize;
         let nb_samples = dst.len() / channels;
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Running limiter for {} samples",
@@ -1556,12 +1555,12 @@ impl AudioLoudNorm {
         element: &super::AudioLoudNorm,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst_log!(CAT, obj: element, "Handling buffer {:?}", buffer);
+        gst::log!(CAT, obj: element, "Handling buffer {:?}", buffer);
 
         let mut state_guard = self.state.borrow_mut();
         let state = match *state_guard {
             None => {
-                gst_error!(CAT, obj: element, "Not negotiated yet");
+                gst::error!(CAT, obj: element, "Not negotiated yet");
                 return Err(gst::FlowError::NotNegotiated);
             }
             Some(ref mut state) => state,
@@ -1569,7 +1568,7 @@ impl AudioLoudNorm {
 
         let mut outbufs = vec![];
         if buffer.flags().contains(gst::BufferFlags::DISCONT) {
-            gst_debug!(CAT, obj: element, "Draining on discontinuity");
+            gst::debug!(CAT, obj: element, "Draining on discontinuity");
             match state.drain(element) {
                 Ok(outbuf) => {
                     outbufs.push(outbuf);
@@ -1587,7 +1586,7 @@ impl AudioLoudNorm {
         drop(state_guard);
 
         for buffer in outbufs {
-            gst_log!(CAT, obj: element, "Outputting buffer {:?}", buffer);
+            gst::log!(CAT, obj: element, "Outputting buffer {:?}", buffer);
             self.srcpad.push(buffer)?;
         }
 
@@ -1602,17 +1601,17 @@ impl AudioLoudNorm {
     ) -> 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(c) => {
                 let caps = c.caps();
-                gst_info!(CAT, obj: pad, "Got caps {:?}", caps);
+                gst::info!(CAT, obj: pad, "Got caps {:?}", caps);
 
                 let info = match gst_audio::AudioInfo::from_caps(caps) {
                     Ok(info) => info,
                     Err(_) => {
-                        gst_error!(CAT, obj: pad, "Failed to parse caps");
+                        gst::error!(CAT, obj: pad, "Failed to parse caps");
                         return false;
                     }
                 };
@@ -1630,9 +1629,9 @@ impl AudioLoudNorm {
                 drop(state);
 
                 if let Some(outbuf) = outbuf {
-                    gst_log!(CAT, obj: element, "Outputting buffer {:?}", outbuf);
+                    gst::log!(CAT, obj: element, "Outputting buffer {:?}", outbuf);
                     if let Err(err) = self.srcpad.push(outbuf) {
-                        gst_error!(CAT, obj: element, "Failed to push drained data: {}", err);
+                        gst::error!(CAT, obj: element, "Failed to push drained data: {}", err);
 
                         return false;
                     }
@@ -1652,9 +1651,9 @@ impl AudioLoudNorm {
                 drop(state);
 
                 if let Some(outbuf) = outbuf {
-                    gst_log!(CAT, obj: element, "Outputting buffer {:?}", outbuf);
+                    gst::log!(CAT, obj: element, "Outputting buffer {:?}", outbuf);
                     if let Err(err) = self.srcpad.push(outbuf) {
-                        gst_error!(
+                        gst::error!(
                             CAT,
                             obj: element,
                             "Failed to push drained data on EOS: {}",
@@ -1691,7 +1690,7 @@ impl AudioLoudNorm {
     ) -> 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) => {
                 let mut peer_query = gst::query::Latency::new();
diff --git a/audio/audiofx/src/audiornnoise/imp.rs b/audio/audiofx/src/audiornnoise/imp.rs
index ea12101c..8a90c476 100644
--- a/audio/audiofx/src/audiornnoise/imp.rs
+++ b/audio/audiofx/src/audiornnoise/imp.rs
@@ -10,7 +10,6 @@
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{gst_debug, gst_error};
 use gst_base::subclass::base_transform::BaseTransformImplExt;
 use gst_base::subclass::base_transform::GenerateOutputSuccess;
 use gst_base::subclass::prelude::*;
@@ -132,7 +131,7 @@ impl AudioRNNoise {
         }
 
         let mut buffer = gst::Buffer::with_size(available).map_err(|e| {
-            gst_error!(
+            gst::error!(
                 CAT,
                 obj: element,
                 "Failed to allocate buffer at EOS {:?}",
@@ -279,7 +278,7 @@ impl BaseTransformImpl for AudioRNNoise {
             ));
         }
 
-        gst_debug!(CAT, obj: element, "Set caps to {}", incaps);
+        gst::debug!(CAT, obj: element, "Set caps to {}", incaps);
 
         let in_info = gst_audio::AudioInfo::from_caps(incaps)
             .map_err(|e| gst::loggable_error!(CAT, "Failed to parse input caps {:?}", e))?;
@@ -337,7 +336,7 @@ impl BaseTransformImpl for AudioRNNoise {
         use gst::EventView;
 
         if let EventView::Eos(_) = event.view() {
-            gst_debug!(CAT, obj: element, "Handling EOS");
+            gst::debug!(CAT, obj: element, "Handling EOS");
             if self.drain(element).is_err() {
                 return false;
             }
@@ -357,7 +356,7 @@ impl BaseTransformImpl for AudioRNNoise {
                 let mut upstream_query = gst::query::Latency::new();
                 if sink_pad.peer_query(&mut upstream_query) {
                     let (live, mut min, mut max) = upstream_query.result();
-                    gst_debug!(
+                    gst::debug!(
                         CAT,
                         obj: element,
                         "Peer latency: live {} min {} max {}",
diff --git a/audio/audiofx/src/ebur128level/imp.rs b/audio/audiofx/src/ebur128level/imp.rs
index 41ba5791..971d13f8 100644
--- a/audio/audiofx/src/ebur128level/imp.rs
+++ b/audio/audiofx/src/ebur128level/imp.rs
@@ -9,7 +9,6 @@
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{gst_debug, gst_error, gst_info};
 use gst_base::prelude::*;
 use gst_base::subclass::prelude::*;
 
@@ -132,7 +131,7 @@ impl ObjectImpl for EbuR128Level {
                         let this = args[0].get::<super::EbuR128Level>().unwrap();
                         let imp = this.imp();
 
-                        gst_info!(CAT, obj: &this, "Resetting measurements",);
+                        gst::info!(CAT, obj: &this, "Resetting measurements",);
                         imp.reset.store(true, atomic::Ordering::SeqCst);
 
                         None
@@ -188,7 +187,7 @@ impl ObjectImpl for EbuR128Level {
         match pspec.name() {
             "mode" => {
                 let mode = value.get().expect("type checked upstream");
-                gst_info!(
+                gst::info!(
                     CAT,
                     obj: obj,
                     "Changing mode from {:?} to {:?}",
@@ -199,7 +198,7 @@ impl ObjectImpl for EbuR128Level {
             }
             "post-messages" => {
                 let post_messages = value.get().expect("type checked upstream");
-                gst_info!(
+                gst::info!(
                     CAT,
                     obj: obj,
                     "Changing post-messages from {} to {}",
@@ -211,7 +210,7 @@ impl ObjectImpl for EbuR128Level {
             "interval" => {
                 let interval =
                     gst::ClockTime::from_nseconds(value.get().expect("type checked upstream"));
-                gst_info!(
+                gst::info!(
                     CAT,
                     obj: obj,
                     "Changing interval from {} to {}",
@@ -309,7 +308,7 @@ impl BaseTransformImpl for EbuR128Level {
             Ok(info) => info,
         };
 
-        gst_debug!(CAT, obj: element, "Configured for caps {}", incaps,);
+        gst::debug!(CAT, obj: element, "Configured for caps {}", incaps,);
 
         let settings = *self.settings.lock().unwrap();
 
@@ -370,7 +369,7 @@ impl BaseTransformImpl for EbuR128Level {
                         gst_audio::AudioChannelPosition::Invalid
                         | gst_audio::AudioChannelPosition::None => ebur128::Channel::Unused,
                         val => {
-                            gst_debug!(
+                            gst::debug!(
                                 CAT,
                                 obj: element,
                                 "Unknown channel position {:?}, ignoring channel",
@@ -414,7 +413,7 @@ impl BaseTransformImpl for EbuR128Level {
         // Drop state
         let _ = self.state.borrow_mut().take();
 
-        gst_info!(CAT, obj: element, "Stopped");
+        gst::info!(CAT, obj: element, "Stopped");
 
         Ok(())
     }
@@ -504,7 +503,7 @@ impl BaseTransformImpl for EbuR128Level {
                     if state.ebur128.mode().contains(ebur128::Mode::M) {
                         match state.ebur128.loudness_momentary() {
                             Ok(loudness) => s.set("momentary-loudness", &loudness),
-                            Err(err) => gst_error!(
+                            Err(err) => gst::error!(
                                 CAT,
                                 obj: element,
                                 "Failed to get momentary loudness: {}",
@@ -516,7 +515,7 @@ impl BaseTransformImpl for EbuR128Level {
                     if state.ebur128.mode().contains(ebur128::Mode::S) {
                         match state.ebur128.loudness_shortterm() {
                             Ok(loudness) => s.set("shortterm-loudness", &loudness),
-                            Err(err) => gst_error!(
+                            Err(err) => gst::error!(
                                 CAT,
                                 obj: element,
                                 "Failed to get shortterm loudness: {}",
@@ -528,7 +527,7 @@ impl BaseTransformImpl for EbuR128Level {
                     if state.ebur128.mode().contains(ebur128::Mode::I) {
                         match state.ebur128.loudness_global() {
                             Ok(loudness) => s.set("global-loudness", &loudness),
-                            Err(err) => gst_error!(
+                            Err(err) => gst::error!(
                                 CAT,
                                 obj: element,
                                 "Failed to get global loudness: {}",
@@ -538,7 +537,7 @@ impl BaseTransformImpl for EbuR128Level {
 
                         match state.ebur128.relative_threshold() {
                             Ok(threshold) => s.set("relative-threshold", &threshold),
-                            Err(err) => gst_error!(
+                            Err(err) => gst::error!(
                                 CAT,
                                 obj: element,
                                 "Failed to get relative threshold: {}",
@@ -550,7 +549,7 @@ impl BaseTransformImpl for EbuR128Level {
                     if state.ebur128.mode().contains(ebur128::Mode::LRA) {
                         match state.ebur128.loudness_range() {
                             Ok(range) => s.set("loudness-range", &range),
-                            Err(err) => gst_error!(
+                            Err(err) => gst::error!(
                                 CAT,
                                 obj: element,
                                 "Failed to get loudness range: {}",
@@ -567,7 +566,12 @@ impl BaseTransformImpl for EbuR128Level {
                         match peaks {
                             Ok(peaks) => s.set("sample-peak", gst::Array::from(peaks)),
                             Err(err) => {
-                                gst_error!(CAT, obj: element, "Failed to get sample peaks: {}", err)
+                                gst::error!(
+                                    CAT,
+                                    obj: element,
+                                    "Failed to get sample peaks: {}",
+                                    err
+                                )
                             }
                         }
                     }
@@ -580,12 +584,12 @@ impl BaseTransformImpl for EbuR128Level {
                         match peaks {
                             Ok(peaks) => s.set("true-peak", gst::Array::from(peaks)),
                             Err(err) => {
-                                gst_error!(CAT, obj: element, "Failed to get true peaks: {}", err)
+                                gst::error!(CAT, obj: element, "Failed to get true peaks: {}", err)
                             }
                         }
                     }
 
-                    gst_debug!(CAT, obj: element, "Posting message {}", s);
+                    gst::debug!(CAT, obj: element, "Posting message {}", s);
 
                     let msg = gst::message::Element::builder(s).src(element).build();
 
@@ -750,12 +754,12 @@ fn interleaved_channel_data_into_slice<'a, T: FromByteSlice>(
 ) -> Result<&'a [T], gst::FlowError> {
     buf.plane_data(0)
         .map_err(|err| {
-            gst_error!(CAT, obj: element, "Failed to get audio data: {}", err);
+            gst::error!(CAT, obj: element, "Failed to get audio data: {}", err);
             gst::FlowError::Error
         })?
         .as_slice_of::<T>()
         .map_err(|err| {
-            gst_error!(CAT, obj: element, "Failed to handle audio data: {}", err);
+            gst::error!(CAT, obj: element, "Failed to handle audio data: {}", err);
             gst::FlowError::Error
         })
 }
@@ -769,12 +773,12 @@ fn non_interleaved_channel_data_into_slices<'a, T: FromByteSlice>(
         .map(|c| {
             buf.plane_data(c)
                 .map_err(|err| {
-                    gst_error!(CAT, obj: element, "Failed to get audio data: {}", err);
+                    gst::error!(CAT, obj: element, "Failed to get audio data: {}", err);
                     gst::FlowError::Error
                 })?
                 .as_slice_of::<T>()
                 .map_err(|err| {
-                    gst_error!(CAT, obj: element, "Failed to handle audio data: {}", err);
+                    gst::error!(CAT, obj: element, "Failed to handle audio data: {}", err);
                     gst::FlowError::Error
                 })
         })
diff --git a/audio/audiofx/src/hrtfrender/imp.rs b/audio/audiofx/src/hrtfrender/imp.rs
index 847217de..a0294b12 100644
--- a/audio/audiofx/src/hrtfrender/imp.rs
+++ b/audio/audiofx/src/hrtfrender/imp.rs
@@ -9,7 +9,6 @@
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{gst_debug, gst_error, gst_log};
 
 use gst_base::subclass::prelude::*;
 
@@ -225,7 +224,7 @@ impl HrtfRender {
         let mut outbuf =
             gst_audio::AudioBufferRef::from_buffer_ref_writable(outbuf, &state.outinfo).map_err(
                 |err| {
-                    gst_error!(CAT, obj: element, "Failed to map buffer : {}", err);
+                    gst::error!(CAT, obj: element, "Failed to map buffer : {}", err);
                     gst::FlowError::Error
                 },
             )?;
@@ -249,13 +248,13 @@ impl HrtfRender {
 
         while state.adapter.available() >= inblksz {
             let inbuf = state.adapter.take_buffer(inblksz).map_err(|_| {
-                gst_error!(CAT, obj: element, "Failed to map buffer");
+                gst::error!(CAT, obj: element, "Failed to map buffer");
                 gst::FlowError::Error
             })?;
 
             let inbuf = gst_audio::AudioBuffer::from_buffer_readable(inbuf, &state.ininfo)
                 .map_err(|_| {
-                    gst_error!(CAT, obj: element, "Failed to map buffer");
+                    gst::error!(CAT, obj: element, "Failed to map buffer");
                     gst::FlowError::Error
                 })?;
 
@@ -497,7 +496,7 @@ impl ObjectImpl for HrtfRender {
 
                 if let Some(state) = state_guard.as_mut() {
                     if objs.len() != state.ininfo.channels() as usize {
-                        gst::gst_warning!(
+                        gst::warning!(
                             CAT,
                             "Could not update spatial objects, expected {} channels, got {}",
                             state.ininfo.channels(),
@@ -647,7 +646,7 @@ impl BaseTransformImpl for HrtfRender {
             full_blocks * state.output_block_size()
         };
 
-        gst_log!(
+        gst::log!(
             CAT,
             obj: element,
             "Adapter size: {}, input size {}, transformed size {}",
@@ -694,7 +693,7 @@ impl BaseTransformImpl for HrtfRender {
             other_caps = filter.intersect_with_mode(&other_caps, gst::CapsIntersectMode::First);
         }
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Transformed caps from {} to {} in direction {:?}",
@@ -772,7 +771,7 @@ impl BaseTransformImpl for HrtfRender {
             adapter: gst_base::UniqueAdapter::new(),
         });
 
-        gst_debug!(CAT, obj: element, "Configured for caps {}", incaps);
+        gst::debug!(CAT, obj: element, "Configured for caps {}", incaps);
 
         Ok(())
     }
@@ -780,7 +779,7 @@ impl BaseTransformImpl for HrtfRender {
     fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         use gst::EventView;
 
-        gst_debug!(CAT, "Handling event {:?}", event);
+        gst::debug!(CAT, "Handling event {:?}", event);
 
         match event.view() {
             EventView::FlushStop(_) => {
@@ -794,7 +793,7 @@ impl BaseTransformImpl for HrtfRender {
             }
             EventView::Eos(_) => {
                 if self.drain(element).is_err() {
-                    gst::gst_warning!(CAT, "Failed to drain internal buffer");
+                    gst::warning!(CAT, "Failed to drain internal buffer");
                     gst::element_warning!(
                         element,
                         gst::CoreError::Event,
diff --git a/audio/claxon/src/claxondec/imp.rs b/audio/claxon/src/claxondec/imp.rs
index 066b9380..e7a59ea1 100644
--- a/audio/claxon/src/claxondec/imp.rs
+++ b/audio/claxon/src/claxondec/imp.rs
@@ -10,7 +10,6 @@
 
 use gst::glib;
 use gst::subclass::prelude::*;
-use gst::{gst_debug, gst_error};
 use gst_audio::prelude::*;
 use gst_audio::subclass::prelude::*;
 
@@ -120,7 +119,7 @@ impl AudioDecoderImpl for ClaxonDec {
     }
 
     fn set_format(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
-        gst_debug!(CAT, obj: element, "Setting format {:?}", caps);
+        gst::debug!(CAT, obj: element, "Setting format {:?}", caps);
 
         let mut audio_info: Option<gst_audio::AudioInfo> = None;
 
@@ -129,7 +128,7 @@ impl AudioDecoderImpl for ClaxonDec {
             let streamheaders = streamheaders.as_slice();
 
             if streamheaders.len() < 2 {
-                gst_debug!(
+                gst::debug!(
                     CAT,
                     obj: element,
                     "Not enough streamheaders, trying in-band"
@@ -137,18 +136,18 @@ impl AudioDecoderImpl for ClaxonDec {
             } else {
                 let ident_buf = streamheaders[0].get::<Option<gst::Buffer>>();
                 if let Ok(Some(ident_buf)) = ident_buf {
-                    gst_debug!(CAT, obj: element, "Got streamheader buffers");
+                    gst::debug!(CAT, obj: element, "Got streamheader buffers");
                     let inmap = ident_buf.map_readable().unwrap();
 
                     if inmap[0..7] != [0x7f, b'F', b'L', b'A', b'C', 0x01, 0x00] {
-                        gst_debug!(CAT, obj: element, "Unknown streamheader format");
+                        gst::debug!(CAT, obj: element, "Unknown streamheader format");
                     } else if let Ok(tstreaminfo) = claxon_streaminfo(&inmap[13..]) {
                         if let Ok(taudio_info) = gstaudioinfo(&tstreaminfo) {
                             // To speed up negotiation
                             if element.set_output_format(&taudio_info).is_err()
                                 || element.negotiate().is_err()
                             {
-                                gst_debug!(
+                                gst::debug!(
                                     CAT,
                                     obj: element,
                                     "Error to negotiate output from based on in-caps streaminfo"
@@ -174,7 +173,7 @@ impl AudioDecoderImpl for ClaxonDec {
         element: &Self::Type,
         inbuf: Option<&gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst_debug!(CAT, obj: element, "Handling buffer {:?}", inbuf);
+        gst::debug!(CAT, obj: element, "Handling buffer {:?}", inbuf);
 
         let inbuf = match inbuf {
             None => return Ok(gst::FlowSuccess::Ok),
@@ -182,7 +181,7 @@ impl AudioDecoderImpl for ClaxonDec {
         };
 
         let inmap = inbuf.map_readable().map_err(|_| {
-            gst_error!(CAT, obj: element, "Failed to buffer readable");
+            gst::error!(CAT, obj: element, "Failed to buffer readable");
             gst::FlowError::Error
         })?;
 
@@ -190,16 +189,16 @@ impl AudioDecoderImpl for ClaxonDec {
         let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?;
 
         if inmap.as_slice() == b"fLaC" {
-            gst_debug!(CAT, obj: element, "fLaC buffer received");
+            gst::debug!(CAT, obj: element, "fLaC buffer received");
         } else if inmap[0] & 0x7F == 0x00 {
-            gst_debug!(CAT, obj: element, "Streaminfo header buffer received");
+            gst::debug!(CAT, obj: element, "Streaminfo header buffer received");
             return self.handle_streaminfo_header(element, state, inmap.as_ref());
         } else if inmap[0] == 0b1111_1111 && inmap[1] & 0b1111_1100 == 0b1111_1000 {
-            gst_debug!(CAT, obj: element, "Data buffer received");
+            gst::debug!(CAT, obj: element, "Data buffer received");
             return self.handle_data(element, state, inmap.as_ref());
         } else {
             // info about other headers in flacparse and https://xiph.org/flac/format.html
-            gst_debug!(
+            gst::debug!(
                 CAT,
                 obj: element,
                 "Other header buffer received {:?}",
@@ -228,7 +227,7 @@ impl ClaxonDec {
             gst::FlowError::Error
         })?;
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Successfully parsed headers: {:?}",
diff --git a/audio/csound/src/filter/imp.rs b/audio/csound/src/filter/imp.rs
index 70246c78..52faf47a 100644
--- a/audio/csound/src/filter/imp.rs
+++ b/audio/csound/src/filter/imp.rs
@@ -9,9 +9,7 @@
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{
-    element_error, error_msg, gst_debug, gst_error, gst_info, gst_log, gst_warning, loggable_error,
-};
+use gst::{element_error, error_msg, loggable_error};
 use gst_base::subclass::base_transform::GenerateOutputSuccess;
 use gst_base::subclass::prelude::*;
 
@@ -163,12 +161,12 @@ impl CsoundFilter {
 
     fn message_callback(msg_type: MessageType, msg: &str) {
         match msg_type {
-            MessageType::CSOUNDMSG_ERROR => gst_error!(CAT, "{}", msg),
-            MessageType::CSOUNDMSG_WARNING => gst_warning!(CAT, "{}", msg),
-            MessageType::CSOUNDMSG_ORCH => gst_info!(CAT, "{}", msg),
-            MessageType::CSOUNDMSG_REALTIME => gst_log!(CAT, "{}", msg),
-            MessageType::CSOUNDMSG_DEFAULT => gst_log!(CAT, "{}", msg),
-            MessageType::CSOUNDMSG_STDOUT => gst_log!(CAT, "{}", msg),
+            MessageType::CSOUNDMSG_ERROR => gst::error!(CAT, "{}", msg),
+            MessageType::CSOUNDMSG_WARNING => gst::warning!(CAT, "{}", msg),
+            MessageType::CSOUNDMSG_ORCH => gst::info!(CAT, "{}", msg),
+            MessageType::CSOUNDMSG_REALTIME => gst::log!(CAT, "{}", msg),
+            MessageType::CSOUNDMSG_DEFAULT => gst::log!(CAT, "{}", msg),
+            MessageType::CSOUNDMSG_STDOUT => gst::log!(CAT, "{}", msg),
         }
     }
 
@@ -193,7 +191,7 @@ impl CsoundFilter {
             (avail / state.in_info.channels() as usize) * state.out_info.channels() as usize;
 
         let mut buffer = gst::Buffer::with_size(out_bytes).map_err(|e| {
-            gst_error!(
+            gst::error!(
                 CAT,
                 obj: element,
                 "Failed to allocate buffer at EOS {:?}",
@@ -257,7 +255,7 @@ impl CsoundFilter {
         outbuf.set_pts(pts);
         outbuf.set_duration(duration);
 
-        gst_log!(
+        gst::log!(
             CAT,
             obj: element,
             "Generating output at: {} - duration: {}",
@@ -510,7 +508,7 @@ impl BaseTransformImpl for CsoundFilter {
         csound.reset();
         let _ = self.state.lock().unwrap().take();
 
-        gst_info!(CAT, obj: element, "Stopped");
+        gst::info!(CAT, obj: element, "Stopped");
 
         Ok(())
     }
@@ -519,7 +517,7 @@ impl BaseTransformImpl for CsoundFilter {
         use gst::EventView;
 
         if let EventView::Eos(_) = event.view() {
-            gst_log!(CAT, obj: element, "Handling Eos");
+            gst::log!(CAT, obj: element, "Handling Eos");
             if self.drain(element).is_err() {
                 return false;
             }
@@ -563,7 +561,7 @@ impl BaseTransformImpl for CsoundFilter {
             new_caps
         };
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Transformed caps from {} to {} in direction {:?}",
@@ -665,7 +663,7 @@ impl BaseTransformImpl for CsoundFilter {
                 return self.generate_output(element, state);
             }
         }
-        gst_log!(CAT, "No enough data to generate output");
+        gst::log!(CAT, "No enough data to generate output");
         Ok(GenerateOutputSuccess::NoOutput)
     }
 }
diff --git a/audio/lewton/src/lewtondec/imp.rs b/audio/lewton/src/lewtondec/imp.rs
index 56e293f5..92abc8b2 100644
--- a/audio/lewton/src/lewtondec/imp.rs
+++ b/audio/lewton/src/lewtondec/imp.rs
@@ -10,7 +10,6 @@
 
 use gst::glib;
 use gst::subclass::prelude::*;
-use gst::{gst_debug, gst_error, gst_warning};
 use gst_audio::audio_decoder_error;
 use gst_audio::prelude::*;
 use gst_audio::subclass::prelude::*;
@@ -123,7 +122,7 @@ impl AudioDecoderImpl for LewtonDec {
     }
 
     fn set_format(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
-        gst_debug!(CAT, obj: element, "Setting format {:?}", caps);
+        gst::debug!(CAT, obj: element, "Setting format {:?}", caps);
 
         // When the caps are changing we require new headers
         let mut state_guard = self.state.borrow_mut();
@@ -141,7 +140,7 @@ impl AudioDecoderImpl for LewtonDec {
         if let Ok(Some(streamheaders)) = s.get_optional::<gst::ArrayRef>("streamheader") {
             let streamheaders = streamheaders.as_slice();
             if streamheaders.len() < 3 {
-                gst_debug!(
+                gst::debug!(
                     CAT,
                     obj: element,
                     "Not enough streamheaders, trying in-band"
@@ -155,7 +154,7 @@ impl AudioDecoderImpl for LewtonDec {
             if let (Ok(Some(ident_buf)), Ok(Some(comment_buf)), Ok(Some(setup_buf))) =
                 (ident_buf, comment_buf, setup_buf)
             {
-                gst_debug!(CAT, obj: element, "Got streamheader buffers");
+                gst::debug!(CAT, obj: element, "Got streamheader buffers");
                 state.header_bufs = (Some(ident_buf), Some(comment_buf), Some(setup_buf));
             }
         }
@@ -164,7 +163,7 @@ impl AudioDecoderImpl for LewtonDec {
     }
 
     fn flush(&self, element: &Self::Type, _hard: bool) {
-        gst_debug!(CAT, obj: element, "Flushing");
+        gst::debug!(CAT, obj: element, "Flushing");
 
         let mut state_guard = self.state.borrow_mut();
         if let Some(ref mut state) = *state_guard {
@@ -177,7 +176,7 @@ impl AudioDecoderImpl for LewtonDec {
         element: &Self::Type,
         inbuf: Option<&gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst_debug!(CAT, obj: element, "Handling buffer {:?}", inbuf);
+        gst::debug!(CAT, obj: element, "Handling buffer {:?}", inbuf);
 
         let inbuf = match inbuf {
             None => return Ok(gst::FlowSuccess::Ok),
@@ -185,7 +184,7 @@ impl AudioDecoderImpl for LewtonDec {
         };
 
         let inmap = inbuf.map_readable().map_err(|_| {
-            gst_error!(CAT, obj: element, "Failed to buffer readable");
+            gst::error!(CAT, obj: element, "Failed to buffer readable");
             gst::FlowError::Error
         })?;
 
@@ -199,7 +198,7 @@ impl AudioDecoderImpl for LewtonDec {
             if state.headerset.is_some() {
                 return Ok(gst::FlowSuccess::Ok);
             } else {
-                gst_error!(CAT, obj: element, "Got empty packet before all headers");
+                gst::error!(CAT, obj: element, "Got empty packet before all headers");
                 return Err(gst::FlowError::Error);
             }
         }
@@ -228,26 +227,26 @@ impl LewtonDec {
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         // ident header
         if indata[0] == 0x01 {
-            gst_debug!(CAT, obj: element, "Got ident header buffer");
+            gst::debug!(CAT, obj: element, "Got ident header buffer");
             state.header_bufs = (Some(inbuf.clone()), None, None);
         } else if indata[0] == 0x03 {
             // comment header
             if state.header_bufs.0.is_none() {
-                gst_warning!(CAT, obj: element, "Got comment header before ident header");
+                gst::warning!(CAT, obj: element, "Got comment header before ident header");
             } else {
-                gst_debug!(CAT, obj: element, "Got comment header buffer");
+                gst::debug!(CAT, obj: element, "Got comment header buffer");
                 state.header_bufs.1 = Some(inbuf.clone());
             }
         } else if indata[0] == 0x05 {
             // setup header
             if state.header_bufs.0.is_none() || state.header_bufs.1.is_none() {
-                gst_warning!(
+                gst::warning!(
                     CAT,
                     obj: element,
                     "Got setup header before ident/comment header"
                 );
             } else {
-                gst_debug!(CAT, obj: element, "Got setup header buffer");
+                gst::debug!(CAT, obj: element, "Got setup header buffer");
                 state.header_bufs.2 = Some(inbuf.clone());
             }
         }
@@ -276,7 +275,7 @@ impl LewtonDec {
 
         // First try to parse the headers
         let ident_map = ident_buf.map_readable().map_err(|_| {
-            gst_error!(CAT, obj: element, "Failed to map ident buffer readable");
+            gst::error!(CAT, obj: element, "Failed to map ident buffer readable");
             gst::FlowError::Error
         })?;
         let ident = lewton::header::read_header_ident(ident_map.as_ref()).map_err(|err| {
@@ -289,7 +288,7 @@ impl LewtonDec {
         })?;
 
         let comment_map = comment_buf.map_readable().map_err(|_| {
-            gst_error!(CAT, obj: element, "Failed to map comment buffer readable");
+            gst::error!(CAT, obj: element, "Failed to map comment buffer readable");
             gst::FlowError::Error
         })?;
         let comment = lewton::header::read_header_comment(comment_map.as_ref()).map_err(|err| {
@@ -302,7 +301,7 @@ impl LewtonDec {
         })?;
 
         let setup_map = setup_buf.map_readable().map_err(|_| {
-            gst_error!(CAT, obj: element, "Failed to map setup buffer readable");
+            gst::error!(CAT, obj: element, "Failed to map setup buffer readable");
             gst::FlowError::Error
         })?;
         let setup = lewton::header::read_header_setup(
@@ -338,7 +337,7 @@ impl LewtonDec {
 
             let mut map = [0; 8];
             if gst_audio::channel_reorder_map(from, to, &mut map[..channels]).is_err() {
-                gst_error!(
+                gst::error!(
                     CAT,
                     obj: element,
                     "Failed to generate channel reorder map from {:?} to {:?}",
@@ -354,7 +353,7 @@ impl LewtonDec {
         }
         let audio_info = audio_info.build().unwrap();
 
-        gst_debug!(
+        gst::debug!(
             CAT,
             obj: element,
             "Successfully parsed headers: {:?}",
@@ -410,7 +409,7 @@ impl LewtonDec {
         }
 
         let sample_count = decoded.samples.len() / audio_info.channels() as usize;
-        gst_debug!(CAT, obj: element, "Got {} decoded samples", sample_count);
+        gst::debug!(CAT, obj: element, "Got {} decoded samples", sample_count);
 
         if sample_count == 0 {
             return element.finish_frame(None, 1);
diff --git a/audio/spotify/src/spotifyaudiosrc/imp.rs b/audio/spotify/src/spotifyaudiosrc/imp.rs
index 1d55f936..caadd381 100644
--- a/audio/spotify/src/spotifyaudiosrc/imp.rs
+++ b/audio/spotify/src/spotifyaudiosrc/imp.rs
@@ -15,7 +15,6 @@ use tokio::{runtime, task::JoinHandle};
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{gst_debug, gst_error, gst_log};
 use gst_base::subclass::{base_src::CreateSuccess, prelude::*};
 
 use librespot::core::{
@@ -250,7 +249,7 @@ impl BaseSrcImpl for SpotifyAudioSrc {
 
         if let Err(err) = RUNTIME.block_on(async move { self.setup().await }) {
             let details = format!("{:?}", err);
-            gst_error!(CAT, obj: src, "failed to start: {}", details);
+            gst::error!(CAT, obj: src, "failed to start: {}", details);
             gst::element_error!(src, gst::ResourceError::Settings, [&details]);
             return Err(gst::error_msg!(gst::ResourceError::Settings, [&details]));
         }
@@ -260,7 +259,7 @@ impl BaseSrcImpl for SpotifyAudioSrc {
 
     fn stop(&self, src: &Self::Type) -> Result<(), gst::ErrorMessage> {
         if let Some(state) = self.state.lock().unwrap().take() {
-            gst_debug!(CAT, obj: src, "stopping");
+            gst::debug!(CAT, obj: src, "stopping");
             state.player.stop();
             state.player_channel_handle.abort();
             // FIXME: not sure why this is needed to unblock BufferSink::write(), dropping State should drop the receiver
@@ -282,15 +281,15 @@ impl BaseSrcImpl for SpotifyAudioSrc {
 
         match state.receiver.recv().unwrap() {
             Message::Buffer(buffer) => {
-                gst_log!(CAT, obj: src, "got buffer of size {}", buffer.size());
+                gst::log!(CAT, obj: src, "got buffer of size {}", buffer.size());
                 Ok(CreateSuccess::NewBuffer(buffer))
             }
             Message::Eos => {
-                gst_debug!(CAT, obj: src, "eos");
+                gst::debug!(CAT, obj: src, "eos");
                 Err(gst::FlowError::Eos)
             }
             Message::Unavailable => {
-                gst_error!(CAT, obj: src, "track is not available");
+                gst::error!(CAT, obj: src, "track is not available");
                 gst::element_error!(
                     src,
                     gst::ResourceError::NotFound,
@@ -331,11 +330,11 @@ impl SpotifyAudioSrc {
 
             let credentials = match cache.credentials() {
                 Some(cached_cred) => {
-                    gst_debug!(CAT, obj: &src, "reuse credentials from cache",);
+                    gst::debug!(CAT, obj: &src, "reuse credentials from cache",);
                     cached_cred
                 }
                 None => {
-                    gst_debug!(CAT, obj: &src, "credentials not in cache",);
+                    gst::debug!(CAT, obj: &src, "credentials not in cache",);
 
                     if settings.username.is_empty() {
                         bail!("username is not set and credentials are not in cache");