mirrors/gst-plugins-rs
mirrors/gst-plugins-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git synced 2024-05-14 14:22:40 +00:00
Code Issues Projects Releases Wiki Activity

Update to gst::_log_macro_

Browse source 
See the details:
https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/980
This commit is contained in:
François Laignel 2022-02-21 18:43:46 +01:00
parent 8263e19313
commit 422ea740ca
84 changed files with 1658 additions and 1742 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

69
audio/audiofx/src/audioloudnorm/imp.rs
View file

@ -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();

9
audio/audiofx/src/audiornnoise/imp.rs
View file

@ -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 {}",

44
audio/audiofx/src/ebur128level/imp.rs
View file

@ -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
})
})

19
audio/audiofx/src/hrtfrender/imp.rs
View file

@ -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,

25
audio/claxon/src/claxondec/imp.rs
View file

@ -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: {:?}",

28
audio/csound/src/filter/imp.rs
View file

@ -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)
}
}

37
audio/lewton/src/lewtondec/imp.rs
View file

@ -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);

15
audio/spotify/src/spotifyaudiosrc/imp.rs
View file

@ -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");

17
generic/file/src/filesink/imp.rs
View file

@ -13,7 +13,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_trace};
use gst_base::subclass::prelude::*;
use std::fs::File;
@ -84,7 +83,7 @@ impl FileSink {
Some(location) => {
match settings.location {
Some(ref location_cur) => {
gst_info!(
gst::info!(
CAT,
obj: element,
"Changing `location` from {:?} to {}",
@ -93,13 +92,13 @@ impl FileSink {
);
}
None => {
gst_info!(CAT, obj: element, "Setting `location` to {}", location,);
gst::info!(CAT, obj: element, "Setting `location` to {}", location,);
}
}
Some(location)
}
None => {
gst_info!(CAT, obj: element, "Resetting `location` to None",);
gst::info!(CAT, obj: element, "Resetting `location` to None",);
None
}
};
@ -148,7 +147,7 @@ impl ObjectImpl for FileSink {
};
if let Err(err) = res {
gst_error!(CAT, obj: obj, "Failed to set property `location`: {}", err);
gst::error!(CAT, obj: obj, "Failed to set property `location`: {}", err);
}
}
_ => unimplemented!(),
@ -230,10 +229,10 @@ impl BaseSinkImpl for FileSink {
]
)
})?;
gst_debug!(CAT, obj: element, "Opened file {:?}", file);
gst::debug!(CAT, obj: element, "Opened file {:?}", file);
*state = State::Started { file, position: 0 };
gst_info!(CAT, obj: element, "Started");
gst::info!(CAT, obj: element, "Started");
Ok(())
}
@ -248,7 +247,7 @@ impl BaseSinkImpl for FileSink {
}
*state = State::Stopped;
gst_info!(CAT, obj: element, "Stopped");
gst::info!(CAT, obj: element, "Stopped");
Ok(())
}
@ -272,7 +271,7 @@ impl BaseSinkImpl for FileSink {
}
};
gst_trace!(CAT, obj: element, "Rendering {:?}", buffer);
gst::trace!(CAT, obj: element, "Rendering {:?}", buffer);
let map = buffer.map_readable().map_err(|_| {
gst::element_error!(element, gst::CoreError::Failed, ["Failed to map buffer"]);
gst::FlowError::Error

15
generic/file/src/filesrc/imp.rs
View file

@ -12,7 +12,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::*;
@ -98,7 +97,7 @@ impl FileSrc {
match settings.location {
Some(ref location_cur) => {
gst_info!(
gst::info!(
CAT,
obj: element,
"Changing `location` from {:?} to {}",
@ -107,13 +106,13 @@ impl FileSrc {
);
}
None => {
gst_info!(CAT, obj: element, "Setting `location to {}", location,);
gst::info!(CAT, obj: element, "Setting `location to {}", location,);
}
}
Some(location)
}
None => {
gst_info!(CAT, obj: element, "Resetting `location` to None",);
gst::info!(CAT, obj: element, "Resetting `location` to None",);
None
}
};
@ -162,7 +161,7 @@ impl ObjectImpl for FileSrc {
};
if let Err(err) = res {
gst_error!(CAT, obj: obj, "Failed to set property `location`: {}", err);
gst::error!(CAT, obj: obj, "Failed to set property `location`: {}", err);
}
}
_ => unimplemented!(),
@ -264,11 +263,11 @@ impl BaseSrcImpl for FileSrc {
)
})?;
gst_debug!(CAT, obj: element, "Opened file {:?}", file);
gst::debug!(CAT, obj: element, "Opened file {:?}", file);
*state = State::Started { file, position: 0 };
gst_info!(CAT, obj: element, "Started");
gst::info!(CAT, obj: element, "Started");
Ok(())
}
@ -284,7 +283,7 @@ impl BaseSrcImpl for FileSrc {
*state = State::Stopped;
gst_info!(CAT, obj: element, "Stopped");
gst::info!(CAT, obj: element, "Stopped");
Ok(())
}

105
generic/fmp4/src/fmp4mux/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_trace, gst_warning};
use std::collections::VecDeque;
use std::sync::Mutex;
@ -114,35 +113,35 @@ impl FMP4Mux {
state: &mut State,
buffer: gst::Buffer,
) -> Result<(), gst::FlowError> {
gst_trace!(CAT, obj: element, "Handling buffer {:?}", buffer);
gst::trace!(CAT, obj: element, "Handling buffer {:?}", buffer);
let segment = match state.segment {
Some(ref segment) => segment,
None => {
gst_error!(CAT, obj: element, "Got buffer before segment");
gst::error!(CAT, obj: element, "Got buffer before segment");
return Err(gst::FlowError::Error);
}
};
if state.caps.is_none() {
gst_error!(CAT, obj: element, "Got buffer before caps");
gst::error!(CAT, obj: element, "Got buffer before caps");
return Err(gst::FlowError::NotNegotiated);
}
let intra_only = state.intra_only;
if !intra_only && buffer.dts().is_none() {
gst_error!(CAT, obj: element, "Require DTS for video streams");
gst::error!(CAT, obj: element, "Require DTS for video streams");
return Err(gst::FlowError::Error);
}
if intra_only && buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) {
gst_error!(CAT, obj: element, "Intra-only stream with delta units");
gst::error!(CAT, obj: element, "Intra-only stream with delta units");
return Err(gst::FlowError::Error);
}
let pts = buffer.pts().ok_or_else(|| {
gst_error!(CAT, obj: element, "Require timestamped buffers");
gst::error!(CAT, obj: element, "Require timestamped buffers");
gst::FlowError::Error
})?;
let duration = buffer.duration();
@ -150,11 +149,11 @@ impl FMP4Mux {
let pts = match segment.to_running_time_full(pts) {
(_, None) => {
gst_error!(CAT, obj: element, "Couldn't convert PTS to running time");
gst::error!(CAT, obj: element, "Couldn't convert PTS to running time");
return Err(gst::FlowError::Error);
}
(pts_signum, _) if pts_signum < 0 => {
gst_error!(CAT, obj: element, "Negative PTSs are not supported");
gst::error!(CAT, obj: element, "Negative PTSs are not supported");
return Err(gst::FlowError::Error);
}
(_, Some(pts)) => pts,
@ -162,7 +161,7 @@ impl FMP4Mux {
let end_pts = match segment.to_running_time_full(end_pts) {
(_, None) => {
gst_error!(
gst::error!(
CAT,
obj: element,
"Couldn't convert end PTS to running time"
@ -170,7 +169,7 @@ impl FMP4Mux {
return Err(gst::FlowError::Error);
}
(pts_signum, _) if pts_signum < 0 => {
gst_error!(CAT, obj: element, "Negative PTSs are not supported");
gst::error!(CAT, obj: element, "Negative PTSs are not supported");
return Err(gst::FlowError::Error);
}
(_, Some(pts)) => pts,
@ -185,7 +184,7 @@ impl FMP4Mux {
let dts = match segment.to_running_time_full(dts) {
(_, None) => {
gst_error!(CAT, obj: element, "Couldn't convert DTS to running time");
gst::error!(CAT, obj: element, "Couldn't convert DTS to running time");
return Err(gst::FlowError::Error);
}
(pts_signum, Some(dts)) if pts_signum < 0 => {
@ -195,7 +194,7 @@ impl FMP4Mux {
let dts_offset = state.dts_offset.unwrap();
if dts > dts_offset {
gst_warning!(CAT, obj: element, "DTS before first DTS");
gst::warning!(CAT, obj: element, "DTS before first DTS");
gst::ClockTime::ZERO
} else {
dts_offset - dts
@ -212,7 +211,7 @@ impl FMP4Mux {
let end_dts = match segment.to_running_time_full(end_dts) {
(_, None) => {
gst_error!(
gst::error!(
CAT,
obj: element,
"Couldn't convert end DTS to running time"
@ -226,7 +225,7 @@ impl FMP4Mux {
let dts_offset = state.dts_offset.unwrap();
if dts > dts_offset {
gst_warning!(CAT, obj: element, "End DTS before first DTS");
gst::warning!(CAT, obj: element, "End DTS before first DTS");
gst::ClockTime::ZERO
} else {
dts_offset - dts
@ -244,7 +243,7 @@ impl FMP4Mux {
};
if !buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Starting new GOP at PTS {} DTS {}",
@ -266,7 +265,7 @@ impl FMP4Mux {
state.queued_gops.push_front(gop);
if let Some(prev_gop) = state.queued_gops.get_mut(1) {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Updating previous GOP starting at PTS {} to end PTS {} DTS {}",
@ -281,7 +280,7 @@ impl FMP4Mux {
// Don't bother logging this for intra-only streams as it would be for every
// single buffer.
if !intra_only {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Previous GOP has final earliest PTS at {}",
@ -293,7 +292,7 @@ impl FMP4Mux {
state.queued_duration =
prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Queued duration updated to {}",
@ -302,7 +301,7 @@ impl FMP4Mux {
} else if intra_only {
state.queued_duration =
prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Queued duration updated to {}",
@ -327,7 +326,7 @@ impl FMP4Mux {
});
if gop.earliest_pts > pts && !gop.final_earliest_pts {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Updating current GOP earliest PTS from {} to {}",
@ -338,7 +337,7 @@ impl FMP4Mux {
gop.earliest_pts_position = pts_position;
if let Some(prev_gop) = state.queued_gops.get_mut(1) {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Updating previous GOP starting PTS {} end time from {} to {}",
@ -357,7 +356,7 @@ impl FMP4Mux {
// lower PTS then it wouldn't be possible to display it in time anymore, i.e. the
// stream would be invalid.
if gop.start_pts <= dts && !gop.final_earliest_pts {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"GOP has final earliest PTS at {}",
@ -368,7 +367,7 @@ impl FMP4Mux {
if let Some(prev_gop) = state.queued_gops.get_mut(1) {
state.queued_duration =
prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Queued duration updated to {}",
@ -377,7 +376,7 @@ impl FMP4Mux {
}
}
} else {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Waiting for keyframe at the beginning of the stream"
@ -407,7 +406,7 @@ impl FMP4Mux {
if state.last_force_keyunit_time.is_none() && oldest_gop.final_earliest_pts {
let fku_running_time = earliest_pts + settings.fragment_duration;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Sending first force-keyunit event for running time {}",
@ -426,7 +425,7 @@ impl FMP4Mux {
{
let fku_running_time =
state.last_force_keyunit_time.unwrap() + settings.fragment_duration;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Sending force-keyunit event for running time {}",
@ -464,7 +463,7 @@ impl FMP4Mux {
// equal to the fragment duration then drain out all complete GOPs, otherwise all
// except for the newest complete GOP.
let drain_gops = if at_eos {
gst_info!(CAT, obj: element, "Draining at EOS");
gst::info!(CAT, obj: element, "Draining at EOS");
state.queued_duration = gst::ClockTime::ZERO;
state
.queued_gops
@ -505,7 +504,7 @@ impl FMP4Mux {
let end_dts = drain_gops[0].end_dts;
let dts_offset = state.dts_offset;
gst_info!(
gst::info!(
CAT,
obj: element,
"Draining {} worth of buffers starting at PTS {} DTS {}, DTS offset {}",
@ -558,7 +557,7 @@ impl FMP4Mux {
dts_offset,
})
.map_err(|err| {
gst_error!(
gst::error!(
CAT,
obj: element,
"Failed to create FMP4 fragment header: {}",
@ -618,7 +617,7 @@ impl FMP4Mux {
});
state.end_pts = Some(end_pts);
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Queued duration updated to {} after draining",
@ -641,7 +640,7 @@ impl FMP4Mux {
buffer_list.as_mut().unwrap().get_mut().unwrap().add(mfra);
}
Err(err) => {
gst_error!(CAT, obj: element, "Failed to create mfra box: {}", err);
gst::error!(CAT, obj: element, "Failed to create mfra box: {}", err);
}
}
}
@ -682,7 +681,7 @@ impl FMP4Mux {
duration: if at_eos { duration } else { None },
})
.map_err(|err| {
gst_error!(CAT, obj: element, "Failed to create FMP4 header: {}", err);
gst::error!(CAT, obj: element, "Failed to create FMP4 header: {}", err);
gst::FlowError::Error
})?;
@ -753,7 +752,7 @@ impl FMP4Mux {
}
if let Some(buffers) = buffers {
gst_trace!(CAT, obj: element, "Pushing buffer list {:?}", buffers);
gst::trace!(CAT, obj: element, "Pushing buffer list {:?}", buffers);
self.srcpad.push_list(buffers)?;
}
@ -763,17 +762,17 @@ impl FMP4Mux {
fn sink_event(&self, pad: &gst::Pad, element: &super::FMP4Mux, mut event: gst::Event) -> bool {
use gst::EventView;
gst_trace!(CAT, obj: pad, "Handling event {:?}", event);
gst::trace!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() {
EventView::Segment(ev) => {
let segment = match ev.segment().downcast_ref::<gst::ClockTime>() {
Some(segment) => {
gst_info!(CAT, obj: pad, "Received segment {:?}", segment);
gst::info!(CAT, obj: pad, "Received segment {:?}", segment);
segment.clone()
}
None => {
gst_warning!(
gst::warning!(
CAT,
obj: pad,
"Received non-TIME segment, replacing with default TIME segment"
@ -793,7 +792,7 @@ impl FMP4Mux {
EventView::Caps(ev) => {
let caps = ev.caps_owned();
gst_info!(CAT, obj: pad, "Received caps {:?}", caps);
gst::info!(CAT, obj: pad, "Received caps {:?}", caps);
let caps = {
let settings = self.settings.lock().unwrap().clone();
let mut state = self.state.lock().unwrap();
@ -803,13 +802,13 @@ impl FMP4Mux {
match s.name() {
"video/x-h264" | "video/x-h265" => {
if !s.has_field_with_type("codec_data", gst::Buffer::static_type()) {
gst_error!(CAT, obj: pad, "Received caps without codec_data");
gst::error!(CAT, obj: pad, "Received caps without codec_data");
return false;
}
}
"audio/mpeg" => {
if !s.has_field_with_type("codec_data", gst::Buffer::static_type()) {
gst_error!(CAT, obj: pad, "Received caps without codec_data");
gst::error!(CAT, obj: pad, "Received caps without codec_data");
return false;
}
state.intra_only = true;
@ -851,10 +850,10 @@ impl FMP4Mux {
match drained {
Ok(Some(buffers)) => {
gst_trace!(CAT, obj: element, "Pushing buffer list {:?}", buffers);
gst::trace!(CAT, obj: element, "Pushing buffer list {:?}", buffers);
if let Err(err) = self.srcpad.push_list(buffers) {
gst_error!(
gst::error!(
CAT,
obj: element,
"Failed pushing EOS buffers downstream: {:?}",
@ -864,7 +863,7 @@ impl FMP4Mux {
}
Ok(None) => {}
Err(err) => {
gst_error!(CAT, obj: element, "Failed draining at EOS: {:?}", err);
gst::error!(CAT, obj: element, "Failed draining at EOS: {:?}", err);
}
}
@ -889,7 +888,7 @@ impl FMP4Mux {
self.srcpad.push_event(gst::event::Caps::new(&caps));
if let Err(err) = self.srcpad.push_list(buffer_list) {
gst_error!(
gst::error!(
CAT,
obj: element,
"Failed pushing updated header buffer downstream: {:?}",
@ -897,13 +896,13 @@ impl FMP4Mux {
);
}
} else {
gst_error!(CAT, obj: element, "Can't rewrite header because downstream is not seekable");
gst::error!(CAT, obj: element, "Can't rewrite header because downstream is not seekable");
}
}
super::HeaderUpdateMode::Update => {
self.srcpad.push_event(gst::event::Caps::new(&caps));
if let Err(err) = self.srcpad.push_list(buffer_list) {
gst_error!(
gst::error!(
CAT,
obj: element,
"Failed pushing updated header buffer downstream: {:?}",
@ -915,7 +914,7 @@ impl FMP4Mux {
}
Ok(None) => {}
Err(err) => {
gst_error!(
gst::error!(
CAT,
obj: element,
"Failed to generate updated header: {:?}",
@ -952,7 +951,7 @@ impl FMP4Mux {
) -> bool {
use gst::QueryViewMut;
gst_trace!(CAT, obj: pad, "Handling query {:?}", query);
gst::trace!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryViewMut::Caps(q) => {
@ -982,7 +981,7 @@ impl FMP4Mux {
fn src_event(&self, pad: &gst::Pad, element: &super::FMP4Mux, event: gst::Event) -> bool {
use gst::EventView;
gst_trace!(CAT, obj: pad, "Handling event {:?}", event);
gst::trace!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() {
EventView::Seek(_ev) => false,
@ -998,7 +997,7 @@ impl FMP4Mux {
) -> bool {
use gst::QueryViewMut;
gst_trace!(CAT, obj: pad, "Handling query {:?}", query);
gst::trace!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryViewMut::Seeking(q) => {
@ -1013,7 +1012,7 @@ impl FMP4Mux {
let settings = self.settings.lock().unwrap();
let (live, min, max) = q.result();
gst_info!(
gst::info!(
CAT,
obj: pad,
"Upstream latency: live {}, min {}, max {}",
@ -1025,7 +1024,7 @@ impl FMP4Mux {
min + settings.fragment_duration,
max.opt_add(settings.fragment_duration),
);
gst_info!(
gst::info!(
CAT,
obj: pad,
"Returning latency: live {}, min {}, max {}",
@ -1221,7 +1220,7 @@ impl ElementImpl for FMP4Mux {
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);
let res = self.parent_change_state(element, transition)?;

49
generic/sodium/src/decrypter/imp.rs
View file

@ -25,7 +25,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log};
use sodiumoxide::crypto::box_;
use std::sync::Mutex;
@ -115,7 +114,7 @@ impl State {
gst::FlowError::Error
})?;
gst_debug!(CAT, obj: pad, "Returned pull size: {}", map.len());
gst::debug!(CAT, obj: pad, "Returned pull size: {}", map.len());
let mut nonce = add_nonce(self.initial_nonce.unwrap(), chunk_index);
let block_size = self.block_size.expect("Block size wasn't set") as usize + box_::MACBYTES;
@ -147,8 +146,8 @@ impl State {
adapter_offset: usize,
) -> Result<gst::PadGetRangeSuccess, gst::FlowError> {
let avail = self.adapter.available();
gst_debug!(CAT, obj: pad, "Avail: {}", avail);
gst_debug!(CAT, obj: pad, "Adapter offset: {}", adapter_offset);
gst::debug!(CAT, obj: pad, "Avail: {}", avail);
gst::debug!(CAT, obj: pad, "Adapter offset: {}", adapter_offset);
// if this underflows, the available buffer in the adapter is smaller than the
// requested offset, which means we have reached EOS
@ -190,7 +189,7 @@ impl State {
let mut map = match buffer.map_writable() {
Ok(map) => map,
Err(e) => {
gst_error!(
gst::error!(
CAT,
obj: pad,
"Failed to map provided buffer writable: {}",
@ -200,7 +199,7 @@ impl State {
}
};
if let Err(e) = self.adapter.copy(0, &mut map[..available_size]) {
gst_error!(CAT, obj: pad, "Failed to copy into provided buffer: {}", e);
gst::error!(CAT, obj: pad, "Failed to copy into provided buffer: {}", e);
return Err(gst::FlowError::Error);
}
if map.len() != available_size {
@ -287,7 +286,7 @@ impl Decrypter {
) -> 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::Scheduling(q) => {
@ -297,12 +296,12 @@ impl Decrypter {
return res;
}
gst_log!(CAT, obj: pad, "Upstream returned {:?}", peer_query);
gst::log!(CAT, obj: pad, "Upstream returned {:?}", peer_query);
let (flags, min, max, align) = peer_query.result();
q.set(flags, min, max, align);
q.add_scheduling_modes(&[gst::PadMode::Pull]);
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
gst::log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true
}
QueryViewMut::Duration(q) => {
@ -314,14 +313,14 @@ impl Decrypter {
let mut peer_query = gst::query::Duration::new(gst::Format::Bytes);
if !self.sinkpad.peer_query(&mut peer_query) {
gst_error!(CAT, "Failed to query upstream duration");
gst::error!(CAT, "Failed to query upstream duration");
return false;
}
let size = match peer_query.result().try_into().unwrap() {
Some(gst::format::Bytes(size)) => size,
None => {
gst_error!(CAT, "Failed to query upstream duration");
gst::error!(CAT, "Failed to query upstream duration");
return false;
}
@ -344,7 +343,7 @@ impl Decrypter {
// subtrack the MAC of each block
let size = size - total_chunks * box_::MACBYTES as u64;
gst_debug!(CAT, obj: pad, "Setting duration bytes: {}", size);
gst::debug!(CAT, obj: pad, "Setting duration bytes: {}", size);
q.set(gst::format::Bytes(size));
true
@ -417,9 +416,9 @@ impl Decrypter {
let state = state.as_mut().unwrap();
state.initial_nonce = Some(nonce);
gst_debug!(CAT, obj: element, "Setting nonce to: {:?}", nonce.0);
gst::debug!(CAT, obj: element, "Setting nonce to: {:?}", nonce.0);
state.block_size = Some(block_size);
gst_debug!(CAT, obj: element, "Setting block size to: {}", block_size);
gst::debug!(CAT, obj: element, "Setting block size to: {}", block_size);
Ok(())
}
@ -436,8 +435,8 @@ impl Decrypter {
+ (chunk_index * block_size as u64)
+ (chunk_index * box_::MACBYTES as u64);
gst_debug!(CAT, obj: pad, "Pull offset: {}", pull_offset);
gst_debug!(CAT, obj: pad, "block size: {}", block_size);
gst::debug!(CAT, obj: pad, "Pull offset: {}", pull_offset);
gst::debug!(CAT, obj: pad, "block size: {}", block_size);
// calculate how many chunks are needed, if we need something like 3.2
// round the number to 4 and cut the buffer afterwards.
@ -456,7 +455,7 @@ impl Decrypter {
// Read at least one chunk in case 0 bytes were requested
let total_chunks = u32::max((checked - 1) / block_size, 1);
gst_debug!(CAT, obj: pad, "Blocks to be pulled: {}", total_chunks);
gst::debug!(CAT, obj: pad, "Blocks to be pulled: {}", total_chunks);
// Pull a buffer of all the chunks we will need
let checked_size = total_chunks.checked_mul(block_size).ok_or_else(|| {
@ -473,18 +472,18 @@ impl Decrypter {
})?;
let total_size = checked_size + (total_chunks * box_::MACBYTES as u32);
gst_debug!(CAT, obj: pad, "Requested pull size: {}", total_size);
gst::debug!(CAT, obj: pad, "Requested pull size: {}", total_size);
self.sinkpad.pull_range(pull_offset, total_size).map_err(|err| {
match 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");
}
gst::FlowError::Eos => {
gst_debug!(CAT, obj: &self.sinkpad, "Eos");
gst::debug!(CAT, obj: &self.sinkpad, "Eos");
}
flow => {
gst_error!(CAT, obj: &self.sinkpad, "Failed to pull, reason: {:?}", flow);
gst::error!(CAT, obj: &self.sinkpad, "Failed to pull, reason: {:?}", flow);
}
};
@ -510,11 +509,11 @@ impl Decrypter {
state.block_size.expect("Block size wasn't set")
};
gst_debug!(CAT, obj: pad, "Requested offset: {}", offset);
gst_debug!(CAT, obj: pad, "Requested size: {}", requested_size);
gst::debug!(CAT, obj: pad, "Requested offset: {}", offset);
gst::debug!(CAT, obj: pad, "Requested size: {}", requested_size);
let chunk_index = offset as u64 / block_size as u64;
gst_debug!(CAT, obj: pad, "Stream Block index: {}", chunk_index);
gst::debug!(CAT, obj: pad, "Stream Block index: {}", chunk_index);
let pull_offset = offset - (chunk_index * block_size as u64);
assert!(pull_offset <= std::u32::MAX as u64);
@ -705,7 +704,7 @@ impl ElementImpl for Decrypter {
element: &Self::Type,
transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_debug!(CAT, obj: element, "Changing state {:?}", transition);
gst::debug!(CAT, obj: element, "Changing state {:?}", transition);
match transition {
gst::StateChange::NullToReady => {

23
generic/sodium/src/encrypter/imp.rs
View file

@ -25,7 +25,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log};
use smallvec::SmallVec;
use sodiumoxide::crypto::box_;
@ -170,7 +169,7 @@ impl Encrypter {
element: &super::Encrypter,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut buffers = BufferVec::new();
let mut state_guard = self.state.lock().unwrap();
@ -197,7 +196,7 @@ impl Encrypter {
for buffer in buffers {
self.srcpad.push(buffer).map_err(|err| {
gst_error!(CAT, obj: element, "Failed to push buffer {:?}", err);
gst::error!(CAT, obj: element, "Failed to push buffer {:?}", err);
err
})?;
}
@ -208,7 +207,7 @@ impl Encrypter {
fn sink_event(&self, pad: &gst::Pad, element: &super::Encrypter, 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(_) => {
@ -240,7 +239,7 @@ impl Encrypter {
for buffer in buffers {
if let Err(err) = self.srcpad.push(buffer) {
gst_error!(CAT, obj: element, "Failed to push buffer at EOS {:?}", err);
gst::error!(CAT, obj: element, "Failed to push buffer at EOS {:?}", err);
return false;
}
}
@ -254,7 +253,7 @@ impl Encrypter {
fn src_event(&self, pad: &gst::Pad, element: &super::Encrypter, 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(_) => false,
@ -270,7 +269,7 @@ impl Encrypter {
) -> 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) => {
@ -280,7 +279,7 @@ impl Encrypter {
gst::GenericFormattedValue::Other(format, -1),
gst::GenericFormattedValue::Other(format, -1),
);
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
gst::log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true
}
QueryViewMut::Duration(q) => {
@ -292,14 +291,14 @@ impl Encrypter {
let mut peer_query = gst::query::Duration::new(gst::Format::Bytes);
if !self.sinkpad.peer_query(&mut peer_query) {
gst_error!(CAT, "Failed to query upstream duration");
gst::error!(CAT, "Failed to query upstream duration");
return false;
}
let size = match peer_query.result().try_into().unwrap() {
Some(gst::format::Bytes(size)) => size,
None => {
gst_error!(CAT, "Failed to query upstream duration");
gst::error!(CAT, "Failed to query upstream duration");
return false;
}
@ -321,7 +320,7 @@ impl Encrypter {
// add static offsets
let size = size + crate::HEADERS_SIZE as u64;
gst_debug!(CAT, obj: pad, "Setting duration bytes: {}", size);
gst::debug!(CAT, obj: pad, "Setting duration bytes: {}", size);
q.set(gst::format::Bytes(size));
true
@ -516,7 +515,7 @@ impl ElementImpl for Encrypter {
element: &Self::Type,
transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_debug!(CAT, obj: element, "Changing state {:?}", transition);
gst::debug!(CAT, obj: element, "Changing state {:?}", transition);
match transition {
gst::StateChange::NullToReady => {

69
generic/threadshare/src/appsrc/imp.rs
View file

@ -26,7 +26,6 @@ use futures::prelude::*;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace};
use once_cell::sync::Lazy;
@ -125,7 +124,7 @@ impl AppSrcPadHandler {
async fn push_prelude(&self, pad: &PadSrcRef<'_>, _element: &super::AppSrc) {
let mut state = self.0.state.lock().await;
if state.need_initial_events {
gst_debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
gst::debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
let stream_id = format!("{:08x}{:08x}", rand::random::<u32>(), rand::random::<u32>());
let stream_start_evt = gst::event::StreamStart::builder(&stream_id)
@ -156,13 +155,13 @@ impl AppSrcPadHandler {
element: &super::AppSrc,
item: StreamItem,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", item);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", item);
self.push_prelude(pad, element).await;
match item {
StreamItem::Buffer(buffer) => {
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", buffer);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", buffer);
pad.push(buffer).await
}
StreamItem::Event(event) => {
@ -172,7 +171,7 @@ impl AppSrcPadHandler {
Err(gst::FlowError::Eos)
}
_ => {
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
pad.push_event(event).await;
Ok(gst::FlowSuccess::Ok)
}
@ -194,7 +193,7 @@ impl PadSrcHandler for AppSrcPadHandler {
) -> bool {
use gst::EventView;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
let ret = match event.view() {
EventView::FlushStart(..) => appsrc.task.flush_start().is_ok(),
@ -205,9 +204,9 @@ impl PadSrcHandler for AppSrcPadHandler {
};
if ret {
gst_log!(CAT, obj: pad.gst_pad(), "Handled {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handled {:?}", event);
} else {
gst_log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
}
ret
@ -222,7 +221,7 @@ impl PadSrcHandler for AppSrcPadHandler {
) -> bool {
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
let ret = match query.view_mut() {
QueryViewMut::Latency(q) => {
q.set(true, gst::ClockTime::ZERO, gst::ClockTime::NONE);
@ -252,9 +251,9 @@ impl PadSrcHandler for AppSrcPadHandler {
};
if ret {
gst_log!(CAT, obj: pad.gst_pad(), "Handled {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handled {:?}", query);
} else {
gst_log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
}
ret
}
@ -297,7 +296,7 @@ impl TaskImpl for AppSrcTask {
let item = match self.receiver.next().await {
Some(item) => item,
None => {
gst_error!(CAT, obj: &self.element, "SrcPad channel aborted");
gst::error!(CAT, obj: &self.element, "SrcPad channel aborted");
gst::element_error!(
&self.element,
gst::StreamError::Failed,
@ -315,17 +314,17 @@ impl TaskImpl for AppSrcTask {
.await;
match res {
Ok(_) => {
gst_log!(CAT, obj: &self.element, "Successfully pushed item");
gst::log!(CAT, obj: &self.element, "Successfully pushed item");
}
Err(gst::FlowError::Eos) => {
gst_debug!(CAT, obj: &self.element, "EOS");
gst::debug!(CAT, obj: &self.element, "EOS");
pad.push_event(gst::event::Eos::new()).await;
}
Err(gst::FlowError::Flushing) => {
gst_debug!(CAT, obj: &self.element, "Flushing");
gst::debug!(CAT, obj: &self.element, "Flushing");
}
Err(err) => {
gst_error!(CAT, obj: &self.element, "Got error {}", err);
gst::error!(CAT, obj: &self.element, "Got error {}", err);
gst::element_error!(
&self.element,
gst::StreamError::Failed,
@ -342,12 +341,12 @@ impl TaskImpl for AppSrcTask {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Stopping task");
gst::log!(CAT, obj: &self.element, "Stopping task");
self.flush();
self.src_pad_handler.reset_state().await;
gst_log!(CAT, obj: &self.element, "Task stopped");
gst::log!(CAT, obj: &self.element, "Task stopped");
Ok(())
}
.boxed()
@ -355,12 +354,12 @@ impl TaskImpl for AppSrcTask {
fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Starting task flush");
gst::log!(CAT, obj: &self.element, "Starting task flush");
self.flush();
self.src_pad_handler.set_need_segment().await;
gst_log!(CAT, obj: &self.element, "Task flush started");
gst::log!(CAT, obj: &self.element, "Task flush started");
Ok(())
}
.boxed()
@ -380,7 +379,7 @@ impl AppSrc {
fn push_buffer(&self, element: &super::AppSrc, mut buffer: gst::Buffer) -> bool {
let state = self.task.lock_state();
if *state != TaskState::Started && *state != TaskState::Paused {
gst_debug!(CAT, obj: element, "Rejecting buffer due to element state");
gst::debug!(CAT, obj: element, "Rejecting buffer due to element state");
return false;
}
@ -394,7 +393,7 @@ impl AppSrc {
buffer.set_dts(now.opt_checked_sub(base_time).ok().flatten());
buffer.set_pts(None);
} else {
gst_error!(CAT, obj: element, "Don't have a clock yet");
gst::error!(CAT, obj: element, "Don't have a clock yet");
return false;
}
}
@ -409,7 +408,7 @@ impl AppSrc {
{
Ok(_) => true,
Err(err) => {
gst_error!(CAT, obj: element, "Failed to queue buffer: {}", err);
gst::error!(CAT, obj: element, "Failed to queue buffer: {}", err);
false
}
}
@ -425,7 +424,7 @@ impl AppSrc {
match sender.try_send(StreamItem::Event(gst::event::Eos::new())) {
Ok(_) => true,
Err(err) => {
gst_error!(CAT, obj: element, "Failed to queue EOS: {}", err);
gst::error!(CAT, obj: element, "Failed to queue EOS: {}", err);
false
}
}
@ -433,7 +432,7 @@ impl AppSrc {
fn prepare(&self, element: &super::AppSrc) -> Result<(), gst::ErrorMessage> {
let settings = self.settings.lock().unwrap();
gst_debug!(CAT, obj: element, "Preparing");
gst::debug!(CAT, obj: element, "Preparing");
let context =
Context::acquire(&settings.context, settings.context_wait).map_err(|err| {
@ -467,38 +466,38 @@ impl AppSrc {
)
})?;
gst_debug!(CAT, obj: element, "Prepared");
gst::debug!(CAT, obj: element, "Prepared");
Ok(())
}
fn unprepare(&self, element: &super::AppSrc) {
gst_debug!(CAT, obj: element, "Unpreparing");
gst::debug!(CAT, obj: element, "Unpreparing");
*self.sender.lock().unwrap() = None;
self.task.unprepare().unwrap();
gst_debug!(CAT, obj: element, "Unprepared");
gst::debug!(CAT, obj: element, "Unprepared");
}
fn stop(&self, element: &super::AppSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
self.task.stop()?;
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
Ok(())
}
fn start(&self, element: &super::AppSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
self.task.start()?;
gst_debug!(CAT, obj: element, "Started");
gst::debug!(CAT, obj: element, "Started");
Ok(())
}
fn pause(&self, element: &super::AppSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Pausing");
gst::debug!(CAT, obj: element, "Pausing");
self.task.pause()?;
gst_debug!(CAT, obj: element, "Paused");
gst::debug!(CAT, obj: element, "Paused");
Ok(())
}
}
@ -698,7 +697,7 @@ impl ElementImpl for AppSrc {
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::NullToReady => {

29
generic/threadshare/src/dataqueue.rs
View file

@ -19,7 +19,6 @@
use futures::future::{self, abortable, AbortHandle};
use gst::gst_debug;
use gst::prelude::*;
use once_cell::sync::Lazy;
@ -128,10 +127,10 @@ impl DataQueue {
pub fn start(&self) {
let mut inner = self.0.lock().unwrap();
if inner.state == DataQueueState::Started {
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue already Started");
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue already Started");
return;
}
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Starting data queue");
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Starting data queue");
inner.state = DataQueueState::Started;
inner.wake();
}
@ -139,10 +138,10 @@ impl DataQueue {
pub fn stop(&self) {
let mut inner = self.0.lock().unwrap();
if inner.state == DataQueueState::Stopped {
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue already Stopped");
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue already Stopped");
return;
}
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Stopping data queue");
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Stopping data queue");
inner.state = DataQueueState::Stopped;
inner.wake();
}
@ -150,7 +149,7 @@ impl DataQueue {
pub fn clear(&self) {
let mut inner = self.0.lock().unwrap();
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Clearing data queue");
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Clearing data queue");
let src_pad = inner.src_pad.clone();
for item in inner.queue.drain(..) {
@ -164,14 +163,14 @@ impl DataQueue {
}
}
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue cleared");
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue cleared");
}
pub fn push(&self, item: DataQueueItem) -> Result<(), DataQueueItem> {
let mut inner = self.0.lock().unwrap();
if inner.state == DataQueueState::Stopped {
gst_debug!(
gst::debug!(
DATA_QUEUE_CAT,
obj: &inner.element,
"Rejecting item {:?} in state {:?}",
@ -181,7 +180,7 @@ impl DataQueue {
return Err(item);
}
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Pushing item {:?}", item);
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Pushing item {:?}", item);
let (count, bytes) = item.size();
let queue_ts = inner.queue.iter().filter_map(|i| i.timestamp()).next();
@ -189,14 +188,14 @@ impl DataQueue {
if let Some(max) = inner.max_size_buffers {
if max <= inner.cur_size_buffers {
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (buffers): {} <= {}", max, inner.cur_size_buffers);
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (buffers): {} <= {}", max, inner.cur_size_buffers);
return Err(item);
}
}
if let Some(max) = inner.max_size_bytes {
if max <= inner.cur_size_bytes {
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (bytes): {} <= {}", max, inner.cur_size_bytes);
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (bytes): {} <= {}", max, inner.cur_size_bytes);
return Err(item);
}
}
@ -210,7 +209,7 @@ impl DataQueue {
};
if max <= level {
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (time): {} <= {}", max, level);
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (time): {} <= {}", max, level);
return Err(item);
}
}
@ -233,10 +232,10 @@ impl DataQueue {
match inner.state {
DataQueueState::Started => match inner.queue.pop_front() {
None => {
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue is empty");
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue is empty");
}
Some(item) => {
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Popped item {:?}", item);
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Popped item {:?}", item);
let (count, bytes) = item.size();
inner.cur_size_buffers -= count;
@ -246,7 +245,7 @@ impl DataQueue {
}
},
DataQueueState::Stopped => {
gst_debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue Stopped");
gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue Stopped");
return None;
}
}

19
generic/threadshare/src/inputselector/imp.rs
View file

@ -24,7 +24,6 @@ use futures::prelude::*;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_log, gst_trace};
use once_cell::sync::Lazy;
@ -143,7 +142,7 @@ impl InputSelectorPadSinkHandler {
}
if is_active {
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", buffer);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", buffer);
if switched_pad && !buffer.flags().contains(gst::BufferFlags::DISCONT) {
let buffer = buffer.make_mut();
@ -189,7 +188,7 @@ impl PadSinkHandler for InputSelectorPadSinkHandler {
let pad_weak = pad.downgrade();
async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists");
gst_log!(CAT, obj: pad.gst_pad(), "Handling buffer list {:?}", list);
gst::log!(CAT, obj: pad.gst_pad(), "Handling buffer list {:?}", list);
// TODO: Ideally we would keep the list intact and forward it in one go
for buffer in list.iter_owned() {
this.handle_item(&pad, &element, buffer).await?;
@ -261,14 +260,14 @@ impl PadSinkHandler for InputSelectorPadSinkHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
gst_log!(CAT, obj: pad.gst_pad(), "Handling query {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handling query {:?}", query);
if query.is_serialized() {
// FIXME: How can we do this (drops ALLOCATION and DRAIN)?
gst_log!(CAT, obj: pad.gst_pad(), "Dropping serialized query {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Dropping serialized query {:?}", query);
false
} else {
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding query {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding query {:?}", query);
inputselector.src_pad.gst_pad().peer_query(query)
}
}
@ -289,7 +288,7 @@ impl PadSrcHandler for InputSelectorPadSrcHandler {
) -> bool {
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
match query.view_mut() {
QueryViewMut::Latency(q) => {
@ -378,9 +377,9 @@ static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
impl InputSelector {
fn unprepare(&self, element: &super::InputSelector) {
let mut state = self.state.lock().unwrap();
gst_debug!(CAT, obj: element, "Unpreparing");
gst::debug!(CAT, obj: element, "Unpreparing");
*state = State::default();
gst_debug!(CAT, obj: element, "Unprepared");
gst::debug!(CAT, obj: element, "Unprepared");
}
}
@ -564,7 +563,7 @@ impl ElementImpl for InputSelector {
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);
if let gst::StateChange::ReadyToNull = transition {
self.unprepare(element);

103
generic/threadshare/src/jitterbuffer/imp.rs
View file

@ -24,7 +24,6 @@ use futures::prelude::*;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log, gst_trace};
use gst_rtp::RTPBuffer;
use once_cell::sync::Lazy;
@ -150,7 +149,7 @@ impl SinkHandler {
state: &mut State,
element: &super::JitterBuffer,
) -> BTreeSet<GapPacket> {
gst_info!(CAT, obj: element, "Resetting");
gst::info!(CAT, obj: element, "Resetting");
state.jbuf.borrow().flush();
state.jbuf.borrow().reset_skew();
@ -181,7 +180,7 @@ impl SinkHandler {
) -> Result<gst::FlowSuccess, gst::FlowError> {
let s = caps.structure(0).ok_or(gst::FlowError::Error)?;
gst_info!(CAT, obj: element, "Parsing {:?}", caps);
gst::info!(CAT, obj: element, "Parsing {:?}", caps);
let payload = s.get::<i32>("payload").map_err(|_| gst::FlowError::Error)?;
@ -226,7 +225,7 @@ impl SinkHandler {
state.packet_spacing = new_packet_spacing;
}
gst_debug!(
gst::debug!(
CAT,
"new packet spacing {}, old packet spacing {} combined to {}",
new_packet_spacing,
@ -249,7 +248,7 @@ impl SinkHandler {
let gap_packets_length = inner.gap_packets.len();
let mut reset = false;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Handling big gap, gap packets length: {}",
@ -263,7 +262,7 @@ impl SinkHandler {
let mut all_consecutive = true;
for gap_packet in inner.gap_packets.iter() {
gst_log!(
gst::log!(
CAT,
obj: element,
"Looking at gap packet with seq {}",
@ -285,7 +284,7 @@ impl SinkHandler {
}
}
gst_debug!(CAT, obj: element, "all consecutive: {}", all_consecutive);
gst::debug!(CAT, obj: element, "all consecutive: {}", all_consecutive);
if all_consecutive && gap_packets_length > 3 {
reset = true;
@ -326,7 +325,7 @@ impl SinkHandler {
let mut dts = buffer.dts();
let mut estimated_dts = false;
gst_log!(
gst::log!(
CAT,
obj: element,
"Storing buffer, seq: {}, rtptime: {}, pt: {}",
@ -359,7 +358,7 @@ impl SinkHandler {
inner.last_pt = Some(pt);
state.clock_rate = None;
gst_debug!(CAT, obj: pad, "New payload type: {}", pt);
gst::debug!(CAT, obj: pad, "New payload type: {}", pt);
if let Some(caps) = pad.current_caps() {
/* Ignore errors at this point, as we want to emit request-pt-map */
@ -397,7 +396,7 @@ impl SinkHandler {
);
if pts.is_none() {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"cannot calculate a valid pts for #{}, discard",
@ -432,7 +431,7 @@ impl SinkHandler {
if gap <= 0 {
state.stats.num_late += 1;
gst_debug!(CAT, obj: element, "Dropping late {}", seq);
gst::debug!(CAT, obj: element, "Dropping late {}", seq);
return Ok(gst::FlowSuccess::Ok);
}
}
@ -476,7 +475,7 @@ impl SinkHandler {
state.earliest_seqnum = Some(seq);
}
gst_log!(CAT, obj: pad, "Stored buffer");
gst::log!(CAT, obj: pad, "Stored buffer");
Ok(gst::FlowSuccess::Ok)
}
@ -527,7 +526,7 @@ impl SinkHandler {
if previous_next_wakeup.is_none()
|| next_wakeup.map_or(false, |next| previous_next_wakeup.unwrap() > next)
{
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Rescheduling for new item {} < {}",
@ -560,7 +559,7 @@ impl PadSinkHandler for SinkHandler {
async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists");
gst_debug!(CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
gst::debug!(CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
this.enqueue_item(pad.gst_pad(), &element, Some(buffer))
}
.boxed()
@ -575,11 +574,11 @@ impl PadSinkHandler for SinkHandler {
) -> bool {
use gst::EventView;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
if let EventView::FlushStart(..) = event.view() {
if let Err(err) = jb.task.flush_start() {
gst_error!(CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::error!(CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -590,7 +589,7 @@ impl PadSinkHandler for SinkHandler {
}
}
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
jb.src_pad.gst_pad().push_event(event)
}
@ -609,7 +608,7 @@ impl PadSinkHandler for SinkHandler {
async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists");
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
let jb = element.imp();
@ -621,7 +620,7 @@ impl PadSinkHandler for SinkHandler {
}
EventView::FlushStop(..) => {
if let Err(err) = jb.task.flush_stop() {
gst_error!(CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::error!(CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -644,7 +643,7 @@ impl PadSinkHandler for SinkHandler {
if forward {
// FIXME: These events should really be queued up and stay in order
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding serialized {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding serialized {:?}", event);
jb.src_pad.push_event(event).await
} else {
true
@ -681,7 +680,7 @@ impl SrcHandler {
Some(seq) => seq,
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Generating lost events seq: {}, last popped seq: {:?}",
@ -819,11 +818,11 @@ impl SrcHandler {
};
for event in lost_events {
gst_debug!(CAT, obj: jb.src_pad.gst_pad(), "Pushing lost event {:?}", event);
gst::debug!(CAT, obj: jb.src_pad.gst_pad(), "Pushing lost event {:?}", event);
let _ = jb.src_pad.push_event(event).await;
}
gst_debug!(CAT, obj: jb.src_pad.gst_pad(), "Pushing {:?} with seq {:?}", buffer, seq);
gst::debug!(CAT, obj: jb.src_pad.gst_pad(), "Pushing {:?} with seq {:?}", buffer, seq);
jb.src_pad.push(buffer).await
}
@ -840,7 +839,7 @@ impl SrcHandler {
) {
let now = element.current_running_time();
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Now is {}, EOS {}, earliest pts is {}, packet_spacing {} and latency {}",
@ -852,7 +851,7 @@ impl SrcHandler {
);
if state.eos {
gst_debug!(CAT, obj: element, "EOS, not waiting");
gst::debug!(CAT, obj: element, "EOS, not waiting");
return (now, Some((now, Duration::ZERO)));
}
@ -868,7 +867,7 @@ impl SrcHandler {
.opt_saturating_sub(now)
.unwrap_or(gst::ClockTime::ZERO);
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Next wakeup at {} with delay {}",
@ -892,12 +891,12 @@ impl PadSrcHandler for SrcHandler {
) -> bool {
use gst::EventView;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
match event.view() {
EventView::FlushStart(..) => {
if let Err(err) = jb.task.flush_start() {
gst_error!(CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::error!(CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -909,7 +908,7 @@ impl PadSrcHandler for SrcHandler {
}
EventView::FlushStop(..) => {
if let Err(err) = jb.task.flush_stop() {
gst_error!(CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::error!(CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -922,7 +921,7 @@ impl PadSrcHandler for SrcHandler {
_ => (),
}
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
jb.sink_pad.gst_pad().push_event(event)
}
@ -935,7 +934,7 @@ impl PadSrcHandler for SrcHandler {
) -> bool {
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", query);
match query.view_mut() {
QueryViewMut::Latency(q) => {
@ -1056,7 +1055,7 @@ impl JitterBufferTask {
impl TaskImpl for JitterBufferTask {
fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Starting task");
gst::log!(CAT, obj: &self.element, "Starting task");
self.src_pad_handler.clear();
self.sink_pad_handler.clear();
@ -1064,7 +1063,7 @@ impl TaskImpl for JitterBufferTask {
let jb = self.element.imp();
*jb.state.lock().unwrap() = State::default();
gst_log!(CAT, obj: &self.element, "Task started");
gst::log!(CAT, obj: &self.element, "Task started");
Ok(())
}
.boxed()
@ -1114,9 +1113,9 @@ impl TaskImpl for JitterBufferTask {
// Got aborted, reschedule if needed
if let Some(delay_fut) = delay_fut {
gst_debug!(CAT, obj: &self.element, "Waiting");
gst::debug!(CAT, obj: &self.element, "Waiting");
if let Err(Aborted) = delay_fut.await {
gst_debug!(CAT, obj: &self.element, "Waiting aborted");
gst::debug!(CAT, obj: &self.element, "Waiting aborted");
return Ok(());
}
}
@ -1132,7 +1131,7 @@ impl TaskImpl for JitterBufferTask {
context_wait,
);
gst_debug!(
gst::debug!(
CAT,
obj: &self.element,
"Woke up at {}, earliest_pts {}",
@ -1190,11 +1189,13 @@ impl TaskImpl for JitterBufferTask {
if let Err(err) = res {
match err {
gst::FlowError::Eos => {
gst_debug!(CAT, obj: &self.element, "Pushing EOS event");
gst::debug!(CAT, obj: &self.element, "Pushing EOS event");
let _ = jb.src_pad.push_event(gst::event::Eos::new()).await;
}
gst::FlowError::Flushing => gst_debug!(CAT, obj: &self.element, "Flushing"),
err => gst_error!(CAT, obj: &self.element, "Error {}", err),
gst::FlowError::Flushing => {
gst::debug!(CAT, obj: &self.element, "Flushing")
}
err => gst::error!(CAT, obj: &self.element, "Error {}", err),
}
return Err(err);
@ -1206,7 +1207,7 @@ impl TaskImpl for JitterBufferTask {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Stopping task");
gst::log!(CAT, obj: &self.element, "Stopping task");
let jb = self.element.imp();
let mut jb_state = jb.state.lock().unwrap();
@ -1220,7 +1221,7 @@ impl TaskImpl for JitterBufferTask {
*jb_state = State::default();
gst_log!(CAT, obj: &self.element, "Task stopped");
gst::log!(CAT, obj: &self.element, "Task stopped");
Ok(())
}
.boxed()
@ -1247,7 +1248,7 @@ static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
impl JitterBuffer {
fn clear_pt_map(&self, element: &super::JitterBuffer) {
gst_info!(CAT, obj: element, "Clearing PT map");
gst::info!(CAT, obj: element, "Clearing PT map");
let mut state = self.state.lock().unwrap();
state.clock_rate = None;
@ -1255,7 +1256,7 @@ impl JitterBuffer {
}
fn prepare(&self, element: &super::JitterBuffer) -> Result<(), gst::ErrorMessage> {
gst_info!(CAT, obj: element, "Preparing");
gst::info!(CAT, obj: element, "Preparing");
let context = {
let settings = self.settings.lock().unwrap();
@ -1274,28 +1275,28 @@ impl JitterBuffer {
)
})?;
gst_info!(CAT, obj: element, "Prepared");
gst::info!(CAT, obj: element, "Prepared");
Ok(())
}
fn unprepare(&self, element: &super::JitterBuffer) {
gst_debug!(CAT, obj: element, "Unpreparing");
gst::debug!(CAT, obj: element, "Unpreparing");
self.task.unprepare().unwrap();
gst_debug!(CAT, obj: element, "Unprepared");
gst::debug!(CAT, obj: element, "Unprepared");
}
fn start(&self, element: &super::JitterBuffer) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
self.task.start()?;
gst_debug!(CAT, obj: element, "Started");
gst::debug!(CAT, obj: element, "Started");
Ok(())
}
fn stop(&self, element: &super::JitterBuffer) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
self.task.stop()?;
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
Ok(())
}
}
@ -1561,7 +1562,7 @@ impl ElementImpl for JitterBuffer {
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::NullToReady => {

115
generic/threadshare/src/proxy/imp.rs
View file

@ -24,7 +24,6 @@ use futures::prelude::*;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace};
use once_cell::sync::Lazy;
@ -227,7 +226,7 @@ impl PadSinkHandler for ProxySinkPadHandler {
async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists");
gst_log!(SINK_CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
gst::log!(SINK_CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
let proxysink = element.imp();
proxysink
.enqueue_item(&element, DataQueueItem::Buffer(buffer))
@ -247,7 +246,7 @@ impl PadSinkHandler for ProxySinkPadHandler {
let element = element.clone().downcast::<super::ProxySink>().unwrap();
async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists");
gst_log!(SINK_CAT, obj: pad.gst_pad(), "Handling {:?}", list);
gst::log!(SINK_CAT, obj: pad.gst_pad(), "Handling {:?}", list);
let proxysink = element.imp();
proxysink
.enqueue_item(&element, DataQueueItem::BufferList(list))
@ -265,7 +264,7 @@ impl PadSinkHandler for ProxySinkPadHandler {
) -> bool {
use gst::EventView;
gst_debug!(SINK_CAT, obj: pad.gst_pad(), "Handling non-serialized {:?}", event);
gst::debug!(SINK_CAT, obj: pad.gst_pad(), "Handling non-serialized {:?}", event);
let src_pad = {
let proxy_ctx = proxysink.proxy_ctx.lock().unwrap();
@ -283,10 +282,10 @@ impl PadSinkHandler for ProxySinkPadHandler {
}
if let Some(src_pad) = src_pad {
gst_log!(SINK_CAT, obj: pad.gst_pad(), "Forwarding non-serialized {:?}", event);
gst::log!(SINK_CAT, obj: pad.gst_pad(), "Forwarding non-serialized {:?}", event);
src_pad.push_event(event)
} else {
gst_error!(SINK_CAT, obj: pad.gst_pad(), "No src pad to forward non-serialized {:?} to", event);
gst::error!(SINK_CAT, obj: pad.gst_pad(), "No src pad to forward non-serialized {:?} to", event);
true
}
}
@ -300,7 +299,7 @@ impl PadSinkHandler for ProxySinkPadHandler {
) -> BoxFuture<'static, bool> {
use gst::EventView;
gst_log!(SINK_CAT, obj: pad.gst_pad(), "Handling serialized {:?}", event);
gst::log!(SINK_CAT, obj: pad.gst_pad(), "Handling serialized {:?}", event);
let pad_weak = pad.downgrade();
let element = element.clone().downcast::<super::ProxySink>().unwrap();
@ -317,7 +316,7 @@ impl PadSinkHandler for ProxySinkPadHandler {
_ => (),
}
gst_log!(SINK_CAT, obj: pad.gst_pad(), "Queuing serialized {:?}", event);
gst::log!(SINK_CAT, obj: pad.gst_pad(), "Queuing serialized {:?}", event);
proxysink
.enqueue_item(&element, DataQueueItem::Event(event))
.await
@ -349,7 +348,7 @@ impl ProxySink {
let proxy_ctx = self.proxy_ctx.lock().unwrap();
let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared();
gst_log!(SINK_CAT, obj: element, "Trying to empty pending queue");
gst::log!(SINK_CAT, obj: element, "Trying to empty pending queue");
let ProxyContextInner {
pending_queue: ref mut pq,
@ -374,7 +373,7 @@ impl ProxySink {
receiver
} else {
gst_log!(SINK_CAT, obj: element, "Pending queue is empty now");
gst::log!(SINK_CAT, obj: element, "Pending queue is empty now");
*pq = None;
return;
}
@ -385,13 +384,13 @@ impl ProxySink {
receiver
}
} else {
gst_log!(SINK_CAT, obj: element, "Flushing, dropping pending queue");
gst::log!(SINK_CAT, obj: element, "Flushing, dropping pending queue");
*pq = None;
return;
}
};
gst_log!(SINK_CAT, obj: element, "Waiting for more queue space");
gst::log!(SINK_CAT, obj: element, "Waiting for more queue space");
let _ = more_queue_space_receiver.await;
}
}
@ -463,20 +462,20 @@ impl ProxySink {
pending_queue.items.push_back(item);
gst_log!(
gst::log!(
SINK_CAT,
obj: element,
"Proxy is full - Pushing first item on pending queue"
);
if schedule_now {
gst_log!(SINK_CAT, obj: element, "Scheduling pending queue now");
gst::log!(SINK_CAT, obj: element, "Scheduling pending queue now");
pending_queue.scheduled = true;
let wait_fut = self.schedule_pending_queue(element);
Some(wait_fut)
} else {
gst_log!(SINK_CAT, obj: element, "Scheduling pending queue later");
gst::log!(SINK_CAT, obj: element, "Scheduling pending queue later");
None
}
@ -496,7 +495,7 @@ impl ProxySink {
};
if let Some(wait_fut) = wait_fut {
gst_log!(
gst::log!(
SINK_CAT,
obj: element,
"Blocking until queue has space again"
@ -510,7 +509,7 @@ impl ProxySink {
}
fn prepare(&self, element: &super::ProxySink) -> Result<(), gst::ErrorMessage> {
gst_debug!(SINK_CAT, obj: element, "Preparing");
gst::debug!(SINK_CAT, obj: element, "Preparing");
let proxy_context = self.settings.lock().unwrap().proxy_context.to_string();
@ -529,22 +528,22 @@ impl ProxySink {
*self.proxy_ctx.lock().unwrap() = Some(proxy_ctx);
gst_debug!(SINK_CAT, obj: element, "Prepared");
gst::debug!(SINK_CAT, obj: element, "Prepared");
Ok(())
}
fn unprepare(&self, element: &super::ProxySink) {
gst_debug!(SINK_CAT, obj: element, "Unpreparing");
gst::debug!(SINK_CAT, obj: element, "Unpreparing");
*self.proxy_ctx.lock().unwrap() = None;
gst_debug!(SINK_CAT, obj: element, "Unprepared");
gst::debug!(SINK_CAT, obj: element, "Unprepared");
}
fn start(&self, element: &super::ProxySink) {
let proxy_ctx = self.proxy_ctx.lock().unwrap();
let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared();
gst_debug!(SINK_CAT, obj: element, "Starting");
gst::debug!(SINK_CAT, obj: element, "Starting");
{
let settings = self.settings.lock().unwrap();
@ -554,19 +553,19 @@ impl ProxySink {
shared_ctx.last_res = Ok(gst::FlowSuccess::Ok);
gst_debug!(SINK_CAT, obj: element, "Started");
gst::debug!(SINK_CAT, obj: element, "Started");
}
fn stop(&self, element: &super::ProxySink) {
let proxy_ctx = self.proxy_ctx.lock().unwrap();
let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared();
gst_debug!(SINK_CAT, obj: element, "Stopping");
gst::debug!(SINK_CAT, obj: element, "Stopping");
let _ = shared_ctx.pending_queue.take();
shared_ctx.last_res = Err(gst::FlowError::Flushing);
gst_debug!(SINK_CAT, obj: element, "Stopped");
gst::debug!(SINK_CAT, obj: element, "Stopped");
}
}
@ -678,7 +677,7 @@ impl ElementImpl for ProxySink {
element: &Self::Type,
transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(SINK_CAT, obj: element, "Changing state {:?}", transition);
gst::trace!(SINK_CAT, obj: element, "Changing state {:?}", transition);
match transition {
gst::StateChange::NullToReady => {
@ -725,15 +724,15 @@ impl ProxySrcPadHandler {
match item {
DataQueueItem::Buffer(buffer) => {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Forwarding {:?}", buffer);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Forwarding {:?}", buffer);
pad.push(buffer).await.map(drop)
}
DataQueueItem::BufferList(list) => {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Forwarding {:?}", list);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Forwarding {:?}", list);
pad.push_list(list).await.map(drop)
}
DataQueueItem::Event(event) => {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
pad.push_event(event).await;
Ok(())
}
@ -753,7 +752,7 @@ impl PadSrcHandler for ProxySrcPadHandler {
) -> bool {
use gst::EventView;
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
let sink_pad = {
let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap();
@ -769,7 +768,7 @@ impl PadSrcHandler for ProxySrcPadHandler {
match event.view() {
EventView::FlushStart(..) => {
if let Err(err) = proxysrc.task.flush_start() {
gst_error!(SRC_CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::error!(SRC_CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -781,7 +780,7 @@ impl PadSrcHandler for ProxySrcPadHandler {
}
EventView::FlushStop(..) => {
if let Err(err) = proxysrc.task.flush_stop() {
gst_error!(SRC_CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::error!(SRC_CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -795,10 +794,10 @@ impl PadSrcHandler for ProxySrcPadHandler {
}
if let Some(sink_pad) = sink_pad {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
sink_pad.push_event(event)
} else {
gst_error!(SRC_CAT, obj: pad.gst_pad(), "No sink pad to forward {:?} to", event);
gst::error!(SRC_CAT, obj: pad.gst_pad(), "No sink pad to forward {:?} to", event);
false
}
}
@ -812,7 +811,7 @@ impl PadSrcHandler for ProxySrcPadHandler {
) -> bool {
use gst::QueryViewMut;
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", query);
let ret = match query.view_mut() {
QueryViewMut::Latency(q) => {
q.set(true, gst::ClockTime::ZERO, gst::ClockTime::NONE);
@ -842,9 +841,9 @@ impl PadSrcHandler for ProxySrcPadHandler {
};
if ret {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Handled {:?}", query);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Handled {:?}", query);
} else {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
}
ret
@ -871,7 +870,7 @@ impl ProxySrcTask {
impl TaskImpl for ProxySrcTask {
fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(SRC_CAT, obj: &self.element, "Starting task");
gst::log!(SRC_CAT, obj: &self.element, "Starting task");
let proxysrc = self.element.imp();
let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap();
@ -885,7 +884,7 @@ impl TaskImpl for ProxySrcTask {
self.dataqueue.start();
gst_log!(SRC_CAT, obj: &self.element, "Task started");
gst::log!(SRC_CAT, obj: &self.element, "Task started");
Ok(())
}
.boxed()
@ -898,7 +897,7 @@ impl TaskImpl for ProxySrcTask {
let item = match item {
Some(item) => item,
None => {
gst_log!(SRC_CAT, obj: &self.element, "DataQueue Stopped");
gst::log!(SRC_CAT, obj: &self.element, "DataQueue Stopped");
return Err(gst::FlowError::Flushing);
}
};
@ -908,25 +907,25 @@ impl TaskImpl for ProxySrcTask {
let res = ProxySrcPadHandler::push_item(&pad, proxysrc, item).await;
match res {
Ok(()) => {
gst_log!(SRC_CAT, obj: &self.element, "Successfully pushed item");
gst::log!(SRC_CAT, obj: &self.element, "Successfully pushed item");
let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap();
let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared();
shared_ctx.last_res = Ok(gst::FlowSuccess::Ok);
}
Err(gst::FlowError::Flushing) => {
gst_debug!(SRC_CAT, obj: &self.element, "Flushing");
gst::debug!(SRC_CAT, obj: &self.element, "Flushing");
let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap();
let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared();
shared_ctx.last_res = Err(gst::FlowError::Flushing);
}
Err(gst::FlowError::Eos) => {
gst_debug!(SRC_CAT, obj: &self.element, "EOS");
gst::debug!(SRC_CAT, obj: &self.element, "EOS");
let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap();
let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared();
shared_ctx.last_res = Err(gst::FlowError::Eos);
}
Err(err) => {
gst_error!(SRC_CAT, obj: &self.element, "Got error {}", err);
gst::error!(SRC_CAT, obj: &self.element, "Got error {}", err);
gst::element_error!(
&self.element,
gst::StreamError::Failed,
@ -946,7 +945,7 @@ impl TaskImpl for ProxySrcTask {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(SRC_CAT, obj: &self.element, "Stopping task");
gst::log!(SRC_CAT, obj: &self.element, "Stopping task");
let proxysrc = self.element.imp();
let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap();
@ -961,7 +960,7 @@ impl TaskImpl for ProxySrcTask {
pending_queue.notify_more_queue_space();
}
gst_log!(SRC_CAT, obj: &self.element, "Task stopped");
gst::log!(SRC_CAT, obj: &self.element, "Task stopped");
Ok(())
}
.boxed()
@ -969,7 +968,7 @@ impl TaskImpl for ProxySrcTask {
fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(SRC_CAT, obj: &self.element, "Starting task flush");
gst::log!(SRC_CAT, obj: &self.element, "Starting task flush");
let proxysrc = self.element.imp();
let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap();
@ -979,7 +978,7 @@ impl TaskImpl for ProxySrcTask {
shared_ctx.last_res = Err(gst::FlowError::Flushing);
gst_log!(SRC_CAT, obj: &self.element, "Task flush started");
gst::log!(SRC_CAT, obj: &self.element, "Task flush started");
Ok(())
}
.boxed()
@ -1005,7 +1004,7 @@ static SRC_CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
impl ProxySrc {
fn prepare(&self, element: &super::ProxySrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(SRC_CAT, obj: element, "Preparing");
gst::debug!(SRC_CAT, obj: element, "Preparing");
let settings = self.settings.lock().unwrap().clone();
@ -1065,13 +1064,13 @@ impl ProxySrc {
)
})?;
gst_debug!(SRC_CAT, obj: element, "Prepared");
gst::debug!(SRC_CAT, obj: element, "Prepared");
Ok(())
}
fn unprepare(&self, element: &super::ProxySrc) {
gst_debug!(SRC_CAT, obj: element, "Unpreparing");
gst::debug!(SRC_CAT, obj: element, "Unpreparing");
{
let settings = self.settings.lock().unwrap();
@ -1084,27 +1083,27 @@ impl ProxySrc {
*self.dataqueue.lock().unwrap() = None;
*self.proxy_ctx.lock().unwrap() = None;
gst_debug!(SRC_CAT, obj: element, "Unprepared");
gst::debug!(SRC_CAT, obj: element, "Unprepared");
}
fn stop(&self, element: &super::ProxySrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(SRC_CAT, obj: element, "Stopping");
gst::debug!(SRC_CAT, obj: element, "Stopping");
self.task.stop()?;
gst_debug!(SRC_CAT, obj: element, "Stopped");
gst::debug!(SRC_CAT, obj: element, "Stopped");
Ok(())
}
fn start(&self, element: &super::ProxySrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(SRC_CAT, obj: element, "Starting");
gst::debug!(SRC_CAT, obj: element, "Starting");
self.task.start()?;
gst_debug!(SRC_CAT, obj: element, "Started");
gst::debug!(SRC_CAT, obj: element, "Started");
Ok(())
}
fn pause(&self, element: &super::ProxySrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(SRC_CAT, obj: element, "Pausing");
gst::debug!(SRC_CAT, obj: element, "Pausing");
self.task.pause()?;
gst_debug!(SRC_CAT, obj: element, "Paused");
gst::debug!(SRC_CAT, obj: element, "Paused");
Ok(())
}
}
@ -1290,7 +1289,7 @@ impl ElementImpl for ProxySrc {
element: &Self::Type,
transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(SRC_CAT, obj: element, "Changing state {:?}", transition);
gst::trace!(SRC_CAT, obj: element, "Changing state {:?}", transition);
match transition {
gst::StateChange::NullToReady => {

103
generic/threadshare/src/queue/imp.rs
View file

@ -24,7 +24,6 @@ use futures::prelude::*;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace};
use once_cell::sync::Lazy;
@ -95,7 +94,7 @@ impl PadSinkHandler for QueuePadSinkHandler {
let element = element.clone().downcast::<super::Queue>().unwrap();
async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists");
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
let queue = element.imp();
queue
.enqueue_item(&element, DataQueueItem::Buffer(buffer))
@ -115,7 +114,7 @@ impl PadSinkHandler for QueuePadSinkHandler {
let element = element.clone().downcast::<super::Queue>().unwrap();
async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists");
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", list);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", list);
let queue = element.imp();
queue
.enqueue_item(&element, DataQueueItem::BufferList(list))
@ -133,11 +132,11 @@ impl PadSinkHandler for QueuePadSinkHandler {
) -> bool {
use gst::EventView;
gst_debug!(CAT, obj: pad.gst_pad(), "Handling non-serialized {:?}", event);
gst::debug!(CAT, obj: pad.gst_pad(), "Handling non-serialized {:?}", event);
if let EventView::FlushStart(..) = event.view() {
if let Err(err) = queue.task.flush_start() {
gst_error!(CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::error!(CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -148,7 +147,7 @@ impl PadSinkHandler for QueuePadSinkHandler {
}
}
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding non-serialized {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding non-serialized {:?}", event);
queue.src_pad.gst_pad().push_event(event)
}
@ -161,7 +160,7 @@ impl PadSinkHandler for QueuePadSinkHandler {
) -> BoxFuture<'static, bool> {
use gst::EventView;
gst_log!(CAT, obj: pad.gst_pad(), "Handling serialized {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handling serialized {:?}", event);
let pad_weak = pad.downgrade();
let element = element.clone().downcast::<super::Queue>().unwrap();
@ -171,7 +170,7 @@ impl PadSinkHandler for QueuePadSinkHandler {
if let EventView::FlushStop(..) = event.view() {
if let Err(err) = queue.task.flush_stop() {
gst_error!(CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::error!(CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -182,7 +181,7 @@ impl PadSinkHandler for QueuePadSinkHandler {
}
}
gst_log!(CAT, obj: pad.gst_pad(), "Queuing serialized {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Queuing serialized {:?}", event);
queue
.enqueue_item(&element, DataQueueItem::Event(event))
.await
@ -198,14 +197,14 @@ impl PadSinkHandler for QueuePadSinkHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
if query.is_serialized() {
// FIXME: How can we do this?
gst_log!(CAT, obj: pad.gst_pad(), "Dropping serialized {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Dropping serialized {:?}", query);
false
} else {
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", query);
queue.src_pad.gst_pad().peer_query(query)
}
}
@ -226,15 +225,15 @@ impl QueuePadSrcHandler {
match item {
DataQueueItem::Buffer(buffer) => {
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", buffer);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", buffer);
pad.push(buffer).await.map(drop)
}
DataQueueItem::BufferList(list) => {
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", list);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", list);
pad.push_list(list).await.map(drop)
}
DataQueueItem::Event(event) => {
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
pad.push_event(event).await;
Ok(())
}
@ -254,17 +253,17 @@ impl PadSrcHandler for QueuePadSrcHandler {
) -> bool {
use gst::EventView;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
match event.view() {
EventView::FlushStart(..) => {
if let Err(err) = queue.task.flush_start() {
gst_error!(CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
gst::error!(CAT, obj: pad.gst_pad(), "FlushStart failed {:?}", err);
}
}
EventView::FlushStop(..) => {
if let Err(err) = queue.task.flush_stop() {
gst_error!(CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::error!(CAT, obj: pad.gst_pad(), "FlushStop failed {:?}", err);
gst::element_error!(
element,
gst::StreamError::Failed,
@ -277,7 +276,7 @@ impl PadSrcHandler for QueuePadSrcHandler {
_ => (),
}
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", event);
queue.sink_pad.gst_pad().push_event(event)
}
@ -290,7 +289,7 @@ impl PadSrcHandler for QueuePadSrcHandler {
) -> bool {
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
if let QueryViewMut::Scheduling(q) = query.view_mut() {
let mut new_query = gst::query::Scheduling::new();
@ -299,7 +298,7 @@ impl PadSrcHandler for QueuePadSrcHandler {
return res;
}
gst_log!(CAT, obj: pad.gst_pad(), "Upstream returned {:?}", new_query);
gst::log!(CAT, obj: pad.gst_pad(), "Upstream returned {:?}", new_query);
let (flags, min, max, align) = new_query.result();
q.set(flags, min, max, align);
@ -311,11 +310,11 @@ impl PadSrcHandler for QueuePadSrcHandler {
.filter(|m| m != &gst::PadMode::Pull)
.collect::<Vec<_>>(),
);
gst_log!(CAT, obj: pad.gst_pad(), "Returning {:?}", q.query_mut());
gst::log!(CAT, obj: pad.gst_pad(), "Returning {:?}", q.query_mut());
return true;
}
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", query);
queue.sink_pad.gst_pad().peer_query(query)
}
}
@ -340,7 +339,7 @@ impl QueueTask {
impl TaskImpl for QueueTask {
fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Starting task");
gst::log!(CAT, obj: &self.element, "Starting task");
let queue = self.element.imp();
let mut last_res = queue.last_res.lock().unwrap();
@ -349,7 +348,7 @@ impl TaskImpl for QueueTask {
*last_res = Ok(gst::FlowSuccess::Ok);
gst_log!(CAT, obj: &self.element, "Task started");
gst::log!(CAT, obj: &self.element, "Task started");
Ok(())
}
.boxed()
@ -362,7 +361,7 @@ impl TaskImpl for QueueTask {
let item = match item {
Some(item) => item,
None => {
gst_log!(CAT, obj: &self.element, "DataQueue Stopped");
gst::log!(CAT, obj: &self.element, "DataQueue Stopped");
return Err(gst::FlowError::Flushing);
}
};
@ -372,20 +371,20 @@ impl TaskImpl for QueueTask {
let res = QueuePadSrcHandler::push_item(&pad, queue, item).await;
match res {
Ok(()) => {
gst_log!(CAT, obj: &self.element, "Successfully pushed item");
gst::log!(CAT, obj: &self.element, "Successfully pushed item");
*queue.last_res.lock().unwrap() = Ok(gst::FlowSuccess::Ok);
}
Err(gst::FlowError::Flushing) => {
gst_debug!(CAT, obj: &self.element, "Flushing");
gst::debug!(CAT, obj: &self.element, "Flushing");
*queue.last_res.lock().unwrap() = Err(gst::FlowError::Flushing);
}
Err(gst::FlowError::Eos) => {
gst_debug!(CAT, obj: &self.element, "EOS");
gst::debug!(CAT, obj: &self.element, "EOS");
*queue.last_res.lock().unwrap() = Err(gst::FlowError::Eos);
pad.push_event(gst::event::Eos::new()).await;
}
Err(err) => {
gst_error!(CAT, obj: &self.element, "Got error {}", err);
gst::error!(CAT, obj: &self.element, "Got error {}", err);
gst::element_error!(
&self.element,
gst::StreamError::Failed,
@ -403,7 +402,7 @@ impl TaskImpl for QueueTask {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Stopping task");
gst::log!(CAT, obj: &self.element, "Stopping task");
let queue = self.element.imp();
let mut last_res = queue.last_res.lock().unwrap();
@ -417,7 +416,7 @@ impl TaskImpl for QueueTask {
*last_res = Err(gst::FlowError::Flushing);
gst_log!(CAT, obj: &self.element, "Task stopped");
gst::log!(CAT, obj: &self.element, "Task stopped");
Ok(())
}
.boxed()
@ -425,7 +424,7 @@ impl TaskImpl for QueueTask {
fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Starting task flush");
gst::log!(CAT, obj: &self.element, "Starting task flush");
let queue = self.element.imp();
let mut last_res = queue.last_res.lock().unwrap();
@ -438,7 +437,7 @@ impl TaskImpl for QueueTask {
*last_res = Err(gst::FlowError::Flushing);
gst_log!(CAT, obj: &self.element, "Task flush started");
gst::log!(CAT, obj: &self.element, "Task flush started");
Ok(())
}
.boxed()
@ -513,7 +512,7 @@ impl Queue {
}
let mut pending_queue_grd = self.pending_queue.lock().unwrap();
gst_log!(CAT, obj: element, "Trying to empty pending queue");
gst::log!(CAT, obj: element, "Trying to empty pending queue");
if let Some(pending_queue) = pending_queue_grd.as_mut() {
let mut failed_item = None;
@ -530,17 +529,17 @@ impl Queue {
receiver
} else {
gst_log!(CAT, obj: element, "Pending queue is empty now");
gst::log!(CAT, obj: element, "Pending queue is empty now");
*pending_queue_grd = None;
return;
}
} else {
gst_log!(CAT, obj: element, "Flushing, dropping pending queue");
gst::log!(CAT, obj: element, "Flushing, dropping pending queue");
return;
}
};
gst_log!(CAT, obj: element, "Waiting for more queue space");
gst::log!(CAT, obj: element, "Waiting for more queue space");
let _ = more_queue_space_receiver.await;
}
}
@ -553,7 +552,7 @@ impl Queue {
let wait_fut = {
let dataqueue = self.dataqueue.lock().unwrap();
let dataqueue = dataqueue.as_ref().ok_or_else(|| {
gst_error!(CAT, obj: element, "No DataQueue");
gst::error!(CAT, obj: element, "No DataQueue");
gst::FlowError::Error
})?;
@ -580,20 +579,20 @@ impl Queue {
pending_queue.as_mut().unwrap().items.push_back(item);
gst_log!(
gst::log!(
CAT,
obj: element,
"Queue is full - Pushing first item on pending queue"
);
if schedule_now {
gst_log!(CAT, obj: element, "Scheduling pending queue now");
gst::log!(CAT, obj: element, "Scheduling pending queue now");
pending_queue.as_mut().unwrap().scheduled = true;
let wait_fut = self.schedule_pending_queue(element);
Some(wait_fut)
} else {
gst_log!(CAT, obj: element, "Scheduling pending queue later");
gst::log!(CAT, obj: element, "Scheduling pending queue later");
None
}
} else {
@ -606,7 +605,7 @@ impl Queue {
};
if let Some(wait_fut) = wait_fut {
gst_log!(CAT, obj: element, "Blocking until queue has space again");
gst::log!(CAT, obj: element, "Blocking until queue has space again");
wait_fut.await;
}
@ -614,7 +613,7 @@ impl Queue {
}
fn prepare(&self, element: &super::Queue) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Preparing");
gst::debug!(CAT, obj: element, "Preparing");
let settings = self.settings.lock().unwrap().clone();
@ -657,13 +656,13 @@ impl Queue {
)
})?;
gst_debug!(CAT, obj: element, "Prepared");
gst::debug!(CAT, obj: element, "Prepared");
Ok(())
}
fn unprepare(&self, element: &super::Queue) {
gst_debug!(CAT, obj: element, "Unpreparing");
gst::debug!(CAT, obj: element, "Unpreparing");
self.task.unprepare().unwrap();
@ -672,20 +671,20 @@ impl Queue {
*self.last_res.lock().unwrap() = Ok(gst::FlowSuccess::Ok);
gst_debug!(CAT, obj: element, "Unprepared");
gst::debug!(CAT, obj: element, "Unprepared");
}
fn stop(&self, element: &super::Queue) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
self.task.stop()?;
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
Ok(())
}
fn start(&self, element: &super::Queue) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
self.task.start()?;
gst_debug!(CAT, obj: element, "Started");
gst::debug!(CAT, obj: element, "Started");
Ok(())
}
}
@ -869,7 +868,7 @@ impl ElementImpl for Queue {
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::NullToReady => {

20
generic/threadshare/src/runtime/executor/context.rs
View file

@ -5,8 +5,6 @@
use futures::prelude::*;
use gst::{gst_debug, gst_error, gst_trace, gst_warning};
use once_cell::sync::Lazy;
use std::collections::HashMap;
@ -51,7 +49,7 @@ where
Fut::Output: Send + 'static,
{
if let Some((cur_context, cur_task_id)) = Context::current_task() {
gst_debug!(
gst::debug!(
RUNTIME_CAT,
"Adding subtask to task {:?} on context {}",
cur_task_id,
@ -86,12 +84,12 @@ where
{
if let Some(context) = Context::current() {
let msg = format!("Attempt to block within Context {}", context.name());
gst_error!(RUNTIME_CAT, "{}", msg);
gst::error!(RUNTIME_CAT, "{}", msg);
panic!("{}", msg);
}
// Not running in a Context thread so we can block
gst_debug!(RUNTIME_CAT, "Blocking on new dummy context");
gst::debug!(RUNTIME_CAT, "Blocking on new dummy context");
Scheduler::block_on(future)
}
@ -157,7 +155,7 @@ impl Context {
if let Some(context_weak) = contexts.get(context_name) {
if let Some(context) = context_weak.upgrade() {
gst_debug!(RUNTIME_CAT, "Joining Context '{}'", context.name());
gst::debug!(RUNTIME_CAT, "Joining Context '{}'", context.name());
return Ok(context);
}
}
@ -165,7 +163,7 @@ impl Context {
let context = Context(Scheduler::start(context_name, wait));
contexts.insert(context_name.into(), context.downgrade());
gst_debug!(RUNTIME_CAT, "New Context '{}'", context.name());
gst::debug!(RUNTIME_CAT, "New Context '{}'", context.name());
Ok(context)
}
@ -221,7 +219,7 @@ impl Context {
self.name()
);
} else {
gst_warning!(
gst::warning!(
RUNTIME_CAT,
"Entering Context {} within {}",
self.name(),
@ -229,7 +227,7 @@ impl Context {
);
}
} else {
gst_debug!(RUNTIME_CAT, "Entering Context {}", self.name());
gst::debug!(RUNTIME_CAT, "Entering Context {}", self.name());
}
self.0.enter(f)
@ -255,7 +253,7 @@ impl Context {
let (ctx, task_id) = match Context::current_task() {
Some(task) => task,
None => {
gst_trace!(RUNTIME_CAT, "No current task");
gst::trace!(RUNTIME_CAT, "No current task");
return false;
}
};
@ -270,7 +268,7 @@ impl Context {
let (ctx, task_id) = match Context::current_task() {
Some(task) => task,
None => {
gst_trace!(RUNTIME_CAT, "No current task");
gst::trace!(RUNTIME_CAT, "No current task");
return Err(sub_task);
}
};

17
generic/threadshare/src/runtime/executor/reactor.rs
View file

@ -7,7 +7,6 @@
use concurrent_queue::ConcurrentQueue;
use futures::ready;
use gst::{gst_trace, gst_warning};
use polling::{Event, Poller};
use slab::Slab;
@ -215,7 +214,7 @@ impl Reactor {
.is_err()
{
// If the queue is full, drain it and try again.
gst_warning!(RUNTIME_CAT, "react: timer_ops is full");
gst::warning!(RUNTIME_CAT, "react: timer_ops is full");
self.process_timer_ops();
}
@ -226,7 +225,7 @@ impl Reactor {
pub fn remove_timer(&mut self, when: Instant, id: usize) {
// Push a remove operation.
while self.timer_ops.push(TimerOp::Remove(when, id)).is_err() {
gst_warning!(RUNTIME_CAT, "react: timer_ops is full");
gst::warning!(RUNTIME_CAT, "react: timer_ops is full");
// If the queue is full, drain it and try again.
self.process_timer_ops();
}
@ -249,7 +248,7 @@ impl Reactor {
// Add wakers to the list.
if !ready.is_empty() {
gst_trace!(RUNTIME_CAT, "process_timers: {} ready wakers", ready.len());
gst::trace!(RUNTIME_CAT, "process_timers: {} ready wakers", ready.len());
for (_, waker) in ready {
wakers.push(waker);
@ -333,7 +332,7 @@ impl Reactor {
// Wake up ready tasks.
if !wakers.is_empty() {
gst_trace!(RUNTIME_CAT, "react: {} ready wakers", wakers.len());
gst::trace!(RUNTIME_CAT, "react: {} ready wakers", wakers.len());
for waker in wakers {
// Don't let a panicking waker blow everything up.
@ -506,7 +505,7 @@ impl<T> Future for Readable<'_, T> {
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
ready!(Pin::new(&mut self.0).poll(cx))?;
gst_trace!(RUNTIME_CAT, "readable: fd={}", self.0.handle.source.raw);
gst::trace!(RUNTIME_CAT, "readable: fd={}", self.0.handle.source.raw);
Poll::Ready(Ok(()))
}
}
@ -526,7 +525,7 @@ impl<T> Future for ReadableOwned<T> {
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
ready!(Pin::new(&mut self.0).poll(cx))?;
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"readable_owned: fd={}",
self.0.handle.source.raw
@ -550,7 +549,7 @@ impl<T> Future for Writable<'_, T> {
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
ready!(Pin::new(&mut self.0).poll(cx))?;
gst_trace!(RUNTIME_CAT, "writable: fd={}", self.0.handle.source.raw);
gst::trace!(RUNTIME_CAT, "writable: fd={}", self.0.handle.source.raw);
Poll::Ready(Ok(()))
}
}
@ -570,7 +569,7 @@ impl<T> Future for WritableOwned<T> {
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
ready!(Pin::new(&mut self.0).poll(cx))?;
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"writable_owned: fd={}",
self.0.handle.source.raw

25
generic/threadshare/src/runtime/executor/scheduler.rs
View file

@ -9,7 +9,6 @@ use futures::channel::oneshot;
use futures::pin_mut;
use gio::glib::clone::Downgrade;
use gst::{gst_debug, gst_error, gst_trace, gst_warning};
use std::cell::RefCell;
use std::future::Future;
@ -56,7 +55,7 @@ impl Scheduler {
let thread_ctx_name = Arc::clone(&context_name);
let join = thread
.spawn(move || {
gst_debug!(
gst::debug!(
RUNTIME_CAT,
"Started Scheduler thread for Context {}",
thread_ctx_name
@ -68,14 +67,14 @@ impl Scheduler {
match this.block_on_priv(shutdown_receiver) {
Ok(_) => {
gst_debug!(
gst::debug!(
RUNTIME_CAT,
"Scheduler thread shut down for Context {}",
thread_ctx_name
);
}
Err(e) => {
gst_error!(
gst::error!(
RUNTIME_CAT,
"Scheduler thread shut down due to an error within Context {}",
thread_ctx_name
@ -149,10 +148,10 @@ impl Scheduler {
res
});
gst_trace!(RUNTIME_CAT, "Blocking on current thread with {:?}", task_id);
gst::trace!(RUNTIME_CAT, "Blocking on current thread with {:?}", task_id);
let _guard = CallOnDrop::new(|| {
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"Blocking on current thread with {:?} done",
task_id,
@ -162,7 +161,7 @@ impl Scheduler {
match this.block_on_priv(task) {
Ok(res) => res,
Err(e) => {
gst_error!(
gst::error!(
RUNTIME_CAT,
"Panic blocking on Context {}",
&Scheduler::DUMMY_NAME
@ -202,7 +201,7 @@ impl Scheduler {
while let Ok(runnable) = self.tasks.pop_runnable() {
panic::catch_unwind(|| runnable.run()).map_err(|err| {
gst_error!(
gst::error!(
RUNTIME_CAT,
"A task has panicked within Context {}",
self.context_name
@ -241,7 +240,7 @@ impl Scheduler {
}
fn close(context_name: Arc<str>) {
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"Closing Scheduler for Context {}",
context_name,
@ -282,7 +281,7 @@ impl Scheduler {
impl Drop for Scheduler {
fn drop(&mut self) {
gst_debug!(
gst::debug!(
RUNTIME_CAT,
"Terminated: Scheduler for Context {}",
self.context_name
@ -315,7 +314,7 @@ impl SchedulerShutdown {
impl Drop for SchedulerShutdown {
fn drop(&mut self) {
if let Some(sender) = self.sender.take() {
gst_debug!(
gst::debug!(
RUNTIME_CAT,
"Shutting down Scheduler thread for Context {}",
self.scheduler.context_name
@ -325,7 +324,7 @@ impl Drop for SchedulerShutdown {
// Don't block shutting down itself
if !self.scheduler.is_current() {
if let Some(join_handler) = self.join.take() {
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"Waiting for Scheduler thread to shutdown for Context {}",
self.scheduler.context_name
@ -429,7 +428,7 @@ impl Handle {
.push(CleanUpOps(source))
.is_err()
{
gst_warning!(RUNTIME_CAT, "scheduler: cleanup_ops is full");
gst::warning!(RUNTIME_CAT, "scheduler: cleanup_ops is full");
}
}

18
generic/threadshare/src/runtime/executor/task.rs
View file

@ -9,8 +9,6 @@ use concurrent_queue::ConcurrentQueue;
use futures::future::BoxFuture;
use futures::prelude::*;
use gst::{gst_log, gst_trace, gst_warning};
use pin_project_lite::pin_project;
use slab::Slab;
@ -139,7 +137,7 @@ impl TaskQueue {
let context_name = Arc::clone(&self.context_name);
let task_fut = async move {
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"Running {:?} on context {}",
task_id,
@ -149,7 +147,7 @@ impl TaskQueue {
let _guard = CallOnDrop::new(move || {
if let Some(task) = tasks_clone.lock().unwrap().try_remove(task_id.0) {
if !task.sub_tasks.is_empty() {
gst_warning!(
gst::warning!(
RUNTIME_CAT,
"Task {:?} on context {} has {} pending sub tasks",
task_id,
@ -159,7 +157,7 @@ impl TaskQueue {
}
}
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"Done {:?} on context {}",
task_id,
@ -203,7 +201,7 @@ impl TaskQueue {
let context_name = Arc::clone(&self.context_name);
let task_fut = async move {
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"Executing sync function on context {} as {:?}",
context_name,
@ -213,7 +211,7 @@ impl TaskQueue {
let _guard = CallOnDrop::new(move || {
let _ = tasks_clone.lock().unwrap().try_remove(task_id.0);
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"Done executing sync function on context {} as {:?}",
context_name,
@ -257,7 +255,7 @@ impl TaskQueue {
{
match self.tasks.lock().unwrap().get_mut(task_id.0) {
Some(task) => {
gst_trace!(
gst::trace!(
RUNTIME_CAT,
"Adding subtask to {:?} on context {}",
task_id,
@ -267,7 +265,7 @@ impl TaskQueue {
Ok(())
}
None => {
gst_trace!(RUNTIME_CAT, "Task was removed in the meantime");
gst::trace!(RUNTIME_CAT, "Task was removed in the meantime");
Err(sub_task)
}
}
@ -287,7 +285,7 @@ impl TaskQueue {
async move {
if let Some((mut sub_tasks, context_name)) = sub_tasks {
if !sub_tasks.is_empty() {
gst_log!(
gst::log!(
RUNTIME_CAT,
"Scheduling draining {} sub tasks from {:?} on '{}'",
sub_tasks.len(),

57
generic/threadshare/src/runtime/pad.rs
View file

@ -74,7 +74,6 @@ use futures::prelude::*;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_fixme, gst_log};
use gst::{FlowError, FlowSuccess};
use std::marker::PhantomData;
@ -129,7 +128,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
) -> Result<(), gst::LoggableError> {
let gst_pad = pad.gst_pad();
if gst_pad.is_active() {
gst_debug!(
gst::debug!(
RUNTIME_CAT,
obj: gst_pad,
"Already activated in {:?} mode ",
@ -141,7 +140,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
gst_pad
.activate_mode(gst::PadMode::Push, true)
.map_err(|err| {
gst_error!(
gst::error!(
RUNTIME_CAT,
obj: gst_pad,
"Error in PadSrc activate: {:?}",
@ -169,7 +168,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
element: &gst::Element,
event: gst::Event,
) -> bool {
gst_log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
pad.gst_pad().event_default(Some(element), event)
}
@ -193,7 +192,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
gst_log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", query);
if query.is_serialized() {
// FIXME serialized queries should be handled with the dataflow
// but we can't return a `Future` because we couldn't honor QueryRef's lifetime
@ -223,10 +222,10 @@ impl PadSrcInner {
}
pub async fn push(&self, buffer: gst::Buffer) -> Result<FlowSuccess, FlowError> {
gst_log!(RUNTIME_CAT, obj: self.gst_pad(), "Pushing {:?}", buffer);
gst::log!(RUNTIME_CAT, obj: self.gst_pad(), "Pushing {:?}", buffer);
let success = self.gst_pad.push(buffer).map_err(|err| {
gst_error!(RUNTIME_CAT,
gst::error!(RUNTIME_CAT,
obj: self.gst_pad(),
"Failed to push Buffer to PadSrc: {:?}",
err,
@ -234,7 +233,7 @@ impl PadSrcInner {
err
})?;
gst_log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks");
gst::log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks");
while Context::current_has_sub_tasks() {
Context::drain_sub_tasks().await?;
}
@ -243,10 +242,10 @@ impl PadSrcInner {
}
pub async fn push_list(&self, list: gst::BufferList) -> Result<FlowSuccess, FlowError> {
gst_log!(RUNTIME_CAT, obj: self.gst_pad(), "Pushing {:?}", list);
gst::log!(RUNTIME_CAT, obj: self.gst_pad(), "Pushing {:?}", list);
let success = self.gst_pad.push_list(list).map_err(|err| {
gst_error!(
gst::error!(
RUNTIME_CAT,
obj: self.gst_pad(),
"Failed to push BufferList to PadSrc: {:?}",
@ -255,7 +254,7 @@ impl PadSrcInner {
err
})?;
gst_log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks");
gst::log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks");
while Context::current_has_sub_tasks() {
Context::drain_sub_tasks().await?;
}
@ -264,11 +263,11 @@ impl PadSrcInner {
}
pub async fn push_event(&self, event: gst::Event) -> bool {
gst_log!(RUNTIME_CAT, obj: &self.gst_pad, "Pushing {:?}", event);
gst::log!(RUNTIME_CAT, obj: &self.gst_pad, "Pushing {:?}", event);
let was_handled = self.gst_pad().push_event(event);
gst_log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks");
gst::log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks");
while Context::current_has_sub_tasks() {
if Context::drain_sub_tasks().await.is_err() {
return false;
@ -333,10 +332,10 @@ impl<'a> PadSrcRef<'a> {
) -> Result<(), gst::LoggableError> {
// Important: don't panic here as the hook is used without `catch_panic_pad_function`
// in the default `activatemode` handling
gst_log!(RUNTIME_CAT, obj: self.gst_pad(), "ActivateMode {:?}, {}", mode, active);
gst::log!(RUNTIME_CAT, obj: self.gst_pad(), "ActivateMode {:?}, {}", mode, active);
if mode == gst::PadMode::Pull {
gst_error!(RUNTIME_CAT, obj: self.gst_pad(), "Pull mode not supported by PadSrc");
gst::error!(RUNTIME_CAT, obj: self.gst_pad(), "Pull mode not supported by PadSrc");
return Err(gst::loggable_error!(
RUNTIME_CAT,
"Pull mode not supported by PadSrc"
@ -399,7 +398,7 @@ impl PadSrc {
H::ElementImpl::catch_panic_pad_function(
parent,
|| {
gst_error!(RUNTIME_CAT, obj: gst_pad, "Panic in PadSrc activate");
gst::error!(RUNTIME_CAT, obj: gst_pad, "Panic in PadSrc activate");
Err(gst::loggable_error!(
RUNTIME_CAT,
"Panic in PadSrc activate"
@ -425,7 +424,7 @@ impl PadSrc {
H::ElementImpl::catch_panic_pad_function(
parent,
|| {
gst_error!(RUNTIME_CAT, obj: gst_pad, "Panic in PadSrc activatemode");
gst::error!(RUNTIME_CAT, obj: gst_pad, "Panic in PadSrc activatemode");
Err(gst::loggable_error!(
RUNTIME_CAT,
"Panic in PadSrc activatemode"
@ -481,7 +480,7 @@ impl PadSrc {
if !query.is_serialized() {
handler.src_query(&this_ref, imp, element.dynamic_cast_ref::<gst::Element>().unwrap(), query)
} else {
gst_fixme!(RUNTIME_CAT, obj: this_ref.gst_pad(), "Serialized Query not supported");
gst::fixme!(RUNTIME_CAT, obj: this_ref.gst_pad(), "Serialized Query not supported");
false
}
},
@ -540,7 +539,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
) -> Result<(), gst::LoggableError> {
let gst_pad = pad.gst_pad();
if gst_pad.is_active() {
gst_debug!(
gst::debug!(
RUNTIME_CAT,
obj: gst_pad,
"Already activated in {:?} mode ",
@ -552,7 +551,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
gst_pad
.activate_mode(gst::PadMode::Push, true)
.map_err(|err| {
gst_error!(
gst::error!(
RUNTIME_CAT,
obj: gst_pad,
"Error in PadSink activate: {:?}",
@ -601,7 +600,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
event: gst::Event,
) -> bool {
assert!(!event.is_serialized());
gst_log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
pad.gst_pad().event_default(Some(element), event)
}
@ -618,7 +617,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists");
gst_log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
pad.gst_pad().event_default(Some(&element), event)
}
@ -664,12 +663,12 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
query: &mut gst::QueryRef,
) -> bool {
if query.is_serialized() {
gst_log!(RUNTIME_CAT, obj: pad.gst_pad(), "Dropping {:?}", query);
gst::log!(RUNTIME_CAT, obj: pad.gst_pad(), "Dropping {:?}", query);
// FIXME serialized queries should be handled with the dataflow
// but we can't return a `Future` because we couldn't honor QueryRef's lifetime
false
} else {
gst_log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(RUNTIME_CAT, obj: pad.gst_pad(), "Handling {:?}", query);
pad.gst_pad().query_default(Some(element), query)
}
}
@ -747,10 +746,10 @@ impl<'a> PadSinkRef<'a> {
) -> Result<(), gst::LoggableError> {
// Important: don't panic here as the hook is used without `catch_panic_pad_function`
// in the default `activatemode` handling
gst_log!(RUNTIME_CAT, obj: self.gst_pad(), "ActivateMode {:?}, {}", mode, active);
gst::log!(RUNTIME_CAT, obj: self.gst_pad(), "ActivateMode {:?}, {}", mode, active);
if mode == gst::PadMode::Pull {
gst_error!(RUNTIME_CAT, obj: self.gst_pad(), "Pull mode not supported by PadSink");
gst::error!(RUNTIME_CAT, obj: self.gst_pad(), "Pull mode not supported by PadSink");
return Err(gst::loggable_error!(
RUNTIME_CAT,
"Pull mode not supported by PadSink"
@ -820,7 +819,7 @@ impl PadSink {
H::ElementImpl::catch_panic_pad_function(
parent,
|| {
gst_error!(RUNTIME_CAT, obj: gst_pad, "Panic in PadSink activate");
gst::error!(RUNTIME_CAT, obj: gst_pad, "Panic in PadSink activate");
Err(gst::loggable_error!(
RUNTIME_CAT,
"Panic in PadSink activate"
@ -846,7 +845,7 @@ impl PadSink {
H::ElementImpl::catch_panic_pad_function(
parent,
|| {
gst_error!(RUNTIME_CAT, obj: gst_pad, "Panic in PadSink activatemode");
gst::error!(RUNTIME_CAT, obj: gst_pad, "Panic in PadSink activatemode");
Err(gst::loggable_error!(
RUNTIME_CAT,
"Panic in PadSink activatemode"
@ -1021,7 +1020,7 @@ impl PadSink {
if !query.is_serialized() {
handler.sink_query(&this_ref, imp, element.dynamic_cast_ref::<gst::Element>().unwrap(), query)
} else {
gst_fixme!(RUNTIME_CAT, obj: this_ref.gst_pad(), "Serialized Query not supported");
gst::fixme!(RUNTIME_CAT, obj: this_ref.gst_pad(), "Serialized Query not supported");
false
}
},

319
generic/threadshare/src/runtime/task.rs
View file

File diff suppressed because it is too large Load diff

15
generic/threadshare/src/socket.rs
View file

@ -22,7 +22,6 @@ use futures::future::BoxFuture;
use gst::glib;
use gst::prelude::*;
use gst::{gst_debug, gst_error, gst_log};
use once_cell::sync::Lazy;
@ -75,7 +74,7 @@ impl<T: SocketRead> Socket<T> {
) -> Result<Self, glib::BoolError> {
// FIXME couldn't we just delegate this to caller?
buffer_pool.set_active(true).map_err(|err| {
gst_error!(
gst::error!(
SOCKET_CAT,
obj: &element,
"Failed to prepare socket: {}",
@ -125,7 +124,7 @@ impl<T: SocketRead> Socket<T> {
// tokio::net::UdpSocket which don't implement pollable functions.
#[allow(clippy::should_implement_trait)]
pub async fn next(&mut self) -> Option<SocketStreamItem> {
gst_log!(SOCKET_CAT, obj: &self.element, "Trying to read data");
gst::log!(SOCKET_CAT, obj: &self.element, "Trying to read data");
if self.mapped_buffer.is_none() {
match self.buffer_pool.acquire_buffer(None) {
@ -133,7 +132,7 @@ impl<T: SocketRead> Socket<T> {
self.mapped_buffer = Some(buffer.into_mapped_buffer_writable().unwrap());
}
Err(err) => {
gst_debug!(SOCKET_CAT, obj: &self.element, "Failed to acquire buffer {:?}", err);
gst::debug!(SOCKET_CAT, obj: &self.element, "Failed to acquire buffer {:?}", err);
return Some(Err(SocketError::Gst(err)));
}
}
@ -150,7 +149,7 @@ impl<T: SocketRead> Socket<T> {
let running_time = time.opt_checked_sub(self.base_time).ok().flatten();
// FIXME maybe we should check if running_time.is_none
// so as to display another message
gst_debug!(
gst::debug!(
SOCKET_CAT,
obj: &self.element,
"Read {} bytes at {} (clock {})",
@ -160,7 +159,7 @@ impl<T: SocketRead> Socket<T> {
);
running_time
} else {
gst_debug!(SOCKET_CAT, obj: &self.element, "Read {} bytes", len);
gst::debug!(SOCKET_CAT, obj: &self.element, "Read {} bytes", len);
gst::ClockTime::NONE
};
@ -176,7 +175,7 @@ impl<T: SocketRead> Socket<T> {
Some(Ok((buffer, saddr)))
}
Err(err) => {
gst_debug!(SOCKET_CAT, obj: &self.element, "Read error {:?}", err);
gst::debug!(SOCKET_CAT, obj: &self.element, "Read error {:?}", err);
Some(Err(SocketError::Io(err)))
}
@ -187,7 +186,7 @@ impl<T: SocketRead> Socket<T> {
impl<T: SocketRead> Drop for Socket<T> {
fn drop(&mut self) {
if let Err(err) = self.buffer_pool.set_active(false) {
gst_error!(SOCKET_CAT, obj: &self.element, "Failed to unprepare socket: {}", err);
gst::error!(SOCKET_CAT, obj: &self.element, "Failed to unprepare socket: {}", err);
}
}
}

65
generic/threadshare/src/tcpclientsrc/imp.rs
View file

@ -25,7 +25,6 @@ use futures::prelude::*;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace};
use once_cell::sync::Lazy;
@ -139,7 +138,7 @@ impl TcpClientSrcPadHandler {
async fn push_prelude(&self, pad: &PadSrcRef<'_>, _element: &super::TcpClientSrc) {
let mut state = self.0.state.lock().await;
if state.need_initial_events {
gst_debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
gst::debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
let stream_id = format!("{:08x}{:08x}", rand::random::<u32>(), rand::random::<u32>());
let stream_start_evt = gst::event::StreamStart::builder(&stream_id)
@ -170,7 +169,7 @@ impl TcpClientSrcPadHandler {
element: &super::TcpClientSrc,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
self.push_prelude(pad, element).await;
@ -195,7 +194,7 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
) -> bool {
use gst::EventView;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
let ret = match event.view() {
EventView::FlushStart(..) => tcpclientsrc.task.flush_start().is_ok(),
@ -206,9 +205,9 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
};
if ret {
gst_log!(CAT, obj: pad.gst_pad(), "Handled {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handled {:?}", event);
} else {
gst_log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
}
ret
@ -223,7 +222,7 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
) -> bool {
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
let ret = match query.view_mut() {
QueryViewMut::Latency(q) => {
q.set(false, gst::ClockTime::ZERO, gst::ClockTime::NONE);
@ -253,9 +252,9 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
};
if ret {
gst_log!(CAT, obj: pad.gst_pad(), "Handled {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handled {:?}", query);
} else {
gst_log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
}
ret
@ -293,7 +292,7 @@ impl TcpClientSrcTask {
impl TaskImpl for TcpClientSrcTask {
fn prepare(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Preparing task connecting to {:?}", self.saddr);
gst::log!(CAT, obj: &self.element, "Preparing task connecting to {:?}", self.saddr);
let socket = Async::<TcpStream>::connect(self.saddr)
.await
@ -318,7 +317,7 @@ impl TaskImpl for TcpClientSrcTask {
})?,
);
gst_log!(CAT, obj: &self.element, "Task prepared");
gst::log!(CAT, obj: &self.element, "Task prepared");
Ok(())
}
.boxed()
@ -333,7 +332,7 @@ impl TaskImpl for TcpClientSrcTask {
async move {
match trigger {
task::Trigger::Prepare => {
gst_error!(CAT, "Task preparation failed: {:?}", err);
gst::error!(CAT, "Task preparation failed: {:?}", err);
self.element.post_error_message(err);
task::Trigger::Error
@ -351,7 +350,7 @@ impl TaskImpl for TcpClientSrcTask {
let buffer = match item {
Some(Ok((buffer, _))) => buffer,
Some(Err(err)) => {
gst_error!(CAT, obj: &self.element, "Got error {:?}", err);
gst::error!(CAT, obj: &self.element, "Got error {:?}", err);
match err {
SocketError::Gst(err) => {
gst::element_error!(
@ -373,7 +372,7 @@ impl TaskImpl for TcpClientSrcTask {
return Err(gst::FlowError::Error);
}
None => {
gst_log!(CAT, obj: &self.element, "SocketStream Stopped");
gst::log!(CAT, obj: &self.element, "SocketStream Stopped");
return Err(gst::FlowError::Flushing);
}
};
@ -385,17 +384,17 @@ impl TaskImpl for TcpClientSrcTask {
.await;
match res {
Ok(_) => {
gst_log!(CAT, obj: &self.element, "Successfully pushed buffer");
gst::log!(CAT, obj: &self.element, "Successfully pushed buffer");
}
Err(gst::FlowError::Flushing) => {
gst_debug!(CAT, obj: &self.element, "Flushing");
gst::debug!(CAT, obj: &self.element, "Flushing");
}
Err(gst::FlowError::Eos) => {
gst_debug!(CAT, obj: &self.element, "EOS");
gst::debug!(CAT, obj: &self.element, "EOS");
pad.push_event(gst::event::Eos::new()).await;
}
Err(err) => {
gst_error!(CAT, obj: &self.element, "Got error {}", err);
gst::error!(CAT, obj: &self.element, "Got error {}", err);
gst::element_error!(
self.element,
gst::StreamError::Failed,
@ -412,9 +411,9 @@ impl TaskImpl for TcpClientSrcTask {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Stopping task");
gst::log!(CAT, obj: &self.element, "Stopping task");
self.src_pad_handler.reset_state().await;
gst_log!(CAT, obj: &self.element, "Task stopped");
gst::log!(CAT, obj: &self.element, "Task stopped");
Ok(())
}
.boxed()
@ -422,9 +421,9 @@ impl TaskImpl for TcpClientSrcTask {
fn flush_stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Stopping task flush");
gst::log!(CAT, obj: &self.element, "Stopping task flush");
self.src_pad_handler.set_need_segment().await;
gst_log!(CAT, obj: &self.element, "Task flush stopped");
gst::log!(CAT, obj: &self.element, "Task flush stopped");
Ok(())
}
.boxed()
@ -450,7 +449,7 @@ impl TcpClientSrc {
fn prepare(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> {
let settings = self.settings.lock().unwrap().clone();
gst_debug!(CAT, obj: element, "Preparing");
gst::debug!(CAT, obj: element, "Preparing");
let context =
Context::acquire(&settings.context, settings.context_wait).map_err(|err| {
@ -511,35 +510,35 @@ impl TcpClientSrc {
)
})?;
gst_debug!(CAT, obj: element, "Prepared");
gst::debug!(CAT, obj: element, "Prepared");
Ok(())
}
fn unprepare(&self, element: &super::TcpClientSrc) {
gst_debug!(CAT, obj: element, "Unpreparing");
gst::debug!(CAT, obj: element, "Unpreparing");
self.task.unprepare().unwrap();
gst_debug!(CAT, obj: element, "Unprepared");
gst::debug!(CAT, obj: element, "Unprepared");
}
fn stop(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
self.task.stop()?;
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
Ok(())
}
fn start(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
self.task.start()?;
gst_debug!(CAT, obj: element, "Started");
gst::debug!(CAT, obj: element, "Started");
Ok(())
}
fn pause(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Pausing");
gst::debug!(CAT, obj: element, "Pausing");
self.task.pause()?;
gst_debug!(CAT, obj: element, "Paused");
gst::debug!(CAT, obj: element, "Paused");
Ok(())
}
}
@ -719,7 +718,7 @@ impl ElementImpl for TcpClientSrc {
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::NullToReady => {

54
generic/threadshare/src/udpsink/imp.rs
View file

@ -26,9 +26,7 @@ use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::EventView;
use gst::{
element_error, error_msg, gst_debug, gst_error, gst_info, gst_log, gst_trace, gst_warning,
};
use gst::{element_error, error_msg};
use once_cell::sync::Lazy;
@ -175,11 +173,11 @@ impl UdpSinkPadHandlerInner {
fn remove_client(&mut self, gst_pad: &gst::Pad, addr: SocketAddr) {
if !self.clients.contains(&addr) {
gst_warning!(CAT, obj: gst_pad, "Not removing unknown client {:?}", &addr);
gst::warning!(CAT, obj: gst_pad, "Not removing unknown client {:?}", &addr);
return;
}
gst_info!(CAT, obj: gst_pad, "Removing client {:?}", addr);
gst::info!(CAT, obj: gst_pad, "Removing client {:?}", addr);
Arc::make_mut(&mut self.clients).retain(|addr2| addr != *addr2);
@ -189,11 +187,11 @@ impl UdpSinkPadHandlerInner {
fn add_client(&mut self, gst_pad: &gst::Pad, addr: SocketAddr) {
if self.clients.contains(&addr) {
gst_warning!(CAT, obj: gst_pad, "Not adding client {:?} again", &addr);
gst::warning!(CAT, obj: gst_pad, "Not adding client {:?} again", &addr);
return;
}
gst_info!(CAT, obj: gst_pad, "Adding client {:?}", addr);
gst::info!(CAT, obj: gst_pad, "Adding client {:?}", addr);
Arc::make_mut(&mut self.clients).push(addr);
@ -492,7 +490,7 @@ impl UdpSinkPadHandler {
};
if let Some(socket) = socket.as_mut() {
gst_log!(CAT, obj: element, "Sending to {:?}", &client);
gst::log!(CAT, obj: element, "Sending to {:?}", &client);
socket.send_to(&data, *client).await.map_err(|err| {
element_error!(
element,
@ -513,7 +511,7 @@ impl UdpSinkPadHandler {
}
}
gst_log!(
gst::log!(
CAT,
obj: element,
"Sent buffer {:?} to all clients",
@ -571,7 +569,7 @@ impl PadSinkHandler for UdpSinkPadHandler {
async move {
if let Some(sender) = sender.lock().await.as_mut() {
if sender.send(TaskItem::Buffer(buffer)).await.is_err() {
gst_debug!(CAT, obj: &element, "Flushing");
gst::debug!(CAT, obj: &element, "Flushing");
return Err(gst::FlowError::Flushing);
}
}
@ -594,7 +592,7 @@ impl PadSinkHandler for UdpSinkPadHandler {
if let Some(sender) = sender.lock().await.as_mut() {
for buffer in list.iter_owned() {
if sender.send(TaskItem::Buffer(buffer)).await.is_err() {
gst_debug!(CAT, obj: &element, "Flushing");
gst::debug!(CAT, obj: &element, "Flushing");
return Err(gst::FlowError::Flushing);
}
}
@ -621,7 +619,7 @@ impl PadSinkHandler for UdpSinkPadHandler {
return udpsink.task.flush_stop().is_ok();
} else if let Some(sender) = sender.lock().await.as_mut() {
if sender.send(TaskItem::Event(event)).await.is_err() {
gst_debug!(CAT, obj: &element, "Flushing");
gst::debug!(CAT, obj: &element, "Flushing");
}
}
@ -665,7 +663,7 @@ impl UdpSinkTask {
impl TaskImpl for UdpSinkTask {
fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Starting task");
gst::log!(CAT, obj: &self.element, "Starting task");
let (sender, receiver) = mpsc::channel(0);
@ -674,7 +672,7 @@ impl TaskImpl for UdpSinkTask {
self.receiver = Some(receiver);
gst_log!(CAT, obj: &self.element, "Task started");
gst::log!(CAT, obj: &self.element, "Task started");
Ok(())
}
.boxed()
@ -781,7 +779,7 @@ impl UdpSink {
};
let saddr = SocketAddr::new(bind_addr, bind_port as u16);
gst_debug!(CAT, obj: element, "Binding to {:?}", saddr);
gst::debug!(CAT, obj: element, "Binding to {:?}", saddr);
let socket = match family {
SocketFamily::Ipv4 => socket2::Socket::new(
@ -799,7 +797,7 @@ impl UdpSink {
let socket = match socket {
Ok(socket) => socket,
Err(err) => {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Failed to create {} socket: {}",
@ -858,7 +856,7 @@ impl UdpSink {
}
fn prepare(&self, element: &super::UdpSink) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Preparing");
gst::debug!(CAT, obj: element, "Preparing");
let context = {
let settings = self.settings.lock().unwrap();
@ -884,31 +882,31 @@ impl UdpSink {
)
})?;
gst_debug!(CAT, obj: element, "Started preparing");
gst::debug!(CAT, obj: element, "Started preparing");
Ok(())
}
fn unprepare(&self, element: &super::UdpSink) {
gst_debug!(CAT, obj: element, "Unpreparing");
gst::debug!(CAT, obj: element, "Unpreparing");
self.task.unprepare().unwrap();
self.sink_pad_handler.unprepare();
gst_debug!(CAT, obj: element, "Unprepared");
gst::debug!(CAT, obj: element, "Unprepared");
}
fn stop(&self, element: &super::UdpSink) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
self.task.stop()?;
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
Ok(())
}
fn start(&self, element: &super::UdpSink) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
self.task.start()?;
gst_debug!(CAT, obj: element, "Started");
gst::debug!(CAT, obj: element, "Started");
Ok(())
}
}
@ -933,7 +931,7 @@ impl UdpSink {
fn try_into_socket_addr(element: &super::UdpSink, host: &str, port: i32) -> Result<SocketAddr, ()> {
let addr: IpAddr = match host.parse() {
Err(err) => {
gst_error!(CAT, obj: element, "Failed to parse host {}: {}", host, err);
gst::error!(CAT, obj: element, "Failed to parse host {}: {}", host, err);
return Err(());
}
Ok(addr) => addr,
@ -941,7 +939,7 @@ fn try_into_socket_addr(element: &super::UdpSink, host: &str, port: i32) -> Resu
let port: u16 = match port.try_into() {
Err(err) => {
gst_error!(CAT, obj: element, "Invalid port {}: {}", port, err);
gst::error!(CAT, obj: element, "Invalid port {}: {}", port, err);
return Err(());
}
Ok(port) => port,
@ -1247,7 +1245,7 @@ impl ObjectImpl for UdpSink {
rsplit[0]
.parse::<i32>()
.map_err(|err| {
gst_error!(CAT, obj: obj, "Invalid port {}: {}", rsplit[0], err);
gst::error!(CAT, obj: obj, "Invalid port {}: {}", rsplit[0], err);
})
.and_then(|port| try_into_socket_addr(obj, rsplit[1], port))
.ok()
@ -1373,7 +1371,7 @@ impl ElementImpl for UdpSink {
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::NullToReady => {

67
generic/threadshare/src/udpsrc/imp.rs
View file

@ -24,7 +24,6 @@ use futures::prelude::*;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace};
use gst_net::*;
use once_cell::sync::Lazy;
@ -157,7 +156,7 @@ impl UdpSrcPadHandler {
async fn push_prelude(&self, pad: &PadSrcRef<'_>, _element: &super::UdpSrc) {
let mut state = self.0.state.lock().await;
if state.need_initial_events {
gst_debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
gst::debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
let stream_id = format!("{:08x}{:08x}", rand::random::<u32>(), rand::random::<u32>());
let stream_start_evt = gst::event::StreamStart::builder(&stream_id)
@ -188,7 +187,7 @@ impl UdpSrcPadHandler {
element: &super::UdpSrc,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", buffer);
self.push_prelude(pad, element).await;
@ -208,7 +207,7 @@ impl PadSrcHandler for UdpSrcPadHandler {
) -> bool {
use gst::EventView;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", event);
let ret = match event.view() {
EventView::FlushStart(..) => udpsrc.task.flush_start().is_ok(),
@ -219,9 +218,9 @@ impl PadSrcHandler for UdpSrcPadHandler {
};
if ret {
gst_log!(CAT, obj: pad.gst_pad(), "Handled {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Handled {:?}", event);
} else {
gst_log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
gst::log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
}
ret
@ -236,7 +235,7 @@ impl PadSrcHandler for UdpSrcPadHandler {
) -> bool {
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
let ret = match query.view_mut() {
QueryViewMut::Latency(q) => {
@ -267,9 +266,9 @@ impl PadSrcHandler for UdpSrcPadHandler {
};
if ret {
gst_log!(CAT, obj: pad.gst_pad(), "Handled {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Handled {:?}", query);
} else {
gst_log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
gst::log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
}
ret
@ -302,10 +301,10 @@ impl UdpSrcTask {
impl TaskImpl for UdpSrcTask {
fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Starting task");
gst::log!(CAT, obj: &self.element, "Starting task");
self.socket
.set_clock(self.element.clock(), self.element.base_time());
gst_log!(CAT, obj: &self.element, "Task started");
gst::log!(CAT, obj: &self.element, "Task started");
Ok(())
}
.boxed()
@ -318,7 +317,7 @@ impl TaskImpl for UdpSrcTask {
let (mut buffer, saddr) = match item {
Some(Ok((buffer, saddr))) => (buffer, saddr),
Some(Err(err)) => {
gst_error!(CAT, obj: &self.element, "Got error {:?}", err);
gst::error!(CAT, obj: &self.element, "Got error {:?}", err);
match err {
SocketError::Gst(err) => {
gst::element_error!(
@ -340,7 +339,7 @@ impl TaskImpl for UdpSrcTask {
return Err(gst::FlowError::Error);
}
None => {
gst_log!(CAT, obj: &self.element, "SocketStream Stopped");
gst::log!(CAT, obj: &self.element, "SocketStream Stopped");
return Err(gst::FlowError::Flushing);
}
};
@ -367,14 +366,14 @@ impl TaskImpl for UdpSrcTask {
.push_buffer(&pad, &self.element, buffer)
.await;
match res {
Ok(_) => gst_log!(CAT, obj: &self.element, "Successfully pushed buffer"),
Err(gst::FlowError::Flushing) => gst_debug!(CAT, obj: &self.element, "Flushing"),
Ok(_) => gst::log!(CAT, obj: &self.element, "Successfully pushed buffer"),
Err(gst::FlowError::Flushing) => gst::debug!(CAT, obj: &self.element, "Flushing"),
Err(gst::FlowError::Eos) => {
gst_debug!(CAT, obj: &self.element, "EOS");
gst::debug!(CAT, obj: &self.element, "EOS");
pad.push_event(gst::event::Eos::new()).await;
}
Err(err) => {
gst_error!(CAT, obj: &self.element, "Got error {}", err);
gst::error!(CAT, obj: &self.element, "Got error {}", err);
gst::element_error!(
self.element,
gst::StreamError::Failed,
@ -391,9 +390,9 @@ impl TaskImpl for UdpSrcTask {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Stopping task");
gst::log!(CAT, obj: &self.element, "Stopping task");
self.src_pad_handler.reset_state().await;
gst_log!(CAT, obj: &self.element, "Task stopped");
gst::log!(CAT, obj: &self.element, "Task stopped");
Ok(())
}
.boxed()
@ -401,9 +400,9 @@ impl TaskImpl for UdpSrcTask {
fn flush_stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(CAT, obj: &self.element, "Stopping task flush");
gst::log!(CAT, obj: &self.element, "Stopping task flush");
self.src_pad_handler.set_need_segment().await;
gst_log!(CAT, obj: &self.element, "Stopped task flush");
gst::log!(CAT, obj: &self.element, "Stopped task flush");
Ok(())
}
.boxed()
@ -429,7 +428,7 @@ impl UdpSrc {
fn prepare(&self, element: &super::UdpSrc) -> Result<(), gst::ErrorMessage> {
let mut settings_guard = self.settings.lock().unwrap();
gst_debug!(CAT, obj: element, "Preparing");
gst::debug!(CAT, obj: element, "Preparing");
let context = Context::acquire(&settings_guard.context, settings_guard.context_wait)
.map_err(|err| {
@ -492,7 +491,7 @@ impl UdpSrc {
};
let saddr = SocketAddr::new(bind_addr, port as u16);
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Binding to {:?} for multicast group {:?}",
@ -503,7 +502,7 @@ impl UdpSrc {
saddr
} else {
let saddr = SocketAddr::new(addr, port as u16);
gst_debug!(CAT, obj: element, "Binding to {:?}", saddr);
gst::debug!(CAT, obj: element, "Binding to {:?}", saddr);
saddr
};
@ -647,40 +646,40 @@ impl UdpSrc {
)
})?;
gst_debug!(CAT, obj: element, "Prepared");
gst::debug!(CAT, obj: element, "Prepared");
Ok(())
}
fn unprepare(&self, element: &super::UdpSrc) {
gst_debug!(CAT, obj: element, "Unpreparing");
gst::debug!(CAT, obj: element, "Unpreparing");
self.settings.lock().unwrap().used_socket = None;
element.notify("used-socket");
self.task.unprepare().unwrap();
gst_debug!(CAT, obj: element, "Unprepared");
gst::debug!(CAT, obj: element, "Unprepared");
}
fn stop(&self, element: &super::UdpSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
self.task.stop()?;
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
Ok(())
}
fn start(&self, element: &super::UdpSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
self.task.start()?;
gst_debug!(CAT, obj: element, "Started");
gst::debug!(CAT, obj: element, "Started");
Ok(())
}
fn pause(&self, element: &super::UdpSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Pausing");
gst::debug!(CAT, obj: element, "Pausing");
self.task.pause()?;
gst_debug!(CAT, obj: element, "Paused");
gst::debug!(CAT, obj: element, "Paused");
Ok(())
}
}
@ -921,7 +920,7 @@ impl ElementImpl for UdpSrc {
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::NullToReady => {

9
generic/threadshare/tests/jitterbuffer.rs
View file

@ -17,7 +17,6 @@
//
// SPDX-License-Identifier: LGPL-2.1-or-later
use gst::gst_debug;
use gst::prelude::*;
use std::sync::mpsc;
@ -92,10 +91,10 @@ fn jb_pipeline() {
pipeline.set_state(gst::State::Playing).unwrap();
gst_debug!(CAT, "jb_pipeline: waiting for {} buffers", BUFFER_NB);
gst::debug!(CAT, "jb_pipeline: waiting for {} buffers", BUFFER_NB);
for idx in 0..BUFFER_NB {
receiver.recv().unwrap();
gst_debug!(CAT, "jb_pipeline: received buffer #{}", idx);
gst::debug!(CAT, "jb_pipeline: received buffer #{}", idx);
}
pipeline.set_state(gst::State::Null).unwrap();
@ -155,10 +154,10 @@ fn jb_ts_pipeline() {
pipeline.set_state(gst::State::Playing).unwrap();
gst_debug!(CAT, "jb_ts_pipeline: waiting for {} buffers", BUFFER_NB);
gst::debug!(CAT, "jb_ts_pipeline: waiting for {} buffers", BUFFER_NB);
for idx in 0..BUFFER_NB {
receiver.recv().unwrap();
gst_debug!(CAT, "jb_ts_pipeline: received buffer #{}", idx);
gst::debug!(CAT, "jb_ts_pipeline: received buffer #{}", idx);
}
pipeline.set_state(gst::State::Null).unwrap();

75
generic/threadshare/tests/pad.rs
View file

@ -29,7 +29,6 @@ use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::EventView;
use gst::{gst_debug, gst_info, gst_log};
use once_cell::sync::Lazy;
@ -93,7 +92,7 @@ mod imp_src {
pad: &PadSrcRef<'_>,
item: Item,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_debug!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", item);
gst::debug!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", item);
match item {
Item::Event(event) => {
@ -117,7 +116,7 @@ mod imp_src {
_element: &gst::Element,
event: gst::Event,
) -> bool {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", event);
let ret = match event.view() {
EventView::FlushStart(..) => {
@ -133,9 +132,9 @@ mod imp_src {
};
if ret {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Handled {:?}", event);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Handled {:?}", event);
} else {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
gst::log!(SRC_CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
}
ret
@ -178,7 +177,7 @@ mod imp_src {
let item = match item {
Some(item) => item,
None => {
gst_log!(SRC_CAT, obj: &self.element, "SrcPad channel aborted");
gst::log!(SRC_CAT, obj: &self.element, "SrcPad channel aborted");
return Err(gst::FlowError::Eos);
}
};
@ -186,9 +185,9 @@ mod imp_src {
let pad = self.src_pad.upgrade().expect("PadSrc no longer exists");
let res = PadSrcTestHandler::push_item(&pad, item).await;
match res {
Ok(_) => gst_log!(SRC_CAT, obj: &self.element, "Successfully pushed item"),
Ok(_) => gst::log!(SRC_CAT, obj: &self.element, "Successfully pushed item"),
Err(gst::FlowError::Flushing) => {
gst_debug!(SRC_CAT, obj: &self.element, "Flushing")
gst::debug!(SRC_CAT, obj: &self.element, "Flushing")
}
Err(err) => panic!("Got error {}", err),
}
@ -200,9 +199,9 @@ mod imp_src {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(SRC_CAT, obj: &self.element, "Stopping task");
gst::log!(SRC_CAT, obj: &self.element, "Stopping task");
self.flush();
gst_log!(SRC_CAT, obj: &self.element, "Task stopped");
gst::log!(SRC_CAT, obj: &self.element, "Task stopped");
Ok(())
}
.boxed()
@ -210,9 +209,9 @@ mod imp_src {
fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move {
gst_log!(SRC_CAT, obj: &self.element, "Starting task flush");
gst::log!(SRC_CAT, obj: &self.element, "Starting task flush");
self.flush();
gst_log!(SRC_CAT, obj: &self.element, "Task flush started");
gst::log!(SRC_CAT, obj: &self.element, "Task flush started");
Ok(())
}
.boxed()
@ -231,7 +230,7 @@ mod imp_src {
pub fn try_push(&self, item: Item) -> Result<(), Item> {
let state = self.task.lock_state();
if *state != TaskState::Started && *state != TaskState::Paused {
gst_debug!(SRC_CAT, "ElementSrcTest rejecting item due to pad state");
gst::debug!(SRC_CAT, "ElementSrcTest rejecting item due to pad state");
return Err(item);
}
@ -245,7 +244,7 @@ mod imp_src {
}
fn prepare(&self, element: &super::ElementSrcTest) -> Result<(), gst::ErrorMessage> {
gst_debug!(SRC_CAT, obj: element, "Preparing");
gst::debug!(SRC_CAT, obj: element, "Preparing");
let settings = self.settings.lock().unwrap().clone();
let context =
@ -271,36 +270,36 @@ mod imp_src {
)
})?;
gst_debug!(SRC_CAT, obj: element, "Prepared");
gst::debug!(SRC_CAT, obj: element, "Prepared");
Ok(())
}
fn unprepare(&self, element: &super::ElementSrcTest) {
gst_debug!(SRC_CAT, obj: element, "Unpreparing");
gst::debug!(SRC_CAT, obj: element, "Unpreparing");
*self.sender.lock().unwrap() = None;
self.task.unprepare().unwrap();
gst_debug!(SRC_CAT, obj: element, "Unprepared");
gst::debug!(SRC_CAT, obj: element, "Unprepared");
}
fn stop(&self, element: &super::ElementSrcTest) {
gst_debug!(SRC_CAT, obj: element, "Stopping");
gst::debug!(SRC_CAT, obj: element, "Stopping");
self.task.stop().unwrap();
gst_debug!(SRC_CAT, obj: element, "Stopped");
gst::debug!(SRC_CAT, obj: element, "Stopped");
}
fn start(&self, element: &super::ElementSrcTest) {
gst_debug!(SRC_CAT, obj: element, "Starting");
gst::debug!(SRC_CAT, obj: element, "Starting");
self.task.start().unwrap();
gst_debug!(SRC_CAT, obj: element, "Started");
gst::debug!(SRC_CAT, obj: element, "Started");
}
fn pause(&self, element: &super::ElementSrcTest) {
gst_debug!(SRC_CAT, obj: element, "Pausing");
gst::debug!(SRC_CAT, obj: element, "Pausing");
self.task.pause().unwrap();
gst_debug!(SRC_CAT, obj: element, "Paused");
gst::debug!(SRC_CAT, obj: element, "Paused");
}
}
@ -403,7 +402,7 @@ mod imp_src {
element: &Self::Type,
transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_log!(SRC_CAT, obj: element, "Changing state {:?}", transition);
gst::log!(SRC_CAT, obj: element, "Changing state {:?}", transition);
match transition {
gst::StateChange::NullToReady => {
@ -523,7 +522,7 @@ mod imp_sink {
element: &gst::Element,
event: gst::Event,
) -> bool {
gst_debug!(SINK_CAT, obj: pad.gst_pad(), "Handling non-serialized {:?}", event);
gst::debug!(SINK_CAT, obj: pad.gst_pad(), "Handling non-serialized {:?}", event);
match event.view() {
EventView::FlushStart(..) => {
@ -541,7 +540,7 @@ mod imp_sink {
element: &gst::Element,
event: gst::Event,
) -> BoxFuture<'static, bool> {
gst_log!(SINK_CAT, obj: pad.gst_pad(), "Handling serialized {:?}", event);
gst::log!(SINK_CAT, obj: pad.gst_pad(), "Handling serialized {:?}", event);
let element = element
.clone()
@ -577,7 +576,7 @@ mod imp_sink {
item: Item,
) -> Result<gst::FlowSuccess, gst::FlowError> {
if !self.flushing.load(Ordering::SeqCst) {
gst_debug!(SINK_CAT, obj: element, "Fowarding {:?}", item);
gst::debug!(SINK_CAT, obj: element, "Fowarding {:?}", item);
self.sender
.lock()
.await
@ -588,7 +587,7 @@ mod imp_sink {
.map(|_| gst::FlowSuccess::Ok)
.map_err(|_| gst::FlowError::Error)
} else {
gst_debug!(
gst::debug!(
SINK_CAT,
obj: element,
"Not fowarding {:?} due to flushing",
@ -599,33 +598,33 @@ mod imp_sink {
}
fn start(&self, element: &super::ElementSinkTest) {
gst_debug!(SINK_CAT, obj: element, "Starting");
gst::debug!(SINK_CAT, obj: element, "Starting");
self.flushing.store(false, Ordering::SeqCst);
gst_debug!(SINK_CAT, obj: element, "Started");
gst::debug!(SINK_CAT, obj: element, "Started");
}
fn stop(&self, element: &super::ElementSinkTest) {
gst_debug!(SINK_CAT, obj: element, "Stopping");
gst::debug!(SINK_CAT, obj: element, "Stopping");
self.flushing.store(true, Ordering::SeqCst);
gst_debug!(SINK_CAT, obj: element, "Stopped");
gst::debug!(SINK_CAT, obj: element, "Stopped");
}
}
impl ElementSinkTest {
pub fn push_flush_start(&self, element: &super::ElementSinkTest) {
gst_debug!(SINK_CAT, obj: element, "Pushing FlushStart");
gst::debug!(SINK_CAT, obj: element, "Pushing FlushStart");
self.sink_pad
.gst_pad()
.push_event(gst::event::FlushStart::new());
gst_debug!(SINK_CAT, obj: element, "FlushStart pushed");
gst::debug!(SINK_CAT, obj: element, "FlushStart pushed");
}
pub fn push_flush_stop(&self, element: &super::ElementSinkTest) {
gst_debug!(SINK_CAT, obj: element, "Pushing FlushStop");
gst::debug!(SINK_CAT, obj: element, "Pushing FlushStop");
self.sink_pad
.gst_pad()
.push_event(gst::event::FlushStop::new(true));
gst_debug!(SINK_CAT, obj: element, "FlushStop pushed");
gst::debug!(SINK_CAT, obj: element, "FlushStop pushed");
}
}
@ -734,7 +733,7 @@ mod imp_sink {
element: &Self::Type,
transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_log!(SINK_CAT, obj: element, "Changing state {:?}", transition);
gst::log!(SINK_CAT, obj: element, "Changing state {:?}", transition);
if let gst::StateChange::PausedToReady = transition {
self.stop(element);
@ -1151,7 +1150,7 @@ fn start_stop_start() {
match futures::executor::block_on(receiver.next()).unwrap() {
Item::Buffer(_buffer) => {
gst_info!(
gst::info!(
imp_src::SRC_CAT,
"{}: initial buffer went through, don't expect any pending item to be dropped",
scenario_name

55
generic/threadshare/tests/pipeline.rs
View file

@ -19,7 +19,6 @@
use gst::glib;
use gst::prelude::*;
use gst::{gst_debug, gst_error};
use once_cell::sync::Lazy;
@ -110,13 +109,13 @@ fn multiple_contexts_queue() {
for _ in 0..BUFFER_NB {
for dest in &destinations {
gst_debug!(CAT, "multiple_contexts_queue: sending buffer to {:?}", dest);
gst::debug!(CAT, "multiple_contexts_queue: sending buffer to {:?}", dest);
socket.send_to(&buffer, dest).unwrap();
std::thread::sleep(std::time::Duration::from_millis(CONTEXT_WAIT as u64));
}
}
gst_debug!(
gst::debug!(
CAT,
"multiple_contexts_queue: waiting for all buffers notifications"
);
@ -147,7 +146,7 @@ fn multiple_contexts_queue() {
}
}
MessageView::Error(err) => {
gst_error!(
gst::error!(
CAT,
"multiple_contexts_queue: Error from {:?}: {} ({:?})",
err.src().map(|s| s.path_string()),
@ -165,9 +164,9 @@ fn multiple_contexts_queue() {
pipeline.set_state(gst::State::Playing).unwrap();
gst_debug!(CAT, "Starting main loop for multiple_contexts_queue...");
gst::debug!(CAT, "Starting main loop for multiple_contexts_queue...");
l.run();
gst_debug!(CAT, "Stopping main loop for multiple_contexts_queue...");
gst::debug!(CAT, "Stopping main loop for multiple_contexts_queue...");
}
#[test]
@ -259,13 +258,13 @@ fn multiple_contexts_proxy() {
for _ in 0..BUFFER_NB {
for dest in &destinations {
gst_debug!(CAT, "multiple_contexts_proxy: sending buffer to {:?}", dest);
gst::debug!(CAT, "multiple_contexts_proxy: sending buffer to {:?}", dest);
socket.send_to(&buffer, dest).unwrap();
std::thread::sleep(std::time::Duration::from_millis(CONTEXT_WAIT as u64));
}
}
gst_debug!(
gst::debug!(
CAT,
"multiple_contexts_proxy: waiting for all buffers notifications"
);
@ -296,7 +295,7 @@ fn multiple_contexts_proxy() {
}
}
MessageView::Error(err) => {
gst_error!(
gst::error!(
CAT,
"multiple_contexts_proxy: Error from {:?}: {} ({:?})",
err.src().map(|s| s.path_string()),
@ -314,9 +313,9 @@ fn multiple_contexts_proxy() {
pipeline.set_state(gst::State::Playing).unwrap();
gst_debug!(CAT, "Starting main loop for multiple_contexts_proxy...");
gst::debug!(CAT, "Starting main loop for multiple_contexts_proxy...");
l.run();
gst_debug!(CAT, "Stopping main loop for multiple_contexts_proxy...");
gst::debug!(CAT, "Stopping main loop for multiple_contexts_proxy...");
}
#[test]
@ -353,7 +352,7 @@ fn eos() {
appsink.set_callbacks(
gst_app::AppSinkCallbacks::builder()
.new_sample(move |appsink| {
gst_debug!(CAT, obj: appsink, "eos: pulling sample");
gst::debug!(CAT, obj: appsink, "eos: pulling sample");
let _ = appsink.pull_sample().unwrap();
sample_notifier.send(()).unwrap();
@ -365,7 +364,7 @@ fn eos() {
);
fn push_buffer(src: &gst::Element) -> bool {
gst_debug!(CAT, obj: src, "eos: pushing buffer");
gst::debug!(CAT, obj: src, "eos: pushing buffer");
src.emit_by_name::<bool>("push-buffer", &[&gst::Buffer::from_slice(vec![0; 1024])])
}
@ -418,7 +417,7 @@ fn eos() {
}
}
MessageView::Error(err) => {
gst_error!(
gst::error!(
CAT,
"eos: Error from {:?}: {} ({:?})",
err.src().map(|s| s.path_string()),
@ -436,9 +435,9 @@ fn eos() {
pipeline.set_state(gst::State::Playing).unwrap();
gst_debug!(CAT, "Starting main loop for eos...");
gst::debug!(CAT, "Starting main loop for eos...");
l.run();
gst_debug!(CAT, "Stopping main loop for eos...");
gst::debug!(CAT, "Stopping main loop for eos...");
}
#[test]
@ -480,7 +479,7 @@ fn premature_shutdown() {
appsink.set_callbacks(
gst_app::AppSinkCallbacks::builder()
.new_sample(move |appsink| {
gst_debug!(CAT, obj: appsink, "premature_shutdown: pulling sample");
gst::debug!(CAT, obj: appsink, "premature_shutdown: pulling sample");
let _sample = appsink.pull_sample().unwrap();
appsink_sender.send(()).unwrap();
@ -491,7 +490,7 @@ fn premature_shutdown() {
);
fn push_buffer(src: &gst::Element, intent: &str) -> bool {
gst_debug!(
gst::debug!(
CAT,
obj: src,
"premature_shutdown: pushing buffer {}",
@ -503,7 +502,7 @@ fn premature_shutdown() {
let pipeline_clone = pipeline.clone();
let l_clone = l.clone();
let mut scenario = Some(move || {
gst_debug!(CAT, "premature_shutdown: STEP 1: Playing");
gst::debug!(CAT, "premature_shutdown: STEP 1: Playing");
// Initialize the dataflow
assert!(push_buffer(&src, "(initial)"));
@ -516,26 +515,26 @@ fn premature_shutdown() {
assert!(push_buffer(&src, "before Playing -> Paused"));
gst_debug!(CAT, "premature_shutdown: STEP 2: Playing -> Paused");
gst::debug!(CAT, "premature_shutdown: STEP 2: Playing -> Paused");
pipeline_clone.set_state(gst::State::Paused).unwrap();
gst_debug!(CAT, "premature_shutdown: STEP 3: Paused -> Playing");
gst::debug!(CAT, "premature_shutdown: STEP 3: Paused -> Playing");
pipeline_clone.set_state(gst::State::Playing).unwrap();
gst_debug!(CAT, "premature_shutdown: Playing again");
gst::debug!(CAT, "premature_shutdown: Playing again");
gst_debug!(CAT, "Waiting for buffer sent before Playing -> Paused");
gst::debug!(CAT, "Waiting for buffer sent before Playing -> Paused");
appsink_receiver.recv().unwrap();
assert!(push_buffer(&src, "after Paused -> Playing"));
gst_debug!(CAT, "Waiting for buffer sent after Paused -> Playing");
gst::debug!(CAT, "Waiting for buffer sent after Paused -> Playing");
appsink_receiver.recv().unwrap();
// Fill up the (dataqueue) and abruptly shutdown
assert!(push_buffer(&src, "filling 1"));
assert!(push_buffer(&src, "filling 2"));
gst_debug!(CAT, "premature_shutdown: STEP 4: Playing -> Null");
gst::debug!(CAT, "premature_shutdown: STEP 4: Playing -> Null");
pipeline_clone.set_state(gst::State::Null).unwrap();
@ -567,7 +566,7 @@ fn premature_shutdown() {
}
}
MessageView::Error(err) => {
gst_error!(
gst::error!(
CAT,
"premature_shutdown: Error from {:?}: {} ({:?})",
err.src().map(|s| s.path_string()),
@ -585,7 +584,7 @@ fn premature_shutdown() {
pipeline.set_state(gst::State::Playing).unwrap();
gst_debug!(CAT, "Starting main loop for premature_shutdown...");
gst::debug!(CAT, "Starting main loop for premature_shutdown...");
l.run();
gst_debug!(CAT, "Stopped main loop for premature_shutdown...");
gst::debug!(CAT, "Stopped main loop for premature_shutdown...");
}

43
net/hlssink3/src/imp.rs
View file

@ -12,7 +12,6 @@ use gio::prelude::*;
use glib::subclass::prelude::*;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_trace, gst_warning};
use m3u8_rs::MediaPlaylistType;
use once_cell::sync::Lazy;
use std::fs;
@ -121,7 +120,7 @@ pub struct HlsSink3 {
impl HlsSink3 {
fn start(&self, element: &super::HlsSink3) {
gst_info!(CAT, obj: element, "Starting");
gst::info!(CAT, obj: element, "Starting");
let (target_duration, playlist_type) = {
let settings = self.settings.lock().unwrap();
@ -142,7 +141,7 @@ impl HlsSink3 {
element: &super::HlsSink3,
fragment_id: u32,
) -> Result<String, String> {
gst_info!(
gst::info!(
CAT,
obj: element,
"Starting the formatting of the fragment-id: {}",
@ -158,7 +157,7 @@ impl HlsSink3 {
let settings = self.settings.lock().unwrap();
let segment_file_location = settings.segment_formatter.segment(fragment_id);
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Segment location formatted: {}",
@ -178,7 +177,7 @@ impl HlsSink3 {
.giostreamsink
.set_property("stream", &fragment_stream);
gst_info!(
gst::info!(
CAT,
obj: element,
"New segment location: {:?}",
@ -215,7 +214,7 @@ impl HlsSink3 {
P: AsRef<path::Path>,
{
let _ = fs::remove_file(location).map_err(|err| {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Could not delete segment file: {}",
@ -229,7 +228,7 @@ impl HlsSink3 {
element: &super::HlsSink3,
fragment_closed_at: Option<gst::ClockTime>,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_info!(CAT, obj: element, "Preparing to write new playlist");
gst::info!(CAT, obj: element, "Preparing to write new playlist");
let mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard {
@ -237,7 +236,7 @@ impl HlsSink3 {
State::Started(s) => s,
};
gst_info!(CAT, obj: element, "COUNT {}", state.playlist.len());
gst::info!(CAT, obj: element, "COUNT {}", state.playlist.len());
// Only add fragment if it's complete.
if let Some(fragment_closed) = fragment_closed_at {
@ -268,7 +267,7 @@ impl HlsSink3 {
&[&playlist_location],
)
.ok_or_else(|| {
gst_error!(
gst::error!(
CAT,
obj: element,
"Could not get stream to write playlist content",
@ -281,7 +280,7 @@ impl HlsSink3 {
.playlist
.write_to(&mut playlist_stream)
.map_err(|err| {
gst_error!(
gst::error!(
CAT,
obj: element,
"Could not write new playlist: {}",
@ -290,7 +289,7 @@ impl HlsSink3 {
gst::StateChangeError
})?;
playlist_stream.flush().map_err(|err| {
gst_error!(
gst::error!(
CAT,
obj: element,
"Could not flush playlist: {}",
@ -307,13 +306,13 @@ impl HlsSink3 {
if !element
.emit_by_name::<bool>(SIGNAL_DELETE_FRAGMENT, &[&old_segment_location])
{
gst_error!(CAT, obj: element, "Could not delete fragment");
gst::error!(CAT, obj: element, "Could not delete fragment");
}
}
}
}
gst_debug!(CAT, obj: element, "Wrote new playlist file!");
gst::debug!(CAT, obj: element, "Wrote new playlist file!");
Ok(gst::StateChangeSuccess::Success)
}
@ -333,19 +332,19 @@ impl HlsSink3 {
&self,
element: &super::HlsSink3,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_debug!(CAT, obj: element, "Preparing to write final playlist");
gst::debug!(CAT, obj: element, "Preparing to write final playlist");
self.write_playlist(element, None)
}
fn stop(&self, element: &super::HlsSink3) {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
let mut state = self.state.lock().unwrap();
if let State::Started(_) = *state {
*state = State::Stopped;
}
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
}
}
@ -680,12 +679,12 @@ impl ObjectImpl for HlsSink3 {
let fragment_id = args[1].get::<u32>().unwrap();
gst_info!(CAT, obj: &element, "Got fragment-id: {}", fragment_id);
gst::info!(CAT, obj: &element, "Got fragment-id: {}", fragment_id);
match hlssink3.on_format_location(&element, fragment_id) {
Ok(segment_location) => Some(segment_location.to_value()),
Err(err) => {
gst_error!(CAT, obj: &element, "on format-location handler: {}", err);
gst::error!(CAT, obj: &element, "on format-location handler: {}", err);
Some("unknown_segment".to_value())
}
}
@ -790,7 +789,7 @@ impl ElementImpl for HlsSink3 {
match templ.name_template().as_ref().map(|val| val.as_str()) {
Some("audio") => {
if settings.audio_sink {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"requested_new_pad: audio pad is already set"
@ -810,7 +809,7 @@ impl ElementImpl for HlsSink3 {
}
Some("video") => {
if settings.video_sink {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"requested_new_pad: video pad is already set"
@ -829,11 +828,11 @@ impl ElementImpl for HlsSink3 {
Some(sink_pad.upcast())
}
None => {
gst_debug!(CAT, obj: element, "template name returned `None`",);
gst::debug!(CAT, obj: element, "template name returned `None`",);
None
}
Some(other_name) => {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"requested_new_pad: name \"{}\" is not audio or video",

7
net/hlssink3/tests/hlssink3.rs
View file

@ -8,7 +8,6 @@
// SPDX-License-Identifier: MPL-2.0
use gio::prelude::*;
use gst::gst_info;
use gst::prelude::*;
use once_cell::sync::Lazy;
use std::io::Write;
@ -174,7 +173,7 @@ fn test_hlssink3_element_with_video_content() -> Result<(), ()> {
pipeline.set_state(gst::State::Playing).unwrap();
gst_info!(
gst::info!(
CAT,
"hlssink3_video_pipeline: waiting for {} buffers",
BUFFER_NB
@ -281,7 +280,7 @@ fn test_hlssink3_element_with_audio_content() -> Result<(), ()> {
pipeline.set_state(gst::State::Playing).unwrap();
gst_info!(CAT, "audio_pipeline: waiting for {} buffers", BUFFER_NB);
gst::info!(CAT, "audio_pipeline: waiting for {} buffers", BUFFER_NB);
let mut eos = false;
let bus = pipeline.bus().unwrap();
@ -378,7 +377,7 @@ fn test_hlssink3_write_correct_playlist_content() -> Result<(), ()> {
pipeline.set_state(gst::State::Playing).unwrap();
gst_info!(
gst::info!(
CAT,
"hlssink3_video_pipeline: waiting for {} buffers",
BUFFER_NB

59
net/reqwest/src/reqwesthttpsrc/imp.rs
View file

@ -22,7 +22,6 @@ use once_cell::sync::Lazy;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_trace, gst_warning};
use gst_base::prelude::*;
use gst_base::subclass::base_src::CreateSuccess;
use gst_base::subclass::prelude::*;
@ -259,7 +258,7 @@ impl ReqwestHttpSrc {
) -> Result<ClientContext, gst::ErrorMessage> {
let mut client_guard = self.client.lock().unwrap();
if let Some(ref client) = *client_guard {
gst_debug!(CAT, obj: src, "Using already configured client");
gst::debug!(CAT, obj: src, "Using already configured client");
return Ok(client.clone());
}
@ -282,7 +281,7 @@ impl ReqwestHttpSrc {
// Hopefully now, self.set_context will have been synchronously called
if let Some(client) = self.external_client.lock().unwrap().clone() {
gst_debug!(CAT, obj: src, "Using shared client");
gst::debug!(CAT, obj: src, "Using shared client");
*client_guard = Some(client.clone());
return Ok(client);
@ -303,7 +302,7 @@ impl ReqwestHttpSrc {
builder = builder.proxy(p);
}
gst_debug!(CAT, obj: src, "Creating new client");
gst::debug!(CAT, obj: src, "Creating new client");
let client = ClientContext(Arc::new(ClientContextInner {
client: builder.build().map_err(|err| {
gst::error_msg!(
@ -317,7 +316,7 @@ impl ReqwestHttpSrc {
// The alternative would be different contexts for different proxy settings, or one context with a
// map from proxy settings to client, but then, how and when to discard those, retaining reuse benefits?
if proxy.is_none() {
gst_debug!(CAT, obj: src, "Sharing new client with other elements");
gst::debug!(CAT, obj: src, "Sharing new client with other elements");
let mut context = gst::Context::new(REQWEST_CLIENT_CONTEXT, true);
{
let context = context.get_mut().unwrap();
@ -343,7 +342,7 @@ impl ReqwestHttpSrc {
use headers::{Connection, ContentLength, ContentRange, HeaderMapExt, Range, UserAgent};
use reqwest::header::{self, HeaderMap, HeaderName, HeaderValue};
gst_debug!(CAT, obj: src, "Creating new request for {}", uri);
gst::debug!(CAT, obj: src, "Creating new request for {}", uri);
let settings = self.settings.lock().unwrap().clone();
@ -386,7 +385,7 @@ impl ReqwestHttpSrc {
let field = match HeaderName::try_from(field) {
Ok(field) => field,
Err(err) => {
gst_warning!(
gst::warning!(
CAT,
obj: src,
"Failed to transform extra-header field name '{}' to header name: {}",
@ -402,7 +401,7 @@ impl ReqwestHttpSrc {
let value = match value.transform::<String>() {
Ok(value) => value,
Err(_) => {
gst_warning!(
gst::warning!(
CAT,
obj: src,
"Failed to transform extra-header '{}' value to string",
@ -417,7 +416,7 @@ impl ReqwestHttpSrc {
let value = match value.parse::<HeaderValue>() {
Ok(value) => value,
Err(_) => {
gst_warning!(
gst::warning!(
CAT,
obj: src,
"Failed to transform extra-header '{}' value to header value",
@ -465,7 +464,7 @@ impl ReqwestHttpSrc {
req
};
gst_debug!(CAT, obj: src, "Sending new request: {:?}", req);
gst::debug!(CAT, obj: src, "Sending new request: {:?}", req);
let future = async {
req.send().await.map_err(|err| {
@ -480,21 +479,21 @@ impl ReqwestHttpSrc {
let res = match res {
Ok(res) => res,
Err(Some(err)) => {
gst_debug!(CAT, obj: src, "Error {:?}", err);
gst::debug!(CAT, obj: src, "Error {:?}", err);
return Err(Some(err));
}
Err(None) => {
gst_debug!(CAT, obj: src, "Flushing");
gst::debug!(CAT, obj: src, "Flushing");
return Err(None);
}
};
gst_debug!(CAT, obj: src, "Received response: {:?}", res);
gst::debug!(CAT, obj: src, "Received response: {:?}", res);
if !res.status().is_success() {
match res.status() {
StatusCode::NOT_FOUND => {
gst_error!(CAT, obj: src, "Resource not found");
gst::error!(CAT, obj: src, "Resource not found");
return Err(Some(gst::error_msg!(
gst::ResourceError::NotFound,
["Resource '{}' not found", uri]
@ -504,14 +503,14 @@ impl ReqwestHttpSrc {
| StatusCode::PAYMENT_REQUIRED
| StatusCode::FORBIDDEN
| StatusCode::PROXY_AUTHENTICATION_REQUIRED => {
gst_error!(CAT, obj: src, "Not authorized: {}", res.status());
gst::error!(CAT, obj: src, "Not authorized: {}", res.status());
return Err(Some(gst::error_msg!(
gst::ResourceError::NotAuthorized,
["Not Authorized for resource '{}': {}", uri, res.status()]
)));
}
_ => {
gst_error!(CAT, obj: src, "Request failed: {}", res.status());
gst::error!(CAT, obj: src, "Request failed: {}", res.status());
return Err(Some(gst::error_msg!(
gst::ResourceError::OpenRead,
["Request for '{}' failed: {}", uri, res.status()]
@ -562,7 +561,7 @@ impl ReqwestHttpSrc {
.and_then(|content_type| content_type.to_str().ok())
.and_then(|content_type| content_type.parse::<mime::Mime>().ok())
{
gst_debug!(CAT, obj: src, "Got content type {}", content_type);
gst::debug!(CAT, obj: src, "Got content type {}", content_type);
if let Some(ref mut caps) = caps {
let caps = caps.get_mut().unwrap();
let s = caps.structure_mut(0).unwrap();
@ -605,7 +604,7 @@ impl ReqwestHttpSrc {
}
}
gst_debug!(CAT, obj: src, "Request successful");
gst::debug!(CAT, obj: src, "Request successful");
Ok(State::Started {
uri,
@ -883,7 +882,7 @@ impl ObjectImpl for ReqwestHttpSrc {
};
if let Err(err) = res {
gst_error!(
gst::error!(
CAT,
obj: obj,
"Failed to set property `{}`: {:?}",
@ -1058,7 +1057,7 @@ impl BaseSrcImpl for ReqwestHttpSrc {
})
.map(|uri| uri.clone())?;
gst_debug!(CAT, obj: src, "Starting for URI {}", uri);
gst::debug!(CAT, obj: src, "Starting for URI {}", uri);
*state = self.do_request(src, uri, 0, None).map_err(|err| {
err.unwrap_or_else(|| {
@ -1070,7 +1069,7 @@ impl BaseSrcImpl for ReqwestHttpSrc {
}
fn stop(&self, src: &Self::Type) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: src, "Stopping");
gst::debug!(CAT, obj: src, "Stopping");
*self.state.lock().unwrap() = State::Stopped;
Ok(())
@ -1116,10 +1115,10 @@ impl BaseSrcImpl for ReqwestHttpSrc {
let start = *segment.start().expect("No start position given");
let stop = segment.stop().map(|stop| *stop);
gst_debug!(CAT, obj: src, "Seeking to {}-{:?}", start, stop);
gst::debug!(CAT, obj: src, "Seeking to {}-{:?}", start, stop);
if position == start && old_stop == stop {
gst_debug!(CAT, obj: src, "No change to current request");
gst::debug!(CAT, obj: src, "No change to current request");
return true;
}
@ -1166,7 +1165,7 @@ impl PushSrcImpl for ReqwestHttpSrc {
let mut current_response = match response.take() {
Some(response) => response,
None => {
gst_error!(CAT, obj: src, "Don't have a response");
gst::error!(CAT, obj: src, "Don't have a response");
gst::element_error!(src, gst::ResourceError::Read, ["Don't have a response"]);
return Err(gst::FlowError::Error);
@ -1178,13 +1177,13 @@ impl PushSrcImpl for ReqwestHttpSrc {
drop(state);
if let Some(caps) = caps {
gst_debug!(CAT, obj: src, "Setting caps {:?}", caps);
gst::debug!(CAT, obj: src, "Setting caps {:?}", caps);
src.set_caps(&caps)
.map_err(|_| gst::FlowError::NotNegotiated)?;
}
if let Some(tags) = tags {
gst_debug!(CAT, obj: src, "Sending iradio tags {:?}", tags);
gst::debug!(CAT, obj: src, "Sending iradio tags {:?}", tags);
let pad = src.static_pad("src").unwrap();
pad.push_event(gst::event::Tag::new(tags));
}
@ -1202,12 +1201,12 @@ impl PushSrcImpl for ReqwestHttpSrc {
let res = match res {
Ok(res) => res,
Err(Some(err)) => {
gst_debug!(CAT, obj: src, "Error {:?}", err);
gst::debug!(CAT, obj: src, "Error {:?}", err);
src.post_error_message(err);
return Err(gst::FlowError::Error);
}
Err(None) => {
gst_debug!(CAT, obj: src, "Flushing");
gst::debug!(CAT, obj: src, "Flushing");
return Err(gst::FlowError::Flushing);
}
};
@ -1230,7 +1229,7 @@ impl PushSrcImpl for ReqwestHttpSrc {
Some(chunk) => {
/* do something with the chunk and store the body again in the state */
gst_trace!(
gst::trace!(
CAT,
obj: src,
"Chunk of {} bytes received at offset {}",
@ -1256,7 +1255,7 @@ impl PushSrcImpl for ReqwestHttpSrc {
}
None => {
/* No further data, end of stream */
gst_debug!(CAT, obj: src, "End of stream");
gst::debug!(CAT, obj: src, "End of stream");
*response = Some(current_response);
Err(gst::FlowError::Eos)
}

10
net/rusoto/src/aws_transcribe_parse/imp.rs
View file

@ -8,7 +8,7 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{element_error, error_msg, gst_error, gst_log, gst_trace};
use gst::{element_error, error_msg};
use serde_derive::Deserialize;
use once_cell::sync::Lazy;
@ -86,7 +86,7 @@ impl TranscribeParse {
_element: &super::TranscribeParse,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut state = self.state.lock().unwrap();
@ -228,7 +228,7 @@ impl TranscribeParse {
) -> bool {
use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() {
EventView::FlushStop(..) => {
let mut state = self.state.lock().unwrap();
@ -238,7 +238,7 @@ impl TranscribeParse {
EventView::Eos(..) => match self.drain() {
Ok(()) => pad.event_default(Some(element), event),
Err(err) => {
gst_error!(CAT, obj: element, "failed to drain on EOS: {}", err);
gst::error!(CAT, obj: element, "failed to drain on EOS: {}", err);
element_error!(
element,
gst::StreamError::Failed,
@ -348,7 +348,7 @@ impl ElementImpl for TranscribeParse {
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 => {

79
net/rusoto/src/aws_transcriber/imp.rs
View file

@ -9,10 +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_trace, gst_warning,
loggable_error,
};
use gst::{element_error, error_msg, loggable_error};
use std::default::Default;
@ -233,7 +230,7 @@ impl Transcriber {
while let Some(buf) = state.buffers.front() {
let pts = buf.pts().unwrap();
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Checking now {} if item is ready for dequeuing, PTS {}, threshold {} vs {}",
@ -282,7 +279,7 @@ impl Transcriber {
.duration(pts - last_position)
.seqnum(seqnum)
.build();
gst_log!(CAT, "Pushing gap: {} -> {}", last_position, pts);
gst::log!(CAT, "Pushing gap: {} -> {}", last_position, pts);
if !self.srcpad.push_event(gap_event) {
return false;
}
@ -290,7 +287,7 @@ impl Transcriber {
Ordering::Less => {
let delta = last_position - pts;
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Updating item PTS ({} < {}), consider increasing latency",
@ -313,7 +310,7 @@ impl Transcriber {
last_position = pts + duration;
gst_debug!(CAT, "Pushing buffer: {} -> {}", pts, pts + duration);
gst::debug!(CAT, "Pushing buffer: {} -> {}", pts, pts + duration);
if self.srcpad.push(buf).is_err() {
return false;
@ -321,7 +318,7 @@ impl Transcriber {
}
/* next, push a gap if we're lagging behind the target position */
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Checking now: {} if we need to push a gap, last_position: {}, threshold: {}",
@ -338,7 +335,7 @@ impl Transcriber {
.seqnum(seqnum)
.build();
gst_log!(
gst::log!(
CAT,
"Pushing gap: {} -> {}",
last_position,
@ -371,7 +368,7 @@ impl Transcriber {
let lateness = self.settings.lock().unwrap().lateness;
if alternative.items.len() <= state.partial_index {
gst_error!(
gst::error!(
CAT,
obj: element,
"sanity check failed, alternative length {} < partial_index {}",
@ -399,7 +396,7 @@ impl Transcriber {
}
/* Should be sent now */
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Item is ready for queuing: {}, PTS {}",
@ -469,7 +466,7 @@ impl Transcriber {
};
for event in events.drain(..) {
gst_info!(CAT, obj: element, "Sending {:?}", event);
gst::info!(CAT, obj: element, "Sending {:?}", event);
self.srcpad.push_event(event);
}
@ -486,7 +483,7 @@ impl Transcriber {
match msg {
Message::Binary(buf) => {
let (_, pkt) = parse_packet(&buf).map_err(|err| {
gst_error!(CAT, obj: element, "Failed to parse packet: {}", err);
gst::error!(CAT, obj: element, "Failed to parse packet: {}", err);
error_msg!(
gst::StreamError::Failed,
["Failed to parse packet: {}", err]
@ -498,7 +495,7 @@ impl Transcriber {
if packet_is_exception(&pkt) {
let message: ExceptionMessage =
serde_json::from_str(payload).map_err(|err| {
gst_error!(
gst::error!(
CAT,
obj: element,
"Unexpected exception message: {} ({})",
@ -510,7 +507,7 @@ impl Transcriber {
["Unexpected exception message: {} ({})", payload, err]
)
})?;
gst_error!(
gst::error!(
CAT,
obj: element,
"AWS raised an error: {}",
@ -531,7 +528,7 @@ impl Transcriber {
})?;
if let Some(result) = transcript.transcript.results.get(0) {
gst_trace!(
gst::trace!(
CAT,
obj: element,
"result: {}",
@ -557,7 +554,7 @@ impl Transcriber {
match tokio::time::timeout(GRANULARITY.into(), future).await {
Err(_) => {
if !self.dequeue(element) {
gst_info!(CAT, obj: element, "Failed to push gap event, pausing");
gst::info!(CAT, obj: element, "Failed to push gap event, pausing");
let _ = self.srcpad.pause_task();
}
@ -565,7 +562,7 @@ impl Transcriber {
}
Ok(res) => {
if !self.dequeue(element) {
gst_info!(CAT, obj: element, "Failed to push gap event, pausing");
gst::info!(CAT, obj: element, "Failed to push gap event, pausing");
let _ = self.srcpad.pause_task();
}
@ -644,7 +641,7 @@ impl Transcriber {
) -> 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) => {
@ -679,23 +676,23 @@ impl Transcriber {
fn sink_event(&self, pad: &gst::Pad, element: &super::Transcriber, 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::Eos(_) => match self.handle_buffer(pad, element, None) {
Err(err) => {
gst_error!(CAT, "Failed to send EOS to AWS: {}", err);
gst::error!(CAT, "Failed to send EOS to AWS: {}", err);
false
}
Ok(_) => true,
},
EventView::FlushStart(_) => {
gst_info!(CAT, obj: element, "Received flush start, disconnecting");
gst::info!(CAT, obj: element, "Received flush start, disconnecting");
let mut ret = pad.event_default(Some(element), event);
match self.srcpad.stop_task() {
Err(err) => {
gst_error!(CAT, obj: element, "Failed to stop srcpad task: {}", err);
gst::error!(CAT, obj: element, "Failed to stop srcpad task: {}", err);
self.disconnect(element);
@ -709,12 +706,12 @@ impl Transcriber {
ret
}
EventView::FlushStop(_) => {
gst_info!(CAT, obj: element, "Received flush stop, restarting task");
gst::info!(CAT, obj: element, "Received flush stop, restarting task");
if pad.event_default(Some(element), event) {
match self.start_task(element) {
Err(err) => {
gst_error!(CAT, obj: element, "Failed to start srcpad task: {}", err);
gst::error!(CAT, obj: element, "Failed to start srcpad task: {}", err);
false
}
Ok(_) => true,
@ -745,7 +742,7 @@ impl Transcriber {
}
EventView::Tag(_) => true,
EventView::Caps(e) => {
gst_info!(CAT, "Received caps {:?}", e);
gst::info!(CAT, "Received caps {:?}", e);
true
}
EventView::StreamStart(_) => true,
@ -781,7 +778,7 @@ impl Transcriber {
for chunk in data.chunks(8192) {
let packet = build_packet(chunk);
ws_sink.send(Message::Binary(packet)).await.map_err(|err| {
gst_error!(CAT, obj: element, "Failed sending packet: {}", err);
gst::error!(CAT, obj: element, "Failed sending packet: {}", err);
gst::FlowError::Error
})?;
}
@ -789,7 +786,7 @@ impl Transcriber {
// EOS
let packet = build_packet(&[]);
ws_sink.send(Message::Binary(packet)).await.map_err(|err| {
gst_error!(CAT, obj: element, "Failed sending packet: {}", err);
gst::error!(CAT, obj: element, "Failed sending packet: {}", err);
gst::FlowError::Error
})?;
}
@ -804,7 +801,7 @@ impl Transcriber {
element: &super::Transcriber,
buffer: Option<gst::Buffer>,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: element, "Handling {:?}", buffer);
gst::log!(CAT, obj: element, "Handling {:?}", buffer);
self.ensure_connection(element).map_err(|err| {
element_error!(
@ -853,7 +850,7 @@ impl Transcriber {
let settings = self.settings.lock().unwrap();
if settings.latency + settings.lateness <= 2 * GRANULARITY {
gst_error!(
gst::error!(
CAT,
obj: element,
"latency + lateness must be greater than 200 milliseconds"
@ -864,7 +861,7 @@ impl Transcriber {
));
}
gst_info!(CAT, obj: element, "Connecting ..");
gst::info!(CAT, obj: element, "Connecting ..");
let creds = match (
settings.access_key.as_ref(),
@ -876,7 +873,7 @@ impl Transcriber {
StaticProvider::new_minimal(access_key.clone(), secret_access_key.clone())
.credentials()
.map_err(|err| {
gst_error!(
gst::error!(
CAT,
obj: element,
"Failed to generate credentials: {}",
@ -892,7 +889,7 @@ impl Transcriber {
_ => {
let _enter = RUNTIME.enter();
futures::executor::block_on(ChainProvider::new().credentials()).map_err(|err| {
gst_error!(CAT, obj: element, "Failed to generate credentials: {}", err);
gst::error!(CAT, obj: element, "Failed to generate credentials: {}", err);
error_msg!(
gst::CoreError::Failed,
["Failed to generate credentials: {}", err]
@ -927,7 +924,7 @@ impl Transcriber {
}
if let Some(ref session_id) = settings.session_id {
gst_debug!(CAT, obj: element, "Using session ID: {}", session_id);
gst::debug!(CAT, obj: element, "Using session ID: {}", session_id);
signed.add_param("session-id", session_id);
}
@ -950,7 +947,7 @@ impl Transcriber {
let _enter = RUNTIME.enter();
futures::executor::block_on(connect_async(format!("wss{}", &url[5..]))).map_err(
|err| {
gst_error!(CAT, obj: element, "Failed to connect: {}", err);
gst::error!(CAT, obj: element, "Failed to connect: {}", err);
error_msg!(gst::CoreError::Failed, ["Failed to connect: {}", err])
},
)?
@ -976,7 +973,7 @@ impl Transcriber {
let msg = match msg {
Ok(msg) => msg,
Err(err) => {
gst_error!(CAT, "Failed to receive data: {}", err);
gst::error!(CAT, "Failed to receive data: {}", err);
element_error!(
element,
gst::StreamError::Failed,
@ -1006,7 +1003,7 @@ impl Transcriber {
state.connected = true;
gst_info!(CAT, obj: element, "Connected");
gst::info!(CAT, obj: element, "Connected");
Ok(())
}
@ -1014,7 +1011,7 @@ impl Transcriber {
fn disconnect(&self, element: &super::Transcriber) {
let mut state = self.state.lock().unwrap();
gst_info!(CAT, obj: element, "Unpreparing");
gst::info!(CAT, obj: element, "Unpreparing");
if let Some(abort_handle) = state.recv_abort_handle.take() {
abort_handle.abort();
@ -1026,7 +1023,7 @@ impl Transcriber {
*state = State::default();
gst_info!(
gst::info!(
CAT,
obj: element,
"Unprepared, connected: {}!",
@ -1316,7 +1313,7 @@ impl ElementImpl for Transcriber {
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);
let mut success = self.parent_change_state(element, transition)?;

33
net/rusoto/src/s3sink/imp.rs
View file

@ -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 gst_base::subclass::prelude::*;
@ -132,10 +131,10 @@ impl Settings {
for (key, value) in structure.iter() {
if let Ok(Ok(value_str)) = value.transform::<String>().map(|v| v.get()) {
gst_log!(CAT, obj: element, "metadata '{}' -> '{}'", key, value_str);
gst::log!(CAT, obj: element, "metadata '{}' -> '{}'", key, value_str);
hash.insert(key.to_string(), value_str);
} else {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Failed to convert metadata '{}' to string ('{:?}')",
@ -207,7 +206,7 @@ impl S3Sink {
let settings = self.settings.lock().unwrap();
match settings.multipart_upload_on_error {
OnError::Abort => {
gst_log!(
gst::log!(
CAT,
obj: element,
"Aborting multipart upload request with id: {}",
@ -215,13 +214,13 @@ impl S3Sink {
);
match self.abort_multipart_upload_request(state) {
Ok(()) => {
gst_log!(
gst::log!(
CAT,
obj: element,
"Aborting multipart upload request succeeded."
);
}
Err(err) => gst_error!(
Err(err) => gst::error!(
CAT,
obj: element,
"Aborting multipart upload failed: {}",
@ -230,7 +229,7 @@ impl S3Sink {
}
}
OnError::Complete => {
gst_log!(
gst::log!(
CAT,
obj: element,
"Completing multipart upload request with id: {}",
@ -238,13 +237,13 @@ impl S3Sink {
);
match self.complete_multipart_upload_request(state) {
Ok(()) => {
gst_log!(
gst::log!(
CAT,
obj: element,
"Complete multipart upload request succeeded."
);
}
Err(err) => gst_error!(
Err(err) => gst::error!(
CAT,
obj: element,
"Completing multipart upload failed: {}",
@ -266,7 +265,7 @@ impl S3Sink {
e_tag: output.e_tag,
part_number: Some(part_number),
});
gst_info!(CAT, obj: element, "Uploaded part {}", part_number);
gst::info!(CAT, obj: element, "Uploaded part {}", part_number);
Ok(())
}
@ -547,7 +546,7 @@ impl S3Sink {
return Ok(());
}
gst_debug!(CAT, obj: object, "Setting uri to {:?}", url_str);
gst::debug!(CAT, obj: object, "Setting uri to {:?}", url_str);
let url_str = url_str.unwrap();
match parse_s3_url(url_str) {
@ -656,7 +655,7 @@ impl ObjectImpl for S3Sink {
) {
let mut settings = self.settings.lock().unwrap();
gst_debug!(
gst::debug!(
CAT,
obj: obj,
"Setting property '{}' to '{:?}'",
@ -804,7 +803,7 @@ impl BaseSinkImpl for S3Sink {
fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
let mut state = self.state.lock().unwrap();
*state = State::Stopped;
gst_info!(CAT, obj: element, "Stopped");
gst::info!(CAT, obj: element, "Stopped");
Ok(())
}
@ -819,7 +818,7 @@ impl BaseSinkImpl for S3Sink {
return Err(gst::FlowError::Error);
}
gst_trace!(CAT, obj: element, "Rendering {:?}", buffer);
gst::trace!(CAT, obj: element, "Rendering {:?}", buffer);
let map = buffer.map_readable().map_err(|_| {
gst::element_error!(element, gst::CoreError::Failed, ["Failed to map buffer"]);
gst::FlowError::Error
@ -829,7 +828,7 @@ impl BaseSinkImpl for S3Sink {
Ok(_) => Ok(gst::FlowSuccess::Ok),
Err(err) => match err {
Some(error_message) => {
gst_error!(
gst::error!(
CAT,
obj: element,
"Multipart upload failed: {}",
@ -839,7 +838,7 @@ impl BaseSinkImpl for S3Sink {
Err(gst::FlowError::Error)
}
_ => {
gst_info!(CAT, obj: element, "Upload interrupted. Flushing...");
gst::info!(CAT, obj: element, "Upload interrupted. Flushing...");
Err(gst::FlowError::Flushing)
}
},
@ -855,7 +854,7 @@ impl BaseSinkImpl for S3Sink {
fn event(&self, element: &Self::Type, event: gst::Event) -> bool {
if let gst::EventView::Eos(_) = event.view() {
if let Err(error_message) = self.finalize_upload(element) {
gst_error!(
gst::error!(
CAT,
obj: element,
"Failed to finalize the upload: {}",

9
net/rusoto/src/s3src/imp.rs
View file

@ -18,7 +18,6 @@ use rusoto_s3::{GetObjectRequest, HeadObjectRequest, S3Client, S3};
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::base_src::CreateSuccess;
@ -150,7 +149,7 @@ impl S3Src {
})?;
if let Some(size) = output.content_length {
gst_info!(CAT, obj: src, "HEAD success, content length = {}", size);
gst::info!(CAT, obj: src, "HEAD success, content length = {}", size);
Ok(size as u64)
} else {
Err(gst::error_msg!(
@ -191,7 +190,7 @@ impl S3Src {
..Default::default()
};
gst_debug!(
gst::debug!(
CAT,
obj: src,
"Requesting range: {}-{}",
@ -209,7 +208,7 @@ impl S3Src {
WaitError::Cancelled => None,
})?;
gst_debug!(
gst::debug!(
CAT,
obj: src,
"Read {} bytes",
@ -466,7 +465,7 @@ impl BaseSrcImpl for S3Src {
Err(None) => Err(gst::FlowError::Flushing),
/* Actual Error */
Err(Some(err)) => {
gst_error!(CAT, obj: src, "Could not GET: {}", err);
gst::error!(CAT, obj: src, "Could not GET: {}", err);
Err(gst::FlowError::Error)
}
}

7
text/ahead/src/textahead/imp.rs
View file

@ -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());
{

5
text/json/src/jsongstenc/imp.rs
View file

@ -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 => {

73
text/json/src/jsongstparse/imp.rs
View file

@ -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 => {

13
text/regex/src/gstregex/imp.rs
View file

@ -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);
}
}
}

27
text/wrap/src/gsttextwrap/imp.rs
View file

@ -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();

13
tutorial/src/identity/imp.rs
View file

@ -11,7 +11,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_log, gst_trace};
use once_cell::sync::Lazy;
@ -44,7 +43,7 @@ impl Identity {
_element: &super::Identity,
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.srcpad.push(buffer)
}
@ -56,7 +55,7 @@ impl Identity {
// See the documentation of gst::Event and gst::EventRef to see what can be done with
// events, and especially the gst::EventView type for inspecting events.
fn sink_event(&self, pad: &gst::Pad, _element: &super::Identity, event: gst::Event) -> bool {
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
gst::log!(CAT, obj: pad, "Handling event {:?}", event);
self.srcpad.push_event(event)
}
@ -75,7 +74,7 @@ impl Identity {
_element: &super::Identity,
query: &mut gst::QueryRef,
) -> bool {
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
gst::log!(CAT, obj: pad, "Handling query {:?}", query);
self.srcpad.peer_query(query)
}
@ -88,7 +87,7 @@ impl Identity {
// See the documentation of gst::Event and gst::EventRef to see what can be done with
// events, and especially the gst::EventView type for inspecting events.
fn src_event(&self, pad: &gst::Pad, _element: &super::Identity, event: gst::Event) -> bool {
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
gst::log!(CAT, obj: pad, "Handling event {:?}", event);
self.sinkpad.push_event(event)
}
@ -107,7 +106,7 @@ impl Identity {
_element: &super::Identity,
query: &mut gst::QueryRef,
) -> bool {
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
gst::log!(CAT, obj: pad, "Handling query {:?}", query);
self.sinkpad.peer_query(query)
}
}
@ -259,7 +258,7 @@ impl ElementImpl for Identity {
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);
// Call the parent class' implementation of ::change_state()
self.parent_change_state(element, transition)

5
tutorial/src/progressbin/imp.rs
View file

@ -9,7 +9,6 @@
// SPDX-License-Identifier: MIT/Apache-2.0
use gst::glib;
use gst::gst_info;
use gst::prelude::*;
use gst::subclass::prelude::*;
use std::sync::Mutex;
@ -111,7 +110,7 @@ impl ObjectImpl for ProgressBin {
let new_output_type = value
.get::<ProgressBinOutput>()
.expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing output from {:?} to {:?}",
@ -238,7 +237,7 @@ impl BinImpl for ProgressBin {
match output_type {
ProgressBinOutput::Println => println!("progress: {:5.1}%", percent),
ProgressBinOutput::DebugCategory => {
gst_info!(CAT, "progress: {:5.1}%", percent);
gst::info!(CAT, "progress: {:5.1}%", percent);
}
};
}

7
tutorial/src/rgb2gray/imp.rs
View file

@ -11,7 +11,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_info};
use gst_base::subclass::prelude::*;
use gst_video::subclass::prelude::*;
@ -134,7 +133,7 @@ impl ObjectImpl for Rgb2Gray {
"invert" => {
let mut settings = self.settings.lock().unwrap();
let invert = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing invert from {} to {}",
@ -146,7 +145,7 @@ impl ObjectImpl for Rgb2Gray {
"shift" => {
let mut settings = self.settings.lock().unwrap();
let shift = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing shift from {} to {}",
@ -322,7 +321,7 @@ impl BaseTransformImpl for Rgb2Gray {
gray_caps
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Transformed caps from {} to {} in direction {:?}",

45
tutorial/src/sinesrc/imp.rs
View file

@ -11,7 +11,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log};
use gst_base::prelude::*;
use gst_base::subclass::base_src::CreateSuccess;
use gst_base::subclass::prelude::*;
@ -240,7 +239,7 @@ impl ObjectImpl for SineSrc {
"samples-per-buffer" => {
let mut settings = self.settings.lock().unwrap();
let samples_per_buffer = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing samples-per-buffer from {} to {}",
@ -255,7 +254,7 @@ impl ObjectImpl for SineSrc {
"freq" => {
let mut settings = self.settings.lock().unwrap();
let freq = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing freq from {} to {}",
@ -267,7 +266,7 @@ impl ObjectImpl for SineSrc {
"volume" => {
let mut settings = self.settings.lock().unwrap();
let volume = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing volume from {} to {}",
@ -279,7 +278,7 @@ impl ObjectImpl for SineSrc {
"mute" => {
let mut settings = self.settings.lock().unwrap();
let mute = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing mute from {} to {}",
@ -291,7 +290,7 @@ impl ObjectImpl for SineSrc {
"is-live" => {
let mut settings = self.settings.lock().unwrap();
let is_live = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing is-live from {} to {}",
@ -423,7 +422,7 @@ impl BaseSrcImpl for SineSrc {
gst::loggable_error!(CAT, "Failed to build `AudioInfo` from caps {}", caps)
})?;
gst_debug!(CAT, obj: element, "Configuring for caps {}", caps);
gst::debug!(CAT, obj: element, "Configuring for caps {}", caps);
element.set_blocksize(info.bpf() * (*self.settings.lock().unwrap()).samples_per_buffer);
@ -471,7 +470,7 @@ impl BaseSrcImpl for SineSrc {
*self.state.lock().unwrap() = Default::default();
self.unlock_stop(element)?;
gst_info!(CAT, obj: element, "Started");
gst::info!(CAT, obj: element, "Started");
Ok(())
}
@ -482,7 +481,7 @@ impl BaseSrcImpl for SineSrc {
*self.state.lock().unwrap() = Default::default();
self.unlock(element)?;
gst_info!(CAT, obj: element, "Stopped");
gst::info!(CAT, obj: element, "Stopped");
Ok(())
}
@ -502,7 +501,7 @@ impl BaseSrcImpl for SineSrc {
let latency = gst::ClockTime::SECOND
.mul_div_floor(settings.samples_per_buffer as u64, info.rate() as u64)
.unwrap();
gst_debug!(CAT, obj: element, "Returning latency {}", latency);
gst::debug!(CAT, obj: element, "Returning latency {}", latency);
q.set(settings.is_live, latency, gst::ClockTime::NONE);
true
} else {
@ -547,7 +546,7 @@ impl BaseSrcImpl for SineSrc {
// and for calculating the timestamps, etc.
if segment.rate() < 0.0 {
gst_error!(CAT, obj: element, "Reverse playback not supported");
gst::error!(CAT, obj: element, "Reverse playback not supported");
return false;
}
@ -579,7 +578,7 @@ impl BaseSrcImpl for SineSrc {
let accumulator =
(sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64));
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Seeked to {}-{:?} (accum: {}) for segment {:?}",
@ -601,7 +600,7 @@ impl BaseSrcImpl for SineSrc {
use std::f64::consts::PI;
if state.info.is_none() {
gst_error!(
gst::error!(
CAT,
obj: element,
"Can only seek in Default format if sample rate is known"
@ -615,7 +614,7 @@ impl BaseSrcImpl for SineSrc {
let accumulator =
(sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64));
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Seeked to {}-{:?} (accum: {}) for segment {:?}",
@ -634,7 +633,7 @@ impl BaseSrcImpl for SineSrc {
true
} else {
gst_error!(
gst::error!(
CAT,
obj: element,
"Can't seek in format {:?}",
@ -648,7 +647,7 @@ impl BaseSrcImpl for SineSrc {
fn unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
// This should unblock the create() function ASAP, so we
// just unschedule the clock it here, if any.
gst_debug!(CAT, obj: element, "Unlocking");
gst::debug!(CAT, obj: element, "Unlocking");
let mut clock_wait = self.clock_wait.lock().unwrap();
if let Some(clock_id) = clock_wait.clock_id.take() {
clock_id.unschedule();
@ -661,7 +660,7 @@ impl BaseSrcImpl for SineSrc {
fn unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
// This signals that unlocking is done, so we can reset
// all values again.
gst_debug!(CAT, obj: element, "Unlock stop");
gst::debug!(CAT, obj: element, "Unlock stop");
let mut clock_wait = self.clock_wait.lock().unwrap();
clock_wait.flushing = false;
@ -695,7 +694,7 @@ impl PushSrcImpl for SineSrc {
// point but at most samples_per_buffer samples per buffer
let n_samples = if let Some(sample_stop) = state.sample_stop {
if sample_stop <= state.sample_offset {
gst_log!(CAT, obj: element, "At EOS");
gst::log!(CAT, obj: element, "At EOS");
return Err(gst::FlowError::Eos);
}
@ -785,7 +784,7 @@ impl PushSrcImpl for SineSrc {
// so that we immediately stop waiting on e.g. shutdown.
let mut clock_wait = self.clock_wait.lock().unwrap();
if clock_wait.flushing {
gst_debug!(CAT, obj: element, "Flushing");
gst::debug!(CAT, obj: element, "Flushing");
return Err(gst::FlowError::Flushing);
}
@ -793,7 +792,7 @@ impl PushSrcImpl for SineSrc {
clock_wait.clock_id = Some(id.clone());
drop(clock_wait);
gst_log!(
gst::log!(
CAT,
obj: element,
"Waiting until {}, now {}",
@ -801,18 +800,18 @@ impl PushSrcImpl for SineSrc {
clock.time().display(),
);
let (res, jitter) = id.wait();
gst_log!(CAT, obj: element, "Waited res {:?} jitter {}", res, jitter);
gst::log!(CAT, obj: element, "Waited res {:?} jitter {}", res, jitter);
self.clock_wait.lock().unwrap().clock_id.take();
// If the clock ID was unscheduled, unlock() was called
// and we should return Flushing immediately.
if res == Err(gst::ClockError::Unscheduled) {
gst_debug!(CAT, obj: element, "Flushing");
gst::debug!(CAT, obj: element, "Flushing");
return Err(gst::FlowError::Flushing);
}
}
gst_debug!(CAT, obj: element, "Produced buffer {:?}", buffer);
gst::debug!(CAT, obj: element, "Produced buffer {:?}", buffer);
Ok(CreateSuccess::NewBuffer(buffer))
}

13
tutorial/tutorial-1.md
View file

@ -146,7 +146,6 @@ With that our `src/lib.rs` is complete, and all following code is only in `src/r
```rust
use gst::glib;
use gst::{gst_debug, gst_info};
use gst_base::subclass::prelude::*;
use std::i32;
@ -438,7 +437,7 @@ impl BaseTransformImpl for Rgb2Gray {
Some(info) => info,
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Configured for caps {} to {}",
@ -455,14 +454,14 @@ impl BaseTransformImpl for Rgb2Gray {
// Drop state
let _ = self.state.lock().unwrap().take();
gst_info!(CAT, obj: element, "Stopped");
gst::info!(CAT, obj: element, "Stopped");
Ok(())
}
}
```
This code should be relatively self-explanatory. In `set_caps` we’re parsing the two caps into a `VideoInfo` and then store this in our `State`, in `stop` we drop the `State` and replace it with `None`. In addition we make use of our debug category here and use the `gst_info!` and `gst_debug!` macros to output the current caps configuration to the GStreamer debug logging system. This information can later be useful for debugging any problems once the element is running.
This code should be relatively self-explanatory. In `set_caps` we’re parsing the two caps into a `VideoInfo` and then store this in our `State`, in `stop` we drop the `State` and replace it with `None`. In addition we make use of our debug category here and use the `gst::info!` and `gst::debug!` macros to output the current caps configuration to the GStreamer debug logging system. This information can later be useful for debugging any problems once the element is running.
Next we have to provide information to the `BaseTransform` base class about the size in bytes of a video frame with specific caps. This is needed so that the base class can allocate an appropriately sized output buffer for us, that we can then fill later. This is done with the `get_unit_size` virtual method, which is required to return the size of one processing unit in specific caps. In our case, one processing unit is one video frame. In the case of raw audio it would be the size of one sample multiplied by the number of channels.
@ -518,7 +517,7 @@ impl BaseTransformImpl for Rgb2Gray {
gray_caps
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Transformed caps from {} to {} in direction {:?}",
@ -778,7 +777,7 @@ impl ObjectImpl for Rgb2Gray {
"invert" => {
let mut settings = self.settings.lock().unwrap();
let invert = value.get_some().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing invert from {} to {}",
@ -790,7 +789,7 @@ impl ObjectImpl for Rgb2Gray {
"shift" => {
let mut settings = self.settings.lock().unwrap();
let shift = value.get_some().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing shift from {} to {}",

51
tutorial/tutorial-2.md
View file

@ -25,7 +25,6 @@ In `src/sinesrc/imp.rs`:
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log};
use gst_base::prelude::*;
use gst_base::subclass::prelude::*;
@ -240,7 +239,7 @@ impl ObjectImpl for SineSrc {
"samples-per-buffer" => {
let mut settings = self.settings.lock().unwrap();
let samples_per_buffer = value.get_some().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing samples-per-buffer from {} to {}",
@ -255,7 +254,7 @@ impl ObjectImpl for SineSrc {
"freq" => {
let mut settings = self.settings.lock().unwrap();
let freq = value.get_some().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing freq from {} to {}",
@ -267,7 +266,7 @@ impl ObjectImpl for SineSrc {
"volume" => {
let mut settings = self.settings.lock().unwrap();
let volume = value.get_some().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing volume from {} to {}",
@ -279,7 +278,7 @@ impl ObjectImpl for SineSrc {
"mute" => {
let mut settings = self.settings.lock().unwrap();
let mute = value.get_some().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing mute from {} to {}",
@ -291,7 +290,7 @@ impl ObjectImpl for SineSrc {
"is-live" => {
let mut settings = self.settings.lock().unwrap();
let is_live = value.get_some().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing is-live from {} to {}",
@ -342,7 +341,7 @@ impl BaseSrcImpl for SineSrc {
// Reset state
*self.state.lock().unwrap() = Default::default();
gst_info!(CAT, obj: element, "Started");
gst::info!(CAT, obj: element, "Started");
true
}
@ -352,7 +351,7 @@ impl BaseSrcImpl for SineSrc {
// Reset state
*self.state.lock().unwrap() = Default::default();
gst_info!(CAT, obj: element, "Stopped");
gst::info!(CAT, obj: element, "Stopped");
true
}
@ -421,7 +420,7 @@ First of all, we need to get notified whenever the caps that our source is confi
gst::loggable_error!(CAT, "Failed to build `AudioInfo` from caps {}", caps)
})?;
gst_debug!(CAT, obj: element, "Configuring for caps {}", caps);
gst::debug!(CAT, obj: element, "Configuring for caps {}", caps);
element.set_blocksize(info.bpf() * (*self.settings.lock().unwrap()).samples_per_buffer);
@ -586,7 +585,7 @@ Now that this is done, we need to implement the `PushSrc::create` virtual meth
// point but at most samples_per_buffer samples per buffer
let n_samples = if let Some(sample_stop) = state.sample_stop {
if sample_stop <= state.sample_offset {
gst_log!(CAT, obj: element, "At EOS");
gst::log!(CAT, obj: element, "At EOS");
return Err(gst::FlowReturn::Eos);
}
@ -645,7 +644,7 @@ Now that this is done, we need to implement the `PushSrc::create` virtual meth
state.sample_offset += n_samples;
drop(state);
gst_debug!(CAT, obj: element, "Produced buffer {:?}", buffer);
gst::debug!(CAT, obj: element, "Produced buffer {:?}", buffer);
Ok(buffer)
}
@ -712,7 +711,7 @@ For working in live mode, we have to add a few different parts in various places
let id = clock.new_single_shot_id(wait_until);
gst_log!(
gst::log!(
CAT,
obj: element,
"Waiting until {}, now {}",
@ -720,7 +719,7 @@ For working in live mode, we have to add a few different parts in various places
clock.get_time().display(),
);
let (res, jitter) = id.wait();
gst_log!(
gst::log!(
CAT,
obj: element,
"Waited res {:?} jitter {}",
@ -729,7 +728,7 @@ For working in live mode, we have to add a few different parts in various places
);
}
gst_debug!(CAT, obj: element, "Produced buffer {:?}", buffer);
gst::debug!(CAT, obj: element, "Produced buffer {:?}", buffer);
Ok(buffer)
}
@ -783,7 +782,7 @@ This querying is done with the `LATENCY` query, which we will have to handle i
let latency = gst::ClockTime::SECOND
.mul_div_floor(settings.samples_per_buffer as u64, info.rate() as u64)
.unwrap();
gst_debug!(CAT, obj: element, "Returning latency {}", latency);
gst::debug!(CAT, obj: element, "Returning latency {}", latency);
q.set(settings.is_live, latency, gst::ClockTime::NONE);
true
} else {
@ -837,7 +836,7 @@ struct SineSrc {
fn unlock(&self, element: &Self::Type) -> bool {
// This should unblock the create() function ASAP, so we
// just unschedule the clock it here, if any.
gst_debug!(CAT, obj: element, "Unlocking");
gst::debug!(CAT, obj: element, "Unlocking");
let mut clock_wait = self.clock_wait.lock().unwrap();
if let Some(clock_id) = clock_wait.clock_id.take() {
clock_id.unschedule();
@ -856,7 +855,7 @@ Once everything is unlocked, we need to reset things again so that data flow can
fn unlock_stop(&self, element: &Self::Type) -> bool {
// This signals that unlocking is done, so we can reset
// all values again.
gst_debug!(CAT, obj: element, "Unlock stop");
gst::debug!(CAT, obj: element, "Unlock stop");
let mut clock_wait = self.clock_wait.lock().unwrap();
clock_wait.flushing = false;
@ -874,7 +873,7 @@ Now as a last step, we need to actually make use of the new struct we added arou
// so that we immediately stop waiting on e.g. shutdown.
let mut clock_wait = self.clock_wait.lock().unwrap();
if clock_wait.flushing {
gst_debug!(CAT, obj: element, "Flushing");
gst::debug!(CAT, obj: element, "Flushing");
return Err(gst::FlowReturn::Flushing);
}
@ -882,7 +881,7 @@ Now as a last step, we need to actually make use of the new struct we added arou
clock_wait.clock_id = Some(id.clone());
drop(clock_wait);
gst_log!(
gst::log!(
CAT,
obj: element,
"Waiting until {}, now {}",
@ -890,7 +889,7 @@ Now as a last step, we need to actually make use of the new struct we added arou
clock.get_time().display(),
);
let (res, jitter) = id.wait();
gst_log!(
gst::log!(
CAT,
obj: element,
"Waited res {:?} jitter {}",
@ -902,7 +901,7 @@ Now as a last step, we need to actually make use of the new struct we added arou
// If the clock ID was unscheduled, unlock() was called
// and we should return Flushing immediately.
if res == gst::ClockReturn::Unscheduled {
gst_debug!(CAT, obj: element, "Flushing");
gst::debug!(CAT, obj: element, "Flushing");
return Err(gst::FlowReturn::Flushing);
}
```
@ -931,7 +930,7 @@ Seeking is implemented in the `BaseSrc::do_seek` virtual method, and signallin
// and for calculating the timestamps, etc.
if segment.get_rate() < 0.0 {
gst_error!(CAT, obj: element, "Reverse playback not supported");
gst::error!(CAT, obj: element, "Reverse playback not supported");
return false;
}
@ -962,7 +961,7 @@ Seeking is implemented in the `BaseSrc::do_seek` virtual method, and signallin
let accumulator =
(sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64));
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Seeked to {}-{:?} (accum: {}) for segment {:?}",
@ -984,7 +983,7 @@ Seeking is implemented in the `BaseSrc::do_seek` virtual method, and signallin
use std::f64::consts::PI;
if state.info.is_none() {
gst_error!(
gst::error!(
CAT,
obj: element,
"Can only seek in Default format if sample rate is known"
@ -998,7 +997,7 @@ Seeking is implemented in the `BaseSrc::do_seek` virtual method, and signallin
let accumulator =
(sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64));
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Seeked to {}-{:?} (accum: {}) for segment {:?}",
@ -1017,7 +1016,7 @@ Seeking is implemented in the `BaseSrc::do_seek` virtual method, and signallin
true
} else {
gst_error!(
gst::error!(
CAT,
obj: element,
"Can't seek in format {:?}",

17
utils/fallbackswitch/src/fallbacksrc/custom_source/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error};
use std::{mem, sync::Mutex};
@ -167,7 +166,7 @@ impl CustomSource {
&self,
element: &super::CustomSource,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
let source = self.source.get().unwrap();
let templates = source.pad_template_list();
@ -176,7 +175,7 @@ impl CustomSource {
.iter()
.any(|templ| templ.presence() == gst::PadPresence::Request)
{
gst_error!(CAT, obj: element, "Request pads not supported");
gst::error!(CAT, obj: element, "Request pads not supported");
gst::element_error!(
element,
gst::LibraryError::Settings,
@ -200,7 +199,7 @@ impl CustomSource {
if !has_sometimes_pads {
self.handle_source_no_more_pads(element);
} else {
gst_debug!(CAT, obj: element, "Found sometimes pads");
gst::debug!(CAT, obj: element, "Found sometimes pads");
let element_weak = element.downgrade();
source.connect_pad_added(move |_, pad| {
@ -245,7 +244,7 @@ impl CustomSource {
element: &super::CustomSource,
pad: &gst::Pad,
) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Source added pad {}", pad.name());
gst::debug!(CAT, obj: element, "Source added pad {}", pad.name());
let mut state = self.state.lock().unwrap();
@ -261,7 +260,7 @@ impl CustomSource {
let caps = match pad.current_caps().unwrap_or_else(|| pad.query_caps(None)) {
caps if !caps.is_any() && !caps.is_empty() => caps,
_ => {
gst_error!(CAT, obj: element, "Pad {} had no caps", pad.name());
gst::error!(CAT, obj: element, "Pad {} had no caps", pad.name());
return Err(gst::error_msg!(
gst::CoreError::Negotiation,
["Pad had no caps"]
@ -312,7 +311,7 @@ impl CustomSource {
}
fn handle_source_pad_removed(&self, element: &super::CustomSource, pad: &gst::Pad) {
gst_debug!(CAT, obj: element, "Source removed pad {}", pad.name());
gst::debug!(CAT, obj: element, "Source removed pad {}", pad.name());
let mut state = self.state.lock().unwrap();
let (i, stream) = match state
@ -335,7 +334,7 @@ impl CustomSource {
}
fn handle_source_no_more_pads(&self, element: &super::CustomSource) {
gst_debug!(CAT, obj: element, "Source signalled no-more-pads");
gst::debug!(CAT, obj: element, "Source signalled no-more-pads");
let state = self.state.lock().unwrap();
let streams = state
@ -358,7 +357,7 @@ impl CustomSource {
}
fn stop(&self, element: &super::CustomSource) {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
let mut state = self.state.lock().unwrap();
let pads = mem::take(&mut state.pads);

169
utils/fallbackswitch/src/fallbacksrc/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_warning};
use std::mem;
use std::sync::Mutex;
@ -319,7 +318,7 @@ impl ObjectImpl for FallbackSrc {
"enable-audio" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing enable-audio from {:?} to {:?}",
@ -331,7 +330,7 @@ impl ObjectImpl for FallbackSrc {
"enable-video" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing enable-video from {:?} to {:?}",
@ -343,7 +342,7 @@ impl ObjectImpl for FallbackSrc {
"uri" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing URI from {:?} to {:?}",
@ -355,7 +354,7 @@ impl ObjectImpl for FallbackSrc {
"source" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing source from {:?} to {:?}",
@ -367,7 +366,7 @@ impl ObjectImpl for FallbackSrc {
"fallback-uri" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing Fallback URI from {:?} to {:?}",
@ -379,7 +378,7 @@ impl ObjectImpl for FallbackSrc {
"timeout" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing timeout from {:?} to {:?}",
@ -391,7 +390,7 @@ impl ObjectImpl for FallbackSrc {
"restart-timeout" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing Restart Timeout from {:?} to {:?}",
@ -403,7 +402,7 @@ impl ObjectImpl for FallbackSrc {
"retry-timeout" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing Retry Timeout from {:?} to {:?}",
@ -415,7 +414,7 @@ impl ObjectImpl for FallbackSrc {
"restart-on-eos" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing restart-on-eos from {:?} to {:?}",
@ -427,7 +426,7 @@ impl ObjectImpl for FallbackSrc {
"min-latency" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing Minimum Latency from {:?} to {:?}",
@ -439,7 +438,7 @@ impl ObjectImpl for FallbackSrc {
"buffer-duration" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing Buffer Duration from {:?} to {:?}",
@ -451,7 +450,7 @@ impl ObjectImpl for FallbackSrc {
"immediate-fallback" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing immediate-fallback from {:?} to {:?}",
@ -463,7 +462,7 @@ impl ObjectImpl for FallbackSrc {
"manual-unblock" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing manual-unblock from {:?} to {:?}",
@ -729,7 +728,7 @@ impl ElementImpl for FallbackSrc {
fn send_event(&self, _element: &Self::Type, event: gst::Event) -> bool {
match event.view() {
gst::EventView::Eos(..) => {
gst_debug!(CAT, "Handling element-level EOS, forwarding to all streams");
gst::debug!(CAT, "Handling element-level EOS, forwarding to all streams");
let mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard {
@ -984,7 +983,7 @@ impl FallbackSrc {
}
fn start(&self, element: &super::FallbackSrc) -> Result<(), gst::StateChangeError> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
let mut state_guard = self.state.lock().unwrap();
if state_guard.is_some() {
return Err(gst::StateChangeError);
@ -1000,7 +999,7 @@ impl FallbackSrc {
{
Some(source) => source,
None => {
gst_error!(CAT, obj: element, "No URI or source element configured");
gst::error!(CAT, obj: element, "No URI or source element configured");
gst::element_error!(
element,
gst::LibraryError::Settings,
@ -1077,12 +1076,12 @@ impl FallbackSrc {
element.notify("status");
gst_debug!(CAT, obj: element, "Started");
gst::debug!(CAT, obj: element, "Started");
Ok(())
}
fn stop(&self, element: &super::FallbackSrc) {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
let mut state_guard = self.state.lock().unwrap();
let mut state = match state_guard.take() {
Some(state) => state,
@ -1134,11 +1133,11 @@ impl FallbackSrc {
timeout.unschedule();
}
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
}
fn change_source_state(&self, element: &super::FallbackSrc, transition: gst::StateChange) {
gst_debug!(CAT, obj: element, "Changing source state: {:?}", transition);
gst::debug!(CAT, obj: element, "Changing source state: {:?}", transition);
let mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard {
Some(state) => state,
@ -1146,14 +1145,14 @@ impl FallbackSrc {
};
if transition.current() <= transition.next() && state.source_pending_restart {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Not starting source because pending restart"
);
return;
} else if transition.next() <= gst::State::Ready && state.source_pending_restart {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Unsetting pending restart because shutting down"
@ -1171,7 +1170,7 @@ impl FallbackSrc {
let res = source.set_state(transition.next());
match res {
Err(_) => {
gst_error!(CAT, obj: element, "Source failed to change state");
gst::error!(CAT, obj: element, "Source failed to change state");
// Try again later if we're not shutting down
if transition != gst::StateChange::ReadyToNull {
let _ = source.set_state(gst::State::Null);
@ -1183,7 +1182,7 @@ impl FallbackSrc {
}
}
Ok(res) => {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Source changed state successfully: {:?}",
@ -1231,7 +1230,7 @@ impl FallbackSrc {
element: &super::FallbackSrc,
pad: &gst::Pad,
) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Pad {} added to source", pad.name(),);
gst::debug!(CAT, obj: element, "Pad {} added to source", pad.name(),);
let mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard {
@ -1297,14 +1296,14 @@ impl FallbackSrc {
let stream = match stream {
None => {
gst_debug!(CAT, obj: element, "No {} stream enabled", type_);
gst::debug!(CAT, obj: element, "No {} stream enabled", type_);
return Ok(());
}
Some(Stream {
source_srcpad: Some(_),
..
}) => {
gst_debug!(CAT, obj: element, "Already configured a {} stream", type_);
gst::debug!(CAT, obj: element, "Already configured a {} stream", type_);
return Ok(());
}
Some(ref mut stream) => stream,
@ -1314,11 +1313,11 @@ impl FallbackSrc {
let imagefreeze =
gst::ElementFactory::make("imagefreeze", None).expect("no imagefreeze found");
gst_debug!(CAT, "image stream, inserting imagefreeze");
gst::debug!(CAT, "image stream, inserting imagefreeze");
element.add(&imagefreeze).unwrap();
imagefreeze.set_property("is-live", true);
if imagefreeze.sync_state_with_parent().is_err() {
gst_error!(CAT, obj: element, "imagefreeze failed to change state",);
gst::error!(CAT, obj: element, "imagefreeze failed to change state",);
return Err(gst::error_msg!(
gst::CoreError::StateChange,
["Failed to change imagefreeze state"]
@ -1331,7 +1330,7 @@ impl FallbackSrc {
};
pad.link(&sinkpad).map_err(|err| {
gst_error!(
gst::error!(
CAT,
obj: element,
"Failed to link source pad to clocksync: {}",
@ -1354,7 +1353,7 @@ impl FallbackSrc {
match info.data {
Some(gst::PadProbeData::Event(ref ev)) if ev.type_() == gst::EventType::Eos => {
gst_debug!(
gst::debug!(
CAT,
obj: &element,
"Received EOS from source on pad {}",
@ -1418,7 +1417,7 @@ impl FallbackSrc {
// a workaround until
// https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/-/issues/800
// is fixed.
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Adding probe to pad {}",
@ -1488,7 +1487,7 @@ impl FallbackSrc {
.as_mut()
.filter(|s| &s.clocksync_queue_srcpad == pad)
{
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Called probe on pad {}",
@ -1500,7 +1499,7 @@ impl FallbackSrc {
.as_mut()
.filter(|s| &s.clocksync_queue_srcpad == pad)
{
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Called probe on pad {}",
@ -1524,7 +1523,7 @@ impl FallbackSrc {
}
})
{
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Removing pad probe for pad {}",
@ -1533,7 +1532,7 @@ impl FallbackSrc {
block.pad.remove_probe(block.probe_id);
}
gst_debug!(CAT, obj: element, "Live source, unblocking directly");
gst::debug!(CAT, obj: element, "Live source, unblocking directly");
drop(state_guard);
element.notify("status");
@ -1550,13 +1549,13 @@ impl FallbackSrc {
let segment = match pad.sticky_event::<gst::event::Segment>(0) {
Some(ev) => ev.segment().clone(),
None => {
gst_warning!(CAT, obj: element, "Have no segment event yet");
gst::warning!(CAT, obj: element, "Have no segment event yet");
return Ok(());
}
};
let segment = segment.downcast::<gst::ClockTime>().map_err(|_| {
gst_error!(CAT, obj: element, "Have no time segment");
gst::error!(CAT, obj: element, "Have no time segment");
gst::error_msg!(gst::CoreError::Clock, ["Have no time segment"])
})?;
@ -1571,7 +1570,7 @@ impl FallbackSrc {
segment.to_running_time(pts)
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Have block running time {}",
@ -1590,14 +1589,14 @@ impl FallbackSrc {
fn unblock_pads(&self, element: &super::FallbackSrc, state: &mut State) {
if state.manually_blocked {
gst_debug!(CAT, obj: element, "Not unblocking yet: manual unblock",);
gst::debug!(CAT, obj: element, "Not unblocking yet: manual unblock",);
return;
}
// Check if all streams are blocked and have a running time and we have
// 100% buffering
if state.stats.buffering_percent < 100 {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Not unblocking yet: buffering {}%",
@ -1608,7 +1607,7 @@ impl FallbackSrc {
let streams = match state.streams {
None => {
gst_debug!(CAT, obj: element, "Have no stream collection yet");
gst::debug!(CAT, obj: element, "Have no stream collection yet");
return;
}
Some(ref streams) => streams,
@ -1660,7 +1659,7 @@ impl FallbackSrc {
let current_running_time = match element.current_running_time() {
Some(current_running_time) => current_running_time,
None => {
gst_debug!(CAT, obj: element, "Waiting for current_running_time");
gst::debug!(CAT, obj: element, "Waiting for current_running_time");
return;
}
};
@ -1671,17 +1670,17 @@ impl FallbackSrc {
&& video_running_time.is_none()
&& !video_is_eos
{
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Waiting for audio and video pads to block"
);
return;
} else if audio_running_time.is_none() && !audio_is_eos {
gst_debug!(CAT, obj: element, "Waiting for audio pad to block");
gst::debug!(CAT, obj: element, "Waiting for audio pad to block");
return;
} else if video_running_time.is_none() && !video_is_eos {
gst_debug!(CAT, obj: element, "Waiting for video pad to block");
gst::debug!(CAT, obj: element, "Waiting for video pad to block");
return;
}
@ -1702,7 +1701,7 @@ impl FallbackSrc {
-((min_running_time - current_running_time).nseconds() as i64)
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Unblocking at {} with pad offset {} (audio: {} eos {}, video {} eos {})",
@ -1739,7 +1738,7 @@ impl FallbackSrc {
let audio_running_time = match audio_running_time {
Some(audio_running_time) => audio_running_time,
None => {
gst_debug!(CAT, obj: element, "Waiting for audio pad to block");
gst::debug!(CAT, obj: element, "Waiting for audio pad to block");
return;
}
};
@ -1750,7 +1749,7 @@ impl FallbackSrc {
-((audio_running_time - current_running_time).nseconds() as i64)
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Unblocking at {} with pad offset {} (audio: {} eos {})",
@ -1774,7 +1773,7 @@ impl FallbackSrc {
let video_running_time = match video_running_time {
Some(video_running_time) => video_running_time,
None => {
gst_debug!(CAT, obj: element, "Waiting for video pad to block");
gst::debug!(CAT, obj: element, "Waiting for video pad to block");
return;
}
};
@ -1785,7 +1784,7 @@ impl FallbackSrc {
-((video_running_time - current_running_time).nseconds() as i64)
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Unblocking at {} with pad offset {} (video: {} eos {})",
@ -1809,7 +1808,7 @@ impl FallbackSrc {
}
fn handle_source_pad_removed(&self, element: &super::FallbackSrc, pad: &gst::Pad) {
gst_debug!(CAT, obj: element, "Pad {} removed from source", pad.name());
gst::debug!(CAT, obj: element, "Pad {} removed from source", pad.name());
let mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard {
@ -1856,11 +1855,11 @@ impl FallbackSrc {
};
if state.source_pending_restart {
gst_debug!(CAT, obj: element, "Has pending restart");
gst::debug!(CAT, obj: element, "Has pending restart");
return;
}
gst_debug!(CAT, obj: element, "Got buffering {}%", m.percent());
gst::debug!(CAT, obj: element, "Got buffering {}%", m.percent());
state.stats.buffering_percent = m.percent();
if state.stats.buffering_percent < 100 {
@ -1901,7 +1900,7 @@ impl FallbackSrc {
let streams = m.stream_collection();
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Got stream collection {:?}",
@ -1916,7 +1915,7 @@ impl FallbackSrc {
}
if !have_audio && state.settings.enable_audio {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Have no audio streams but audio is enabled"
@ -1924,7 +1923,7 @@ impl FallbackSrc {
}
if !have_video && state.settings.enable_video {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Have no video streams but video is enabled"
@ -1964,7 +1963,7 @@ impl FallbackSrc {
Some(src) => src,
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Got error message from {}",
@ -1985,7 +1984,7 @@ impl FallbackSrc {
if src == video_stream.fallback_input
|| src.has_as_ancestor(&video_stream.fallback_input)
{
gst_debug!(CAT, obj: element, "Got error from video fallback input");
gst::debug!(CAT, obj: element, "Got error from video fallback input");
let prev_fallback_uri = video_stream
.fallback_input
@ -2009,7 +2008,7 @@ impl FallbackSrc {
}
}
gst_error!(
gst::error!(
CAT,
obj: element,
"Give up for error message from {}",
@ -2025,11 +2024,11 @@ impl FallbackSrc {
state: &mut State,
reason: RetryReason,
) {
gst_debug!(CAT, obj: element, "Handling source error: {:?}", reason);
gst::debug!(CAT, obj: element, "Handling source error: {:?}", reason);
state.stats.last_retry_reason = reason;
if state.source_pending_restart {
gst_debug!(CAT, obj: element, "Source is already pending restart");
gst::debug!(CAT, obj: element, "Source is already pending restart");
return;
}
@ -2082,7 +2081,7 @@ impl FallbackSrc {
source_pending_restart: false,
..
}) => {
gst_debug!(CAT, obj: element, "Restarting source not needed anymore");
gst::debug!(CAT, obj: element, "Restarting source not needed anymore");
return;
}
Some(state) => state,
@ -2098,7 +2097,7 @@ impl FallbackSrc {
}
})
{
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Removing pad probe for pad {}",
@ -2108,7 +2107,7 @@ impl FallbackSrc {
}
drop(state_guard);
gst_debug!(CAT, obj: element, "Shutting down source");
gst::debug!(CAT, obj: element, "Shutting down source");
let _ = source.set_state(gst::State::Null);
// Sleep for 1s before retrying
@ -2120,7 +2119,7 @@ impl FallbackSrc {
source_pending_restart: false,
..
}) => {
gst_debug!(CAT, obj: element, "Restarting source not needed anymore");
gst::debug!(CAT, obj: element, "Restarting source not needed anymore");
return;
}
Some(state) => state,
@ -2134,7 +2133,7 @@ impl FallbackSrc {
stream.source_srcpad = None;
}
gst_debug!(CAT, obj: element, "Waiting for 1s before retrying");
gst::debug!(CAT, obj: element, "Waiting for 1s before retrying");
let clock = gst::SystemClock::obtain();
let wait_time = clock.time().unwrap() + gst::ClockTime::SECOND;
assert!(state.source_pending_restart_timeout.is_none());
@ -2148,7 +2147,7 @@ impl FallbackSrc {
Some(element) => element,
};
gst_debug!(CAT, obj: &element, "Woke up, retrying");
gst::debug!(CAT, obj: &element, "Woke up, retrying");
element.call_async(|element| {
let src = element.imp();
@ -2159,7 +2158,7 @@ impl FallbackSrc {
source_pending_restart: false,
..
}) => {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Restarting source not needed anymore"
@ -2195,7 +2194,7 @@ impl FallbackSrc {
state.last_buffering_update = None;
if let Some(timeout) = state.source_restart_timeout.take() {
gst_debug!(CAT, obj: element, "Unscheduling restart timeout");
gst::debug!(CAT, obj: element, "Unscheduling restart timeout");
timeout.unschedule();
}
drop(state_guard);
@ -2207,7 +2206,7 @@ impl FallbackSrc {
}
if source.sync_state_with_parent().is_err() {
gst_error!(CAT, obj: element, "Source failed to change state");
gst::error!(CAT, obj: element, "Source failed to change state");
let _ = source.set_state(gst::State::Null);
let mut state_guard = src.state.lock().unwrap();
let state = state_guard.as_mut().expect("no state");
@ -2243,7 +2242,7 @@ impl FallbackSrc {
elapsed: gst::ClockTime,
) {
if state.source_pending_restart {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Not scheduling source restart timeout because source is pending restart already",
@ -2252,7 +2251,7 @@ impl FallbackSrc {
}
if state.is_image {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Not scheduling source restart timeout because we are playing back an image",
@ -2261,7 +2260,7 @@ impl FallbackSrc {
}
if state.manually_blocked {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Not scheduling source restart timeout because we are manually blocked",
@ -2271,7 +2270,7 @@ impl FallbackSrc {
let clock = gst::SystemClock::obtain();
let wait_time = clock.time().unwrap() + state.settings.restart_timeout - elapsed;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Scheduling source restart timeout for {}",
@ -2290,11 +2289,11 @@ impl FallbackSrc {
element.call_async(move |element| {
let src = element.imp();
gst_debug!(CAT, obj: element, "Source restart timeout triggered");
gst::debug!(CAT, obj: element, "Source restart timeout triggered");
let mut state_guard = src.state.lock().unwrap();
let state = match &mut *state_guard {
None => {
gst_debug!(CAT, obj: element, "Restarting source not needed anymore");
gst::debug!(CAT, obj: element, "Restarting source not needed anymore");
return;
}
Some(state) => state,
@ -2310,13 +2309,13 @@ impl FallbackSrc {
.map(|i| i.elapsed() >= state.settings.restart_timeout.into())
.unwrap_or(state.stats.buffering_percent == 100)
{
gst_debug!(CAT, obj: element, "Not buffering, restarting source");
gst::debug!(CAT, obj: element, "Not buffering, restarting source");
src.handle_source_error(element, state, RetryReason::Timeout);
drop(state_guard);
element.notify("statistics");
} else {
gst_debug!(CAT, obj: element, "Buffering, restarting source later");
gst::debug!(CAT, obj: element, "Buffering, restarting source later");
let elapsed = state
.last_buffering_update
.and_then(|last_buffering_update| {
@ -2327,7 +2326,7 @@ impl FallbackSrc {
src.schedule_source_restart_timeout(element, state, elapsed);
}
} else {
gst_debug!(CAT, obj: element, "Restarting source not needed anymore");
gst::debug!(CAT, obj: element, "Restarting source not needed anymore");
}
});
})
@ -2380,19 +2379,19 @@ impl FallbackSrc {
// If we have the fallback activated then start the retry timeout unless it was started
// already. Otherwise cancel the retry timeout.
if self.have_fallback_activated(element, state) {
gst_warning!(CAT, obj: element, "Switched to fallback stream");
gst::warning!(CAT, obj: element, "Switched to fallback stream");
if state.source_restart_timeout.is_none() {
self.schedule_source_restart_timeout(element, state, gst::ClockTime::ZERO);
}
} else {
gst_debug!(CAT, obj: element, "Switched to main stream");
gst::debug!(CAT, obj: element, "Switched to main stream");
if let Some(timeout) = state.source_retry_timeout.take() {
gst_debug!(CAT, obj: element, "Unscheduling retry timeout");
gst::debug!(CAT, obj: element, "Unscheduling retry timeout");
timeout.unschedule();
}
if let Some(timeout) = state.source_restart_timeout.take() {
gst_debug!(CAT, obj: element, "Unscheduling restart timeout");
gst::debug!(CAT, obj: element, "Unscheduling restart timeout");
timeout.unschedule();
}
}

31
utils/fallbackswitch/src/fallbacksrc/video_fallback/imp.rs
View file

@ -10,7 +10,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_warning};
use std::sync::{atomic::AtomicBool, atomic::Ordering, Mutex};
@ -107,7 +106,7 @@ impl ObjectImpl for VideoFallbackSource {
"uri" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing URI from {:?} to {:?}",
@ -119,7 +118,7 @@ impl ObjectImpl for VideoFallbackSource {
"min-latency" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing Minimum Latency from {} to {}",
@ -212,13 +211,13 @@ impl BinImpl for VideoFallbackSource {
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
.is_err()
{
gst_warning!(CAT, obj: bin, "Got error {:?}", err);
gst::warning!(CAT, obj: bin, "Got error {:?}", err);
self.parent_handle_message(bin, msg)
} else {
// Suppress error message if we posted error previously.
// Otherwise parent fallbacksrc would be confused by
// multiple error message.
gst_debug!(CAT, obj: bin, "Ignore error {:?}", err);
gst::debug!(CAT, obj: bin, "Ignore error {:?}", err);
}
}
_ => self.parent_handle_message(bin, msg),
@ -243,12 +242,12 @@ impl VideoFallbackSource {
.unwrap()
.set_uri(uri)
{
gst_warning!(CAT, obj: element, "Failed to set URI: {}", err);
gst::warning!(CAT, obj: element, "Failed to set URI: {}", err);
return None;
}
if filesrc.set_state(gst::State::Ready).is_err() {
gst_warning!(CAT, obj: element, "Couldn't set state READY");
gst::warning!(CAT, obj: element, "Couldn't set state READY");
let _ = filesrc.set_state(gst::State::Null);
return None;
}
@ -258,7 +257,7 @@ impl VideoFallbackSource {
// via open() and fstat() in there.
let pad = filesrc.static_pad("src").unwrap();
if pad.set_active(true).is_err() {
gst_warning!(CAT, obj: element, "Couldn't active pad");
gst::warning!(CAT, obj: element, "Couldn't active pad");
let _ = filesrc.set_state(gst::State::Null);
return None;
}
@ -272,7 +271,7 @@ impl VideoFallbackSource {
min_latency: gst::ClockTime,
uri: Option<&str>,
) -> gst::Element {
gst_debug!(CAT, obj: element, "Creating source with uri {:?}", uri);
gst::debug!(CAT, obj: element, "Creating source with uri {:?}", uri);
let source = gst::Bin::new(None);
let filesrc = self.file_src_for_uri(element, uri);
@ -331,7 +330,7 @@ impl VideoFallbackSource {
.unwrap();
if imagefreeze.try_set_property("is-live", true).is_err() {
gst_error!(
gst::error!(
CAT,
obj: element,
"imagefreeze does not support live mode, this will probably misbehave"
@ -375,7 +374,7 @@ impl VideoFallbackSource {
decoder = gst::ElementFactory::make("pngdec", Some("decoder"))
.expect("pngdec not found");
} else {
gst_error!(CAT, obj: &element, "Unsupported caps {}", caps);
gst::error!(CAT, obj: &element, "Unsupported caps {}", caps);
gst::element_error!(
element,
gst::StreamError::Format,
@ -389,7 +388,7 @@ impl VideoFallbackSource {
if let Err(_err) =
gst::Element::link_many(&[&typefind, &decoder, &videoconvert])
{
gst_error!(CAT, obj: &element, "Can't link fallback image decoder");
gst::error!(CAT, obj: &element, "Can't link fallback image decoder");
gst::element_error!(
element,
gst::StreamError::Format,
@ -431,11 +430,11 @@ impl VideoFallbackSource {
&self,
element: &super::VideoFallbackSource,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
let mut state_guard = self.state.lock().unwrap();
if state_guard.is_some() {
gst_error!(CAT, obj: element, "State struct wasn't cleared");
gst::error!(CAT, obj: element, "State struct wasn't cleared");
return Err(gst::StateChangeError);
}
@ -454,7 +453,7 @@ impl VideoFallbackSource {
}
fn stop(&self, element: &super::VideoFallbackSource) {
gst_debug!(CAT, obj: element, "Stopping");
gst::debug!(CAT, obj: element, "Stopping");
let mut state_guard = self.state.lock().unwrap();
let state = match state_guard.take() {
@ -468,6 +467,6 @@ impl VideoFallbackSource {
let _ = self.srcpad.set_target(None::<&gst::Pad>);
element.remove(&state.source).unwrap();
self.got_error.store(false, Ordering::Relaxed);
gst_debug!(CAT, obj: element, "Stopped");
gst::debug!(CAT, obj: element, "Stopped");
}
}

88
utils/fallbackswitch/src/fallbackswitch/imp.rs
View file

@ -11,8 +11,6 @@ use gst::glib;
use gst_base::prelude::*;
use gst_base::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log, gst_warning};
use once_cell::sync::Lazy;
use std::sync::{Mutex, RwLock};
@ -179,7 +177,7 @@ impl FallbackSwitch {
}
let segment = segment.downcast::<gst::ClockTime>().map_err(|_| {
gst_error!(CAT, obj: pad, "Only TIME segments supported");
gst::error!(CAT, obj: pad, "Only TIME segments supported");
gst::FlowError::Error
})?;
@ -194,7 +192,7 @@ impl FallbackSwitch {
.opt_le(target_running_time.into())
.unwrap_or(false)
{
gst_debug!(CAT, obj: pad, "Dropping trailing buffer {:?}", buffer);
gst::debug!(CAT, obj: pad, "Dropping trailing buffer {:?}", buffer);
pad.drop_buffer();
running_time = new_running_time;
} else {
@ -223,7 +221,7 @@ impl FallbackSwitch {
cur_running_time: impl Into<Option<gst::ClockTime>>,
) -> Result<Option<(gst::Buffer, gst::Caps, bool)>, gst::FlowError> {
// If we got a buffer on the sinkpad just handle it
gst_debug!(
gst::debug!(
CAT,
obj: preferred_pad,
"Got buffer on pad {} - {:?}",
@ -232,7 +230,7 @@ impl FallbackSwitch {
);
if buffer.pts().is_none() {
gst_error!(CAT, obj: preferred_pad, "Only buffers with PTS supported");
gst::error!(CAT, obj: preferred_pad, "Only buffers with PTS supported");
return Err(gst::FlowError::Error);
}
@ -240,7 +238,7 @@ impl FallbackSwitch {
.segment()
.downcast::<gst::ClockTime>()
.map_err(|_| {
gst_error!(CAT, obj: preferred_pad, "Only TIME segments supported");
gst::error!(CAT, obj: preferred_pad, "Only TIME segments supported");
gst::FlowError::Error
})?;
@ -269,7 +267,7 @@ impl FallbackSwitch {
};
if is_late {
gst_debug!(
gst::debug!(
CAT,
obj: preferred_pad,
"Buffer is too late: {} > {}",
@ -285,7 +283,7 @@ impl FallbackSwitch {
if let Some(true) = is_late {
/* This buffer arrived too late - we either already switched
* to the other pad or there's no point outputting this anyway */
gst_debug!(
gst::debug!(
CAT,
obj: preferred_pad,
"Buffer is too late and timeout reached: {} + {} <= {}",
@ -304,7 +302,7 @@ impl FallbackSwitch {
if pad_change {
if buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) {
gst_info!(
gst::info!(
CAT,
obj: preferred_pad,
"Can't change back to sinkpad {}, waiting for keyframe",
@ -318,7 +316,7 @@ impl FallbackSwitch {
return Ok(None);
}
gst_info!(CAT, obj: preferred_pad, "Active pad changed to sinkpad");
gst::info!(CAT, obj: preferred_pad, "Active pad changed to sinkpad");
*active_sinkpad = Some(preferred_pad.clone().upcast());
}
drop(active_sinkpad);
@ -356,7 +354,7 @@ impl FallbackSwitch {
.pop_buffer()
.ok_or(gst_base::AGGREGATOR_FLOW_NEED_DATA)?;
gst_debug!(
gst::debug!(
CAT,
obj: backup_pad,
"Got buffer on fallback sinkpad {:?}",
@ -364,7 +362,7 @@ impl FallbackSwitch {
);
if buffer.pts().is_none() {
gst_error!(CAT, obj: backup_pad, "Only buffers with PTS supported");
gst::error!(CAT, obj: backup_pad, "Only buffers with PTS supported");
return Err(gst::FlowError::Error);
}
@ -373,7 +371,7 @@ impl FallbackSwitch {
.segment()
.downcast::<gst::ClockTime>()
.map_err(|_| {
gst_error!(CAT, obj: backup_pad, "Only TIME segments supported");
gst::error!(CAT, obj: backup_pad, "Only TIME segments supported");
gst::FlowError::Error
})?;
let running_time = backup_segment.to_running_time(buffer.dts_or_pts());
@ -413,7 +411,7 @@ impl FallbackSwitch {
// Get the next one if this one is before the timeout
if !timed_out {
gst_debug!(
gst::debug!(
CAT,
obj: backup_pad,
"Timeout not reached yet: {} + {} > {}",
@ -423,7 +421,7 @@ impl FallbackSwitch {
);
continue;
}
gst_debug!(
gst::debug!(
CAT,
obj: backup_pad,
"Timeout reached: {} + {} <= {}",
@ -432,7 +430,7 @@ impl FallbackSwitch {
running_time.display(),
);
} else {
gst_debug!(
gst::debug!(
CAT,
obj: backup_pad,
"Consuming buffer as we haven't yet received a buffer on the other pad",
@ -444,7 +442,7 @@ impl FallbackSwitch {
&& active_sinkpad.as_ref() != Some(backup_pad.upcast_ref::<gst::Pad>());
if pad_change {
if buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) {
gst_info!(
gst::info!(
CAT,
obj: backup_pad,
"Can't change to sinkpad {} yet, waiting for keyframe",
@ -458,7 +456,7 @@ impl FallbackSwitch {
continue;
}
gst_info!(
gst::info!(
CAT,
obj: backup_pad,
"Active pad changed to fallback sinkpad"
@ -501,10 +499,10 @@ impl FallbackSwitch {
let settings = self.settings.lock().unwrap().clone();
let mut state = self.output_state.lock().unwrap();
gst_debug!(CAT, obj: agg, "Aggregate called: timeout {}", timeout);
gst::debug!(CAT, obj: agg, "Aggregate called: timeout {}", timeout);
if self.primary_sinkpad.is_eos() {
gst_log!(CAT, obj: agg, "Sinkpad is EOS");
gst::log!(CAT, obj: agg, "Sinkpad is EOS");
return (Err(gst::FlowError::Eos), (false, false));
}
@ -575,7 +573,7 @@ impl FallbackSwitch {
/* If we can't auto-switch, then can't fetch anything from the backup pad */
if !settings.auto_switch {
/* Not switching, but backup pad needs draining of late buffers still */
gst_log!(
gst::log!(
CAT,
obj: agg,
"No primary buffer, but can't autoswitch - draining backup pad"
@ -606,7 +604,7 @@ impl FallbackSwitch {
}
if let (false, Some(backup_pad)) = (timeout, &backup_pad) {
gst_debug!(CAT, obj: agg, "Have fallback sinkpad but no timeout yet");
gst::debug!(CAT, obj: agg, "Have fallback sinkpad but no timeout yet");
(
Err(gst_base::AGGREGATOR_FLOW_NEED_DATA),
state.check_health_changes(
@ -628,7 +626,7 @@ impl FallbackSwitch {
)
} else {
// Otherwise there's not much we can do at this point
gst_debug!(
gst::debug!(
CAT,
obj: agg,
"Got no buffer on sinkpad and have no fallback sinkpad"
@ -742,7 +740,7 @@ impl ObjectImpl for FallbackSwitch {
"timeout" => {
let mut settings = self.settings.lock().unwrap();
let timeout = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing timeout from {} to {}",
@ -755,7 +753,7 @@ impl ObjectImpl for FallbackSwitch {
"active-pad" => {
let settings = self.settings.lock().unwrap();
if settings.auto_switch {
gst_warning!(
gst::warning!(
CAT,
obj: obj,
"active-pad property setting ignored, because auto-switch=true"
@ -883,13 +881,13 @@ impl ElementImpl for FallbackSwitch {
if templ != &fallback_sink_templ
|| (name.is_some() && name.as_deref() != Some("fallback_sink"))
{
gst_error!(CAT, obj: element, "Wrong pad template or name");
gst::error!(CAT, obj: element, "Wrong pad template or name");
return None;
}
let mut fallback_sinkpad = self.fallback_sinkpad.write().unwrap();
if fallback_sinkpad.is_some() {
gst_error!(CAT, obj: element, "Already have a fallback sinkpad");
gst::error!(CAT, obj: element, "Already have a fallback sinkpad");
return None;
}
@ -916,7 +914,7 @@ impl ElementImpl for FallbackSwitch {
*fallback_sinkpad = None;
drop(fallback_sinkpad);
element.remove_pad(pad).unwrap();
gst_debug!(CAT, obj: element, "Removed fallback sinkpad {:?}", pad);
gst::debug!(CAT, obj: element, "Removed fallback sinkpad {:?}", pad);
}
*self.fallback_state.write().unwrap() = PadInputState::default();
*self.active_sinkpad.lock().unwrap() = None;
@ -951,7 +949,7 @@ impl AggregatorImpl for FallbackSwitch {
match event.view() {
EventView::Gap(gap) => {
if gap.gap_flags().contains(gst::GapFlags::DATA) {
gst_debug!(CAT, obj: agg_pad, "Dropping gap event");
gst::debug!(CAT, obj: agg_pad, "Dropping gap event");
Ok(gst::FlowSuccess::Ok)
} else {
self.parent_sink_event_pre_queue(agg, agg_pad, event)
@ -972,7 +970,7 @@ impl AggregatorImpl for FallbackSwitch {
match event.view() {
EventView::Caps(caps) => {
let caps = caps.caps_owned();
gst_debug!(CAT, obj: agg_pad, "Received caps {}", caps);
gst::debug!(CAT, obj: agg_pad, "Received caps {}", caps);
let audio_info;
let video_info;
@ -1035,7 +1033,7 @@ impl AggregatorImpl for FallbackSwitch {
};
if preferred_pad.peek_buffer().is_some() {
gst_debug!(
gst::debug!(
CAT,
obj: agg,
"Have buffer on sinkpad {}, immediate timeout",
@ -1043,14 +1041,14 @@ impl AggregatorImpl for FallbackSwitch {
);
Some(gst::ClockTime::ZERO)
} else if self.primary_sinkpad.is_eos() {
gst_debug!(CAT, obj: agg, "Sinkpad is EOS, immediate timeout");
gst::debug!(CAT, obj: agg, "Sinkpad is EOS, immediate timeout");
Some(gst::ClockTime::ZERO)
} else if let Some((buffer, backup_sinkpad)) = backup_pad
.as_ref()
.and_then(|p| p.peek_buffer().map(|buffer| (buffer, p)))
{
if buffer.pts().is_none() {
gst_error!(CAT, obj: agg, "Only buffers with PTS supported");
gst::error!(CAT, obj: agg, "Only buffers with PTS supported");
// Trigger aggregate immediately to error out immediately
return Some(gst::ClockTime::ZERO);
}
@ -1058,14 +1056,14 @@ impl AggregatorImpl for FallbackSwitch {
let segment = match backup_sinkpad.segment().downcast::<gst::ClockTime>() {
Ok(segment) => segment,
Err(_) => {
gst_error!(CAT, obj: agg, "Only TIME segments supported");
gst::error!(CAT, obj: agg, "Only TIME segments supported");
// Trigger aggregate immediately to error out immediately
return Some(gst::ClockTime::ZERO);
}
};
let running_time = segment.to_running_time(buffer.dts_or_pts());
gst_debug!(
gst::debug!(
CAT,
obj: agg,
"Have buffer on {} pad, timeout at {}",
@ -1074,7 +1072,7 @@ impl AggregatorImpl for FallbackSwitch {
);
running_time
} else {
gst_debug!(CAT, obj: agg, "No buffer available on either input");
gst::debug!(CAT, obj: agg, "No buffer available on either input");
gst::ClockTime::NONE
}
}
@ -1090,14 +1088,14 @@ impl AggregatorImpl for FallbackSwitch {
let segment = match agg_pad.segment().downcast::<gst::ClockTime>() {
Ok(segment) => segment,
Err(_) => {
gst_error!(CAT, obj: agg, "Only TIME segments supported");
gst::error!(CAT, obj: agg, "Only TIME segments supported");
return Some(buffer);
}
};
let pts = buffer.pts();
if pts.is_none() {
gst_error!(CAT, obj: agg, "Only buffers with PTS supported");
gst::error!(CAT, obj: agg, "Only buffers with PTS supported");
return Some(buffer);
}
@ -1137,7 +1135,7 @@ impl AggregatorImpl for FallbackSwitch {
unreachable!()
};
gst_debug!(
gst::debug!(
CAT,
obj: agg_pad,
"Clipping buffer {:?} with PTS {} and duration {}",
@ -1175,12 +1173,12 @@ impl AggregatorImpl for FallbackSwitch {
agg: &Self::Type,
timeout: bool,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_debug!(CAT, obj: agg, "Aggregate called: timeout {}", timeout);
gst::debug!(CAT, obj: agg, "Aggregate called: timeout {}", timeout);
let (res, (primary_health_change, fallback_health_change)) = self.next_buffer(agg, timeout);
if primary_health_change {
gst_debug!(
gst::debug!(
CAT,
obj: agg,
"Primary pad health now {}",
@ -1189,7 +1187,7 @@ impl AggregatorImpl for FallbackSwitch {
agg.notify("primary-health");
}
if fallback_health_change {
gst_debug!(
gst::debug!(
CAT,
obj: agg,
"Fallback pad health now {}",
@ -1202,7 +1200,7 @@ impl AggregatorImpl for FallbackSwitch {
let current_src_caps = agg.static_pad("src").unwrap().current_caps();
if Some(&active_caps) != current_src_caps.as_ref() {
gst_info!(
gst::info!(
CAT,
obj: agg,
"Caps change from {:?} to {:?}",
@ -1216,7 +1214,7 @@ impl AggregatorImpl for FallbackSwitch {
agg.notify("active-pad");
buffer.make_mut().set_flags(gst::BufferFlags::DISCONT);
}
gst_debug!(CAT, obj: agg, "Finishing buffer {:?}", buffer);
gst::debug!(CAT, obj: agg, "Finishing buffer {:?}", buffer);
agg.finish_buffer(buffer)
}

13
utils/fallbackswitch/tests/fallbackswitch.rs
View file

@ -6,7 +6,6 @@
//
// SPDX-License-Identifier: MPL-2.0
use gst::gst_debug;
use gst::prelude::*;
use once_cell::sync::Lazy;
@ -345,7 +344,7 @@ impl std::ops::Deref for Pipeline {
fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline {
init();
gst_debug!(TEST_CAT, "Setting up pipeline");
gst::debug!(TEST_CAT, "Setting up pipeline");
let clock = gst_check::TestClock::new();
clock.set_time(gst::ClockTime::ZERO);
@ -430,11 +429,11 @@ fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline {
None
}
}) {
gst_debug!(TEST_CAT, "Processing clock ID at {}", clock_id.time());
gst::debug!(TEST_CAT, "Processing clock ID at {}", clock_id.time());
if let Some(clock_id) = clock.process_next_clock_id() {
gst_debug!(TEST_CAT, "Processed clock ID at {}", clock_id.time());
gst::debug!(TEST_CAT, "Processed clock ID at {}", clock_id.time());
if clock_id.time().is_zero() {
gst_debug!(TEST_CAT, "Stopping clock thread");
gst::debug!(TEST_CAT, "Stopping clock thread");
return;
}
}
@ -529,7 +528,7 @@ fn set_time(pipeline: &Pipeline, time: gst::ClockTime) {
.downcast::<gst_check::TestClock>()
.unwrap();
gst_debug!(TEST_CAT, "Setting time to {}", time);
gst::debug!(TEST_CAT, "Setting time to {}", time);
clock.set_time(gst::ClockTime::SECOND + time);
}
@ -544,7 +543,7 @@ fn wait_eos(pipeline: &Pipeline) {
use std::{thread, time};
if sink.is_eos() {
gst_debug!(TEST_CAT, "Waited for EOS");
gst::debug!(TEST_CAT, "Waited for EOS");
break;
}
thread::sleep(time::Duration::from_millis(10));

163
utils/togglerecord/src/togglerecord/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_log, gst_trace, gst_warning};
use once_cell::sync::Lazy;
use parking_lot::{Condvar, Mutex};
@ -353,7 +352,7 @@ impl ToggleRecord {
let data = match data.clip(&state, &state.in_segment) {
Some(data) => data,
None => {
gst_log!(CAT, obj: pad, "Dropping raw data outside segment");
gst::log!(CAT, obj: pad, "Dropping raw data outside segment");
return Ok(HandleResult::Drop);
}
};
@ -385,7 +384,7 @@ impl ToggleRecord {
// get the wrong state
self.main_stream_cond.notify_all();
gst_log!(
gst::log!(
CAT,
obj: pad,
"Main stream current running time {}-{} (position: {}-{})",
@ -401,12 +400,12 @@ impl ToggleRecord {
let mut rec_state = self.state.lock();
let settings_changed = match rec_state.recording_state {
RecordingState::Recording if !settings.record => {
gst_debug!(CAT, obj: pad, "Stopping recording");
gst::debug!(CAT, obj: pad, "Stopping recording");
rec_state.recording_state = RecordingState::Stopping;
true
}
RecordingState::Stopped if settings.record => {
gst_debug!(CAT, obj: pad, "Starting recording");
gst::debug!(CAT, obj: pad, "Starting recording");
rec_state.recording_state = RecordingState::Starting;
true
}
@ -417,19 +416,19 @@ impl ToggleRecord {
RecordingState::Recording => {
// Remember where we stopped last, in case of EOS
rec_state.last_recording_stop = current_running_time_end;
gst_log!(CAT, obj: pad, "Passing buffer (recording)");
gst::log!(CAT, obj: pad, "Passing buffer (recording)");
Ok(HandleResult::Pass(data))
}
RecordingState::Stopping => {
if !data.is_keyframe() {
// Remember where we stopped last, in case of EOS
rec_state.last_recording_stop = current_running_time_end;
gst_log!(CAT, obj: pad, "Passing non-keyframe buffer (stopping)");
gst::log!(CAT, obj: pad, "Passing non-keyframe buffer (stopping)");
drop(rec_state);
drop(state);
if settings_changed {
gst_debug!(CAT, obj: pad, "Requesting a new keyframe");
gst::debug!(CAT, obj: pad, "Requesting a new keyframe");
stream
.sinkpad
.push_event(gst_video::UpstreamForceKeyUnitEvent::builder().build());
@ -445,7 +444,7 @@ impl ToggleRecord {
.opt_checked_sub(rec_state.last_recording_start)
.ok()
.flatten();
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Stopping at {}, started at {}, current duration {}, previous accumulated recording duration {}",
@ -469,12 +468,12 @@ impl ToggleRecord {
.unwrap_or(false)
})
{
gst_log!(CAT, obj: pad, "Waiting for other streams to stop");
gst::log!(CAT, obj: pad, "Waiting for other streams to stop");
self.main_stream_cond.wait(&mut state);
}
if state.flushing {
gst_debug!(CAT, obj: pad, "Flushing");
gst::debug!(CAT, obj: pad, "Flushing");
return Ok(HandleResult::Flushing);
}
@ -485,7 +484,7 @@ impl ToggleRecord {
rec_state.last_recording_start = None;
rec_state.last_recording_stop = None;
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Stopped at {}, recording duration {}",
@ -495,7 +494,7 @@ impl ToggleRecord {
// Then become Stopped and drop this buffer. We always stop right before
// a keyframe
gst_log!(CAT, obj: pad, "Dropping buffer (stopped)");
gst::log!(CAT, obj: pad, "Dropping buffer (stopped)");
drop(rec_state);
drop(state);
@ -504,18 +503,18 @@ impl ToggleRecord {
Ok(HandleResult::Drop)
}
RecordingState::Stopped => {
gst_log!(CAT, obj: pad, "Dropping buffer (stopped)");
gst::log!(CAT, obj: pad, "Dropping buffer (stopped)");
Ok(HandleResult::Drop)
}
RecordingState::Starting => {
// If this is no keyframe, we can directly go out again here and drop the frame
if !data.is_keyframe() {
gst_log!(CAT, obj: pad, "Dropping non-keyframe buffer (starting)");
gst::log!(CAT, obj: pad, "Dropping non-keyframe buffer (starting)");
drop(rec_state);
drop(state);
if settings_changed {
gst_debug!(CAT, obj: pad, "Requesting a new keyframe");
gst::debug!(CAT, obj: pad, "Requesting a new keyframe");
stream
.sinkpad
.push_event(gst_video::UpstreamForceKeyUnitEvent::builder().build());
@ -532,7 +531,7 @@ impl ToggleRecord {
.saturating_sub(rec_state.recording_duration)
.nseconds()
}) as i64;
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Starting at {}, previous accumulated recording duration {}",
@ -562,18 +561,18 @@ impl ToggleRecord {
.unwrap_or(false)
})
{
gst_log!(CAT, obj: pad, "Waiting for other streams to start");
gst::log!(CAT, obj: pad, "Waiting for other streams to start");
self.main_stream_cond.wait(&mut state);
}
if state.flushing {
gst_debug!(CAT, obj: pad, "Flushing");
gst::debug!(CAT, obj: pad, "Flushing");
return Ok(HandleResult::Flushing);
}
let mut rec_state = self.state.lock();
rec_state.recording_state = RecordingState::Recording;
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Started at {}, recording duration {}",
@ -581,7 +580,7 @@ impl ToggleRecord {
rec_state.recording_duration
);
gst_log!(CAT, obj: pad, "Passing buffer (recording)");
gst::log!(CAT, obj: pad, "Passing buffer (recording)");
drop(rec_state);
drop(state);
@ -630,7 +629,7 @@ impl ToggleRecord {
let data = match data.clip(&state, &state.in_segment) {
None => {
gst_log!(CAT, obj: pad, "Dropping raw data outside segment");
gst::log!(CAT, obj: pad, "Dropping raw data outside segment");
return Ok(HandleResult::Drop);
}
Some(data) => data,
@ -653,7 +652,7 @@ impl ToggleRecord {
.opt_max(state.current_running_time_end)
.or(current_running_time_end);
gst_log!(
gst::log!(
CAT,
obj: pad,
"Secondary stream current running time {}-{} (position: {}-{}",
@ -705,7 +704,7 @@ impl ToggleRecord {
&& !main_state.eos
&& !state.flushing
{
gst_log!(
gst::log!(
CAT,
obj: pad,
"Waiting at {}-{} in {:?} state, main stream at {}-{}",
@ -724,7 +723,7 @@ impl ToggleRecord {
}
if state.flushing {
gst_debug!(CAT, obj: pad, "Flushing");
gst::debug!(CAT, obj: pad, "Flushing");
return Ok(HandleResult::Flushing);
}
@ -733,7 +732,7 @@ impl ToggleRecord {
if main_state.eos {
// If we have no start or stop position (we never recorded) then we're EOS too now
if rec_state.last_recording_stop.is_none() || rec_state.last_recording_start.is_none() {
gst_debug!(CAT, obj: pad, "Main stream EOS and recording never started",);
gst::debug!(CAT, obj: pad, "Main stream EOS and recording never started",);
return Ok(HandleResult::Eos(self.check_and_update_eos(
pad,
stream,
@ -754,7 +753,7 @@ impl ToggleRecord {
{
// Otherwise if we're before the recording start but the end of the buffer is after
// the start and we can clip, clip the buffer and pass it onwards.
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Main stream EOS and we're not EOS yet (overlapping recording start, {} < {} < {})",
@ -779,12 +778,12 @@ impl ToggleRecord {
segment.set_start(clip_start);
segment.set_stop(clip_stop);
gst_log!(CAT, obj: pad, "Clipping to segment {:?}", segment);
gst::log!(CAT, obj: pad, "Clipping to segment {:?}", segment);
if let Some(data) = data.clip(&*state, &segment) {
return Ok(HandleResult::Pass(data));
} else {
gst_warning!(CAT, obj: pad, "Complete buffer clipped!");
gst::warning!(CAT, obj: pad, "Complete buffer clipped!");
return Ok(HandleResult::Drop);
}
} else if current_running_time
@ -794,7 +793,7 @@ impl ToggleRecord {
// Otherwise if the buffer starts before the recording start, drop it. This
// means that we either can't clip, or that the end is also before the
// recording start
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Main stream EOS and we're not EOS yet (before recording start, {} < {})",
@ -812,7 +811,7 @@ impl ToggleRecord {
{
// Similarly if the end is after the recording stop but the start is before and we
// can clip, clip the buffer and pass it through.
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Main stream EOS and we're not EOS yet (overlapping recording end, {} < {} < {})",
@ -837,12 +836,12 @@ impl ToggleRecord {
segment.set_start(clip_start);
segment.set_stop(clip_stop);
gst_log!(CAT, obj: pad, "Clipping to segment {:?}", segment,);
gst::log!(CAT, obj: pad, "Clipping to segment {:?}", segment,);
if let Some(data) = data.clip(&*state, &segment) {
return Ok(HandleResult::Pass(data));
} else {
gst_warning!(CAT, obj: pad, "Complete buffer clipped!");
gst::warning!(CAT, obj: pad, "Complete buffer clipped!");
return Ok(HandleResult::Eos(self.check_and_update_eos(
pad,
stream,
@ -857,7 +856,7 @@ impl ToggleRecord {
// Otherwise if the end of the buffer is after the recording stop, we're EOS
// now. This means that we either couldn't clip or that the start is also after
// the recording stop
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Main stream EOS and we're EOS too (after recording end, {} > {})",
@ -880,7 +879,7 @@ impl ToggleRecord {
.opt_le(rec_state.last_recording_stop)
.unwrap_or(false));
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Main stream EOS and we're not EOS yet (before recording end, {} <= {} <= {})",
@ -905,7 +904,7 @@ impl ToggleRecord {
assert!(current_running_time
.opt_ge(rec_state.last_recording_start)
.unwrap_or(false));
gst_log!(CAT, obj: pad, "Passing buffer (recording)");
gst::log!(CAT, obj: pad, "Passing buffer (recording)");
Ok(HandleResult::Pass(data))
}
RecordingState::Stopping => {
@ -913,7 +912,7 @@ impl ToggleRecord {
let last_recording_stop = match rec_state.last_recording_stop {
Some(last_recording_stop) => last_recording_stop,
None => {
gst_log!(
gst::log!(
CAT,
obj: pad,
"Passing buffer (stopping: waiting for keyframe)",
@ -930,7 +929,7 @@ impl ToggleRecord {
if current_running_time_end
.map_or(false, |cur_rt_end| cur_rt_end <= last_recording_stop)
{
gst_log!(
gst::log!(
CAT,
obj: pad,
"Passing buffer (stopping: {} <= {})",
@ -943,7 +942,7 @@ impl ToggleRecord {
&& current_running_time_end
.map_or(false, |cur_rt_end| cur_rt_end > last_recording_stop)
{
gst_log!(
gst::log!(
CAT,
obj: pad,
"Passing buffer (stopping: {} < {} < {})",
@ -961,16 +960,16 @@ impl ToggleRecord {
let mut segment = state.in_segment.clone();
segment.set_stop(clip_stop);
gst_log!(CAT, obj: pad, "Clipping to segment {:?}", segment,);
gst::log!(CAT, obj: pad, "Clipping to segment {:?}", segment,);
if let Some(data) = data.clip(&*state, &segment) {
Ok(HandleResult::Pass(data))
} else {
gst_warning!(CAT, obj: pad, "Complete buffer clipped!");
gst::warning!(CAT, obj: pad, "Complete buffer clipped!");
Ok(HandleResult::Drop)
}
} else {
gst_log!(
gst::log!(
CAT,
obj: pad,
"Dropping buffer (stopping: {} > {})",
@ -988,7 +987,7 @@ impl ToggleRecord {
.unwrap_or(false));
// We're properly stopped
gst_log!(CAT, obj: pad, "Dropping buffer (stopped)");
gst::log!(CAT, obj: pad, "Dropping buffer (stopped)");
Ok(HandleResult::Drop)
}
RecordingState::Starting => {
@ -996,7 +995,7 @@ impl ToggleRecord {
let last_recording_start = match rec_state.last_recording_start {
Some(last_recording_start) => last_recording_start,
None => {
gst_log!(
gst::log!(
CAT,
obj: pad,
"Dropping buffer (starting: waiting for keyframe)",
@ -1011,7 +1010,7 @@ impl ToggleRecord {
let current_running_time = current_running_time.expect("checked_above");
if current_running_time >= last_recording_start {
gst_log!(
gst::log!(
CAT,
obj: pad,
"Passing buffer (starting: {} >= {})",
@ -1024,7 +1023,7 @@ impl ToggleRecord {
&& current_running_time_end
.map_or(false, |cur_rt_end| cur_rt_end > last_recording_start)
{
gst_log!(
gst::log!(
CAT,
obj: pad,
"Passing buffer (starting: {} < {} < {})",
@ -1042,16 +1041,16 @@ impl ToggleRecord {
let mut segment = state.in_segment.clone();
segment.set_start(clip_start);
gst_log!(CAT, obj: pad, "Clipping to segment {:?}", segment);
gst::log!(CAT, obj: pad, "Clipping to segment {:?}", segment);
if let Some(data) = data.clip(&*state, &segment) {
Ok(HandleResult::Pass(data))
} else {
gst_warning!(CAT, obj: pad, "Complete buffer clipped!");
gst::warning!(CAT, obj: pad, "Complete buffer clipped!");
Ok(HandleResult::Drop)
}
} else {
gst_log!(
gst::log!(
CAT,
obj: pad,
"Dropping buffer (starting: {} < {})",
@ -1093,7 +1092,7 @@ impl ToggleRecord {
});
if all_others_eos {
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"All streams are in EOS state, change state to Stopped"
@ -1138,7 +1137,7 @@ impl ToggleRecord {
if !all_others_not_eos {
let settings = self.settings.lock();
if settings.record {
gst_debug!(CAT, obj: pad, "Restarting recording after EOS");
gst::debug!(CAT, obj: pad, "Restarting recording after EOS");
rec_state.recording_state = RecordingState::Starting;
}
}
@ -1162,7 +1161,7 @@ impl ToggleRecord {
gst::FlowError::Error
})?;
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
{
let state = stream.state.lock();
@ -1216,7 +1215,7 @@ impl ToggleRecord {
let mut state = stream.state.lock();
if state.discont_pending {
gst_debug!(CAT, obj: pad, "Pending discont");
gst::debug!(CAT, obj: pad, "Pending discont");
let buffer = buffer.make_mut();
buffer.set_flags(gst::BufferFlags::DISCONT);
state.discont_pending = false;
@ -1244,11 +1243,11 @@ impl ToggleRecord {
.build(),
);
state.segment_pending = false;
gst_debug!(CAT, obj: pad, "Pending Segment {:?}", &state.out_segment);
gst::debug!(CAT, obj: pad, "Pending Segment {:?}", &state.out_segment);
}
if !state.pending_events.is_empty() {
gst_debug!(CAT, obj: pad, "Pushing pending events");
gst::debug!(CAT, obj: pad, "Pushing pending events");
}
events.append(&mut state.pending_events);
@ -1266,7 +1265,7 @@ impl ToggleRecord {
out_running_time
};
gst_log!(
gst::log!(
CAT,
obj: pad,
"Pushing buffer with running time {}: {:?}",
@ -1296,7 +1295,7 @@ impl ToggleRecord {
Some(stream) => stream.clone(),
};
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
gst::log!(CAT, obj: pad, "Handling event {:?}", event);
let mut forward = true;
let mut send_pending = false;
@ -1330,12 +1329,12 @@ impl ToggleRecord {
let s = caps.structure(0).unwrap();
if s.name().starts_with("audio/") {
state.audio_info = gst_audio::AudioInfo::from_caps(caps).ok();
gst_log!(CAT, obj: pad, "Got audio caps {:?}", state.audio_info);
gst::log!(CAT, obj: pad, "Got audio caps {:?}", state.audio_info);
state.video_info = None;
} else if s.name().starts_with("video/") {
state.audio_info = None;
state.video_info = gst_video::VideoInfo::from_caps(caps).ok();
gst_log!(CAT, obj: pad, "Got video caps {:?}", state.video_info);
gst::log!(CAT, obj: pad, "Got video caps {:?}", state.video_info);
} else {
state.audio_info = None;
state.video_info = None;
@ -1374,12 +1373,12 @@ impl ToggleRecord {
state.current_running_time = None;
state.current_running_time_end = None;
gst_debug!(CAT, obj: pad, "Got new Segment {:?}", state.in_segment);
gst::debug!(CAT, obj: pad, "Got new Segment {:?}", state.in_segment);
forward = false;
}
EventView::Gap(e) => {
gst_debug!(CAT, obj: pad, "Handling Gap event {:?}", event);
gst::debug!(CAT, obj: pad, "Handling Gap event {:?}", event);
let (pts, duration) = e.get();
let handle_result = if stream == self.main_stream {
self.handle_main_stream(element, pad, &stream, (pts, duration))
@ -1423,7 +1422,7 @@ impl ToggleRecord {
}
self.main_stream_cond.notify_all();
gst_debug!(CAT, obj: pad, "Stream is not EOS now");
gst::debug!(CAT, obj: pad, "Stream is not EOS now");
}
EventView::Eos(..) => {
let main_state = if stream != self.main_stream {
@ -1445,7 +1444,7 @@ impl ToggleRecord {
}
self.main_stream_cond.notify_all();
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Stream is EOS now, sending any pending events"
@ -1470,7 +1469,7 @@ impl ToggleRecord {
{
let mut state = stream.state.lock();
if state.segment_pending {
gst_log!(CAT, obj: pad, "Storing event for later pushing");
gst::log!(CAT, obj: pad, "Storing event for later pushing");
state.pending_events.push(event);
return true;
}
@ -1498,10 +1497,10 @@ impl ToggleRecord {
}
if forward {
gst_log!(CAT, obj: pad, "Forwarding event {:?}", event);
gst::log!(CAT, obj: pad, "Forwarding event {:?}", event);
stream.srcpad.push_event(event)
} else {
gst_log!(CAT, obj: pad, "Dropping event {:?}", event);
gst::log!(CAT, obj: pad, "Dropping event {:?}", event);
true
}
}
@ -1524,7 +1523,7 @@ impl ToggleRecord {
Some(stream) => stream.clone(),
};
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
gst::log!(CAT, obj: pad, "Handling query {:?}", query);
stream.srcpad.peer_query(query)
}
@ -1552,7 +1551,7 @@ impl ToggleRecord {
Some(stream) => stream.clone(),
};
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
gst::log!(CAT, obj: pad, "Handling event {:?}", event);
let forward = !matches!(event.view(), EventView::Seek(..));
@ -1564,10 +1563,10 @@ impl ToggleRecord {
drop(rec_state);
if forward {
gst_log!(CAT, obj: pad, "Forwarding event {:?}", event);
gst::log!(CAT, obj: pad, "Forwarding event {:?}", event);
stream.sinkpad.push_event(event)
} else {
gst_log!(CAT, obj: pad, "Dropping event {:?}", event);
gst::log!(CAT, obj: pad, "Dropping event {:?}", event);
false
}
}
@ -1592,7 +1591,7 @@ impl ToggleRecord {
Some(stream) => stream.clone(),
};
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryViewMut::Scheduling(q) => {
let mut new_query = gst::query::Scheduling::new();
@ -1601,7 +1600,7 @@ impl ToggleRecord {
return res;
}
gst_log!(CAT, obj: pad, "Downstream returned {:?}", new_query);
gst::log!(CAT, obj: pad, "Downstream returned {:?}", new_query);
let (flags, min, max, align) = new_query.result();
q.set(flags, min, max, align);
@ -1613,7 +1612,7 @@ impl ToggleRecord {
.filter(|m| m != &gst::PadMode::Pull)
.collect::<Vec<_>>(),
);
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
gst::log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true
}
QueryViewMut::Seeking(q) => {
@ -1625,7 +1624,7 @@ impl ToggleRecord {
gst::GenericFormattedValue::new(format, -1),
);
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
gst::log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true
}
// Position and duration is always the current recording position
@ -1643,7 +1642,7 @@ impl ToggleRecord {
.ok()
.flatten()
{
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Returning position {} = {} - ({} + {})",
@ -1655,7 +1654,7 @@ impl ToggleRecord {
recording_duration += delta;
}
} else {
gst_debug!(CAT, obj: pad, "Returning position {}", recording_duration);
gst::debug!(CAT, obj: pad, "Returning position {}", recording_duration);
}
q.set(recording_duration);
true
@ -1677,7 +1676,7 @@ impl ToggleRecord {
.ok()
.flatten()
{
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Returning duration {} = {} - ({} + {})",
@ -1689,7 +1688,7 @@ impl ToggleRecord {
recording_duration += delta;
}
} else {
gst_debug!(CAT, obj: pad, "Returning duration {}", recording_duration);
gst::debug!(CAT, obj: pad, "Returning duration {}", recording_duration);
}
q.set(recording_duration);
true
@ -1698,7 +1697,7 @@ impl ToggleRecord {
}
}
_ => {
gst_log!(CAT, obj: pad, "Forwarding query {:?}", query);
gst::log!(CAT, obj: pad, "Forwarding query {:?}", query);
stream.sinkpad.peer_query(query)
}
}
@ -1852,7 +1851,7 @@ impl ObjectImpl for ToggleRecord {
"record" => {
let mut settings = self.settings.lock();
let record = value.get().expect("type checked upstream");
gst_debug!(
gst::debug!(
CAT,
obj: obj,
"Setting record from {:?} to {:?}",
@ -1865,7 +1864,7 @@ impl ObjectImpl for ToggleRecord {
"is-live" => {
let mut settings = self.settings.lock();
let live = value.get().expect("type checked upstream");
gst_debug!(
gst::debug!(
CAT,
obj: obj,
"Setting live from {:?} to {:?}",
@ -1972,7 +1971,7 @@ impl ElementImpl for ToggleRecord {
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 => {

51
utils/uriplaylistbin/src/uriplaylistbin/imp.rs
View file

@ -12,7 +12,6 @@ use std::sync::{Mutex, MutexGuard};
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_fixme, gst_info, gst_log, gst_warning};
use once_cell::sync::Lazy;
@ -177,7 +176,7 @@ impl State {
if let Some(blocked) = self.blocked.take() {
let (messages, sender) = blocked.set_streaming(self.streams_topology.n_streams());
gst_log!(
gst::log!(
CAT,
obj: element,
"send pending message of item #{} and unblock its pads",
@ -758,7 +757,7 @@ impl ObjectImpl for UriPlaylistBin {
"uris" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing uris from {:?} to {:?}",
@ -770,7 +769,7 @@ impl ObjectImpl for UriPlaylistBin {
"iterations" => {
let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing iterations from {:?} to {:?}",
@ -942,7 +941,7 @@ impl ElementImpl for UriPlaylistBin {
impl UriPlaylistBin {
fn start(&self, element: &super::UriPlaylistBin) -> Result<(), PlaylistError> {
gst_debug!(CAT, obj: element, "Starting");
gst::debug!(CAT, obj: element, "Starting");
{
let mut state_guard = self.state.lock().unwrap();
assert!(state_guard.is_none());
@ -974,7 +973,7 @@ impl UriPlaylistBin {
// clean up done items, so uridecodebin elements and concat sink pads don't pile up in the pipeline
while let Some(done) = state.done.pop() {
let uridecodebin = done.uridecodebin();
gst_log!(CAT, obj: element, "remove {} from bin", uridecodebin.name());
gst::log!(CAT, obj: element, "remove {} from bin", uridecodebin.name());
for (concat, sink_pad) in done.concat_sink_pads() {
// calling release_request_pad() while holding the pad stream lock would deadlock
@ -1002,7 +1001,7 @@ impl UriPlaylistBin {
let n_streaming = state.streaming.len();
if n_streaming > MAX_STREAMING_ITEMS {
gst_log!(
gst::log!(
CAT,
obj: element,
"Too many items streaming ({}), wait before starting the next one",
@ -1015,7 +1014,7 @@ impl UriPlaylistBin {
let item = match state.playlist.next()? {
Some(item) => item,
None => {
gst_debug!(CAT, obj: element, "no more item to queue",);
gst::debug!(CAT, obj: element, "no more item to queue",);
// unblock last item
state.unblock_item(element);
@ -1026,7 +1025,7 @@ impl UriPlaylistBin {
}
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"start decoding item #{}: {}",
@ -1063,7 +1062,7 @@ impl UriPlaylistBin {
let element_weak = element.downgrade();
let receiver = item.receiver();
gst_debug!(
gst::debug!(
CAT,
obj: &element,
"Block pad {} until streamsynchronizer is flushed",
@ -1079,7 +1078,7 @@ impl UriPlaylistBin {
let _ = receiver.recv();
gst_log!(
gst::log!(
CAT,
obj: &element,
"pad {}:{} has been unblocked",
@ -1124,7 +1123,7 @@ impl UriPlaylistBin {
if src.has_as_ancestor(&uridecodebin) {
let topology = StreamsTopology::from(stream_collection_msg.stream_collection());
gst_debug!(
gst::debug!(
CAT,
obj: element,
"got stream collection from {}: {:?}",
@ -1139,7 +1138,7 @@ impl UriPlaylistBin {
assert!(state.waiting_for_pads.is_none());
if state.streams_topology != topology {
gst_debug!(
gst::debug!(
CAT,
obj: element, "streams topoly changed ('{:?}' -> '{:?}'), waiting for streamsynchronize to be flushed",
state.streams_topology, topology);
@ -1179,7 +1178,7 @@ impl UriPlaylistBin {
if src.has_as_ancestor(&uridecodebin) {
// stream-selected message is from the blocked item, queue the message until it's unblocked
gst_debug!(
gst::debug!(
CAT,
obj: element,
"queue stream-selected message from {} as item is currently blocked",
@ -1216,7 +1215,7 @@ impl UriPlaylistBin {
let (stream_type, stream_index) = match stream_type_from_pad_name(&pad_name) {
Ok((stream_type, stream_index)) => (stream_type, stream_index),
Err(e) => {
gst_warning!(CAT, obj: &element, "Ignoring pad {}: {}", pad_name, e);
gst::warning!(CAT, obj: &element, "Ignoring pad {}: {}", pad_name, e);
return;
}
};
@ -1230,7 +1229,7 @@ impl UriPlaylistBin {
let concat = match concat {
None => {
gst_debug!(
gst::debug!(
CAT,
obj: &element,
"stream {} from item #{}: creating concat element",
@ -1299,7 +1298,7 @@ impl UriPlaylistBin {
if let Some(item) = item {
if item.dec_waiting_eos_ss() {
gst_debug!(CAT, obj: &element, "streamsynchronizer has been flushed, reorganize pipeline to fit new streams topology and unblock item");
gst::debug!(CAT, obj: &element, "streamsynchronizer has been flushed, reorganize pipeline to fit new streams topology and unblock item");
imp.handle_topology_change(&element);
gst::PadProbeReturn::Drop
} else {
@ -1331,7 +1330,7 @@ impl UriPlaylistBin {
gst::EventView::SelectStreams(_) => {
// TODO: handle select-streams event
let element = parent.unwrap();
gst_fixme!(
gst::fixme!(
CAT,
obj: element,
"select-streams event not supported ('{:?}')",
@ -1361,7 +1360,7 @@ impl UriPlaylistBin {
concat
}
Some(concat) => {
gst_debug!(
gst::debug!(
CAT,
obj: &element,
"stream {} from item #{}: re-using concat element {}",
@ -1394,7 +1393,7 @@ impl UriPlaylistBin {
if !item.is_streaming() {
// block pad until next item is ready
gst_log!(
gst::log!(
CAT,
obj: &element,
"blocking pad {}:{} until next item is ready",
@ -1404,7 +1403,7 @@ impl UriPlaylistBin {
let _ = receiver.recv();
gst_log!(
gst::log!(
CAT,
obj: &element,
"pad {}:{} has been unblocked",
@ -1420,7 +1419,7 @@ impl UriPlaylistBin {
{
if item.dec_waiting_eos() {
// all the streams are eos, item is now done
gst_log!(
gst::log!(
CAT,
obj: &element,
"all streams of item #{} are eos",
@ -1460,7 +1459,7 @@ impl UriPlaylistBin {
if item.dec_n_pads_pending() == 0 {
// we got all the pads
gst_debug!(
gst::debug!(
CAT,
obj: &element,
"got all the pads for item #{}",
@ -1484,7 +1483,7 @@ impl UriPlaylistBin {
};
if start_next {
gst_debug!(
gst::debug!(
CAT,
obj: &element,
"got all pending streams, queue next item"
@ -1519,7 +1518,7 @@ impl UriPlaylistBin {
while n_stream < concats.len() {
// need to remove concat elements
let concat = concats.pop().unwrap();
gst_log!(CAT, obj: element, "remove {}", concat.name());
gst::log!(CAT, obj: element, "remove {}", concat.name());
let concat_src = concat.static_pad("src").unwrap();
let ss_sink = concat_src.peer().unwrap();
@ -1592,7 +1591,7 @@ impl UriPlaylistBin {
}
}
let error_msg = error.to_string();
gst_error!(CAT, obj: element, "{}", error_msg);
gst::error!(CAT, obj: element, "{}", error_msg);
match error {
PlaylistError::PluginMissing { .. } => {

5
video/cdg/src/cdgdec/imp.rs
View file

@ -9,7 +9,6 @@
// SPDX-License-Identifier: MIT/Apache-2.0
use gst::glib;
use gst::gst_debug;
use gst::subclass::prelude::*;
use gst_video::prelude::*;
use gst_video::subclass::prelude::*;
@ -189,7 +188,7 @@ impl VideoDecoderImpl for CdgDec {
}
}
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Finish frame pts={}",
@ -221,7 +220,7 @@ impl VideoDecoderImpl for CdgDec {
}
fn flush(&self, element: &Self::Type) -> bool {
gst_debug!(CAT, obj: element, "flushing, reset CDG interpreter");
gst::debug!(CAT, obj: element, "flushing, reset CDG interpreter");
let mut cdg_inter = self.cdg_inter.lock().unwrap();
cdg_inter.reset(false);

3
video/cdg/src/cdgparse/imp.rs
View file

@ -10,7 +10,6 @@
use gst::format::Bytes;
use gst::glib;
use gst::gst_debug;
use gst::subclass::prelude::*;
use gst_base::prelude::*;
use gst_base::subclass::prelude::*;
@ -204,7 +203,7 @@ impl BaseParseImpl for CdgParse {
buffer.set_flags(gst::BufferFlags::HEADER);
}
gst_debug!(CAT, obj: element, "Found frame pts={}", pts);
gst::debug!(CAT, obj: element, "Found frame pts={}", pts);
element.finish_frame(frame, CDG_PACKET_SIZE as u32)?;

11
video/closedcaption/src/ccdetect/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_trace, gst_warning};
use gst_base::subclass::prelude::*;
use crate::ccutils::{extract_cdp, ParseError, ParseErrorCode};
@ -75,7 +74,7 @@ struct CCPacketContents {
impl CCDetect {
fn detect_cc_data(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, "cc_data length is not a multiple of 3, truncating");
}
/* logic from ccconverter */
@ -85,7 +84,7 @@ impl CCDetect {
for (i, triple) in data.chunks_exact(3).enumerate() {
let cc_valid = (triple[0] & 0x04) == 0x04;
let cc_type = triple[0] & 0x03;
gst_trace!(
gst::trace!(
CAT,
"triple:{} have ccp:{} 608:{} 708:{} data:{:02x},{:02x},{:02x} cc_valid:{} cc_type:{:02b}",
i * 3,
@ -159,7 +158,7 @@ impl CCDetect {
let mut state_guard = self.state.lock().unwrap();
let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?;
gst_trace!(
gst::trace!(
CAT,
"packet contains {:?} current settings {:?} and state {:?}",
cc_packet,
@ -194,7 +193,7 @@ impl CCDetect {
state.last_cc708_change = Some(ts);
}
gst_trace!(CAT, "changed to settings {:?} state {:?}", settings, state);
gst::trace!(CAT, "changed to settings {:?} state {:?}", settings, state);
}
if notify_cc608 {
@ -365,7 +364,7 @@ impl BaseTransformImpl for CCDetect {
let cc_packet = match Self::detect(format, map.as_slice()) {
Ok(v) => v,
Err(e) => {
gst_warning!(CAT, "{}", &e.to_string());
gst::warning!(CAT, "{}", &e.to_string());
gst::element_warning!(element, gst::StreamError::Decode, [&e.to_string()]);
CCPacketContents {
cc608: false,

31
video/closedcaption/src/cea608overlay/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_error, gst_info, gst_log, gst_trace, gst_warning};
use gst_video::prelude::*;
use once_cell::sync::Lazy;
@ -249,7 +248,7 @@ impl Cea608Overlay {
let buffer = match render_buffer() {
Some(buffer) => buffer,
None => {
gst_error!(CAT, obj: element, "Failed to render buffer");
gst::error!(CAT, obj: element, "Failed to render buffer");
state.composition = None;
return;
}
@ -329,7 +328,7 @@ impl Cea608Overlay {
pts: gst::ClockTime,
) {
if data.len() % 3 != 0 {
gst_warning!(CAT, "cc_data length is not a multiple of 3, truncating");
gst::warning!(CAT, "cc_data length is not a multiple of 3, truncating");
}
for triple in data.chunks_exact(3) {
@ -340,7 +339,7 @@ impl Cea608Overlay {
if cc_type == 0x00 || cc_type == 0x01 {
if state.selected_field.is_none() {
state.selected_field = Some(cc_type);
gst_info!(
gst::info!(
CAT,
obj: element,
"Selected field {} automatically",
@ -356,7 +355,7 @@ impl Cea608Overlay {
let text = match state.caption_frame.to_text(true) {
Ok(text) => text,
Err(_) => {
gst_error!(
gst::error!(
CAT,
obj: pad,
"Failed to convert caption frame to text"
@ -386,14 +385,14 @@ impl Cea608Overlay {
pts: gst::ClockTime,
) {
if data.len() % 3 != 0 {
gst_warning!(CAT, "cc_data length is not a multiple of 3, truncating");
gst::warning!(CAT, "cc_data length is not a multiple of 3, truncating");
}
for triple in data.chunks_exact(3) {
let cc_type = triple[0] & 0x01;
if state.selected_field.is_none() {
state.selected_field = Some(cc_type);
gst_info!(
gst::info!(
CAT,
obj: element,
"Selected field {} automatically",
@ -409,7 +408,7 @@ impl Cea608Overlay {
let text = match state.caption_frame.to_text(true) {
Ok(text) => text,
Err(_) => {
gst_error!(CAT, obj: pad, "Failed to convert caption frame to text");
gst::error!(CAT, obj: pad, "Failed to convert caption frame to text");
continue;
}
};
@ -432,10 +431,10 @@ impl Cea608Overlay {
element: &super::Cea608Overlay,
mut buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let pts = buffer.pts().ok_or_else(|| {
gst_error!(CAT, obj: pad, "Require timestamped buffers");
gst::error!(CAT, obj: pad, "Require timestamped buffers");
gst::FlowError::Error
})?;
@ -456,7 +455,7 @@ impl Cea608Overlay {
self.decode_cc_data(pad, element, &mut state, data, pts);
}
Err(e) => {
gst_warning!(CAT, "{}", &e.to_string());
gst::warning!(CAT, "{}", &e.to_string());
gst::element_warning!(element, gst::StreamError::Decode, [&e.to_string()]);
}
}
@ -475,7 +474,7 @@ impl Cea608Overlay {
let text = match state.caption_frame.to_text(true) {
Ok(text) => text,
Err(_) => {
gst_error!(
gst::error!(
CAT,
obj: pad,
"Failed to convert caption frame to text"
@ -495,7 +494,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, obj: element, "Reached timeout, clearing overlay");
state.composition.take();
state.last_cc_pts.take();
}
@ -514,7 +513,7 @@ impl Cea608Overlay {
.unwrap();
if composition.blend(&mut frame).is_err() {
gst_error!(CAT, obj: pad, "Failed to blend composition");
gst::error!(CAT, obj: pad, "Failed to blend composition");
}
}
}
@ -531,7 +530,7 @@ impl Cea608Overlay {
) -> 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 mut state = self.state.lock().unwrap();
@ -751,7 +750,7 @@ impl ElementImpl for Cea608Overlay {
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 => {

49
video/closedcaption/src/cea608tojson/imp.rs
View file

@ -28,7 +28,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace, gst_warning};
use crate::ffi;
use crate::ttutils::{Cea608Mode, Chunk, Line, Lines, TextStyle};
@ -403,7 +402,7 @@ fn dump(
let end = pts.opt_add(duration.into());
if cc_data != 0x8080 {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"{} -> {}: {}",
@ -412,7 +411,7 @@ fn dump(
eia608_to_text(cc_data)
);
} else {
gst_trace!(
gst::trace!(
CAT,
obj: element,
"{} -> {}: padding",
@ -461,7 +460,7 @@ impl State {
}
fn drain(&mut self, element: &super::Cea608ToJson, flush: bool) -> Option<TimestampedLines> {
gst_log!(CAT, obj: element, "Draining");
gst::log!(CAT, obj: element, "Draining");
let pts = if self.settings.unbuffered {
self.current_pts
@ -536,7 +535,7 @@ impl State {
fn drain_pending(&mut self, element: &super::Cea608ToJson) -> Option<TimestampedLines> {
if let Some(mut pending) = self.pending_lines.take() {
gst_log!(CAT, obj: element, "Draining pending");
gst::log!(CAT, obj: element, "Draining pending");
pending.duration = self
.current_pts
.opt_add(self.current_duration)
@ -560,7 +559,7 @@ impl State {
return None;
}
gst_log!(CAT, obj: element, "preamble: {:?}", preamble);
gst::log!(CAT, obj: element, "preamble: {:?}", preamble);
let drain_roll_up = self.cursor.row != preamble.row as u32;
@ -646,7 +645,7 @@ impl State {
) -> Option<TimestampedLines> {
let (cmd, chan) = parse_control(cc_data);
gst_log!(CAT, obj: element, "Command for CC {}", chan);
gst::log!(CAT, obj: element, "Command for CC {}", chan);
if chan != 0 {
return None;
@ -679,7 +678,7 @@ impl State {
return self.update_mode(element, Cea608Mode::RollUp4);
}
ffi::eia608_control_t_eia608_control_carriage_return => {
gst_log!(CAT, obj: element, "carriage return");
gst::log!(CAT, obj: element, "carriage return");
if let Some(mode) = self.mode {
// https://www.law.cornell.edu/cfr/text/47/79.101 (f)(2)(i) (f)(3)(i)
@ -755,7 +754,7 @@ 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, obj: element, "Unknown command {}!", cmd);
}
}
@ -790,7 +789,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, obj: element, "No row to append decoded text to!");
}
}
@ -812,7 +811,7 @@ impl State {
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, obj: element, "Skipping duplicate");
return None;
}
@ -821,14 +820,14 @@ impl State {
self.current_duration = duration;
if is_xds(cc_data) {
gst_log!(CAT, obj: element, "XDS, ignoring");
gst::log!(CAT, obj: element, "XDS, ignoring");
} else if is_control(cc_data) {
gst_log!(CAT, obj: element, "control!");
gst::log!(CAT, obj: element, "control!");
return self.decode_control(element, 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");
gst::log!(CAT, obj: element, "text");
self.decode_text(element, cc_data);
if mode.is_rollup() && self.settings.unbuffered {
@ -836,10 +835,10 @@ impl State {
}
}
} else if is_preamble(cc_data) {
gst_log!(CAT, obj: element, "preamble");
gst::log!(CAT, obj: element, "preamble");
return self.decode_preamble(element, cc_data);
} else if is_midrowchange(cc_data) {
gst_log!(CAT, obj: element, "midrowchange");
gst::log!(CAT, obj: element, "midrowchange");
self.decode_midrowchange(cc_data);
}
None
@ -852,7 +851,7 @@ impl Cea608ToJson {
element: &super::Cea608ToJson,
lines: TimestampedLines,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_debug!(CAT, obj: element, "outputting: {:?}", lines);
gst::debug!(CAT, obj: element, "outputting: {:?}", lines);
let json = serde_json::to_string(&lines.lines).map_err(|err| {
gst::element_error!(
@ -871,7 +870,7 @@ impl Cea608ToJson {
buf_mut.set_duration(lines.duration);
}
gst_log!(CAT, obj: element, "Pushing {:?}", buf);
gst::log!(CAT, obj: element, "Pushing {:?}", buf);
self.srcpad.push(buf)
}
@ -882,30 +881,30 @@ impl Cea608ToJson {
element: &super::Cea608ToJson,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_trace!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::trace!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut state = self.state.borrow_mut();
let pts = buffer.pts();
if pts.is_none() {
gst_error!(CAT, obj: pad, "Require timestamped buffers");
gst::error!(CAT, obj: pad, "Require timestamped buffers");
return Err(gst::FlowError::Error);
}
let duration = buffer.duration();
if duration.is_none() {
gst_error!(CAT, obj: pad, "Require buffers with duration");
gst::error!(CAT, obj: pad, "Require buffers with duration");
return Err(gst::FlowError::Error);
}
let data = buffer.map_readable().map_err(|_| {
gst_error!(CAT, obj: pad, "Can't map buffer readable");
gst::error!(CAT, obj: pad, "Can't map buffer readable");
gst::FlowError::Error
})?;
if data.len() < 2 {
gst_error!(CAT, obj: pad, "Invalid closed caption packet size");
gst::error!(CAT, obj: pad, "Invalid closed caption packet size");
return Ok(gst::FlowSuccess::Ok);
}
@ -933,7 +932,7 @@ impl Cea608ToJson {
fn sink_event(&self, pad: &gst::Pad, element: &super::Cea608ToJson, 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 our own caps downstream
@ -1107,7 +1106,7 @@ impl ElementImpl for Cea608ToJson {
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 => {

31
video/closedcaption/src/cea608tott/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace};
use crate::caption_frame::{CaptionFrame, Status};
use atomic_refcell::AtomicRefCell;
@ -65,32 +64,32 @@ impl Cea608ToTt {
_element: &super::Cea608ToTt,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut state = self.state.borrow_mut();
let format = match state.format {
Some(format) => format,
None => {
gst_error!(CAT, obj: pad, "Not negotiated yet");
gst::error!(CAT, obj: pad, "Not negotiated yet");
return Err(gst::FlowError::NotNegotiated);
}
};
let buffer_pts = buffer.pts().ok_or_else(|| {
gst_error!(CAT, obj: pad, "Require timestamped buffers");
gst::error!(CAT, obj: pad, "Require timestamped buffers");
gst::FlowError::Error
})?;
let pts = (buffer_pts.nseconds() as f64) / 1_000_000_000.0;
let data = buffer.map_readable().map_err(|_| {
gst_error!(CAT, obj: pad, "Can't map buffer readable");
gst::error!(CAT, obj: pad, "Can't map buffer readable");
gst::FlowError::Error
})?;
if data.len() < 2 {
gst_error!(CAT, obj: pad, "Invalid closed caption packet size");
gst::error!(CAT, obj: pad, "Invalid closed caption packet size");
return Ok(gst::FlowSuccess::Ok);
}
@ -101,19 +100,19 @@ impl Cea608ToTt {
{
Ok(Status::Ok) => return Ok(gst::FlowSuccess::Ok),
Err(_) => {
gst_error!(CAT, obj: pad, "Failed to decode closed caption packet");
gst::error!(CAT, obj: pad, "Failed to decode closed caption packet");
return Ok(gst::FlowSuccess::Ok);
}
Ok(Status::Clear) => {
gst_debug!(CAT, obj: pad, "Clearing previous closed caption packet");
gst::debug!(CAT, obj: pad, "Clearing previous closed caption packet");
state.previous_text.take()
}
Ok(Status::Ready) => {
gst_debug!(CAT, obj: pad, "Have new closed caption packet");
gst::debug!(CAT, obj: pad, "Have new closed caption packet");
let text = match state.caption_frame.to_text(false) {
Ok(text) => text,
Err(_) => {
gst_error!(CAT, obj: pad, "Failed to convert caption frame to text");
gst::error!(CAT, obj: pad, "Failed to convert caption frame to text");
return Ok(gst::FlowSuccess::Ok);
}
};
@ -125,7 +124,7 @@ impl Cea608ToTt {
let previous_text = match previous_text {
Some(previous_text) => previous_text,
None => {
gst_debug!(CAT, obj: pad, "Have no previous text");
gst::debug!(CAT, obj: pad, "Have no previous text");
return Ok(gst::FlowSuccess::Ok);
}
};
@ -271,7 +270,7 @@ impl Cea608ToTt {
fn sink_event(&self, pad: &gst::Pad, element: &super::Cea608ToTt, 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(..) => {
let mut state = self.state.borrow_mut();
@ -286,13 +285,13 @@ impl Cea608ToTt {
};
if downstream_caps.is_empty() {
gst_error!(CAT, obj: pad, "Empty downstream caps");
gst::error!(CAT, obj: pad, "Empty downstream caps");
return false;
}
downstream_caps.fixate();
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Negotiating for downstream caps {}",
@ -327,7 +326,7 @@ impl Cea608ToTt {
EventView::Eos(..) => {
let mut state = self.state.borrow_mut();
if let Some((timestamp, text)) = state.previous_text.take() {
gst_debug!(CAT, obj: pad, "Outputting final text on EOS");
gst::debug!(CAT, obj: pad, "Outputting final text on EOS");
let format = state.format.unwrap();
@ -490,7 +489,7 @@ impl ElementImpl for Cea608ToTt {
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 => {

36
video/closedcaption/src/jsontovtt/imp.rs
View file

@ -7,10 +7,10 @@
//
// SPDX-License-Identifier: MPL-2.0
use gst::element_error;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{element_error, gst_debug, gst_error, gst_log, gst_trace, gst_warning};
use crate::jsontovtt::fku::ForceKeyUnitRequest;
use crate::ttutils::Lines;
@ -248,31 +248,31 @@ impl State {
let mut ret = vec![];
let data = buffer.map_readable().map_err(|_| {
gst_error!(CAT, obj: pad, "Can't map buffer readable");
gst::error!(CAT, obj: pad, "Can't map buffer readable");
gst::FlowError::Error
})?;
let lines: Lines = serde_json::from_slice(&data).map_err(|err| {
gst_error!(CAT, obj: pad, "Failed to parse input as json: {}", err);
gst::error!(CAT, obj: pad, "Failed to parse input as json: {}", err);
gst::FlowError::Error
})?;
let pts = buffer.pts().ok_or_else(|| {
gst_error!(CAT, obj: pad, "Require timestamped buffers");
gst::error!(CAT, obj: pad, "Require timestamped buffers");
gst::FlowError::Error
})?;
let duration = buffer.duration().ok_or_else(|| {
gst_error!(CAT, obj: pad, "Require buffers with duration");
gst::error!(CAT, obj: pad, "Require buffers with duration");
gst::FlowError::Error
})?;
let (pts, duration) = match clamp(&self.segment, pts, Some(duration)) {
Some((pts, duration)) => (pts, duration.unwrap()),
None => {
gst_warning!(
gst::warning!(
CAT,
obj: pad,
"Dropping buffer outside segment: {:?}",
@ -307,7 +307,7 @@ impl State {
let (pts, duration) = match clamp(&self.segment, pts, duration) {
Some((pts, duration)) => (pts, duration),
None => {
gst_warning!(CAT, "Ignoring gap outside segment");
gst::warning!(CAT, "Ignoring gap outside segment");
return ret;
}
};
@ -326,7 +326,7 @@ impl State {
fn handle_eos(&mut self) -> Vec<gst::Buffer> {
let mut ret = vec![];
gst_log!(CAT, "handling EOS, {}", self.pending.len());
gst::log!(CAT, "handling EOS, {}", self.pending.len());
self.drain(&mut ret, None);
ret
@ -340,7 +340,7 @@ impl JsonToVtt {
_element: &super::JsonToVtt,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_trace!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::trace!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut state = self.state.lock().unwrap();
let buffers = state.handle_buffer(pad, buffer)?;
@ -359,20 +359,20 @@ impl JsonToVtt {
fn src_event(&self, pad: &gst::Pad, element: &super::JsonToVtt, 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::CustomUpstream(ev) => {
if gst_video::ForceKeyUnitEvent::is(ev) {
match gst_video::UpstreamForceKeyUnitEvent::parse(ev) {
Ok(fku_event) => {
gst_log!(CAT, obj: pad, "Handling fku {:?}", fku_event);
gst::log!(CAT, obj: pad, "Handling fku {:?}", fku_event);
if fku_event.running_time.is_some() {
self.handle_fku(ForceKeyUnitRequest::new_from_event(&fku_event));
}
}
Err(_) => gst_warning!(
Err(_) => gst::warning!(
CAT,
obj: element,
"Invalid force-key-unit event received from downstream: {:?}",
@ -390,10 +390,10 @@ impl JsonToVtt {
fn sink_event(&self, pad: &gst::Pad, element: &super::JsonToVtt, 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::Eos(..) => {
gst_log!(CAT, obj: pad, "Handling EOS");
gst::log!(CAT, obj: pad, "Handling EOS");
let mut state = self.state.lock().unwrap();
let buffers = state.handle_eos();
drop(state);
@ -407,13 +407,13 @@ impl JsonToVtt {
};
if downstream_caps.is_empty() {
gst_error!(CAT, obj: pad, "Empty downstream caps");
gst::error!(CAT, obj: pad, "Empty downstream caps");
return false;
}
downstream_caps.fixate();
gst_debug!(
gst::debug!(
CAT,
obj: pad,
"Negotiating for downstream caps {}",
@ -454,7 +454,7 @@ impl JsonToVtt {
pad.event_default(Some(element), event)
}
EventView::Gap(ev) => {
gst_log!(CAT, obj: pad, "Handling gap {:?}", ev);
gst::log!(CAT, obj: pad, "Handling gap {:?}", ev);
let mut state = self.state.lock().unwrap();
let buffers = state.handle_gap(ev);
drop(state);
@ -582,7 +582,7 @@ impl ElementImpl for JsonToVtt {
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);
if transition == gst::StateChange::ReadyToPaused {
let mut state = self.state.lock().unwrap();

15
video/closedcaption/src/mcc_enc/imp.rs
View file

@ -10,7 +10,6 @@ use gst::glib;
use gst::prelude::*;
use gst::structure;
use gst::subclass::prelude::*;
use gst::{gst_error, gst_log, gst_trace};
use chrono::prelude::*;
use uuid::Uuid;
@ -318,7 +317,7 @@ impl MccEnc {
element: &super::MccEnc,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut state = self.state.lock().unwrap();
@ -342,7 +341,7 @@ impl MccEnc {
fn sink_event(&self, pad: &gst::Pad, element: &super::MccEnc, 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(ev) => {
@ -351,7 +350,7 @@ impl MccEnc {
let framerate = match s.get::<gst::Fraction>("framerate") {
Ok(framerate) => framerate,
Err(structure::GetError::FieldNotFound { .. }) => {
gst_error!(CAT, obj: pad, "Caps without framerate");
gst::error!(CAT, obj: pad, "Caps without framerate");
return false;
}
err => panic!("MccEnc::sink_event caps: {:?}", err),
@ -385,10 +384,10 @@ impl MccEnc {
fn src_event(&self, pad: &gst::Pad, element: &super::MccEnc, 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(_) => {
gst_log!(CAT, obj: pad, "Dropping seek event");
gst::log!(CAT, obj: pad, "Dropping seek event");
false
}
_ => pad.event_default(Some(element), event),
@ -403,7 +402,7 @@ impl MccEnc {
) -> 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) => {
@ -611,7 +610,7 @@ impl ElementImpl for MccEnc {
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 => {

87
video/closedcaption/src/mcc_parse/imp.rs
View file

@ -9,10 +9,7 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{
element_error, gst_debug, gst_error, gst_fixme, gst_info, gst_log, gst_trace, gst_warning,
loggable_error,
};
use gst::{element_error, loggable_error};
use gst_video::ValidVideoTimeCode;
use std::cmp;
@ -191,7 +188,7 @@ impl State {
gst::FlowError::Error
})?;
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Invalid timecode {:?}, using previous {:?}",
@ -218,7 +215,7 @@ impl State {
let start_position = self.start_position.expect("checked above");
let nsecs = nsecs.checked_sub(start_position).unwrap_or_else(|| {
gst_fixme!(
gst::fixme!(
CAT,
obj: element,
"New position {} < start position {}",
@ -234,7 +231,7 @@ impl State {
{
self.last_position = Some(nsecs);
} else {
gst_fixme!(
gst::fixme!(
CAT,
obj: element,
"New position {} < last position {}",
@ -310,7 +307,7 @@ impl State {
};
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);
}
}
@ -387,7 +384,7 @@ impl MccParse {
Ok(Some(MccLine::Caption(tc, Some(data)))) => {
assert!(!state.seeking);
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Got caption buffer with timecode {:?} and size {}",
@ -406,7 +403,7 @@ impl MccParse {
}
if data.len() < 3 {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Too small caption packet: {}",
@ -419,14 +416,14 @@ 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, obj: element, "Unknown DID {:x} SDID {:x}", did, sdid);
continue;
}
};
let len = data[2];
if data.len() < 3 + len as usize {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Too small caption packet: {} < {}",
@ -454,7 +451,7 @@ impl MccParse {
state = self.handle_skipped_line(element, tc, state)?;
}
Ok(Some(MccLine::TimeCodeRate(rate, df))) => {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Got timecode rate {} (drop frame {})",
@ -468,7 +465,7 @@ impl MccParse {
}
}
Ok(Some(line)) => {
gst_debug!(CAT, obj: element, "Got line '{:?}'", line);
gst::debug!(CAT, obj: element, "Got line '{:?}'", line);
}
Err((line, err)) => {
element_error!(
@ -562,13 +559,13 @@ impl MccParse {
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
})?;
@ -592,18 +589,18 @@ impl MccParse {
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
}
};
@ -657,7 +654,7 @@ impl MccParse {
&self,
element: &super::MccParse,
) -> Result<Option<ValidVideoTimeCode>, 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);
@ -724,7 +721,7 @@ impl MccParse {
}
if last_tc.is_some() || offset == 0 {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Duration scan done, last_tc: {:?}",
@ -757,7 +754,7 @@ impl MccParse {
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);
}
}
@ -790,13 +787,13 @@ impl MccParse {
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");
let _ = self.sinkpad.pause_task();
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);
element_error!(
element,
@ -841,17 +838,17 @@ impl MccParse {
Err(flow) => {
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);
element_error!(
element,
@ -872,7 +869,7 @@ impl MccParse {
element: &super::MccParse,
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), false)
}
@ -900,17 +897,17 @@ impl MccParse {
fn sink_event(&self, pad: &gst::Pad, element: &super::MccParse, 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(_) => {
@ -921,9 +918,9 @@ impl MccParse {
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, false) {
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)
}
@ -932,7 +929,7 @@ impl MccParse {
&& !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
@ -945,7 +942,7 @@ impl MccParse {
fn perform_seek(&self, event: &gst::event::Seek, element: &super::MccParse) -> 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;
}
@ -954,7 +951,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, obj: element, "seek has invalid format");
return false;
}
};
@ -962,18 +959,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, 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;
}
@ -983,14 +980,14 @@ impl MccParse {
.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);
let _ = self.sinkpad.pause_task();
@ -1018,7 +1015,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, obj: element, "Sending event {:?} upstream", event);
self.sinkpad.push_event(event);
state = self.state.lock().unwrap();
@ -1039,7 +1036,7 @@ impl MccParse {
fn src_event(&self, pad: &gst::Pad, element: &super::MccParse, 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),
@ -1054,7 +1051,7 @@ impl MccParse {
) -> 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) => {
@ -1252,7 +1249,7 @@ impl ElementImpl for MccParse {
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 => {

23
video/closedcaption/src/scc_enc/imp.rs
View file

@ -11,7 +11,6 @@ use gst::glib;
use gst::prelude::*;
use gst::structure;
use gst::subclass::prelude::*;
use gst::{gst_error, gst_log, gst_trace};
use gst_video::{self, ValidVideoTimeCode};
use once_cell::sync::Lazy;
@ -255,13 +254,13 @@ impl SccEnc {
element: &super::SccEnc,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut state = self.state.lock().unwrap();
let res = state.generate_caption(element, buffer)?;
if let Some(outbuf) = res {
gst_trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &outbuf);
gst::trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &outbuf);
drop(state);
self.srcpad.push(outbuf)?;
@ -273,7 +272,7 @@ impl SccEnc {
fn sink_event(&self, pad: &gst::Pad, element: &super::SccEnc, 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(ev) => {
@ -282,7 +281,7 @@ impl SccEnc {
let framerate = match s.get::<gst::Fraction>("framerate") {
Ok(framerate) => Some(framerate),
Err(structure::GetError::FieldNotFound { .. }) => {
gst_error!(CAT, obj: pad, "Caps without framerate");
gst::error!(CAT, obj: pad, "Caps without framerate");
return false;
}
err => panic!("SccEnc::sink_event caps: {:?}", err),
@ -301,15 +300,15 @@ impl SccEnc {
let outbuf = state.write_line(element);
if let Ok(Some(buffer)) = outbuf {
gst_trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &buffer);
gst::trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &buffer);
drop(state);
if self.srcpad.push(buffer).is_err() {
gst_error!(CAT, obj: pad, "Failed to push buffer to the pad");
gst::error!(CAT, obj: pad, "Failed to push buffer to the pad");
return false;
}
} else if let Err(err) = outbuf {
gst_error!(CAT, obj: pad, "Failed to write a line after EOS: {:?}", err);
gst::error!(CAT, obj: pad, "Failed to write a line after EOS: {:?}", err);
return false;
}
pad.event_default(Some(element), event)
@ -321,10 +320,10 @@ impl SccEnc {
fn src_event(&self, pad: &gst::Pad, element: &super::SccEnc, 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(_) => {
gst_log!(CAT, obj: pad, "Dropping seek event");
gst::log!(CAT, obj: pad, "Dropping seek event");
false
}
_ => pad.event_default(Some(element), event),
@ -339,7 +338,7 @@ impl SccEnc {
) -> 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) => {
@ -512,7 +511,7 @@ impl ElementImpl for SccEnc {
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 => {

81
video/closedcaption/src/scc_parse/imp.rs
View file

@ -10,10 +10,7 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{
element_error, gst_debug, gst_error, gst_fixme, gst_info, gst_log, gst_trace, gst_warning,
loggable_error,
};
use gst::{element_error, loggable_error};
use std::cmp;
use std::sync::{Mutex, MutexGuard};
@ -164,7 +161,7 @@ impl State {
gst::FlowError::Error
})?;
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Invalid timecode {:?}, using previous {:?}",
@ -192,7 +189,7 @@ impl State {
{
self.last_position = Some(nsecs);
} else {
gst_fixme!(
gst::fixme!(
CAT,
obj: element,
"New position {} < last position {}",
@ -256,7 +253,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, obj: element, "Caps changed to {:?}", &caps);
}
}
@ -314,7 +311,7 @@ impl SccParse {
state = self.handle_line(tc, data, element, state)?;
}
Ok(Some(line)) => {
gst_debug!(CAT, obj: element, "Got line '{:?}'", line);
gst::debug!(CAT, obj: element, "Got line '{:?}'", line);
}
Err((line, err)) => {
element_error!(
@ -342,7 +339,7 @@ impl SccParse {
element: &super::SccParse,
mut state: MutexGuard<State>,
) -> Result<MutexGuard<State>, gst::FlowError> {
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Got caption buffer with timecode {:?} and size {}",
@ -370,7 +367,7 @@ impl SccParse {
end_timecode.add_frames(num_bufs + 1);
let stop_time = end_timecode.time_since_daily_jam();
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Checking inside of segment, line start {} line stop {} segment start {} num bufs {}",
@ -417,7 +414,7 @@ impl SccParse {
if clip_buffers {
let end_time = buffer.pts().opt_add(buffer.duration());
if end_time.opt_lt(segment_start).unwrap_or(false) {
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Skip segment clipped buffer {:?}",
@ -452,12 +449,12 @@ impl SccParse {
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_list(buffers).map_err(|err| {
gst_error!(CAT, obj: element, "Pushing buffer returned {:?}", err);
gst::error!(CAT, obj: element, "Pushing buffer returned {:?}", err);
err
})?;
@ -480,18 +477,18 @@ impl SccParse {
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
}
};
@ -545,7 +542,7 @@ impl SccParse {
&self,
element: &super::SccParse,
) -> Result<Option<gst_video::ValidVideoTimeCode>, 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);
@ -614,7 +611,7 @@ impl SccParse {
}
if last_tc.is_some() || offset == 0 {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Duration scan done, last_tc: {:?}",
@ -645,7 +642,7 @@ impl SccParse {
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);
}
}
@ -669,13 +666,13 @@ impl SccParse {
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");
let _ = self.sinkpad.pause_task();
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);
element_error!(
element,
@ -719,17 +716,17 @@ impl SccParse {
Err(flow) => {
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);
element_error!(
element,
@ -750,7 +747,7 @@ impl SccParse {
element: &super::SccParse,
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))
}
@ -775,17 +772,17 @@ impl SccParse {
fn sink_event(&self, pad: &gst::Pad, element: &super::SccParse, 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(_) => {
@ -796,9 +793,9 @@ impl SccParse {
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)
}
@ -807,7 +804,7 @@ impl SccParse {
&& !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
@ -820,7 +817,7 @@ impl SccParse {
fn perform_seek(&self, event: &gst::event::Seek, element: &super::SccParse) -> 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;
}
@ -829,7 +826,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, obj: element, "seek has invalid format");
return false;
}
};
@ -837,18 +834,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, 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;
}
@ -858,14 +855,14 @@ impl SccParse {
.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);
let _ = self.sinkpad.pause_task();
@ -893,7 +890,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, obj: element, "Sending event {:?} upstream", event);
self.sinkpad.push_event(event);
state = self.state.lock().unwrap();
@ -914,7 +911,7 @@ impl SccParse {
fn src_event(&self, pad: &gst::Pad, element: &super::SccParse, 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),
@ -929,7 +926,7 @@ impl SccParse {
) -> 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) => {
@ -1112,7 +1109,7 @@ impl ElementImpl for SccParse {
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 => {

27
video/closedcaption/src/transcriberbin/imp.rs
View file

@ -11,7 +11,6 @@ use anyhow::Error;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log, gst_trace};
use std::sync::Mutex;
use once_cell::sync::Lazy;
@ -85,7 +84,7 @@ impl TranscriberBin {
element: &super::TranscriberBin,
state: &mut State,
) -> Result<(), Error> {
gst_debug!(CAT, obj: element, "Building transcription bin");
gst::debug!(CAT, obj: element, "Building transcription bin");
let aqueue_transcription = gst::ElementFactory::make("queue", Some("transqueue"))?;
let ccconverter = gst::ElementFactory::make("ccconverter", None)?;
@ -263,7 +262,7 @@ impl TranscriberBin {
let passthrough = self.settings.lock().unwrap().passthrough;
if passthrough {
gst_debug!(CAT, obj: element, "disabling transcription bin");
gst::debug!(CAT, obj: element, "disabling transcription bin");
let bin_sink_pad = state.transcription_bin.static_pad("sink").unwrap();
if let Some(audio_tee_pad) = bin_sink_pad.peer() {
@ -330,7 +329,7 @@ impl TranscriberBin {
fn setup_cc_mode(&self, element: &super::TranscriberBin, state: &State) {
let mode = self.settings.lock().unwrap().mode;
gst_debug!(CAT, obj: element, "setting CC mode {:?}", mode);
gst::debug!(CAT, obj: element, "setting CC mode {:?}", mode);
state.tttocea608.set_property("mode", mode);
@ -353,7 +352,7 @@ impl TranscriberBin {
element: &super::TranscriberBin,
old_transcriber: &gst::Element,
) -> Result<(), Error> {
gst_error!(
gst::error!(
CAT,
obj: element,
"Relinking transcriber, old: {:?}, new: {:?}",
@ -386,7 +385,7 @@ impl TranscriberBin {
) -> 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) => {
@ -463,7 +462,7 @@ impl TranscriberBin {
) -> 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) => {
let mut state = self.state.lock().unwrap();
@ -481,7 +480,7 @@ impl TranscriberBin {
}
if !had_framerate {
gst_info!(
gst::info!(
CAT,
obj: element,
"Received video caps, setting up transcription"
@ -666,7 +665,7 @@ impl ObjectImpl for TranscriberBin {
match self.relink_transcriber(state, obj, &old_transcriber) {
Ok(()) => (),
Err(err) => {
gst_error!(CAT, "invalid transcriber: {}", err);
gst::error!(CAT, "invalid transcriber: {}", err);
drop(s);
*self.state.lock().unwrap() = None;
}
@ -725,12 +724,12 @@ impl ObjectImpl for TranscriberBin {
Ok(mut state) => match self.construct_internal_bin(obj, &mut state) {
Ok(()) => Some(state),
Err(err) => {
gst_error!(CAT, "Failed to build internal bin: {}", err);
gst::error!(CAT, "Failed to build internal bin: {}", err);
None
}
},
Err(err) => {
gst_error!(CAT, "Failed to build state: {}", err);
gst::error!(CAT, "Failed to build state: {}", err);
None
}
}
@ -804,7 +803,7 @@ impl ElementImpl for TranscriberBin {
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 => {
@ -812,7 +811,7 @@ impl ElementImpl for TranscriberBin {
if let Some(ref mut state) = state.as_mut() {
if state.framerate.is_some() {
gst_info!(
gst::info!(
CAT,
obj: element,
"Received video caps, setting up transcription"
@ -846,7 +845,7 @@ impl BinImpl for TranscriberBin {
if let Some(state) = s.as_ref() {
if msg.src().as_ref() == Some(state.transcriber.upcast_ref()) {
gst_error!(
gst::error!(
CAT,
obj: bin,
"Transcriber has posted an error ({:?}), going back to passthrough",

35
video/closedcaption/src/tttocea608/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace, gst_warning};
use once_cell::sync::Lazy;
@ -160,7 +159,7 @@ fn cc_data_buffer(
let data = cc_data.to_be_bytes();
if cc_data != 0x8080 {
gst_log!(
gst::log!(
CAT,
obj: element,
"{} -> {}: {}",
@ -169,7 +168,7 @@ fn cc_data_buffer(
eia608_to_text(cc_data)
);
} else {
gst_trace!(CAT, obj: element, "{} -> {}: padding", pts, pts + duration);
gst::trace!(CAT, obj: element, "{} -> {}: padding", pts, pts + duration);
}
buf_mut.copy_from_slice(0, &data).unwrap();
@ -213,7 +212,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, obj: element, "More text than bandwidth!");
}
let next_pts = (self.last_frame_no * gst::ClockTime::SECOND)
@ -561,7 +560,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, obj: element, "Initial skip to frame no {}", frame_no);
state.last_frame_no = pts.mul_div_floor(fps_n, fps_d).unwrap().seconds();
}
@ -613,14 +612,14 @@ impl TtToCea608 {
let mut prev_char = 0;
for line in &lines.lines {
gst_log!(CAT, obj: element, "Processing {:?}", line);
gst::log!(CAT, obj: element, "Processing {:?}", line);
if let Some(line_row) = line.row {
row = line_row;
}
if row > 14 {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Dropping line after 15th row: {:?}",
@ -687,7 +686,7 @@ 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, obj: element, "Not translating UTF8: {}", c);
cc_data = *SPACE;
}
@ -756,7 +755,7 @@ impl TtToCea608 {
}
} else if col > 31 {
if chars.peek().is_some() {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Dropping characters after 32nd column: {}",
@ -805,7 +804,7 @@ impl TtToCea608 {
element: &super::TtToCea608,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: element, "Handling {:?}", buffer);
gst::log!(CAT, obj: element, "Handling {:?}", buffer);
let pts = buffer.pts().ok_or_else(|| {
gst::element_error!(
@ -826,7 +825,7 @@ impl TtToCea608 {
})?;
let data = buffer.map_readable().map_err(|_| {
gst_error!(CAT, obj: pad, "Can't map buffer readable");
gst::error!(CAT, obj: pad, "Can't map buffer readable");
gst::FlowError::Error
})?;
@ -843,7 +842,7 @@ impl TtToCea608 {
match state.json_input {
false => {
let data = std::str::from_utf8(&data).map_err(|err| {
gst_error!(CAT, obj: pad, "Can't decode utf8: {}", err);
gst::error!(CAT, obj: pad, "Can't decode utf8: {}", err);
gst::FlowError::Error
})?;
@ -877,7 +876,7 @@ impl TtToCea608 {
}
true => {
lines = serde_json::from_slice(&data).map_err(|err| {
gst_error!(CAT, obj: pad, "Failed to parse input as json: {}", err);
gst::error!(CAT, obj: pad, "Failed to parse input as json: {}", err);
gst::FlowError::Error
})?;
@ -893,7 +892,7 @@ impl TtToCea608 {
}
fn sink_event(&self, pad: &gst::Pad, element: &super::TtToCea608, event: gst::Event) -> bool {
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
gst::log!(CAT, obj: pad, "Handling event {:?}", event);
use gst::EventView;
@ -905,7 +904,7 @@ impl TtToCea608 {
};
if downstream_caps.is_empty() {
gst_error!(CAT, obj: pad, "Empty downstream caps");
gst::error!(CAT, obj: pad, "Empty downstream caps");
return false;
}
@ -925,7 +924,7 @@ impl TtToCea608 {
let s = upstream_caps.structure(0).unwrap();
state.json_input = s.name() == "application/x-json";
gst_debug!(CAT, obj: pad, "Pushing caps {}", caps);
gst::debug!(CAT, obj: pad, "Pushing caps {}", caps);
let new_event = gst::event::Caps::new(&downstream_caps);
@ -946,7 +945,7 @@ impl TtToCea608 {
if state.last_frame_no == 0 {
state.last_frame_no = timestamp.mul_div_floor(fps_n, fps_d).unwrap().seconds();
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Initial skip to frame no {}",
@ -1213,7 +1212,7 @@ impl ElementImpl for TtToCea608 {
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 => {

3
video/closedcaption/src/tttojson/imp.rs
View file

@ -7,7 +7,6 @@
// SPDX-License-Identifier: MPL-2.0
use gst::glib;
use gst::gst_log;
use gst::prelude::*;
use gst::subclass::prelude::*;
@ -124,7 +123,7 @@ impl TtToJson {
fn sink_event(&self, pad: &gst::Pad, element: &super::TtToJson, 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(_) => {

47
video/dav1d/src/dav1ddec/imp.rs
View file

@ -11,7 +11,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_trace, gst_warning};
use gst_video::prelude::*;
use gst_video::subclass::prelude::*;
@ -60,7 +59,7 @@ impl Dav1dDec {
(dav1d::PixelLayout::I422, _) => "I422",
(dav1d::PixelLayout::I444, _) => "Y444",
(layout, bpc) => {
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Unsupported dav1d format {:?}/{:?}",
@ -90,7 +89,7 @@ impl Dav1dDec {
}
};
f.parse::<gst_video::VideoFormat>().unwrap_or_else(|_| {
gst_warning!(CAT, obj: element, "Unsupported dav1d format: {}", f);
gst::warning!(CAT, obj: element, "Unsupported dav1d format: {}", f);
gst_video::VideoFormat::Unknown
})
}
@ -121,7 +120,7 @@ impl Dav1dDec {
return Ok(state_guard);
}
gst_info!(
gst::info!(
CAT,
obj: element,
"Negotiating format {:?} picture dimensions {}x{}",
@ -146,7 +145,7 @@ impl Dav1dDec {
}
fn flush_decoder(&self, element: &super::Dav1dDec, state_guard: &mut Option<State>) {
gst_info!(CAT, obj: element, "Flushing decoder");
gst::info!(CAT, obj: element, "Flushing decoder");
let state = state_guard.as_mut().unwrap();
state.decoder.flush();
@ -159,7 +158,7 @@ impl Dav1dDec {
input_buffer: gst::Buffer,
frame: gst_video::VideoCodecFrame,
) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> {
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Sending data to decoder for frame {}",
@ -182,15 +181,15 @@ impl Dav1dDec {
.send_data(input_data, frame_number, timestamp, duration)
{
Ok(()) => {
gst_trace!(CAT, obj: element, "Decoder returned OK");
gst::trace!(CAT, obj: element, "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, obj: element, "Decoder returned EAGAIN");
Ok(std::ops::ControlFlow::Continue(()))
}
Err(err) => {
gst_error!(CAT, "Sending data failed (error code: {})", err);
gst::error!(CAT, "Sending data failed (error code: {})", err);
element.release_frame(frame);
return gst_video::video_decoder_error!(
element,
@ -208,21 +207,21 @@ impl Dav1dDec {
element: &super::Dav1dDec,
state_guard: &mut AtomicRefMut<Option<State>>,
) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> {
gst_trace!(CAT, obj: element, "Sending pending data to decoder");
gst::trace!(CAT, obj: element, "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, obj: element, "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, obj: element, "Decoder returned EAGAIN");
Ok(std::ops::ControlFlow::Continue(()))
}
Err(err) => {
gst_error!(CAT, "Sending data failed (error code: {})", err);
gst::error!(CAT, "Sending data failed (error code: {})", err);
return gst_video::video_decoder_error!(
element,
1,
@ -274,7 +273,7 @@ impl Dav1dDec {
let mem = if video_meta_supported || src_stride == dest_stride {
gst::Memory::from_slice(plane)
} else {
gst_trace!(
gst::trace!(
gst::CAT_PERFORMANCE,
obj: element,
"Copying decoded video frame component {:?}",
@ -335,7 +334,7 @@ impl Dav1dDec {
mut state_guard: AtomicRefMut<'s, Option<State>>,
pic: &dav1d::Picture,
) -> Result<AtomicRefMut<'s, Option<State>>, gst::FlowError> {
gst_trace!(CAT, obj: element, "Handling picture {}", pic.offset());
gst::trace!(CAT, obj: element, "Handling picture {}", pic.offset());
state_guard = self.handle_resolution_change(element, state_guard, pic)?;
@ -352,14 +351,14 @@ impl Dav1dDec {
element.finish_frame(frame)?;
Ok(self.state.borrow_mut())
} else {
gst_warning!(CAT, obj: element, "No frame found for offset {}", offset);
gst::warning!(CAT, obj: element, "No frame found for offset {}", offset);
Ok(state_guard)
}
}
fn drop_decoded_pictures(&self, element: &super::Dav1dDec, state_guard: &mut Option<State>) {
while let Ok(Some(pic)) = self.pending_pictures(element, state_guard) {
gst_debug!(CAT, obj: element, "Dropping picture {}", pic.offset());
gst::debug!(CAT, obj: element, "Dropping picture {}", pic.offset());
drop(pic);
}
}
@ -369,21 +368,21 @@ impl Dav1dDec {
element: &super::Dav1dDec,
state_guard: &mut Option<State>,
) -> Result<Option<dav1d::Picture>, gst::FlowError> {
gst_trace!(CAT, obj: element, "Retrieving pending picture");
gst::trace!(CAT, obj: element, "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, obj: element, "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, obj: element, "Decoder needs more data");
Ok(None)
}
Err(err) => {
gst_error!(
gst::error!(
CAT,
obj: element,
"Retrieving decoded picture failed (error code {})",
@ -598,7 +597,7 @@ impl VideoDecoderImpl for Dav1dDec {
}
fn flush(&self, element: &Self::Type) -> bool {
gst_info!(CAT, obj: element, "Flushing");
gst::info!(CAT, obj: element, "Flushing");
{
let mut state_guard = self.state.borrow_mut();
@ -610,7 +609,7 @@ impl VideoDecoderImpl for Dav1dDec {
}
fn drain(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_info!(CAT, obj: element, "Draining");
gst::info!(CAT, obj: element, "Draining");
{
let mut state_guard = self.state.borrow_mut();
@ -622,7 +621,7 @@ impl VideoDecoderImpl for Dav1dDec {
}
fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_info!(CAT, obj: element, "Finishing");
gst::info!(CAT, obj: element, "Finishing");
{
let mut state_guard = self.state.borrow_mut();

2
video/ffv1/src/ffv1dec/imp.rs
View file

@ -436,7 +436,7 @@ impl VideoDecoderImpl for Ffv1Dec {
.expect("Could not map input buffer for read");
let decoded_frame = decoder.decode_frame(input_buffer.as_slice()).map_err(|e| {
gst::gst_error!(CAT, "Decoding failed: {}", e);
gst::error!(CAT, "Decoding failed: {}", e);
gst::FlowError::Error
})?;

73
video/flavors/src/flvdemux/imp.rs
View file

@ -18,7 +18,6 @@ use ::flavors::parser as flavors;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace, gst_warning};
use num_rational::Rational32;
@ -317,10 +316,10 @@ impl FlvDemux {
// gst::SchedulingFlags::SEEKABLE,
// )
// {
// gst_debug!(CAT, obj: pad, "Activating in Pull mode");
// gst::debug!(CAT, obj: pad, "Activating in Pull mode");
// 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
// }
};
@ -378,7 +377,7 @@ impl FlvDemux {
fn sink_event(&self, pad: &gst::Pad, element: &super::FlvDemux, 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::Eos(..) => {
// TODO implement
@ -471,7 +470,7 @@ impl FlvDemux {
element: &super::FlvDemux,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut adapter = self.adapter.lock().unwrap();
adapter.push(buffer);
@ -484,7 +483,7 @@ impl FlvDemux {
let header = match self.find_header(element, &mut *adapter) {
Ok(header) => header,
Err(_) => {
gst_trace!(CAT, obj: element, "Need more data");
gst::trace!(CAT, obj: element, "Need more data");
return Ok(gst::FlowSuccess::Ok);
}
};
@ -513,7 +512,7 @@ impl FlvDemux {
} => {
let avail = adapter.available();
if avail == 0 {
gst_trace!(CAT, obj: element, "Need more data");
gst::trace!(CAT, obj: element, "Need more data");
return Ok(gst::FlowSuccess::Ok);
}
let skip = cmp::min(avail, *skip_left as usize);
@ -525,7 +524,7 @@ impl FlvDemux {
match res {
Ok(None) => {
gst_trace!(CAT, obj: element, "Need more data");
gst::trace!(CAT, obj: element, "Need more data");
return Ok(gst::FlowSuccess::Ok);
}
Ok(Some(events)) => {
@ -556,7 +555,7 @@ impl FlvDemux {
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, obj: element, "Found FLV header: {:?}", header);
drop(data);
adapter.flush(9);
@ -618,7 +617,7 @@ impl FlvDemux {
if let Some(pad) = pad {
let res = pad.push(buffer);
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Pushing buffer for stream {:?} returned {:?}",
@ -710,7 +709,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, obj: element, "Previous tag size {}", previous_size);
// Nothing to do here, we just consume it for now
}
}
@ -726,7 +725,7 @@ impl StreamingState {
Ok((_, tag_header)) => tag_header,
};
gst_trace!(CAT, obj: element, "Parsed tag header {:?}", tag_header);
gst::trace!(CAT, obj: element, "Parsed tag header {:?}", tag_header);
drop(data);
@ -738,17 +737,17 @@ impl StreamingState {
match tag_header.tag_type {
flavors::TagType::Script => {
gst_trace!(CAT, obj: element, "Found script tag");
gst::trace!(CAT, obj: element, "Found script tag");
Ok(self.handle_script_tag(element, &tag_header, adapter))
}
flavors::TagType::Audio => {
gst_trace!(CAT, obj: element, "Found audio tag");
gst::trace!(CAT, obj: element, "Found audio tag");
self.handle_audio_tag(element, &tag_header, adapter)
}
flavors::TagType::Video => {
gst_trace!(CAT, obj: element, "Found video tag");
gst::trace!(CAT, obj: element, "Found video tag");
self.handle_video_tag(element, &tag_header, adapter)
}
@ -770,10 +769,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, obj: element, "Got script tag: {:?}", script_data);
let metadata = Metadata::new(script_data);
gst_debug!(CAT, obj: element, "Got metadata: {:?}", metadata);
gst::debug!(CAT, obj: element, "Got metadata: {:?}", metadata);
let audio_changed = self
.audio
@ -801,10 +800,10 @@ impl StreamingState {
}
}
Ok((_, ref script_data)) => {
gst_trace!(CAT, obj: element, "Got script tag: {:?}", script_data);
gst::trace!(CAT, obj: element, "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, obj: element, "Error parsing script tag: {:?}", err);
}
Err(nom::Err::Incomplete(_)) => {
// ignore
@ -824,7 +823,7 @@ impl StreamingState {
) -> SmallVec<[Event; 4]> {
let mut events = SmallVec::new();
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Got audio data header: {:?}",
@ -835,7 +834,7 @@ impl StreamingState {
AudioFormat::new(data_header, &self.metadata, &self.aac_sequence_header);
if self.audio.as_ref() != Some(&new_audio_format) {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Got new audio format: {:?}",
@ -853,7 +852,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, obj: element, "Have all expected streams now");
self.got_all_streams = true;
events.push(Event::HaveAllStreams);
}
@ -870,7 +869,7 @@ impl StreamingState {
// Not big enough for the AAC packet header, ship!
if tag_header.data_size < 1 + 1 {
adapter.flush((tag_header.data_size - 1) as usize);
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Too small packet for AAC packet header {}",
@ -883,7 +882,7 @@ impl StreamingState {
match flavors::aac_audio_packet_header(&*data) {
Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
gst_error!(
gst::error!(
CAT,
obj: element,
"Invalid AAC audio packet header: {:?}",
@ -895,7 +894,7 @@ impl StreamingState {
}
Err(nom::Err::Incomplete(_)) => unreachable!(),
Ok((_, header)) => {
gst_trace!(CAT, obj: element, "Got AAC packet header {:?}", header);
gst::trace!(CAT, obj: element, "Got AAC packet header {:?}", header);
match header.packet_type {
flavors::AACPacketType::SequenceHeader => {
drop(data);
@ -903,7 +902,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, obj: element, "Got AAC sequence header {:?}", buffer,);
self.aac_sequence_header = Some(buffer);
Ok(true)
@ -929,7 +928,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, obj: element, "Invalid audio data header: {:?}", err);
drop(data);
adapter.flush(tag_header.data_size as usize);
return Ok(SmallVec::new());
@ -972,7 +971,7 @@ impl StreamingState {
buffer.set_pts(gst::ClockTime::from_mseconds(tag_header.timestamp as u64));
}
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Outputting audio buffer {:?} for tag {:?}",
@ -994,7 +993,7 @@ impl StreamingState {
) -> SmallVec<[Event; 4]> {
let mut events = SmallVec::new();
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Got video data header: {:?}",
@ -1005,7 +1004,7 @@ impl StreamingState {
VideoFormat::new(data_header, &self.metadata, &self.avc_sequence_header);
if self.video.as_ref() != Some(&new_video_format) {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Got new video format: {:?}",
@ -1023,7 +1022,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, obj: element, "Have all expected streams now");
self.got_all_streams = true;
events.push(Event::HaveAllStreams);
}
@ -1040,7 +1039,7 @@ impl StreamingState {
// Not big enough for the AVC packet header, skip!
if tag_header.data_size < 1 + 4 {
adapter.flush((tag_header.data_size - 1) as usize);
gst_warning!(
gst::warning!(
CAT,
obj: element,
"Too small packet for AVC packet header {}",
@ -1052,7 +1051,7 @@ 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!(
gst::error!(
CAT,
obj: element,
"Invalid AVC video packet header: {:?}",
@ -1064,7 +1063,7 @@ impl StreamingState {
}
Err(nom::Err::Incomplete(_)) => unreachable!(),
Ok((_, header)) => {
gst_trace!(CAT, obj: element, "Got AVC packet header {:?}", header);
gst::trace!(CAT, obj: element, "Got AVC packet header {:?}", header);
match header.packet_type {
flavors::AVCPacketType::SequenceHeader => {
drop(data);
@ -1072,7 +1071,7 @@ impl StreamingState {
let buffer = adapter
.take_buffer((tag_header.data_size - 1 - 4) as usize)
.unwrap();
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Got AVC sequence header {:?} of size {}",
@ -1110,7 +1109,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, obj: element, "Invalid video data header: {:?}", err);
drop(data);
adapter.flush(tag_header.data_size as usize);
return Ok(SmallVec::new());
@ -1184,7 +1183,7 @@ impl StreamingState {
buffer.set_pts(gst::ClockTime::from_mseconds(pts));
}
gst_trace!(
gst::trace!(
CAT,
obj: element,
"Outputting video buffer {:?} for tag {:?}, keyframe: {}",

7
video/gif/src/gifenc/imp.rs
View file

@ -10,7 +10,6 @@
use atomic_refcell::AtomicRefCell;
use gst::glib;
use gst::gst_debug;
use gst::subclass::prelude::*;
use gst_video::prelude::*;
use gst_video::subclass::prelude::*;
@ -290,7 +289,7 @@ impl VideoEncoderImpl for GifEnc {
.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, obj: element, "Setting format {:?}", video_info);
{
let mut state = State::new(video_info);
@ -321,7 +320,7 @@ impl VideoEncoderImpl for GifEnc {
let mut state_guard = self.state.borrow_mut();
let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Sending frame {}",
@ -429,7 +428,7 @@ impl VideoEncoderImpl for GifEnc {
impl GifEnc {
fn flush_encoder(&self, element: &super::GifEnc) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_debug!(CAT, obj: element, "Flushing");
gst::debug!(CAT, obj: element, "Flushing");
let trailer_buffer = self.state.borrow_mut().as_mut().map(|state| {
// Drop encoder to flush and take flushed data (gif trailer)

19
video/gtk4/src/sink/imp.rs
View file

@ -17,7 +17,6 @@ use glib::prelude::*;
use glib::Sender;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_trace};
use gst_base::subclass::prelude::*;
use gst_video::subclass::prelude::*;
@ -92,7 +91,7 @@ impl ObjectImpl for PaintableSink {
let paintable = match &*paintable {
Some(ref paintable) => paintable,
None => {
gst_error!(CAT, obj: obj, "Failed to create paintable");
gst::error!(CAT, obj: obj, "Failed to create paintable");
return None::<&gtk::gdk::Paintable>.to_value();
}
};
@ -101,7 +100,7 @@ impl ObjectImpl for PaintableSink {
match paintable.try_get() {
Ok(paintable) => paintable.to_value(),
Err(_) => {
gst_error!(
gst::error!(
CAT,
obj: obj,
"Can't retrieve Paintable from non-main thread"
@ -189,7 +188,7 @@ impl ElementImpl for PaintableSink {
}
if paintable.is_none() {
gst_error!(CAT, obj: element, "Failed to create paintable");
gst::error!(CAT, obj: element, "Failed to create paintable");
return Err(gst::StateChangeError);
}
}
@ -212,7 +211,7 @@ 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);
gst::debug!(CAT, obj: element, "Setting caps {:?}", caps);
let video_info = gst_video::VideoInfo::from_caps(caps)
.map_err(|_| gst::loggable_error!(CAT, "Invalid caps"))?;
@ -242,28 +241,28 @@ impl VideoSinkImpl for PaintableSink {
element: &Self::Type,
buffer: &gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_trace!(CAT, obj: element, "Rendering buffer {:?}", buffer);
gst::trace!(CAT, obj: element, "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, obj: element, "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, obj: element, "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, obj: element, "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, obj: element, "Have main thread receiver shut down");
gst::FlowError::Error
})?;

6
video/gtk4/src/sink/mod.rs
View file

@ -13,8 +13,6 @@ use gtk::glib;
use gtk::glib::prelude::*;
use gtk::subclass::prelude::*;
use gst::{gst_debug, gst_trace};
use fragile::Fragile;
use std::sync::{mpsc, MutexGuard};
@ -54,7 +52,7 @@ impl PaintableSink {
&self,
paintable_storage: &mut MutexGuard<Option<Fragile<SinkPaintable>>>,
) {
gst_debug!(imp::CAT, obj: self, "Initializing paintable");
gst::debug!(imp::CAT, obj: self, "Initializing paintable");
let context = glib::MainContext::default();
@ -98,7 +96,7 @@ impl PaintableSink {
match action {
SinkEvent::FrameChanged => {
gst_trace!(imp::CAT, obj: self, "Frame changed");
gst::trace!(imp::CAT, obj: self, "Frame changed");
paintable.get().handle_frame_changed(self.pending_frame())
}
}

10
video/gtk4/src/sink/paintable/imp.rs
View file

@ -13,8 +13,6 @@ use gtk::prelude::*;
use gtk::subclass::prelude::*;
use gtk::{gdk, glib, graphene};
use gst::{gst_debug, gst_trace};
use crate::sink::frame::{Frame, Texture};
use std::cell::RefCell;
@ -77,7 +75,7 @@ impl PaintableImpl for SinkPaintable {
let paintables = self.paintables.borrow();
if !paintables.is_empty() {
gst_trace!(CAT, obj: paintable, "Snapshotting frame");
gst::trace!(CAT, obj: paintable, "Snapshotting frame");
let (frame_width, frame_height) =
paintables.first().map(|p| (p.width, p.height)).unwrap();
@ -127,7 +125,7 @@ impl PaintableImpl for SinkPaintable {
snapshot.pop();
}
} else {
gst_trace!(CAT, obj: paintable, "Snapshotting black frame");
gst::trace!(CAT, obj: paintable, "Snapshotting black frame");
snapshot.append_color(
&gdk::RGBA::BLACK,
&graphene::Rect::new(0f32, 0f32, width as f32, height as f32),
@ -139,7 +137,7 @@ impl PaintableImpl for SinkPaintable {
impl SinkPaintable {
pub(super) fn handle_frame_changed(&self, obj: &super::SinkPaintable, frame: Option<Frame>) {
if let Some(frame) = frame {
gst_trace!(CAT, obj: obj, "Received new frame");
gst::trace!(CAT, obj: obj, "Received new frame");
let new_paintables = frame.into_textures(&mut *self.cached_textures.borrow_mut());
let new_size = new_paintables
@ -153,7 +151,7 @@ impl SinkPaintable {
.map(|p| (f32::round(p.width) as u32, f32::round(p.height) as u32));
if Some(new_size) != old_size {
gst_debug!(
gst::debug!(
CAT,
obj: obj,
"Size changed from {:?} to {:?}",

15
video/hsv/src/hsvdetector/imp.rs
View file

@ -12,7 +12,6 @@ use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_info};
use gst_base::subclass::prelude::*;
use gst_video::subclass::prelude::*;
@ -238,7 +237,7 @@ impl ObjectImpl for HsvDetector {
"hue-ref" => {
let mut settings = self.settings.lock().unwrap();
let hue_ref = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing hue-ref from {} to {}",
@ -250,7 +249,7 @@ impl ObjectImpl for HsvDetector {
"hue-var" => {
let mut settings = self.settings.lock().unwrap();
let hue_var = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing hue-var from {} to {}",
@ -262,7 +261,7 @@ impl ObjectImpl for HsvDetector {
"saturation-ref" => {
let mut settings = self.settings.lock().unwrap();
let saturation_ref = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing saturation-ref from {} to {}",
@ -274,7 +273,7 @@ impl ObjectImpl for HsvDetector {
"saturation-var" => {
let mut settings = self.settings.lock().unwrap();
let saturation_var = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing saturation-var from {} to {}",
@ -286,7 +285,7 @@ impl ObjectImpl for HsvDetector {
"value-ref" => {
let mut settings = self.settings.lock().unwrap();
let value_ref = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing value-ref from {} to {}",
@ -298,7 +297,7 @@ impl ObjectImpl for HsvDetector {
"value-var" => {
let mut settings = self.settings.lock().unwrap();
let value_var = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing value-var from {} to {}",
@ -436,7 +435,7 @@ impl BaseTransformImpl for HsvDetector {
}
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Transformed caps from {} to {} in direction {:?}",

11
video/hsv/src/hsvfilter/imp.rs
View file

@ -9,7 +9,6 @@
// SPDX-License-Identifier: MIT/Apache-2.0
use gst::glib;
use gst::gst_info;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst_base::subclass::prelude::*;
@ -187,7 +186,7 @@ impl ObjectImpl for HsvFilter {
"hue-shift" => {
let mut settings = self.settings.lock().unwrap();
let hue_shift = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing hue-shift from {} to {}",
@ -199,7 +198,7 @@ impl ObjectImpl for HsvFilter {
"saturation-mul" => {
let mut settings = self.settings.lock().unwrap();
let saturation_mul = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing saturation-mul from {} to {}",
@ -211,7 +210,7 @@ impl ObjectImpl for HsvFilter {
"saturation-off" => {
let mut settings = self.settings.lock().unwrap();
let saturation_off = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing saturation-off from {} to {}",
@ -223,7 +222,7 @@ impl ObjectImpl for HsvFilter {
"value-mul" => {
let mut settings = self.settings.lock().unwrap();
let value_mul = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing value-mul from {} to {}",
@ -235,7 +234,7 @@ impl ObjectImpl for HsvFilter {
"value-off" => {
let mut settings = self.settings.lock().unwrap();
let value_off = value.get().expect("type checked upstream");
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing value-off from {} to {}",

21
video/rav1e/src/rav1enc/imp.rs
View file

@ -10,7 +10,6 @@
use atomic_refcell::AtomicRefCell;
use gst::glib;
use gst::gst_debug;
use gst::subclass::prelude::*;
use gst_video::prelude::*;
use gst_video::subclass::prelude::*;
@ -634,7 +633,7 @@ impl VideoEncoderImpl for Rav1Enc {
.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, obj: element, "Setting format {:?}", video_info);
let settings = self.settings.lock().unwrap();
@ -884,13 +883,13 @@ impl VideoEncoderImpl for Rav1Enc {
}
fn flush(&self, element: &Self::Type) -> 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 {
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, obj: element, "Dropping packet on flush",);
}
}
@ -898,7 +897,7 @@ impl VideoEncoderImpl for Rav1Enc {
}
fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_debug!(CAT, obj: element, "Finishing");
gst::debug!(CAT, obj: element, "Finishing");
let mut state_guard = self.state.borrow_mut();
if let Some(ref mut state) = *state_guard {
@ -919,7 +918,7 @@ impl VideoEncoderImpl for Rav1Enc {
self.output_frames(element, state)?;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Sending frame {}",
@ -947,7 +946,7 @@ impl VideoEncoderImpl for Rav1Enc {
.contains(gst_video::VideoCodecFrameFlags::FORCE_KEYFRAME),
) {
Ok(_) => {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Sent frame {}",
@ -974,7 +973,7 @@ impl Rav1Enc {
loop {
match state.context.receive_packet() {
Ok((packet_type, packet_number, frame_number, packet_data)) => {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Received packet {} of size {}, frame type {:?}",
@ -993,10 +992,10 @@ impl Rav1Enc {
element.finish_frame(Some(frame))?;
}
Err(data::EncoderStatus::Encoded) => {
gst_debug!(CAT, obj: element, "Encoded but not output frame yet",);
gst::debug!(CAT, obj: element, "Encoded but not output frame yet",);
}
Err(data::EncoderStatus::NeedMoreData) => {
gst_debug!(CAT, obj: element, "Encoded but need more data",);
gst::debug!(CAT, obj: element, "Encoded but need more data",);
return Ok(gst::FlowSuccess::Ok);
}
Err(data::EncoderStatus::Failure) => {
@ -1008,7 +1007,7 @@ impl Rav1Enc {
return Err(gst::FlowError::Error);
}
Err(err) => {
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Soft error when receiving frame: {:?}",

7
video/rspng/src/pngenc/imp.rs
View file

@ -13,7 +13,6 @@ use std::{io, io::Write, sync::Arc};
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error};
use gst_video::prelude::*;
use gst_video::subclass::prelude::*;
@ -129,7 +128,7 @@ impl State {
gst_video::VideoFormat::Rgb => png::ColorType::Rgb,
gst_video::VideoFormat::Rgba => png::ColorType::Rgba,
_ => {
gst_error!(CAT, "format is not supported yet");
gst::error!(CAT, "format is not supported yet");
unreachable!()
}
};
@ -310,7 +309,7 @@ impl VideoEncoderImpl for PngEncoder {
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, obj: element, "Setting format {:?}", video_info);
{
let settings = self.settings.lock();
let mut state = State::new(video_info);
@ -334,7 +333,7 @@ impl VideoEncoderImpl for PngEncoder {
let mut state_guard = self.state.lock();
let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Sending frame {}",

16
video/videofx/src/border/roundedcorners.rs
View file

@ -7,7 +7,7 @@
//
// SPDX-License-Identifier: MPL-2.0
use gst::{glib, gst_debug, gst_info, gst_log, subclass::prelude::*};
use gst::{glib, subclass::prelude::*};
use gst_base::{
prelude::*,
subclass::base_transform::{InputBuffer, PrepareOutputBufferSuccess},
@ -306,7 +306,7 @@ impl ObjectImpl for RoundedCorners {
if settings.border_radius_px != border_radius {
settings.changed = true;
settings.border_radius_px = border_radius;
gst_info!(
gst::info!(
CAT,
obj: obj,
"Changing border radius from {} to {}",
@ -408,7 +408,7 @@ impl BaseTransformImpl for RoundedCorners {
fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
let _ = self.state.lock().unwrap().take();
gst_info!(CAT, obj: element, "Stopped");
gst::info!(CAT, obj: element, "Stopped");
Ok(())
}
@ -460,7 +460,7 @@ impl BaseTransformImpl for RoundedCorners {
output_caps
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Transformed caps from {} to {} in direction {:?}",
@ -489,7 +489,7 @@ impl BaseTransformImpl for RoundedCorners {
Ok(info) => info,
};
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Configured for caps {} to {}",
@ -531,7 +531,7 @@ impl BaseTransformImpl for RoundedCorners {
let mut settings = self.settings.lock().unwrap();
if settings.changed {
settings.changed = false;
gst_debug!(
gst::debug!(
CAT,
obj: element,
"Caps or border radius changed, generating alpha mask"
@ -571,7 +571,7 @@ impl BaseTransformImpl for RoundedCorners {
match inbuf {
InputBuffer::Writable(outbuf) => {
gst_log!(
gst::log!(
CAT,
obj: element,
"Received writable input buffer of size: {}",
@ -583,7 +583,7 @@ impl BaseTransformImpl for RoundedCorners {
self.add_video_meta(outbuf, out_info, alpha_plane_offset, true)
}
InputBuffer::Readable(buf) => {
gst_log!(
gst::log!(
CAT,
obj: element,
"Received readable input buffer of size: {}",

9
video/webp/src/dec/imp.rs
View file

@ -9,7 +9,6 @@
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::{gst_log, gst_trace};
use libwebp_sys as ffi;
use once_cell::sync::Lazy;
@ -140,7 +139,7 @@ impl WebPDec {
_element: &super::WebPDec,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
let mut state = self.state.lock().unwrap();
@ -238,7 +237,7 @@ impl WebPDec {
fn sink_event(&self, pad: &gst::Pad, element: &super::WebPDec, 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::FlushStop(..) => {
let mut state = self.state.lock().unwrap();
@ -259,7 +258,7 @@ impl WebPDec {
fn src_event(&self, pad: &gst::Pad, element: &super::WebPDec, 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(..) => false,
_ => pad.event_default(Some(element), event),
@ -371,7 +370,7 @@ impl ElementImpl for WebPDec {
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);
if transition == gst::StateChange::PausedToReady {
*self.state.lock().unwrap() = State::default();