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-06-09 01:39:22 +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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log};
use std::mem; use std::mem;
use std::sync::Mutex; use std::sync::Mutex;
@ -265,7 +264,7 @@ impl State {
// Drains everything // Drains everything
fn drain(&mut self, element: &super::AudioLoudNorm) -> Result<gst::Buffer, gst::FlowError> { 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 (pts, distance) = self.adapter.prev_pts();
let distance_samples = distance / self.info.bpf() as u64; let distance_samples = distance / self.info.bpf() as u64;
@ -300,7 +299,7 @@ impl State {
self.frame_type = FrameType::Final; self.frame_type = FrameType::Final;
} else if src.is_empty() { } else if src.is_empty() {
// Nothing to drain at all // 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); return Err(gst::FlowError::Eos);
} }
@ -344,7 +343,7 @@ impl State {
} }
} }
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Calculated global loudness for first frame {} with peak {}", "Calculated global loudness for first frame {} with peak {}",
@ -398,7 +397,7 @@ impl State {
*delta = f64::powf(10.0, env_shortterm / 20.); *delta = f64::powf(10.0, env_shortterm / 20.);
} }
self.prev_delta = self.delta[self.index]; self.prev_delta = self.delta[self.index];
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Initializing for first frame with gain adjustment of {}", "Initializing for first frame with gain adjustment of {}",
@ -460,7 +459,7 @@ impl State {
self.index + 11 - 30 self.index + 11 - 30
}); });
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Applying gain adjustment {}-{}", "Applying gain adjustment {}-{}",
@ -534,7 +533,7 @@ impl State {
.relative_threshold() .relative_threshold()
.map_err(|_| gst::FlowError::Error)?; .map_err(|_| gst::FlowError::Error)?;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Calculated global loudness {}, short term loudness {} and relative threshold {}", "Calculated global loudness {}, short term loudness {} and relative threshold {}",
@ -557,7 +556,7 @@ impl State {
.map_err(|_| gst::FlowError::Error)?; .map_err(|_| gst::FlowError::Error)?;
if shortterm_out >= self.target_i { if shortterm_out >= self.target_i {
self.above_threshold = true; self.above_threshold = true;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Above threshold now ({} >= {}, {} > -70)", "Above threshold now ({} >= {}, {} > -70)",
@ -585,7 +584,7 @@ impl State {
} }
self.prev_delta = self.delta[self.index]; self.prev_delta = self.delta[self.index];
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Calculated new gain adjustment {}", "Calculated new gain adjustment {}",
@ -789,7 +788,7 @@ impl State {
) -> Result<(gst::Buffer, Option<gst::ClockTime>), gst::FlowError> { ) -> Result<(gst::Buffer, Option<gst::ClockTime>), gst::FlowError> {
// Apply a linear scale factor to the whole buffer // Apply a linear scale factor to the whole buffer
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Applying linear gain adjustment of {}", "Applying linear gain adjustment of {}",
@ -868,7 +867,7 @@ impl State {
// LIMITER_ATTACK_WINDOW before the peak position. // LIMITER_ATTACK_WINDOW before the peak position.
smp_cnt += LIMITER_LOOKAHEAD + peak_delta - LIMITER_ATTACK_WINDOW; smp_cnt += LIMITER_LOOKAHEAD + peak_delta - LIMITER_ATTACK_WINDOW;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Found peak {} at sample {}, going to attack state at sample {} (gain reduction {}-{})", "Found peak {} at sample {}, going to attack state at sample {} (gain reduction {}-{})",
@ -1005,7 +1004,7 @@ impl State {
self.env_cnt = 0; self.env_cnt = 0;
self.sustain_cnt = None; self.sustain_cnt = None;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Found new peak {} at sample {}, restarting attack state at sample {} (gain reduction {}-{})", "Found new peak {} at sample {}, restarting attack state at sample {} (gain reduction {}-{})",
@ -1054,7 +1053,7 @@ impl State {
// reach the new peak // reach the new peak
self.sustain_cnt = Some(self.env_cnt); self.sustain_cnt = Some(self.env_cnt);
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Found new peak {} at sample {}, adjusting attack state at sample {} (gain reduction {}-{})", "Found new peak {} at sample {}, adjusting attack state at sample {} (gain reduction {}-{})",
@ -1069,7 +1068,7 @@ impl State {
} else { } else {
// We're ending the attack state this much before the new peak so need // 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. // to ensure that we at least sustain it for that long afterwards.
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Found new low peak {} at sample {} in attack state at sample {}", "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 self.env_cnt == LIMITER_ATTACK_WINDOW && smp_cnt < nb_samples {
// If we reached the target gain reduction, go into sustain state. // If we reached the target gain reduction, go into sustain state.
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Going to sustain state at sample {} (gain reduction {})", "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[0] = self.gain_reduction[1];
self.gain_reduction[1] = gain_reduction; self.gain_reduction[1] = gain_reduction;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Found new peak {} at sample {}, going back to attack state at sample {} (gain reduction {}-{})", "Found new peak {} at sample {}, going back to attack state at sample {} (gain reduction {}-{})",
@ -1175,7 +1174,7 @@ impl State {
self.gain_reduction[1], self.gain_reduction[1],
); );
} else { } else {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Found new peak {} at sample {}, going sustain further at sample {} (gain reduction {})", "Found new peak {} at sample {}, going sustain further at sample {} (gain reduction {})",
@ -1202,7 +1201,7 @@ impl State {
self.gain_reduction[1] = 1.; self.gain_reduction[1] = 1.;
self.env_cnt = 0; self.env_cnt = 0;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Going to release state for sample {} at sample {} (gain reduction {}-1.0)", "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[0] = current_gain_reduction;
self.gain_reduction[1] = gain_reduction; self.gain_reduction[1] = gain_reduction;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Found new peak {} at sample {}, going back to attack state at sample {} (gain reduction {}-{})", "Found new peak {} at sample {}, going back to attack state at sample {} (gain reduction {}-{})",
@ -1284,7 +1283,7 @@ impl State {
); );
} else { } else {
self.gain_reduction[1] = current_gain_reduction; self.gain_reduction[1] = current_gain_reduction;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Going from release to sustain state at sample {} because of low peak {} at sample {} (gain reduction {})", "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 we're done with the release, go to out state
if smp_cnt < nb_samples { if smp_cnt < nb_samples {
self.limiter_state = LimiterState::Out; self.limiter_state = LimiterState::Out;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Leaving release state and going to out state at sample {}", "Leaving release state and going to out state at sample {}",
@ -1363,7 +1362,7 @@ impl State {
self.limiter_state = LimiterState::Sustain; self.limiter_state = LimiterState::Sustain;
self.sustain_cnt = Some(LIMITER_LOOKAHEAD); self.sustain_cnt = Some(LIMITER_LOOKAHEAD);
self.gain_reduction[1] = self.target_tp / max; self.gain_reduction[1] = self.target_tp / max;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Reducing gain for start of first frame by {} ({} > {}) and going to sustain state", "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 channels = self.info.channels() as usize;
let nb_samples = dst.len() / channels; let nb_samples = dst.len() / channels;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Running limiter for {} samples", "Running limiter for {} samples",
@ -1556,12 +1555,12 @@ impl AudioLoudNorm {
element: &super::AudioLoudNorm, element: &super::AudioLoudNorm,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 mut state_guard = self.state.borrow_mut();
let state = match *state_guard { let state = match *state_guard {
None => { None => {
gst_error!(CAT, obj: element, "Not negotiated yet"); gst::error!(CAT, obj: element, "Not negotiated yet");
return Err(gst::FlowError::NotNegotiated); return Err(gst::FlowError::NotNegotiated);
} }
Some(ref mut state) => state, Some(ref mut state) => state,
@ -1569,7 +1568,7 @@ impl AudioLoudNorm {
let mut outbufs = vec![]; let mut outbufs = vec![];
if buffer.flags().contains(gst::BufferFlags::DISCONT) { 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) { match state.drain(element) {
Ok(outbuf) => { Ok(outbuf) => {
outbufs.push(outbuf); outbufs.push(outbuf);
@ -1587,7 +1586,7 @@ impl AudioLoudNorm {
drop(state_guard); drop(state_guard);
for buffer in outbufs { for buffer in outbufs {
gst_log!(CAT, obj: element, "Outputting buffer {:?}", buffer); gst::log!(CAT, obj: element, "Outputting buffer {:?}", buffer);
self.srcpad.push(buffer)?; self.srcpad.push(buffer)?;
} }
@ -1602,17 +1601,17 @@ impl AudioLoudNorm {
) -> bool { ) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(c) => { EventView::Caps(c) => {
let caps = c.caps(); 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) { let info = match gst_audio::AudioInfo::from_caps(caps) {
Ok(info) => info, Ok(info) => info,
Err(_) => { Err(_) => {
gst_error!(CAT, obj: pad, "Failed to parse caps"); gst::error!(CAT, obj: pad, "Failed to parse caps");
return false; return false;
} }
}; };
@ -1630,9 +1629,9 @@ impl AudioLoudNorm {
drop(state); drop(state);
if let Some(outbuf) = outbuf { 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) { 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; return false;
} }
@ -1652,9 +1651,9 @@ impl AudioLoudNorm {
drop(state); drop(state);
if let Some(outbuf) = outbuf { 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) { if let Err(err) = self.srcpad.push(outbuf) {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to push drained data on EOS: {}", "Failed to push drained data on EOS: {}",
@ -1691,7 +1690,7 @@ impl AudioLoudNorm {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Latency(q) => { QueryViewMut::Latency(q) => {
let mut peer_query = gst::query::Latency::new(); 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error};
use gst_base::subclass::base_transform::BaseTransformImplExt; use gst_base::subclass::base_transform::BaseTransformImplExt;
use gst_base::subclass::base_transform::GenerateOutputSuccess; use gst_base::subclass::base_transform::GenerateOutputSuccess;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -132,7 +131,7 @@ impl AudioRNNoise {
} }
let mut buffer = gst::Buffer::with_size(available).map_err(|e| { let mut buffer = gst::Buffer::with_size(available).map_err(|e| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to allocate buffer at EOS {:?}", "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) let in_info = gst_audio::AudioInfo::from_caps(incaps)
.map_err(|e| gst::loggable_error!(CAT, "Failed to parse input caps {:?}", e))?; .map_err(|e| gst::loggable_error!(CAT, "Failed to parse input caps {:?}", e))?;
@ -337,7 +336,7 @@ impl BaseTransformImpl for AudioRNNoise {
use gst::EventView; use gst::EventView;
if let EventView::Eos(_) = event.view() { 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() { if self.drain(element).is_err() {
return false; return false;
} }
@ -357,7 +356,7 @@ impl BaseTransformImpl for AudioRNNoise {
let mut upstream_query = gst::query::Latency::new(); let mut upstream_query = gst::query::Latency::new();
if sink_pad.peer_query(&mut upstream_query) { if sink_pad.peer_query(&mut upstream_query) {
let (live, mut min, mut max) = upstream_query.result(); let (live, mut min, mut max) = upstream_query.result();
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Peer latency: live {} min {} max {}", "Peer latency: live {} min {} max {}",

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

@ -9,7 +9,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info};
use gst_base::prelude::*; use gst_base::prelude::*;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -132,7 +131,7 @@ impl ObjectImpl for EbuR128Level {
let this = args[0].get::<super::EbuR128Level>().unwrap(); let this = args[0].get::<super::EbuR128Level>().unwrap();
let imp = this.imp(); 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); imp.reset.store(true, atomic::Ordering::SeqCst);
None None
@ -188,7 +187,7 @@ impl ObjectImpl for EbuR128Level {
match pspec.name() { match pspec.name() {
"mode" => { "mode" => {
let mode = value.get().expect("type checked upstream"); let mode = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing mode from {:?} to {:?}", "Changing mode from {:?} to {:?}",
@ -199,7 +198,7 @@ impl ObjectImpl for EbuR128Level {
} }
"post-messages" => { "post-messages" => {
let post_messages = value.get().expect("type checked upstream"); let post_messages = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing post-messages from {} to {}", "Changing post-messages from {} to {}",
@ -211,7 +210,7 @@ impl ObjectImpl for EbuR128Level {
"interval" => { "interval" => {
let interval = let interval =
gst::ClockTime::from_nseconds(value.get().expect("type checked upstream")); gst::ClockTime::from_nseconds(value.get().expect("type checked upstream"));
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing interval from {} to {}", "Changing interval from {} to {}",
@ -309,7 +308,7 @@ impl BaseTransformImpl for EbuR128Level {
Ok(info) => info, 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(); let settings = *self.settings.lock().unwrap();
@ -370,7 +369,7 @@ impl BaseTransformImpl for EbuR128Level {
gst_audio::AudioChannelPosition::Invalid gst_audio::AudioChannelPosition::Invalid
| gst_audio::AudioChannelPosition::None => ebur128::Channel::Unused, | gst_audio::AudioChannelPosition::None => ebur128::Channel::Unused,
val => { val => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Unknown channel position {:?}, ignoring channel", "Unknown channel position {:?}, ignoring channel",
@ -414,7 +413,7 @@ impl BaseTransformImpl for EbuR128Level {
// Drop state // Drop state
let _ = self.state.borrow_mut().take(); let _ = self.state.borrow_mut().take();
gst_info!(CAT, obj: element, "Stopped"); gst::info!(CAT, obj: element, "Stopped");
Ok(()) Ok(())
} }
@ -504,7 +503,7 @@ impl BaseTransformImpl for EbuR128Level {
if state.ebur128.mode().contains(ebur128::Mode::M) { if state.ebur128.mode().contains(ebur128::Mode::M) {
match state.ebur128.loudness_momentary() { match state.ebur128.loudness_momentary() {
Ok(loudness) => s.set("momentary-loudness", &loudness), Ok(loudness) => s.set("momentary-loudness", &loudness),
Err(err) => gst_error!( Err(err) => gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to get momentary loudness: {}", "Failed to get momentary loudness: {}",
@ -516,7 +515,7 @@ impl BaseTransformImpl for EbuR128Level {
if state.ebur128.mode().contains(ebur128::Mode::S) { if state.ebur128.mode().contains(ebur128::Mode::S) {
match state.ebur128.loudness_shortterm() { match state.ebur128.loudness_shortterm() {
Ok(loudness) => s.set("shortterm-loudness", &loudness), Ok(loudness) => s.set("shortterm-loudness", &loudness),
Err(err) => gst_error!( Err(err) => gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to get shortterm loudness: {}", "Failed to get shortterm loudness: {}",
@ -528,7 +527,7 @@ impl BaseTransformImpl for EbuR128Level {
if state.ebur128.mode().contains(ebur128::Mode::I) { if state.ebur128.mode().contains(ebur128::Mode::I) {
match state.ebur128.loudness_global() { match state.ebur128.loudness_global() {
Ok(loudness) => s.set("global-loudness", &loudness), Ok(loudness) => s.set("global-loudness", &loudness),
Err(err) => gst_error!( Err(err) => gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to get global loudness: {}", "Failed to get global loudness: {}",
@ -538,7 +537,7 @@ impl BaseTransformImpl for EbuR128Level {
match state.ebur128.relative_threshold() { match state.ebur128.relative_threshold() {
Ok(threshold) => s.set("relative-threshold", &threshold), Ok(threshold) => s.set("relative-threshold", &threshold),
Err(err) => gst_error!( Err(err) => gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to get relative threshold: {}", "Failed to get relative threshold: {}",
@ -550,7 +549,7 @@ impl BaseTransformImpl for EbuR128Level {
if state.ebur128.mode().contains(ebur128::Mode::LRA) { if state.ebur128.mode().contains(ebur128::Mode::LRA) {
match state.ebur128.loudness_range() { match state.ebur128.loudness_range() {
Ok(range) => s.set("loudness-range", &range), Ok(range) => s.set("loudness-range", &range),
Err(err) => gst_error!( Err(err) => gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to get loudness range: {}", "Failed to get loudness range: {}",
@ -567,7 +566,12 @@ impl BaseTransformImpl for EbuR128Level {
match peaks { match peaks {
Ok(peaks) => s.set("sample-peak", gst::Array::from(peaks)), Ok(peaks) => s.set("sample-peak", gst::Array::from(peaks)),
Err(err) => { 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 { match peaks {
Ok(peaks) => s.set("true-peak", gst::Array::from(peaks)), Ok(peaks) => s.set("true-peak", gst::Array::from(peaks)),
Err(err) => { 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(); 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> { ) -> Result<&'a [T], gst::FlowError> {
buf.plane_data(0) buf.plane_data(0)
.map_err(|err| { .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 gst::FlowError::Error
})? })?
.as_slice_of::<T>() .as_slice_of::<T>()
.map_err(|err| { .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 gst::FlowError::Error
}) })
} }
@ -769,12 +773,12 @@ fn non_interleaved_channel_data_into_slices<'a, T: FromByteSlice>(
.map(|c| { .map(|c| {
buf.plane_data(c) buf.plane_data(c)
.map_err(|err| { .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 gst::FlowError::Error
})? })?
.as_slice_of::<T>() .as_slice_of::<T>()
.map_err(|err| { .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 gst::FlowError::Error
}) })
}) })

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

@ -9,7 +9,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log};
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -225,7 +224,7 @@ impl HrtfRender {
let mut outbuf = let mut outbuf =
gst_audio::AudioBufferRef::from_buffer_ref_writable(outbuf, &state.outinfo).map_err( gst_audio::AudioBufferRef::from_buffer_ref_writable(outbuf, &state.outinfo).map_err(
|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 gst::FlowError::Error
}, },
)?; )?;
@ -249,13 +248,13 @@ impl HrtfRender {
while state.adapter.available() >= inblksz { while state.adapter.available() >= inblksz {
let inbuf = state.adapter.take_buffer(inblksz).map_err(|_| { 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 gst::FlowError::Error
})?; })?;
let inbuf = gst_audio::AudioBuffer::from_buffer_readable(inbuf, &state.ininfo) let inbuf = gst_audio::AudioBuffer::from_buffer_readable(inbuf, &state.ininfo)
.map_err(|_| { .map_err(|_| {
gst_error!(CAT, obj: element, "Failed to map buffer"); gst::error!(CAT, obj: element, "Failed to map buffer");
gst::FlowError::Error gst::FlowError::Error
})?; })?;
@ -497,7 +496,7 @@ impl ObjectImpl for HrtfRender {
if let Some(state) = state_guard.as_mut() { if let Some(state) = state_guard.as_mut() {
if objs.len() != state.ininfo.channels() as usize { if objs.len() != state.ininfo.channels() as usize {
gst::gst_warning!( gst::warning!(
CAT, CAT,
"Could not update spatial objects, expected {} channels, got {}", "Could not update spatial objects, expected {} channels, got {}",
state.ininfo.channels(), state.ininfo.channels(),
@ -647,7 +646,7 @@ impl BaseTransformImpl for HrtfRender {
full_blocks * state.output_block_size() full_blocks * state.output_block_size()
}; };
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Adapter size: {}, input size {}, transformed size {}", "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); other_caps = filter.intersect_with_mode(&other_caps, gst::CapsIntersectMode::First);
} }
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Transformed caps from {} to {} in direction {:?}", "Transformed caps from {} to {} in direction {:?}",
@ -772,7 +771,7 @@ impl BaseTransformImpl for HrtfRender {
adapter: gst_base::UniqueAdapter::new(), adapter: gst_base::UniqueAdapter::new(),
}); });
gst_debug!(CAT, obj: element, "Configured for caps {}", incaps); gst::debug!(CAT, obj: element, "Configured for caps {}", incaps);
Ok(()) Ok(())
} }
@ -780,7 +779,7 @@ impl BaseTransformImpl for HrtfRender {
fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_debug!(CAT, "Handling event {:?}", event); gst::debug!(CAT, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::FlushStop(_) => { EventView::FlushStop(_) => {
@ -794,7 +793,7 @@ impl BaseTransformImpl for HrtfRender {
} }
EventView::Eos(_) => { EventView::Eos(_) => {
if self.drain(element).is_err() { 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!( gst::element_warning!(
element, element,
gst::CoreError::Event, gst::CoreError::Event,

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

@ -10,7 +10,6 @@
use gst::glib; use gst::glib;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error};
use gst_audio::prelude::*; use gst_audio::prelude::*;
use gst_audio::subclass::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> { 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; let mut audio_info: Option<gst_audio::AudioInfo> = None;
@ -129,7 +128,7 @@ impl AudioDecoderImpl for ClaxonDec {
let streamheaders = streamheaders.as_slice(); let streamheaders = streamheaders.as_slice();
if streamheaders.len() < 2 { if streamheaders.len() < 2 {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Not enough streamheaders, trying in-band" "Not enough streamheaders, trying in-band"
@ -137,18 +136,18 @@ impl AudioDecoderImpl for ClaxonDec {
} else { } else {
let ident_buf = streamheaders[0].get::<Option<gst::Buffer>>(); let ident_buf = streamheaders[0].get::<Option<gst::Buffer>>();
if let Ok(Some(ident_buf)) = ident_buf { 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(); let inmap = ident_buf.map_readable().unwrap();
if inmap[0..7] != [0x7f, b'F', b'L', b'A', b'C', 0x01, 0x00] { 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..]) { } else if let Ok(tstreaminfo) = claxon_streaminfo(&inmap[13..]) {
if let Ok(taudio_info) = gstaudioinfo(&tstreaminfo) { if let Ok(taudio_info) = gstaudioinfo(&tstreaminfo) {
// To speed up negotiation // To speed up negotiation
if element.set_output_format(&taudio_info).is_err() if element.set_output_format(&taudio_info).is_err()
|| element.negotiate().is_err() || element.negotiate().is_err()
{ {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Error to negotiate output from based on in-caps streaminfo" "Error to negotiate output from based on in-caps streaminfo"
@ -174,7 +173,7 @@ impl AudioDecoderImpl for ClaxonDec {
element: &Self::Type, element: &Self::Type,
inbuf: Option<&gst::Buffer>, inbuf: Option<&gst::Buffer>,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 { let inbuf = match inbuf {
None => return Ok(gst::FlowSuccess::Ok), None => return Ok(gst::FlowSuccess::Ok),
@ -182,7 +181,7 @@ impl AudioDecoderImpl for ClaxonDec {
}; };
let inmap = inbuf.map_readable().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
@ -190,16 +189,16 @@ impl AudioDecoderImpl for ClaxonDec {
let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?; let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?;
if inmap.as_slice() == b"fLaC" { 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 { } 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()); return self.handle_streaminfo_header(element, state, inmap.as_ref());
} else if inmap[0] == 0b1111_1111 && inmap[1] & 0b1111_1100 == 0b1111_1000 { } 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()); return self.handle_data(element, state, inmap.as_ref());
} else { } else {
// info about other headers in flacparse and https://xiph.org/flac/format.html // info about other headers in flacparse and https://xiph.org/flac/format.html
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Other header buffer received {:?}", "Other header buffer received {:?}",
@ -228,7 +227,7 @@ impl ClaxonDec {
gst::FlowError::Error gst::FlowError::Error
})?; })?;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Successfully parsed headers: {:?}", "Successfully parsed headers: {:?}",

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

@ -9,9 +9,7 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{ use gst::{element_error, error_msg, loggable_error};
element_error, error_msg, gst_debug, gst_error, gst_info, gst_log, gst_warning, loggable_error,
};
use gst_base::subclass::base_transform::GenerateOutputSuccess; use gst_base::subclass::base_transform::GenerateOutputSuccess;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -163,12 +161,12 @@ impl CsoundFilter {
fn message_callback(msg_type: MessageType, msg: &str) { fn message_callback(msg_type: MessageType, msg: &str) {
match msg_type { match msg_type {
MessageType::CSOUNDMSG_ERROR => gst_error!(CAT, "{}", msg), MessageType::CSOUNDMSG_ERROR => gst::error!(CAT, "{}", msg),
MessageType::CSOUNDMSG_WARNING => gst_warning!(CAT, "{}", msg), MessageType::CSOUNDMSG_WARNING => gst::warning!(CAT, "{}", msg),
MessageType::CSOUNDMSG_ORCH => gst_info!(CAT, "{}", msg), MessageType::CSOUNDMSG_ORCH => gst::info!(CAT, "{}", msg),
MessageType::CSOUNDMSG_REALTIME => gst_log!(CAT, "{}", msg), MessageType::CSOUNDMSG_REALTIME => gst::log!(CAT, "{}", msg),
MessageType::CSOUNDMSG_DEFAULT => gst_log!(CAT, "{}", msg), MessageType::CSOUNDMSG_DEFAULT => gst::log!(CAT, "{}", msg),
MessageType::CSOUNDMSG_STDOUT => 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; (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| { let mut buffer = gst::Buffer::with_size(out_bytes).map_err(|e| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to allocate buffer at EOS {:?}", "Failed to allocate buffer at EOS {:?}",
@ -257,7 +255,7 @@ impl CsoundFilter {
outbuf.set_pts(pts); outbuf.set_pts(pts);
outbuf.set_duration(duration); outbuf.set_duration(duration);
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Generating output at: {} - duration: {}", "Generating output at: {} - duration: {}",
@ -510,7 +508,7 @@ impl BaseTransformImpl for CsoundFilter {
csound.reset(); csound.reset();
let _ = self.state.lock().unwrap().take(); let _ = self.state.lock().unwrap().take();
gst_info!(CAT, obj: element, "Stopped"); gst::info!(CAT, obj: element, "Stopped");
Ok(()) Ok(())
} }
@ -519,7 +517,7 @@ impl BaseTransformImpl for CsoundFilter {
use gst::EventView; use gst::EventView;
if let EventView::Eos(_) = event.view() { 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() { if self.drain(element).is_err() {
return false; return false;
} }
@ -563,7 +561,7 @@ impl BaseTransformImpl for CsoundFilter {
new_caps new_caps
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Transformed caps from {} to {} in direction {:?}", "Transformed caps from {} to {} in direction {:?}",
@ -665,7 +663,7 @@ impl BaseTransformImpl for CsoundFilter {
return self.generate_output(element, state); 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) Ok(GenerateOutputSuccess::NoOutput)
} }
} }

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

@ -10,7 +10,6 @@
use gst::glib; use gst::glib;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_warning};
use gst_audio::audio_decoder_error; use gst_audio::audio_decoder_error;
use gst_audio::prelude::*; use gst_audio::prelude::*;
use gst_audio::subclass::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> { 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 // When the caps are changing we require new headers
let mut state_guard = self.state.borrow_mut(); 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") { if let Ok(Some(streamheaders)) = s.get_optional::<gst::ArrayRef>("streamheader") {
let streamheaders = streamheaders.as_slice(); let streamheaders = streamheaders.as_slice();
if streamheaders.len() < 3 { if streamheaders.len() < 3 {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Not enough streamheaders, trying in-band" "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))) = if let (Ok(Some(ident_buf)), Ok(Some(comment_buf)), Ok(Some(setup_buf))) =
(ident_buf, comment_buf, 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)); 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) { 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(); let mut state_guard = self.state.borrow_mut();
if let Some(ref mut state) = *state_guard { if let Some(ref mut state) = *state_guard {
@ -177,7 +176,7 @@ impl AudioDecoderImpl for LewtonDec {
element: &Self::Type, element: &Self::Type,
inbuf: Option<&gst::Buffer>, inbuf: Option<&gst::Buffer>,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 { let inbuf = match inbuf {
None => return Ok(gst::FlowSuccess::Ok), None => return Ok(gst::FlowSuccess::Ok),
@ -185,7 +184,7 @@ impl AudioDecoderImpl for LewtonDec {
}; };
let inmap = inbuf.map_readable().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
@ -199,7 +198,7 @@ impl AudioDecoderImpl for LewtonDec {
if state.headerset.is_some() { if state.headerset.is_some() {
return Ok(gst::FlowSuccess::Ok); return Ok(gst::FlowSuccess::Ok);
} else { } 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); return Err(gst::FlowError::Error);
} }
} }
@ -228,26 +227,26 @@ impl LewtonDec {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
// ident header // ident header
if indata[0] == 0x01 { 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); state.header_bufs = (Some(inbuf.clone()), None, None);
} else if indata[0] == 0x03 { } else if indata[0] == 0x03 {
// comment header // comment header
if state.header_bufs.0.is_none() { 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 { } 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()); state.header_bufs.1 = Some(inbuf.clone());
} }
} else if indata[0] == 0x05 { } else if indata[0] == 0x05 {
// setup header // setup header
if state.header_bufs.0.is_none() || state.header_bufs.1.is_none() { if state.header_bufs.0.is_none() || state.header_bufs.1.is_none() {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Got setup header before ident/comment header" "Got setup header before ident/comment header"
); );
} else { } 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()); state.header_bufs.2 = Some(inbuf.clone());
} }
} }
@ -276,7 +275,7 @@ impl LewtonDec {
// First try to parse the headers // First try to parse the headers
let ident_map = ident_buf.map_readable().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
let ident = lewton::header::read_header_ident(ident_map.as_ref()).map_err(|err| { 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(|_| { 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 gst::FlowError::Error
})?; })?;
let comment = lewton::header::read_header_comment(comment_map.as_ref()).map_err(|err| { 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(|_| { 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 gst::FlowError::Error
})?; })?;
let setup = lewton::header::read_header_setup( let setup = lewton::header::read_header_setup(
@ -338,7 +337,7 @@ impl LewtonDec {
let mut map = [0; 8]; let mut map = [0; 8];
if gst_audio::channel_reorder_map(from, to, &mut map[..channels]).is_err() { if gst_audio::channel_reorder_map(from, to, &mut map[..channels]).is_err() {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to generate channel reorder map from {:?} to {:?}", "Failed to generate channel reorder map from {:?} to {:?}",
@ -354,7 +353,7 @@ impl LewtonDec {
} }
let audio_info = audio_info.build().unwrap(); let audio_info = audio_info.build().unwrap();
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Successfully parsed headers: {:?}", "Successfully parsed headers: {:?}",
@ -410,7 +409,7 @@ impl LewtonDec {
} }
let sample_count = decoded.samples.len() / audio_info.channels() as usize; 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 { if sample_count == 0 {
return element.finish_frame(None, 1); 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log};
use gst_base::subclass::{base_src::CreateSuccess, prelude::*}; use gst_base::subclass::{base_src::CreateSuccess, prelude::*};
use librespot::core::{ use librespot::core::{
@ -250,7 +249,7 @@ impl BaseSrcImpl for SpotifyAudioSrc {
if let Err(err) = RUNTIME.block_on(async move { self.setup().await }) { if let Err(err) = RUNTIME.block_on(async move { self.setup().await }) {
let details = format!("{:?}", err); 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]); gst::element_error!(src, gst::ResourceError::Settings, [&details]);
return Err(gst::error_msg!(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> { fn stop(&self, src: &Self::Type) -> Result<(), gst::ErrorMessage> {
if let Some(state) = self.state.lock().unwrap().take() { 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.stop();
state.player_channel_handle.abort(); state.player_channel_handle.abort();
// FIXME: not sure why this is needed to unblock BufferSink::write(), dropping State should drop the receiver // 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() { match state.receiver.recv().unwrap() {
Message::Buffer(buffer) => { 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)) Ok(CreateSuccess::NewBuffer(buffer))
} }
Message::Eos => { Message::Eos => {
gst_debug!(CAT, obj: src, "eos"); gst::debug!(CAT, obj: src, "eos");
Err(gst::FlowError::Eos) Err(gst::FlowError::Eos)
} }
Message::Unavailable => { Message::Unavailable => {
gst_error!(CAT, obj: src, "track is not available"); gst::error!(CAT, obj: src, "track is not available");
gst::element_error!( gst::element_error!(
src, src,
gst::ResourceError::NotFound, gst::ResourceError::NotFound,
@ -331,11 +330,11 @@ impl SpotifyAudioSrc {
let credentials = match cache.credentials() { let credentials = match cache.credentials() {
Some(cached_cred) => { Some(cached_cred) => {
gst_debug!(CAT, obj: &src, "reuse credentials from cache",); gst::debug!(CAT, obj: &src, "reuse credentials from cache",);
cached_cred cached_cred
} }
None => { None => {
gst_debug!(CAT, obj: &src, "credentials not in cache",); gst::debug!(CAT, obj: &src, "credentials not in cache",);
if settings.username.is_empty() { if settings.username.is_empty() {
bail!("username is not set and credentials are not in cache"); 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_trace};
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
use std::fs::File; use std::fs::File;
@ -84,7 +83,7 @@ impl FileSink {
Some(location) => { Some(location) => {
match settings.location { match settings.location {
Some(ref location_cur) => { Some(ref location_cur) => {
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Changing `location` from {:?} to {}", "Changing `location` from {:?} to {}",
@ -93,13 +92,13 @@ impl FileSink {
); );
} }
None => { None => {
gst_info!(CAT, obj: element, "Setting `location` to {}", location,); gst::info!(CAT, obj: element, "Setting `location` to {}", location,);
} }
} }
Some(location) Some(location)
} }
None => { None => {
gst_info!(CAT, obj: element, "Resetting `location` to None",); gst::info!(CAT, obj: element, "Resetting `location` to None",);
None None
} }
}; };
@ -148,7 +147,7 @@ impl ObjectImpl for FileSink {
}; };
if let Err(err) = res { 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!(), _ => 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 }; *state = State::Started { file, position: 0 };
gst_info!(CAT, obj: element, "Started"); gst::info!(CAT, obj: element, "Started");
Ok(()) Ok(())
} }
@ -248,7 +247,7 @@ impl BaseSinkImpl for FileSink {
} }
*state = State::Stopped; *state = State::Stopped;
gst_info!(CAT, obj: element, "Stopped"); gst::info!(CAT, obj: element, "Stopped");
Ok(()) 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(|_| { let map = buffer.map_readable().map_err(|_| {
gst::element_error!(element, gst::CoreError::Failed, ["Failed to map buffer"]); gst::element_error!(element, gst::CoreError::Failed, ["Failed to map buffer"]);
gst::FlowError::Error gst::FlowError::Error

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

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

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

@ -9,7 +9,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_trace, gst_warning};
use std::collections::VecDeque; use std::collections::VecDeque;
use std::sync::Mutex; use std::sync::Mutex;
@ -114,35 +113,35 @@ impl FMP4Mux {
state: &mut State, state: &mut State,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<(), gst::FlowError> { ) -> Result<(), gst::FlowError> {
gst_trace!(CAT, obj: element, "Handling buffer {:?}", buffer); gst::trace!(CAT, obj: element, "Handling buffer {:?}", buffer);
let segment = match state.segment { let segment = match state.segment {
Some(ref segment) => segment, Some(ref segment) => segment,
None => { None => {
gst_error!(CAT, obj: element, "Got buffer before segment"); gst::error!(CAT, obj: element, "Got buffer before segment");
return Err(gst::FlowError::Error); return Err(gst::FlowError::Error);
} }
}; };
if state.caps.is_none() { 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); return Err(gst::FlowError::NotNegotiated);
} }
let intra_only = state.intra_only; let intra_only = state.intra_only;
if !intra_only && buffer.dts().is_none() { 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); return Err(gst::FlowError::Error);
} }
if intra_only && buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) { 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); return Err(gst::FlowError::Error);
} }
let pts = buffer.pts().ok_or_else(|| { 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 gst::FlowError::Error
})?; })?;
let duration = buffer.duration(); let duration = buffer.duration();
@ -150,11 +149,11 @@ impl FMP4Mux {
let pts = match segment.to_running_time_full(pts) { let pts = match segment.to_running_time_full(pts) {
(_, None) => { (_, 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); return Err(gst::FlowError::Error);
} }
(pts_signum, _) if pts_signum < 0 => { (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); return Err(gst::FlowError::Error);
} }
(_, Some(pts)) => pts, (_, Some(pts)) => pts,
@ -162,7 +161,7 @@ impl FMP4Mux {
let end_pts = match segment.to_running_time_full(end_pts) { let end_pts = match segment.to_running_time_full(end_pts) {
(_, None) => { (_, None) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Couldn't convert end PTS to running time" "Couldn't convert end PTS to running time"
@ -170,7 +169,7 @@ impl FMP4Mux {
return Err(gst::FlowError::Error); return Err(gst::FlowError::Error);
} }
(pts_signum, _) if pts_signum < 0 => { (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); return Err(gst::FlowError::Error);
} }
(_, Some(pts)) => pts, (_, Some(pts)) => pts,
@ -185,7 +184,7 @@ impl FMP4Mux {
let dts = match segment.to_running_time_full(dts) { let dts = match segment.to_running_time_full(dts) {
(_, None) => { (_, 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); return Err(gst::FlowError::Error);
} }
(pts_signum, Some(dts)) if pts_signum < 0 => { (pts_signum, Some(dts)) if pts_signum < 0 => {
@ -195,7 +194,7 @@ impl FMP4Mux {
let dts_offset = state.dts_offset.unwrap(); let dts_offset = state.dts_offset.unwrap();
if dts > dts_offset { 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 gst::ClockTime::ZERO
} else { } else {
dts_offset - dts dts_offset - dts
@ -212,7 +211,7 @@ impl FMP4Mux {
let end_dts = match segment.to_running_time_full(end_dts) { let end_dts = match segment.to_running_time_full(end_dts) {
(_, None) => { (_, None) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Couldn't convert end DTS to running time" "Couldn't convert end DTS to running time"
@ -226,7 +225,7 @@ impl FMP4Mux {
let dts_offset = state.dts_offset.unwrap(); let dts_offset = state.dts_offset.unwrap();
if dts > dts_offset { 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 gst::ClockTime::ZERO
} else { } else {
dts_offset - dts dts_offset - dts
@ -244,7 +243,7 @@ impl FMP4Mux {
}; };
if !buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) { if !buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Starting new GOP at PTS {} DTS {}", "Starting new GOP at PTS {} DTS {}",
@ -266,7 +265,7 @@ impl FMP4Mux {
state.queued_gops.push_front(gop); state.queued_gops.push_front(gop);
if let Some(prev_gop) = state.queued_gops.get_mut(1) { if let Some(prev_gop) = state.queued_gops.get_mut(1) {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Updating previous GOP starting at PTS {} to end PTS {} DTS {}", "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 // Don't bother logging this for intra-only streams as it would be for every
// single buffer. // single buffer.
if !intra_only { if !intra_only {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Previous GOP has final earliest PTS at {}", "Previous GOP has final earliest PTS at {}",
@ -293,7 +292,7 @@ impl FMP4Mux {
state.queued_duration = state.queued_duration =
prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts; prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Queued duration updated to {}", "Queued duration updated to {}",
@ -302,7 +301,7 @@ impl FMP4Mux {
} else if intra_only { } else if intra_only {
state.queued_duration = state.queued_duration =
prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts; prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Queued duration updated to {}", "Queued duration updated to {}",
@ -327,7 +326,7 @@ impl FMP4Mux {
}); });
if gop.earliest_pts > pts && !gop.final_earliest_pts { if gop.earliest_pts > pts && !gop.final_earliest_pts {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Updating current GOP earliest PTS from {} to {}", "Updating current GOP earliest PTS from {} to {}",
@ -338,7 +337,7 @@ impl FMP4Mux {
gop.earliest_pts_position = pts_position; gop.earliest_pts_position = pts_position;
if let Some(prev_gop) = state.queued_gops.get_mut(1) { if let Some(prev_gop) = state.queued_gops.get_mut(1) {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Updating previous GOP starting PTS {} end time from {} to {}", "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 // lower PTS then it wouldn't be possible to display it in time anymore, i.e. the
// stream would be invalid. // stream would be invalid.
if gop.start_pts <= dts && !gop.final_earliest_pts { if gop.start_pts <= dts && !gop.final_earliest_pts {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"GOP has final earliest PTS at {}", "GOP has final earliest PTS at {}",
@ -368,7 +367,7 @@ impl FMP4Mux {
if let Some(prev_gop) = state.queued_gops.get_mut(1) { if let Some(prev_gop) = state.queued_gops.get_mut(1) {
state.queued_duration = state.queued_duration =
prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts; prev_gop.end_pts - state.queued_gops.back().unwrap().earliest_pts;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Queued duration updated to {}", "Queued duration updated to {}",
@ -377,7 +376,7 @@ impl FMP4Mux {
} }
} }
} else { } else {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Waiting for keyframe at the beginning of the stream" "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 { if state.last_force_keyunit_time.is_none() && oldest_gop.final_earliest_pts {
let fku_running_time = earliest_pts + settings.fragment_duration; let fku_running_time = earliest_pts + settings.fragment_duration;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Sending first force-keyunit event for running time {}", "Sending first force-keyunit event for running time {}",
@ -426,7 +425,7 @@ impl FMP4Mux {
{ {
let fku_running_time = let fku_running_time =
state.last_force_keyunit_time.unwrap() + settings.fragment_duration; state.last_force_keyunit_time.unwrap() + settings.fragment_duration;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Sending force-keyunit event for running time {}", "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 // equal to the fragment duration then drain out all complete GOPs, otherwise all
// except for the newest complete GOP. // except for the newest complete GOP.
let drain_gops = if at_eos { 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_duration = gst::ClockTime::ZERO;
state state
.queued_gops .queued_gops
@ -505,7 +504,7 @@ impl FMP4Mux {
let end_dts = drain_gops[0].end_dts; let end_dts = drain_gops[0].end_dts;
let dts_offset = state.dts_offset; let dts_offset = state.dts_offset;
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Draining {} worth of buffers starting at PTS {} DTS {}, DTS offset {}", "Draining {} worth of buffers starting at PTS {} DTS {}, DTS offset {}",
@ -558,7 +557,7 @@ impl FMP4Mux {
dts_offset, dts_offset,
}) })
.map_err(|err| { .map_err(|err| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to create FMP4 fragment header: {}", "Failed to create FMP4 fragment header: {}",
@ -618,7 +617,7 @@ impl FMP4Mux {
}); });
state.end_pts = Some(end_pts); state.end_pts = Some(end_pts);
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Queued duration updated to {} after draining", "Queued duration updated to {} after draining",
@ -641,7 +640,7 @@ impl FMP4Mux {
buffer_list.as_mut().unwrap().get_mut().unwrap().add(mfra); buffer_list.as_mut().unwrap().get_mut().unwrap().add(mfra);
} }
Err(err) => { 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 }, duration: if at_eos { duration } else { None },
}) })
.map_err(|err| { .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 gst::FlowError::Error
})?; })?;
@ -753,7 +752,7 @@ impl FMP4Mux {
} }
if let Some(buffers) = buffers { 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)?; 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 { fn sink_event(&self, pad: &gst::Pad, element: &super::FMP4Mux, mut event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_trace!(CAT, obj: pad, "Handling event {:?}", event); gst::trace!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Segment(ev) => { EventView::Segment(ev) => {
let segment = match ev.segment().downcast_ref::<gst::ClockTime>() { let segment = match ev.segment().downcast_ref::<gst::ClockTime>() {
Some(segment) => { Some(segment) => {
gst_info!(CAT, obj: pad, "Received segment {:?}", segment); gst::info!(CAT, obj: pad, "Received segment {:?}", segment);
segment.clone() segment.clone()
} }
None => { None => {
gst_warning!( gst::warning!(
CAT, CAT,
obj: pad, obj: pad,
"Received non-TIME segment, replacing with default TIME segment" "Received non-TIME segment, replacing with default TIME segment"
@ -793,7 +792,7 @@ impl FMP4Mux {
EventView::Caps(ev) => { EventView::Caps(ev) => {
let caps = ev.caps_owned(); let caps = ev.caps_owned();
gst_info!(CAT, obj: pad, "Received caps {:?}", caps); gst::info!(CAT, obj: pad, "Received caps {:?}", caps);
let caps = { let caps = {
let settings = self.settings.lock().unwrap().clone(); let settings = self.settings.lock().unwrap().clone();
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
@ -803,13 +802,13 @@ impl FMP4Mux {
match s.name() { match s.name() {
"video/x-h264" | "video/x-h265" => { "video/x-h264" | "video/x-h265" => {
if !s.has_field_with_type("codec_data", gst::Buffer::static_type()) { 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; return false;
} }
} }
"audio/mpeg" => { "audio/mpeg" => {
if !s.has_field_with_type("codec_data", gst::Buffer::static_type()) { 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; return false;
} }
state.intra_only = true; state.intra_only = true;
@ -851,10 +850,10 @@ impl FMP4Mux {
match drained { match drained {
Ok(Some(buffers)) => { 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) { if let Err(err) = self.srcpad.push_list(buffers) {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed pushing EOS buffers downstream: {:?}", "Failed pushing EOS buffers downstream: {:?}",
@ -864,7 +863,7 @@ impl FMP4Mux {
} }
Ok(None) => {} Ok(None) => {}
Err(err) => { 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)); self.srcpad.push_event(gst::event::Caps::new(&caps));
if let Err(err) = self.srcpad.push_list(buffer_list) { if let Err(err) = self.srcpad.push_list(buffer_list) {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed pushing updated header buffer downstream: {:?}", "Failed pushing updated header buffer downstream: {:?}",
@ -897,13 +896,13 @@ impl FMP4Mux {
); );
} }
} else { } 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 => { super::HeaderUpdateMode::Update => {
self.srcpad.push_event(gst::event::Caps::new(&caps)); self.srcpad.push_event(gst::event::Caps::new(&caps));
if let Err(err) = self.srcpad.push_list(buffer_list) { if let Err(err) = self.srcpad.push_list(buffer_list) {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed pushing updated header buffer downstream: {:?}", "Failed pushing updated header buffer downstream: {:?}",
@ -915,7 +914,7 @@ impl FMP4Mux {
} }
Ok(None) => {} Ok(None) => {}
Err(err) => { Err(err) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to generate updated header: {:?}", "Failed to generate updated header: {:?}",
@ -952,7 +951,7 @@ impl FMP4Mux {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_trace!(CAT, obj: pad, "Handling query {:?}", query); gst::trace!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Caps(q) => { QueryViewMut::Caps(q) => {
@ -982,7 +981,7 @@ impl FMP4Mux {
fn src_event(&self, pad: &gst::Pad, element: &super::FMP4Mux, event: gst::Event) -> bool { fn src_event(&self, pad: &gst::Pad, element: &super::FMP4Mux, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_trace!(CAT, obj: pad, "Handling event {:?}", event); gst::trace!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Seek(_ev) => false, EventView::Seek(_ev) => false,
@ -998,7 +997,7 @@ impl FMP4Mux {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_trace!(CAT, obj: pad, "Handling query {:?}", query); gst::trace!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Seeking(q) => { QueryViewMut::Seeking(q) => {
@ -1013,7 +1012,7 @@ impl FMP4Mux {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
let (live, min, max) = q.result(); let (live, min, max) = q.result();
gst_info!( gst::info!(
CAT, CAT,
obj: pad, obj: pad,
"Upstream latency: live {}, min {}, max {}", "Upstream latency: live {}, min {}, max {}",
@ -1025,7 +1024,7 @@ impl FMP4Mux {
min + settings.fragment_duration, min + settings.fragment_duration,
max.opt_add(settings.fragment_duration), max.opt_add(settings.fragment_duration),
); );
gst_info!( gst::info!(
CAT, CAT,
obj: pad, obj: pad,
"Returning latency: live {}, min {}, max {}", "Returning latency: live {}, min {}, max {}",
@ -1221,7 +1220,7 @@ impl ElementImpl for FMP4Mux {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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)?; 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log};
use sodiumoxide::crypto::box_; use sodiumoxide::crypto::box_;
use std::sync::Mutex; use std::sync::Mutex;
@ -115,7 +114,7 @@ impl State {
gst::FlowError::Error 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 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; 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, adapter_offset: usize,
) -> Result<gst::PadGetRangeSuccess, gst::FlowError> { ) -> Result<gst::PadGetRangeSuccess, gst::FlowError> {
let avail = self.adapter.available(); let avail = self.adapter.available();
gst_debug!(CAT, obj: pad, "Avail: {}", avail); gst::debug!(CAT, obj: pad, "Avail: {}", avail);
gst_debug!(CAT, obj: pad, "Adapter offset: {}", adapter_offset); gst::debug!(CAT, obj: pad, "Adapter offset: {}", adapter_offset);
// if this underflows, the available buffer in the adapter is smaller than the // if this underflows, the available buffer in the adapter is smaller than the
// requested offset, which means we have reached EOS // requested offset, which means we have reached EOS
@ -190,7 +189,7 @@ impl State {
let mut map = match buffer.map_writable() { let mut map = match buffer.map_writable() {
Ok(map) => map, Ok(map) => map,
Err(e) => { Err(e) => {
gst_error!( gst::error!(
CAT, CAT,
obj: pad, obj: pad,
"Failed to map provided buffer writable: {}", "Failed to map provided buffer writable: {}",
@ -200,7 +199,7 @@ impl State {
} }
}; };
if let Err(e) = self.adapter.copy(0, &mut map[..available_size]) { 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); return Err(gst::FlowError::Error);
} }
if map.len() != available_size { if map.len() != available_size {
@ -287,7 +286,7 @@ impl Decrypter {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Scheduling(q) => { QueryViewMut::Scheduling(q) => {
@ -297,12 +296,12 @@ impl Decrypter {
return res; 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(); let (flags, min, max, align) = peer_query.result();
q.set(flags, min, max, align); q.set(flags, min, max, align);
q.add_scheduling_modes(&[gst::PadMode::Pull]); 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 true
} }
QueryViewMut::Duration(q) => { QueryViewMut::Duration(q) => {
@ -314,14 +313,14 @@ impl Decrypter {
let mut peer_query = gst::query::Duration::new(gst::Format::Bytes); let mut peer_query = gst::query::Duration::new(gst::Format::Bytes);
if !self.sinkpad.peer_query(&mut peer_query) { 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; return false;
} }
let size = match peer_query.result().try_into().unwrap() { let size = match peer_query.result().try_into().unwrap() {
Some(gst::format::Bytes(size)) => size, Some(gst::format::Bytes(size)) => size,
None => { None => {
gst_error!(CAT, "Failed to query upstream duration"); gst::error!(CAT, "Failed to query upstream duration");
return false; return false;
} }
@ -344,7 +343,7 @@ impl Decrypter {
// subtrack the MAC of each block // subtrack the MAC of each block
let size = size - total_chunks * box_::MACBYTES as u64; 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)); q.set(gst::format::Bytes(size));
true true
@ -417,9 +416,9 @@ impl Decrypter {
let state = state.as_mut().unwrap(); let state = state.as_mut().unwrap();
state.initial_nonce = Some(nonce); 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); 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(()) Ok(())
} }
@ -436,8 +435,8 @@ impl Decrypter {
+ (chunk_index * block_size as u64) + (chunk_index * block_size as u64)
+ (chunk_index * box_::MACBYTES as u64); + (chunk_index * box_::MACBYTES as u64);
gst_debug!(CAT, obj: pad, "Pull offset: {}", pull_offset); gst::debug!(CAT, obj: pad, "Pull offset: {}", pull_offset);
gst_debug!(CAT, obj: pad, "block size: {}", block_size); gst::debug!(CAT, obj: pad, "block size: {}", block_size);
// calculate how many chunks are needed, if we need something like 3.2 // calculate how many chunks are needed, if we need something like 3.2
// round the number to 4 and cut the buffer afterwards. // 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 // Read at least one chunk in case 0 bytes were requested
let total_chunks = u32::max((checked - 1) / block_size, 1); 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 // Pull a buffer of all the chunks we will need
let checked_size = total_chunks.checked_mul(block_size).ok_or_else(|| { 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); 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| { self.sinkpad.pull_range(pull_offset, total_size).map_err(|err| {
match err { match err {
gst::FlowError::Flushing => { 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::FlowError::Eos => {
gst_debug!(CAT, obj: &self.sinkpad, "Eos"); gst::debug!(CAT, obj: &self.sinkpad, "Eos");
} }
flow => { 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") state.block_size.expect("Block size wasn't set")
}; };
gst_debug!(CAT, obj: pad, "Requested offset: {}", offset); gst::debug!(CAT, obj: pad, "Requested offset: {}", offset);
gst_debug!(CAT, obj: pad, "Requested size: {}", requested_size); gst::debug!(CAT, obj: pad, "Requested size: {}", requested_size);
let chunk_index = offset as u64 / block_size as u64; 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); let pull_offset = offset - (chunk_index * block_size as u64);
assert!(pull_offset <= std::u32::MAX as u64); assert!(pull_offset <= std::u32::MAX as u64);
@ -705,7 +704,7 @@ impl ElementImpl for Decrypter {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_debug!(CAT, obj: element, "Changing state {:?}", transition); gst::debug!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::NullToReady => { gst::StateChange::NullToReady => {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -7,7 +7,6 @@
use concurrent_queue::ConcurrentQueue; use concurrent_queue::ConcurrentQueue;
use futures::ready; use futures::ready;
use gst::{gst_trace, gst_warning};
use polling::{Event, Poller}; use polling::{Event, Poller};
use slab::Slab; use slab::Slab;
@ -215,7 +214,7 @@ impl Reactor {
.is_err() .is_err()
{ {
// If the queue is full, drain it and try again. // 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(); self.process_timer_ops();
} }
@ -226,7 +225,7 @@ impl Reactor {
pub fn remove_timer(&mut self, when: Instant, id: usize) { pub fn remove_timer(&mut self, when: Instant, id: usize) {
// Push a remove operation. // Push a remove operation.
while self.timer_ops.push(TimerOp::Remove(when, id)).is_err() { 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. // If the queue is full, drain it and try again.
self.process_timer_ops(); self.process_timer_ops();
} }
@ -249,7 +248,7 @@ impl Reactor {
// Add wakers to the list. // Add wakers to the list.
if !ready.is_empty() { 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 { for (_, waker) in ready {
wakers.push(waker); wakers.push(waker);
@ -333,7 +332,7 @@ impl Reactor {
// Wake up ready tasks. // Wake up ready tasks.
if !wakers.is_empty() { 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 { for waker in wakers {
// Don't let a panicking waker blow everything up. // 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> { fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
ready!(Pin::new(&mut self.0).poll(cx))?; 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(())) 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> { fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
ready!(Pin::new(&mut self.0).poll(cx))?; ready!(Pin::new(&mut self.0).poll(cx))?;
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"readable_owned: fd={}", "readable_owned: fd={}",
self.0.handle.source.raw 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> { fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
ready!(Pin::new(&mut self.0).poll(cx))?; 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(())) 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> { fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
ready!(Pin::new(&mut self.0).poll(cx))?; ready!(Pin::new(&mut self.0).poll(cx))?;
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"writable_owned: fd={}", "writable_owned: fd={}",
self.0.handle.source.raw 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 futures::pin_mut;
use gio::glib::clone::Downgrade; use gio::glib::clone::Downgrade;
use gst::{gst_debug, gst_error, gst_trace, gst_warning};
use std::cell::RefCell; use std::cell::RefCell;
use std::future::Future; use std::future::Future;
@ -56,7 +55,7 @@ impl Scheduler {
let thread_ctx_name = Arc::clone(&context_name); let thread_ctx_name = Arc::clone(&context_name);
let join = thread let join = thread
.spawn(move || { .spawn(move || {
gst_debug!( gst::debug!(
RUNTIME_CAT, RUNTIME_CAT,
"Started Scheduler thread for Context {}", "Started Scheduler thread for Context {}",
thread_ctx_name thread_ctx_name
@ -68,14 +67,14 @@ impl Scheduler {
match this.block_on_priv(shutdown_receiver) { match this.block_on_priv(shutdown_receiver) {
Ok(_) => { Ok(_) => {
gst_debug!( gst::debug!(
RUNTIME_CAT, RUNTIME_CAT,
"Scheduler thread shut down for Context {}", "Scheduler thread shut down for Context {}",
thread_ctx_name thread_ctx_name
); );
} }
Err(e) => { Err(e) => {
gst_error!( gst::error!(
RUNTIME_CAT, RUNTIME_CAT,
"Scheduler thread shut down due to an error within Context {}", "Scheduler thread shut down due to an error within Context {}",
thread_ctx_name thread_ctx_name
@ -149,10 +148,10 @@ impl Scheduler {
res 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(|| { let _guard = CallOnDrop::new(|| {
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"Blocking on current thread with {:?} done", "Blocking on current thread with {:?} done",
task_id, task_id,
@ -162,7 +161,7 @@ impl Scheduler {
match this.block_on_priv(task) { match this.block_on_priv(task) {
Ok(res) => res, Ok(res) => res,
Err(e) => { Err(e) => {
gst_error!( gst::error!(
RUNTIME_CAT, RUNTIME_CAT,
"Panic blocking on Context {}", "Panic blocking on Context {}",
&Scheduler::DUMMY_NAME &Scheduler::DUMMY_NAME
@ -202,7 +201,7 @@ impl Scheduler {
while let Ok(runnable) = self.tasks.pop_runnable() { while let Ok(runnable) = self.tasks.pop_runnable() {
panic::catch_unwind(|| runnable.run()).map_err(|err| { panic::catch_unwind(|| runnable.run()).map_err(|err| {
gst_error!( gst::error!(
RUNTIME_CAT, RUNTIME_CAT,
"A task has panicked within Context {}", "A task has panicked within Context {}",
self.context_name self.context_name
@ -241,7 +240,7 @@ impl Scheduler {
} }
fn close(context_name: Arc<str>) { fn close(context_name: Arc<str>) {
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"Closing Scheduler for Context {}", "Closing Scheduler for Context {}",
context_name, context_name,
@ -282,7 +281,7 @@ impl Scheduler {
impl Drop for Scheduler { impl Drop for Scheduler {
fn drop(&mut self) { fn drop(&mut self) {
gst_debug!( gst::debug!(
RUNTIME_CAT, RUNTIME_CAT,
"Terminated: Scheduler for Context {}", "Terminated: Scheduler for Context {}",
self.context_name self.context_name
@ -315,7 +314,7 @@ impl SchedulerShutdown {
impl Drop for SchedulerShutdown { impl Drop for SchedulerShutdown {
fn drop(&mut self) { fn drop(&mut self) {
if let Some(sender) = self.sender.take() { if let Some(sender) = self.sender.take() {
gst_debug!( gst::debug!(
RUNTIME_CAT, RUNTIME_CAT,
"Shutting down Scheduler thread for Context {}", "Shutting down Scheduler thread for Context {}",
self.scheduler.context_name self.scheduler.context_name
@ -325,7 +324,7 @@ impl Drop for SchedulerShutdown {
// Don't block shutting down itself // Don't block shutting down itself
if !self.scheduler.is_current() { if !self.scheduler.is_current() {
if let Some(join_handler) = self.join.take() { if let Some(join_handler) = self.join.take() {
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"Waiting for Scheduler thread to shutdown for Context {}", "Waiting for Scheduler thread to shutdown for Context {}",
self.scheduler.context_name self.scheduler.context_name
@ -429,7 +428,7 @@ impl Handle {
.push(CleanUpOps(source)) .push(CleanUpOps(source))
.is_err() .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::future::BoxFuture;
use futures::prelude::*; use futures::prelude::*;
use gst::{gst_log, gst_trace, gst_warning};
use pin_project_lite::pin_project; use pin_project_lite::pin_project;
use slab::Slab; use slab::Slab;
@ -139,7 +137,7 @@ impl TaskQueue {
let context_name = Arc::clone(&self.context_name); let context_name = Arc::clone(&self.context_name);
let task_fut = async move { let task_fut = async move {
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"Running {:?} on context {}", "Running {:?} on context {}",
task_id, task_id,
@ -149,7 +147,7 @@ impl TaskQueue {
let _guard = CallOnDrop::new(move || { let _guard = CallOnDrop::new(move || {
if let Some(task) = tasks_clone.lock().unwrap().try_remove(task_id.0) { if let Some(task) = tasks_clone.lock().unwrap().try_remove(task_id.0) {
if !task.sub_tasks.is_empty() { if !task.sub_tasks.is_empty() {
gst_warning!( gst::warning!(
RUNTIME_CAT, RUNTIME_CAT,
"Task {:?} on context {} has {} pending sub tasks", "Task {:?} on context {} has {} pending sub tasks",
task_id, task_id,
@ -159,7 +157,7 @@ impl TaskQueue {
} }
} }
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"Done {:?} on context {}", "Done {:?} on context {}",
task_id, task_id,
@ -203,7 +201,7 @@ impl TaskQueue {
let context_name = Arc::clone(&self.context_name); let context_name = Arc::clone(&self.context_name);
let task_fut = async move { let task_fut = async move {
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"Executing sync function on context {} as {:?}", "Executing sync function on context {} as {:?}",
context_name, context_name,
@ -213,7 +211,7 @@ impl TaskQueue {
let _guard = CallOnDrop::new(move || { let _guard = CallOnDrop::new(move || {
let _ = tasks_clone.lock().unwrap().try_remove(task_id.0); let _ = tasks_clone.lock().unwrap().try_remove(task_id.0);
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"Done executing sync function on context {} as {:?}", "Done executing sync function on context {} as {:?}",
context_name, context_name,
@ -257,7 +255,7 @@ impl TaskQueue {
{ {
match self.tasks.lock().unwrap().get_mut(task_id.0) { match self.tasks.lock().unwrap().get_mut(task_id.0) {
Some(task) => { Some(task) => {
gst_trace!( gst::trace!(
RUNTIME_CAT, RUNTIME_CAT,
"Adding subtask to {:?} on context {}", "Adding subtask to {:?} on context {}",
task_id, task_id,
@ -267,7 +265,7 @@ impl TaskQueue {
Ok(()) Ok(())
} }
None => { None => {
gst_trace!(RUNTIME_CAT, "Task was removed in the meantime"); gst::trace!(RUNTIME_CAT, "Task was removed in the meantime");
Err(sub_task) Err(sub_task)
} }
} }
@ -287,7 +285,7 @@ impl TaskQueue {
async move { async move {
if let Some((mut sub_tasks, context_name)) = sub_tasks { if let Some((mut sub_tasks, context_name)) = sub_tasks {
if !sub_tasks.is_empty() { if !sub_tasks.is_empty() {
gst_log!( gst::log!(
RUNTIME_CAT, RUNTIME_CAT,
"Scheduling draining {} sub tasks from {:?} on '{}'", "Scheduling draining {} sub tasks from {:?} on '{}'",
sub_tasks.len(), sub_tasks.len(),

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

@ -74,7 +74,6 @@ use futures::prelude::*;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_fixme, gst_log};
use gst::{FlowError, FlowSuccess}; use gst::{FlowError, FlowSuccess};
use std::marker::PhantomData; use std::marker::PhantomData;
@ -129,7 +128,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
let gst_pad = pad.gst_pad(); let gst_pad = pad.gst_pad();
if gst_pad.is_active() { if gst_pad.is_active() {
gst_debug!( gst::debug!(
RUNTIME_CAT, RUNTIME_CAT,
obj: gst_pad, obj: gst_pad,
"Already activated in {:?} mode ", "Already activated in {:?} mode ",
@ -141,7 +140,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
gst_pad gst_pad
.activate_mode(gst::PadMode::Push, true) .activate_mode(gst::PadMode::Push, true)
.map_err(|err| { .map_err(|err| {
gst_error!( gst::error!(
RUNTIME_CAT, RUNTIME_CAT,
obj: gst_pad, obj: gst_pad,
"Error in PadSrc activate: {:?}", "Error in PadSrc activate: {:?}",
@ -169,7 +168,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
element: &gst::Element, element: &gst::Element,
event: gst::Event, event: gst::Event,
) -> bool { ) -> 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) pad.gst_pad().event_default(Some(element), event)
} }
@ -193,7 +192,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
element: &gst::Element, element: &gst::Element,
query: &mut gst::QueryRef, query: &mut gst::QueryRef,
) -> bool { ) -> 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() { if query.is_serialized() {
// FIXME serialized queries should be handled with the dataflow // FIXME serialized queries should be handled with the dataflow
// but we can't return a `Future` because we couldn't honor QueryRef's lifetime // 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> { 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| { let success = self.gst_pad.push(buffer).map_err(|err| {
gst_error!(RUNTIME_CAT, gst::error!(RUNTIME_CAT,
obj: self.gst_pad(), obj: self.gst_pad(),
"Failed to push Buffer to PadSrc: {:?}", "Failed to push Buffer to PadSrc: {:?}",
err, err,
@ -234,7 +233,7 @@ impl PadSrcInner {
err 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() { while Context::current_has_sub_tasks() {
Context::drain_sub_tasks().await?; Context::drain_sub_tasks().await?;
} }
@ -243,10 +242,10 @@ impl PadSrcInner {
} }
pub async fn push_list(&self, list: gst::BufferList) -> Result<FlowSuccess, FlowError> { 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| { let success = self.gst_pad.push_list(list).map_err(|err| {
gst_error!( gst::error!(
RUNTIME_CAT, RUNTIME_CAT,
obj: self.gst_pad(), obj: self.gst_pad(),
"Failed to push BufferList to PadSrc: {:?}", "Failed to push BufferList to PadSrc: {:?}",
@ -255,7 +254,7 @@ impl PadSrcInner {
err 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() { while Context::current_has_sub_tasks() {
Context::drain_sub_tasks().await?; Context::drain_sub_tasks().await?;
} }
@ -264,11 +263,11 @@ impl PadSrcInner {
} }
pub async fn push_event(&self, event: gst::Event) -> bool { 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); 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() { while Context::current_has_sub_tasks() {
if Context::drain_sub_tasks().await.is_err() { if Context::drain_sub_tasks().await.is_err() {
return false; return false;
@ -333,10 +332,10 @@ impl<'a> PadSrcRef<'a> {
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
// Important: don't panic here as the hook is used without `catch_panic_pad_function` // Important: don't panic here as the hook is used without `catch_panic_pad_function`
// in the default `activatemode` handling // 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 { 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!( return Err(gst::loggable_error!(
RUNTIME_CAT, RUNTIME_CAT,
"Pull mode not supported by PadSrc" "Pull mode not supported by PadSrc"
@ -399,7 +398,7 @@ impl PadSrc {
H::ElementImpl::catch_panic_pad_function( H::ElementImpl::catch_panic_pad_function(
parent, 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!( Err(gst::loggable_error!(
RUNTIME_CAT, RUNTIME_CAT,
"Panic in PadSrc activate" "Panic in PadSrc activate"
@ -425,7 +424,7 @@ impl PadSrc {
H::ElementImpl::catch_panic_pad_function( H::ElementImpl::catch_panic_pad_function(
parent, 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!( Err(gst::loggable_error!(
RUNTIME_CAT, RUNTIME_CAT,
"Panic in PadSrc activatemode" "Panic in PadSrc activatemode"
@ -481,7 +480,7 @@ impl PadSrc {
if !query.is_serialized() { if !query.is_serialized() {
handler.src_query(&this_ref, imp, element.dynamic_cast_ref::<gst::Element>().unwrap(), query) handler.src_query(&this_ref, imp, element.dynamic_cast_ref::<gst::Element>().unwrap(), query)
} else { } 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 false
} }
}, },
@ -540,7 +539,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
let gst_pad = pad.gst_pad(); let gst_pad = pad.gst_pad();
if gst_pad.is_active() { if gst_pad.is_active() {
gst_debug!( gst::debug!(
RUNTIME_CAT, RUNTIME_CAT,
obj: gst_pad, obj: gst_pad,
"Already activated in {:?} mode ", "Already activated in {:?} mode ",
@ -552,7 +551,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
gst_pad gst_pad
.activate_mode(gst::PadMode::Push, true) .activate_mode(gst::PadMode::Push, true)
.map_err(|err| { .map_err(|err| {
gst_error!( gst::error!(
RUNTIME_CAT, RUNTIME_CAT,
obj: gst_pad, obj: gst_pad,
"Error in PadSink activate: {:?}", "Error in PadSink activate: {:?}",
@ -601,7 +600,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
event: gst::Event, event: gst::Event,
) -> bool { ) -> bool {
assert!(!event.is_serialized()); 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) pad.gst_pad().event_default(Some(element), event)
} }
@ -618,7 +617,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
async move { async move {
let pad = pad_weak.upgrade().expect("PadSink no longer exists"); 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) pad.gst_pad().event_default(Some(&element), event)
} }
@ -664,12 +663,12 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
query: &mut gst::QueryRef, query: &mut gst::QueryRef,
) -> bool { ) -> bool {
if query.is_serialized() { 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 // FIXME serialized queries should be handled with the dataflow
// but we can't return a `Future` because we couldn't honor QueryRef's lifetime // but we can't return a `Future` because we couldn't honor QueryRef's lifetime
false false
} else { } 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) pad.gst_pad().query_default(Some(element), query)
} }
} }
@ -747,10 +746,10 @@ impl<'a> PadSinkRef<'a> {
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
// Important: don't panic here as the hook is used without `catch_panic_pad_function` // Important: don't panic here as the hook is used without `catch_panic_pad_function`
// in the default `activatemode` handling // 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 { 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!( return Err(gst::loggable_error!(
RUNTIME_CAT, RUNTIME_CAT,
"Pull mode not supported by PadSink" "Pull mode not supported by PadSink"
@ -820,7 +819,7 @@ impl PadSink {
H::ElementImpl::catch_panic_pad_function( H::ElementImpl::catch_panic_pad_function(
parent, 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!( Err(gst::loggable_error!(
RUNTIME_CAT, RUNTIME_CAT,
"Panic in PadSink activate" "Panic in PadSink activate"
@ -846,7 +845,7 @@ impl PadSink {
H::ElementImpl::catch_panic_pad_function( H::ElementImpl::catch_panic_pad_function(
parent, 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!( Err(gst::loggable_error!(
RUNTIME_CAT, RUNTIME_CAT,
"Panic in PadSink activatemode" "Panic in PadSink activatemode"
@ -1021,7 +1020,7 @@ impl PadSink {
if !query.is_serialized() { if !query.is_serialized() {
handler.sink_query(&this_ref, imp, element.dynamic_cast_ref::<gst::Element>().unwrap(), query) handler.sink_query(&this_ref, imp, element.dynamic_cast_ref::<gst::Element>().unwrap(), query)
} else { } 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 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::{gst_debug, gst_error, gst_log};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -75,7 +74,7 @@ impl<T: SocketRead> Socket<T> {
) -> Result<Self, glib::BoolError> { ) -> Result<Self, glib::BoolError> {
// FIXME couldn't we just delegate this to caller? // FIXME couldn't we just delegate this to caller?
buffer_pool.set_active(true).map_err(|err| { buffer_pool.set_active(true).map_err(|err| {
gst_error!( gst::error!(
SOCKET_CAT, SOCKET_CAT,
obj: &element, obj: &element,
"Failed to prepare socket: {}", "Failed to prepare socket: {}",
@ -125,7 +124,7 @@ impl<T: SocketRead> Socket<T> {
// tokio::net::UdpSocket which don't implement pollable functions. // tokio::net::UdpSocket which don't implement pollable functions.
#[allow(clippy::should_implement_trait)] #[allow(clippy::should_implement_trait)]
pub async fn next(&mut self) -> Option<SocketStreamItem> { 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() { if self.mapped_buffer.is_none() {
match self.buffer_pool.acquire_buffer(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()); self.mapped_buffer = Some(buffer.into_mapped_buffer_writable().unwrap());
} }
Err(err) => { 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))); 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(); let running_time = time.opt_checked_sub(self.base_time).ok().flatten();
// FIXME maybe we should check if running_time.is_none // FIXME maybe we should check if running_time.is_none
// so as to display another message // so as to display another message
gst_debug!( gst::debug!(
SOCKET_CAT, SOCKET_CAT,
obj: &self.element, obj: &self.element,
"Read {} bytes at {} (clock {})", "Read {} bytes at {} (clock {})",
@ -160,7 +159,7 @@ impl<T: SocketRead> Socket<T> {
); );
running_time running_time
} else { } else {
gst_debug!(SOCKET_CAT, obj: &self.element, "Read {} bytes", len); gst::debug!(SOCKET_CAT, obj: &self.element, "Read {} bytes", len);
gst::ClockTime::NONE gst::ClockTime::NONE
}; };
@ -176,7 +175,7 @@ impl<T: SocketRead> Socket<T> {
Some(Ok((buffer, saddr))) Some(Ok((buffer, saddr)))
} }
Err(err) => { 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))) Some(Err(SocketError::Io(err)))
} }
@ -187,7 +186,7 @@ impl<T: SocketRead> Socket<T> {
impl<T: SocketRead> Drop for Socket<T> { impl<T: SocketRead> Drop for Socket<T> {
fn drop(&mut self) { fn drop(&mut self) {
if let Err(err) = self.buffer_pool.set_active(false) { 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -139,7 +138,7 @@ impl TcpClientSrcPadHandler {
async fn push_prelude(&self, pad: &PadSrcRef<'_>, _element: &super::TcpClientSrc) { async fn push_prelude(&self, pad: &PadSrcRef<'_>, _element: &super::TcpClientSrc) {
let mut state = self.0.state.lock().await; let mut state = self.0.state.lock().await;
if state.need_initial_events { 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_id = format!("{:08x}{:08x}", rand::random::<u32>(), rand::random::<u32>());
let stream_start_evt = gst::event::StreamStart::builder(&stream_id) let stream_start_evt = gst::event::StreamStart::builder(&stream_id)
@ -170,7 +169,7 @@ impl TcpClientSrcPadHandler {
element: &super::TcpClientSrc, element: &super::TcpClientSrc,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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; self.push_prelude(pad, element).await;
@ -195,7 +194,7 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
) -> bool { ) -> bool {
use gst::EventView; 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() { let ret = match event.view() {
EventView::FlushStart(..) => tcpclientsrc.task.flush_start().is_ok(), EventView::FlushStart(..) => tcpclientsrc.task.flush_start().is_ok(),
@ -206,9 +205,9 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
}; };
if ret { if ret {
gst_log!(CAT, obj: pad.gst_pad(), "Handled {:?}", event); gst::log!(CAT, obj: pad.gst_pad(), "Handled {:?}", event);
} else { } else {
gst_log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event); gst::log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", event);
} }
ret ret
@ -223,7 +222,7 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
) -> bool { ) -> bool {
use gst::QueryViewMut; 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() { let ret = match query.view_mut() {
QueryViewMut::Latency(q) => { QueryViewMut::Latency(q) => {
q.set(false, gst::ClockTime::ZERO, gst::ClockTime::NONE); q.set(false, gst::ClockTime::ZERO, gst::ClockTime::NONE);
@ -253,9 +252,9 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
}; };
if ret { if ret {
gst_log!(CAT, obj: pad.gst_pad(), "Handled {:?}", query); gst::log!(CAT, obj: pad.gst_pad(), "Handled {:?}", query);
} else { } else {
gst_log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query); gst::log!(CAT, obj: pad.gst_pad(), "Didn't handle {:?}", query);
} }
ret ret
@ -293,7 +292,7 @@ impl TcpClientSrcTask {
impl TaskImpl for TcpClientSrcTask { impl TaskImpl for TcpClientSrcTask {
fn prepare(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { fn prepare(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move { 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) let socket = Async::<TcpStream>::connect(self.saddr)
.await .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(()) Ok(())
} }
.boxed() .boxed()
@ -333,7 +332,7 @@ impl TaskImpl for TcpClientSrcTask {
async move { async move {
match trigger { match trigger {
task::Trigger::Prepare => { task::Trigger::Prepare => {
gst_error!(CAT, "Task preparation failed: {:?}", err); gst::error!(CAT, "Task preparation failed: {:?}", err);
self.element.post_error_message(err); self.element.post_error_message(err);
task::Trigger::Error task::Trigger::Error
@ -351,7 +350,7 @@ impl TaskImpl for TcpClientSrcTask {
let buffer = match item { let buffer = match item {
Some(Ok((buffer, _))) => buffer, Some(Ok((buffer, _))) => buffer,
Some(Err(err)) => { Some(Err(err)) => {
gst_error!(CAT, obj: &self.element, "Got error {:?}", err); gst::error!(CAT, obj: &self.element, "Got error {:?}", err);
match err { match err {
SocketError::Gst(err) => { SocketError::Gst(err) => {
gst::element_error!( gst::element_error!(
@ -373,7 +372,7 @@ impl TaskImpl for TcpClientSrcTask {
return Err(gst::FlowError::Error); return Err(gst::FlowError::Error);
} }
None => { None => {
gst_log!(CAT, obj: &self.element, "SocketStream Stopped"); gst::log!(CAT, obj: &self.element, "SocketStream Stopped");
return Err(gst::FlowError::Flushing); return Err(gst::FlowError::Flushing);
} }
}; };
@ -385,17 +384,17 @@ impl TaskImpl for TcpClientSrcTask {
.await; .await;
match res { match res {
Ok(_) => { Ok(_) => {
gst_log!(CAT, obj: &self.element, "Successfully pushed buffer"); gst::log!(CAT, obj: &self.element, "Successfully pushed buffer");
} }
Err(gst::FlowError::Flushing) => { Err(gst::FlowError::Flushing) => {
gst_debug!(CAT, obj: &self.element, "Flushing"); gst::debug!(CAT, obj: &self.element, "Flushing");
} }
Err(gst::FlowError::Eos) => { 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; pad.push_event(gst::event::Eos::new()).await;
} }
Err(err) => { Err(err) => {
gst_error!(CAT, obj: &self.element, "Got error {}", err); gst::error!(CAT, obj: &self.element, "Got error {}", err);
gst::element_error!( gst::element_error!(
self.element, self.element,
gst::StreamError::Failed, gst::StreamError::Failed,
@ -412,9 +411,9 @@ impl TaskImpl for TcpClientSrcTask {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move { 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; self.src_pad_handler.reset_state().await;
gst_log!(CAT, obj: &self.element, "Task stopped"); gst::log!(CAT, obj: &self.element, "Task stopped");
Ok(()) Ok(())
} }
.boxed() .boxed()
@ -422,9 +421,9 @@ impl TaskImpl for TcpClientSrcTask {
fn flush_stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { fn flush_stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move { 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; 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(()) Ok(())
} }
.boxed() .boxed()
@ -450,7 +449,7 @@ impl TcpClientSrc {
fn prepare(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> { fn prepare(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> {
let settings = self.settings.lock().unwrap().clone(); let settings = self.settings.lock().unwrap().clone();
gst_debug!(CAT, obj: element, "Preparing"); gst::debug!(CAT, obj: element, "Preparing");
let context = let context =
Context::acquire(&settings.context, settings.context_wait).map_err(|err| { 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(()) Ok(())
} }
fn unprepare(&self, element: &super::TcpClientSrc) { fn unprepare(&self, element: &super::TcpClientSrc) {
gst_debug!(CAT, obj: element, "Unpreparing"); gst::debug!(CAT, obj: element, "Unpreparing");
self.task.unprepare().unwrap(); 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> { fn stop(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Stopping"); gst::debug!(CAT, obj: element, "Stopping");
self.task.stop()?; self.task.stop()?;
gst_debug!(CAT, obj: element, "Stopped"); gst::debug!(CAT, obj: element, "Stopped");
Ok(()) Ok(())
} }
fn start(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> { fn start(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Starting"); gst::debug!(CAT, obj: element, "Starting");
self.task.start()?; self.task.start()?;
gst_debug!(CAT, obj: element, "Started"); gst::debug!(CAT, obj: element, "Started");
Ok(()) Ok(())
} }
fn pause(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> { fn pause(&self, element: &super::TcpClientSrc) -> Result<(), gst::ErrorMessage> {
gst_debug!(CAT, obj: element, "Pausing"); gst::debug!(CAT, obj: element, "Pausing");
self.task.pause()?; self.task.pause()?;
gst_debug!(CAT, obj: element, "Paused"); gst::debug!(CAT, obj: element, "Paused");
Ok(()) Ok(())
} }
} }
@ -719,7 +718,7 @@ impl ElementImpl for TcpClientSrc {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::NullToReady => { gst::StateChange::NullToReady => {

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

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

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

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

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

@ -17,7 +17,6 @@
// //
// SPDX-License-Identifier: LGPL-2.1-or-later // SPDX-License-Identifier: LGPL-2.1-or-later
use gst::gst_debug;
use gst::prelude::*; use gst::prelude::*;
use std::sync::mpsc; use std::sync::mpsc;
@ -92,10 +91,10 @@ fn jb_pipeline() {
pipeline.set_state(gst::State::Playing).unwrap(); 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 { for idx in 0..BUFFER_NB {
receiver.recv().unwrap(); 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(); pipeline.set_state(gst::State::Null).unwrap();
@ -155,10 +154,10 @@ fn jb_ts_pipeline() {
pipeline.set_state(gst::State::Playing).unwrap(); 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 { for idx in 0..BUFFER_NB {
receiver.recv().unwrap(); 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(); 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::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::EventView; use gst::EventView;
use gst::{gst_debug, gst_info, gst_log};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -93,7 +92,7 @@ mod imp_src {
pad: &PadSrcRef<'_>, pad: &PadSrcRef<'_>,
item: Item, item: Item,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 { match item {
Item::Event(event) => { Item::Event(event) => {
@ -117,7 +116,7 @@ mod imp_src {
_element: &gst::Element, _element: &gst::Element,
event: gst::Event, event: gst::Event,
) -> bool { ) -> 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() { let ret = match event.view() {
EventView::FlushStart(..) => { EventView::FlushStart(..) => {
@ -133,9 +132,9 @@ mod imp_src {
}; };
if ret { if ret {
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Handled {:?}", event); gst::log!(SRC_CAT, obj: pad.gst_pad(), "Handled {:?}", event);
} else { } 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 ret
@ -178,7 +177,7 @@ mod imp_src {
let item = match item { let item = match item {
Some(item) => item, Some(item) => item,
None => { 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); return Err(gst::FlowError::Eos);
} }
}; };
@ -186,9 +185,9 @@ mod imp_src {
let pad = self.src_pad.upgrade().expect("PadSrc no longer exists"); let pad = self.src_pad.upgrade().expect("PadSrc no longer exists");
let res = PadSrcTestHandler::push_item(&pad, item).await; let res = PadSrcTestHandler::push_item(&pad, item).await;
match res { 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) => { 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), Err(err) => panic!("Got error {}", err),
} }
@ -200,9 +199,9 @@ mod imp_src {
fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move { async move {
gst_log!(SRC_CAT, obj: &self.element, "Stopping task"); gst::log!(SRC_CAT, obj: &self.element, "Stopping task");
self.flush(); self.flush();
gst_log!(SRC_CAT, obj: &self.element, "Task stopped"); gst::log!(SRC_CAT, obj: &self.element, "Task stopped");
Ok(()) Ok(())
} }
.boxed() .boxed()
@ -210,9 +209,9 @@ mod imp_src {
fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> {
async move { async move {
gst_log!(SRC_CAT, obj: &self.element, "Starting task flush"); gst::log!(SRC_CAT, obj: &self.element, "Starting task flush");
self.flush(); self.flush();
gst_log!(SRC_CAT, obj: &self.element, "Task flush started"); gst::log!(SRC_CAT, obj: &self.element, "Task flush started");
Ok(()) Ok(())
} }
.boxed() .boxed()
@ -231,7 +230,7 @@ mod imp_src {
pub fn try_push(&self, item: Item) -> Result<(), Item> { pub fn try_push(&self, item: Item) -> Result<(), Item> {
let state = self.task.lock_state(); let state = self.task.lock_state();
if *state != TaskState::Started && *state != TaskState::Paused { 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); return Err(item);
} }
@ -245,7 +244,7 @@ mod imp_src {
} }
fn prepare(&self, element: &super::ElementSrcTest) -> Result<(), gst::ErrorMessage> { 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 settings = self.settings.lock().unwrap().clone();
let context = let context =
@ -271,36 +270,36 @@ mod imp_src {
) )
})?; })?;
gst_debug!(SRC_CAT, obj: element, "Prepared"); gst::debug!(SRC_CAT, obj: element, "Prepared");
Ok(()) Ok(())
} }
fn unprepare(&self, element: &super::ElementSrcTest) { 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.sender.lock().unwrap() = None;
self.task.unprepare().unwrap(); self.task.unprepare().unwrap();
gst_debug!(SRC_CAT, obj: element, "Unprepared"); gst::debug!(SRC_CAT, obj: element, "Unprepared");
} }
fn stop(&self, element: &super::ElementSrcTest) { fn stop(&self, element: &super::ElementSrcTest) {
gst_debug!(SRC_CAT, obj: element, "Stopping"); gst::debug!(SRC_CAT, obj: element, "Stopping");
self.task.stop().unwrap(); self.task.stop().unwrap();
gst_debug!(SRC_CAT, obj: element, "Stopped"); gst::debug!(SRC_CAT, obj: element, "Stopped");
} }
fn start(&self, element: &super::ElementSrcTest) { fn start(&self, element: &super::ElementSrcTest) {
gst_debug!(SRC_CAT, obj: element, "Starting"); gst::debug!(SRC_CAT, obj: element, "Starting");
self.task.start().unwrap(); self.task.start().unwrap();
gst_debug!(SRC_CAT, obj: element, "Started"); gst::debug!(SRC_CAT, obj: element, "Started");
} }
fn pause(&self, element: &super::ElementSrcTest) { fn pause(&self, element: &super::ElementSrcTest) {
gst_debug!(SRC_CAT, obj: element, "Pausing"); gst::debug!(SRC_CAT, obj: element, "Pausing");
self.task.pause().unwrap(); 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, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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 { match transition {
gst::StateChange::NullToReady => { gst::StateChange::NullToReady => {
@ -523,7 +522,7 @@ mod imp_sink {
element: &gst::Element, element: &gst::Element,
event: gst::Event, event: gst::Event,
) -> bool { ) -> 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() { match event.view() {
EventView::FlushStart(..) => { EventView::FlushStart(..) => {
@ -541,7 +540,7 @@ mod imp_sink {
element: &gst::Element, element: &gst::Element,
event: gst::Event, event: gst::Event,
) -> BoxFuture<'static, bool> { ) -> 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 let element = element
.clone() .clone()
@ -577,7 +576,7 @@ mod imp_sink {
item: Item, item: Item,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
if !self.flushing.load(Ordering::SeqCst) { if !self.flushing.load(Ordering::SeqCst) {
gst_debug!(SINK_CAT, obj: element, "Fowarding {:?}", item); gst::debug!(SINK_CAT, obj: element, "Fowarding {:?}", item);
self.sender self.sender
.lock() .lock()
.await .await
@ -588,7 +587,7 @@ mod imp_sink {
.map(|_| gst::FlowSuccess::Ok) .map(|_| gst::FlowSuccess::Ok)
.map_err(|_| gst::FlowError::Error) .map_err(|_| gst::FlowError::Error)
} else { } else {
gst_debug!( gst::debug!(
SINK_CAT, SINK_CAT,
obj: element, obj: element,
"Not fowarding {:?} due to flushing", "Not fowarding {:?} due to flushing",
@ -599,33 +598,33 @@ mod imp_sink {
} }
fn start(&self, element: &super::ElementSinkTest) { 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); 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) { 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); self.flushing.store(true, Ordering::SeqCst);
gst_debug!(SINK_CAT, obj: element, "Stopped"); gst::debug!(SINK_CAT, obj: element, "Stopped");
} }
} }
impl ElementSinkTest { impl ElementSinkTest {
pub fn push_flush_start(&self, element: &super::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 self.sink_pad
.gst_pad() .gst_pad()
.push_event(gst::event::FlushStart::new()); .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) { 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 self.sink_pad
.gst_pad() .gst_pad()
.push_event(gst::event::FlushStop::new(true)); .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, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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 { if let gst::StateChange::PausedToReady = transition {
self.stop(element); self.stop(element);
@ -1151,7 +1150,7 @@ fn start_stop_start() {
match futures::executor::block_on(receiver.next()).unwrap() { match futures::executor::block_on(receiver.next()).unwrap() {
Item::Buffer(_buffer) => { Item::Buffer(_buffer) => {
gst_info!( gst::info!(
imp_src::SRC_CAT, imp_src::SRC_CAT,
"{}: initial buffer went through, don't expect any pending item to be dropped", "{}: initial buffer went through, don't expect any pending item to be dropped",
scenario_name scenario_name

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

@ -19,7 +19,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::{gst_debug, gst_error};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -110,13 +109,13 @@ fn multiple_contexts_queue() {
for _ in 0..BUFFER_NB { for _ in 0..BUFFER_NB {
for dest in &destinations { 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(); socket.send_to(&buffer, dest).unwrap();
std::thread::sleep(std::time::Duration::from_millis(CONTEXT_WAIT as u64)); std::thread::sleep(std::time::Duration::from_millis(CONTEXT_WAIT as u64));
} }
} }
gst_debug!( gst::debug!(
CAT, CAT,
"multiple_contexts_queue: waiting for all buffers notifications" "multiple_contexts_queue: waiting for all buffers notifications"
); );
@ -147,7 +146,7 @@ fn multiple_contexts_queue() {
} }
} }
MessageView::Error(err) => { MessageView::Error(err) => {
gst_error!( gst::error!(
CAT, CAT,
"multiple_contexts_queue: Error from {:?}: {} ({:?})", "multiple_contexts_queue: Error from {:?}: {} ({:?})",
err.src().map(|s| s.path_string()), err.src().map(|s| s.path_string()),
@ -165,9 +164,9 @@ fn multiple_contexts_queue() {
pipeline.set_state(gst::State::Playing).unwrap(); 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(); l.run();
gst_debug!(CAT, "Stopping main loop for multiple_contexts_queue..."); gst::debug!(CAT, "Stopping main loop for multiple_contexts_queue...");
} }
#[test] #[test]
@ -259,13 +258,13 @@ fn multiple_contexts_proxy() {
for _ in 0..BUFFER_NB { for _ in 0..BUFFER_NB {
for dest in &destinations { 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(); socket.send_to(&buffer, dest).unwrap();
std::thread::sleep(std::time::Duration::from_millis(CONTEXT_WAIT as u64)); std::thread::sleep(std::time::Duration::from_millis(CONTEXT_WAIT as u64));
} }
} }
gst_debug!( gst::debug!(
CAT, CAT,
"multiple_contexts_proxy: waiting for all buffers notifications" "multiple_contexts_proxy: waiting for all buffers notifications"
); );
@ -296,7 +295,7 @@ fn multiple_contexts_proxy() {
} }
} }
MessageView::Error(err) => { MessageView::Error(err) => {
gst_error!( gst::error!(
CAT, CAT,
"multiple_contexts_proxy: Error from {:?}: {} ({:?})", "multiple_contexts_proxy: Error from {:?}: {} ({:?})",
err.src().map(|s| s.path_string()), err.src().map(|s| s.path_string()),
@ -314,9 +313,9 @@ fn multiple_contexts_proxy() {
pipeline.set_state(gst::State::Playing).unwrap(); 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(); l.run();
gst_debug!(CAT, "Stopping main loop for multiple_contexts_proxy..."); gst::debug!(CAT, "Stopping main loop for multiple_contexts_proxy...");
} }
#[test] #[test]
@ -353,7 +352,7 @@ fn eos() {
appsink.set_callbacks( appsink.set_callbacks(
gst_app::AppSinkCallbacks::builder() gst_app::AppSinkCallbacks::builder()
.new_sample(move |appsink| { .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(); let _ = appsink.pull_sample().unwrap();
sample_notifier.send(()).unwrap(); sample_notifier.send(()).unwrap();
@ -365,7 +364,7 @@ fn eos() {
); );
fn push_buffer(src: &gst::Element) -> bool { 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])]) src.emit_by_name::<bool>("push-buffer", &[&gst::Buffer::from_slice(vec![0; 1024])])
} }
@ -418,7 +417,7 @@ fn eos() {
} }
} }
MessageView::Error(err) => { MessageView::Error(err) => {
gst_error!( gst::error!(
CAT, CAT,
"eos: Error from {:?}: {} ({:?})", "eos: Error from {:?}: {} ({:?})",
err.src().map(|s| s.path_string()), err.src().map(|s| s.path_string()),
@ -436,9 +435,9 @@ fn eos() {
pipeline.set_state(gst::State::Playing).unwrap(); 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(); l.run();
gst_debug!(CAT, "Stopping main loop for eos..."); gst::debug!(CAT, "Stopping main loop for eos...");
} }
#[test] #[test]
@ -480,7 +479,7 @@ fn premature_shutdown() {
appsink.set_callbacks( appsink.set_callbacks(
gst_app::AppSinkCallbacks::builder() gst_app::AppSinkCallbacks::builder()
.new_sample(move |appsink| { .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(); let _sample = appsink.pull_sample().unwrap();
appsink_sender.send(()).unwrap(); appsink_sender.send(()).unwrap();
@ -491,7 +490,7 @@ fn premature_shutdown() {
); );
fn push_buffer(src: &gst::Element, intent: &str) -> bool { fn push_buffer(src: &gst::Element, intent: &str) -> bool {
gst_debug!( gst::debug!(
CAT, CAT,
obj: src, obj: src,
"premature_shutdown: pushing buffer {}", "premature_shutdown: pushing buffer {}",
@ -503,7 +502,7 @@ fn premature_shutdown() {
let pipeline_clone = pipeline.clone(); let pipeline_clone = pipeline.clone();
let l_clone = l.clone(); let l_clone = l.clone();
let mut scenario = Some(move || { let mut scenario = Some(move || {
gst_debug!(CAT, "premature_shutdown: STEP 1: Playing"); gst::debug!(CAT, "premature_shutdown: STEP 1: Playing");
// Initialize the dataflow // Initialize the dataflow
assert!(push_buffer(&src, "(initial)")); assert!(push_buffer(&src, "(initial)"));
@ -516,26 +515,26 @@ fn premature_shutdown() {
assert!(push_buffer(&src, "before Playing -> Paused")); 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(); 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(); 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(); appsink_receiver.recv().unwrap();
assert!(push_buffer(&src, "after Paused -> Playing")); 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(); appsink_receiver.recv().unwrap();
// Fill up the (dataqueue) and abruptly shutdown // Fill up the (dataqueue) and abruptly shutdown
assert!(push_buffer(&src, "filling 1")); assert!(push_buffer(&src, "filling 1"));
assert!(push_buffer(&src, "filling 2")); 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(); pipeline_clone.set_state(gst::State::Null).unwrap();
@ -567,7 +566,7 @@ fn premature_shutdown() {
} }
} }
MessageView::Error(err) => { MessageView::Error(err) => {
gst_error!( gst::error!(
CAT, CAT,
"premature_shutdown: Error from {:?}: {} ({:?})", "premature_shutdown: Error from {:?}: {} ({:?})",
err.src().map(|s| s.path_string()), err.src().map(|s| s.path_string()),
@ -585,7 +584,7 @@ fn premature_shutdown() {
pipeline.set_state(gst::State::Playing).unwrap(); 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(); 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 glib::subclass::prelude::*;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_trace, gst_warning};
use m3u8_rs::MediaPlaylistType; use m3u8_rs::MediaPlaylistType;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use std::fs; use std::fs;
@ -121,7 +120,7 @@ pub struct HlsSink3 {
impl HlsSink3 { impl HlsSink3 {
fn start(&self, element: &super::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 (target_duration, playlist_type) = {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
@ -142,7 +141,7 @@ impl HlsSink3 {
element: &super::HlsSink3, element: &super::HlsSink3,
fragment_id: u32, fragment_id: u32,
) -> Result<String, String> { ) -> Result<String, String> {
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Starting the formatting of the fragment-id: {}", "Starting the formatting of the fragment-id: {}",
@ -158,7 +157,7 @@ impl HlsSink3 {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
let segment_file_location = settings.segment_formatter.segment(fragment_id); let segment_file_location = settings.segment_formatter.segment(fragment_id);
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Segment location formatted: {}", "Segment location formatted: {}",
@ -178,7 +177,7 @@ impl HlsSink3 {
.giostreamsink .giostreamsink
.set_property("stream", &fragment_stream); .set_property("stream", &fragment_stream);
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"New segment location: {:?}", "New segment location: {:?}",
@ -215,7 +214,7 @@ impl HlsSink3 {
P: AsRef<path::Path>, P: AsRef<path::Path>,
{ {
let _ = fs::remove_file(location).map_err(|err| { let _ = fs::remove_file(location).map_err(|err| {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Could not delete segment file: {}", "Could not delete segment file: {}",
@ -229,7 +228,7 @@ impl HlsSink3 {
element: &super::HlsSink3, element: &super::HlsSink3,
fragment_closed_at: Option<gst::ClockTime>, fragment_closed_at: Option<gst::ClockTime>,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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 mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard { let state = match &mut *state_guard {
@ -237,7 +236,7 @@ impl HlsSink3 {
State::Started(s) => s, 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. // Only add fragment if it's complete.
if let Some(fragment_closed) = fragment_closed_at { if let Some(fragment_closed) = fragment_closed_at {
@ -268,7 +267,7 @@ impl HlsSink3 {
&[&playlist_location], &[&playlist_location],
) )
.ok_or_else(|| { .ok_or_else(|| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Could not get stream to write playlist content", "Could not get stream to write playlist content",
@ -281,7 +280,7 @@ impl HlsSink3 {
.playlist .playlist
.write_to(&mut playlist_stream) .write_to(&mut playlist_stream)
.map_err(|err| { .map_err(|err| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Could not write new playlist: {}", "Could not write new playlist: {}",
@ -290,7 +289,7 @@ impl HlsSink3 {
gst::StateChangeError gst::StateChangeError
})?; })?;
playlist_stream.flush().map_err(|err| { playlist_stream.flush().map_err(|err| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Could not flush playlist: {}", "Could not flush playlist: {}",
@ -307,13 +306,13 @@ impl HlsSink3 {
if !element if !element
.emit_by_name::<bool>(SIGNAL_DELETE_FRAGMENT, &[&old_segment_location]) .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) Ok(gst::StateChangeSuccess::Success)
} }
@ -333,19 +332,19 @@ impl HlsSink3 {
&self, &self,
element: &super::HlsSink3, element: &super::HlsSink3,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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) self.write_playlist(element, None)
} }
fn stop(&self, element: &super::HlsSink3) { 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(); let mut state = self.state.lock().unwrap();
if let State::Started(_) = *state { if let State::Started(_) = *state {
*state = State::Stopped; *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(); 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) { match hlssink3.on_format_location(&element, fragment_id) {
Ok(segment_location) => Some(segment_location.to_value()), Ok(segment_location) => Some(segment_location.to_value()),
Err(err) => { 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()) Some("unknown_segment".to_value())
} }
} }
@ -790,7 +789,7 @@ impl ElementImpl for HlsSink3 {
match templ.name_template().as_ref().map(|val| val.as_str()) { match templ.name_template().as_ref().map(|val| val.as_str()) {
Some("audio") => { Some("audio") => {
if settings.audio_sink { if settings.audio_sink {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"requested_new_pad: audio pad is already set" "requested_new_pad: audio pad is already set"
@ -810,7 +809,7 @@ impl ElementImpl for HlsSink3 {
} }
Some("video") => { Some("video") => {
if settings.video_sink { if settings.video_sink {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"requested_new_pad: video pad is already set" "requested_new_pad: video pad is already set"
@ -829,11 +828,11 @@ impl ElementImpl for HlsSink3 {
Some(sink_pad.upcast()) Some(sink_pad.upcast())
} }
None => { None => {
gst_debug!(CAT, obj: element, "template name returned `None`",); gst::debug!(CAT, obj: element, "template name returned `None`",);
None None
} }
Some(other_name) => { Some(other_name) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"requested_new_pad: name \"{}\" is not audio or video", "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 // SPDX-License-Identifier: MPL-2.0
use gio::prelude::*; use gio::prelude::*;
use gst::gst_info;
use gst::prelude::*; use gst::prelude::*;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use std::io::Write; use std::io::Write;
@ -174,7 +173,7 @@ fn test_hlssink3_element_with_video_content() -> Result<(), ()> {
pipeline.set_state(gst::State::Playing).unwrap(); pipeline.set_state(gst::State::Playing).unwrap();
gst_info!( gst::info!(
CAT, CAT,
"hlssink3_video_pipeline: waiting for {} buffers", "hlssink3_video_pipeline: waiting for {} buffers",
BUFFER_NB BUFFER_NB
@ -281,7 +280,7 @@ fn test_hlssink3_element_with_audio_content() -> Result<(), ()> {
pipeline.set_state(gst::State::Playing).unwrap(); 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 mut eos = false;
let bus = pipeline.bus().unwrap(); let bus = pipeline.bus().unwrap();
@ -378,7 +377,7 @@ fn test_hlssink3_write_correct_playlist_content() -> Result<(), ()> {
pipeline.set_state(gst::State::Playing).unwrap(); pipeline.set_state(gst::State::Playing).unwrap();
gst_info!( gst::info!(
CAT, CAT,
"hlssink3_video_pipeline: waiting for {} buffers", "hlssink3_video_pipeline: waiting for {} buffers",
BUFFER_NB 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_trace, gst_warning};
use gst_base::prelude::*; use gst_base::prelude::*;
use gst_base::subclass::base_src::CreateSuccess; use gst_base::subclass::base_src::CreateSuccess;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -259,7 +258,7 @@ impl ReqwestHttpSrc {
) -> Result<ClientContext, gst::ErrorMessage> { ) -> Result<ClientContext, gst::ErrorMessage> {
let mut client_guard = self.client.lock().unwrap(); let mut client_guard = self.client.lock().unwrap();
if let Some(ref client) = *client_guard { 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()); return Ok(client.clone());
} }
@ -282,7 +281,7 @@ impl ReqwestHttpSrc {
// Hopefully now, self.set_context will have been synchronously called // Hopefully now, self.set_context will have been synchronously called
if let Some(client) = self.external_client.lock().unwrap().clone() { 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()); *client_guard = Some(client.clone());
return Ok(client); return Ok(client);
@ -303,7 +302,7 @@ impl ReqwestHttpSrc {
builder = builder.proxy(p); 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 { let client = ClientContext(Arc::new(ClientContextInner {
client: builder.build().map_err(|err| { client: builder.build().map_err(|err| {
gst::error_msg!( gst::error_msg!(
@ -317,7 +316,7 @@ impl ReqwestHttpSrc {
// The alternative would be different contexts for different proxy settings, or one context with a // 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? // map from proxy settings to client, but then, how and when to discard those, retaining reuse benefits?
if proxy.is_none() { 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 mut context = gst::Context::new(REQWEST_CLIENT_CONTEXT, true);
{ {
let context = context.get_mut().unwrap(); let context = context.get_mut().unwrap();
@ -343,7 +342,7 @@ impl ReqwestHttpSrc {
use headers::{Connection, ContentLength, ContentRange, HeaderMapExt, Range, UserAgent}; use headers::{Connection, ContentLength, ContentRange, HeaderMapExt, Range, UserAgent};
use reqwest::header::{self, HeaderMap, HeaderName, HeaderValue}; 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(); let settings = self.settings.lock().unwrap().clone();
@ -386,7 +385,7 @@ impl ReqwestHttpSrc {
let field = match HeaderName::try_from(field) { let field = match HeaderName::try_from(field) {
Ok(field) => field, Ok(field) => field,
Err(err) => { Err(err) => {
gst_warning!( gst::warning!(
CAT, CAT,
obj: src, obj: src,
"Failed to transform extra-header field name '{}' to header name: {}", "Failed to transform extra-header field name '{}' to header name: {}",
@ -402,7 +401,7 @@ impl ReqwestHttpSrc {
let value = match value.transform::<String>() { let value = match value.transform::<String>() {
Ok(value) => value, Ok(value) => value,
Err(_) => { Err(_) => {
gst_warning!( gst::warning!(
CAT, CAT,
obj: src, obj: src,
"Failed to transform extra-header '{}' value to string", "Failed to transform extra-header '{}' value to string",
@ -417,7 +416,7 @@ impl ReqwestHttpSrc {
let value = match value.parse::<HeaderValue>() { let value = match value.parse::<HeaderValue>() {
Ok(value) => value, Ok(value) => value,
Err(_) => { Err(_) => {
gst_warning!( gst::warning!(
CAT, CAT,
obj: src, obj: src,
"Failed to transform extra-header '{}' value to header value", "Failed to transform extra-header '{}' value to header value",
@ -465,7 +464,7 @@ impl ReqwestHttpSrc {
req req
}; };
gst_debug!(CAT, obj: src, "Sending new request: {:?}", req); gst::debug!(CAT, obj: src, "Sending new request: {:?}", req);
let future = async { let future = async {
req.send().await.map_err(|err| { req.send().await.map_err(|err| {
@ -480,21 +479,21 @@ impl ReqwestHttpSrc {
let res = match res { let res = match res {
Ok(res) => res, Ok(res) => res,
Err(Some(err)) => { Err(Some(err)) => {
gst_debug!(CAT, obj: src, "Error {:?}", err); gst::debug!(CAT, obj: src, "Error {:?}", err);
return Err(Some(err)); return Err(Some(err));
} }
Err(None) => { Err(None) => {
gst_debug!(CAT, obj: src, "Flushing"); gst::debug!(CAT, obj: src, "Flushing");
return Err(None); return Err(None);
} }
}; };
gst_debug!(CAT, obj: src, "Received response: {:?}", res); gst::debug!(CAT, obj: src, "Received response: {:?}", res);
if !res.status().is_success() { if !res.status().is_success() {
match res.status() { match res.status() {
StatusCode::NOT_FOUND => { 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!( return Err(Some(gst::error_msg!(
gst::ResourceError::NotFound, gst::ResourceError::NotFound,
["Resource '{}' not found", uri] ["Resource '{}' not found", uri]
@ -504,14 +503,14 @@ impl ReqwestHttpSrc {
| StatusCode::PAYMENT_REQUIRED | StatusCode::PAYMENT_REQUIRED
| StatusCode::FORBIDDEN | StatusCode::FORBIDDEN
| StatusCode::PROXY_AUTHENTICATION_REQUIRED => { | 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!( return Err(Some(gst::error_msg!(
gst::ResourceError::NotAuthorized, gst::ResourceError::NotAuthorized,
["Not Authorized for resource '{}': {}", uri, res.status()] ["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!( return Err(Some(gst::error_msg!(
gst::ResourceError::OpenRead, gst::ResourceError::OpenRead,
["Request for '{}' failed: {}", uri, res.status()] ["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.to_str().ok())
.and_then(|content_type| content_type.parse::<mime::Mime>().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 { if let Some(ref mut caps) = caps {
let caps = caps.get_mut().unwrap(); let caps = caps.get_mut().unwrap();
let s = caps.structure_mut(0).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 { Ok(State::Started {
uri, uri,
@ -883,7 +882,7 @@ impl ObjectImpl for ReqwestHttpSrc {
}; };
if let Err(err) = res { if let Err(err) = res {
gst_error!( gst::error!(
CAT, CAT,
obj: obj, obj: obj,
"Failed to set property `{}`: {:?}", "Failed to set property `{}`: {:?}",
@ -1058,7 +1057,7 @@ impl BaseSrcImpl for ReqwestHttpSrc {
}) })
.map(|uri| uri.clone())?; .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| { *state = self.do_request(src, uri, 0, None).map_err(|err| {
err.unwrap_or_else(|| { err.unwrap_or_else(|| {
@ -1070,7 +1069,7 @@ impl BaseSrcImpl for ReqwestHttpSrc {
} }
fn stop(&self, src: &Self::Type) -> Result<(), gst::ErrorMessage> { 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; *self.state.lock().unwrap() = State::Stopped;
Ok(()) Ok(())
@ -1116,10 +1115,10 @@ impl BaseSrcImpl for ReqwestHttpSrc {
let start = *segment.start().expect("No start position given"); let start = *segment.start().expect("No start position given");
let stop = segment.stop().map(|stop| *stop); 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 { 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; return true;
} }
@ -1166,7 +1165,7 @@ impl PushSrcImpl for ReqwestHttpSrc {
let mut current_response = match response.take() { let mut current_response = match response.take() {
Some(response) => response, Some(response) => response,
None => { 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"]); gst::element_error!(src, gst::ResourceError::Read, ["Don't have a response"]);
return Err(gst::FlowError::Error); return Err(gst::FlowError::Error);
@ -1178,13 +1177,13 @@ impl PushSrcImpl for ReqwestHttpSrc {
drop(state); drop(state);
if let Some(caps) = caps { 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) src.set_caps(&caps)
.map_err(|_| gst::FlowError::NotNegotiated)?; .map_err(|_| gst::FlowError::NotNegotiated)?;
} }
if let Some(tags) = tags { 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(); let pad = src.static_pad("src").unwrap();
pad.push_event(gst::event::Tag::new(tags)); pad.push_event(gst::event::Tag::new(tags));
} }
@ -1202,12 +1201,12 @@ impl PushSrcImpl for ReqwestHttpSrc {
let res = match res { let res = match res {
Ok(res) => res, Ok(res) => res,
Err(Some(err)) => { Err(Some(err)) => {
gst_debug!(CAT, obj: src, "Error {:?}", err); gst::debug!(CAT, obj: src, "Error {:?}", err);
src.post_error_message(err); src.post_error_message(err);
return Err(gst::FlowError::Error); return Err(gst::FlowError::Error);
} }
Err(None) => { Err(None) => {
gst_debug!(CAT, obj: src, "Flushing"); gst::debug!(CAT, obj: src, "Flushing");
return Err(gst::FlowError::Flushing); return Err(gst::FlowError::Flushing);
} }
}; };
@ -1230,7 +1229,7 @@ impl PushSrcImpl for ReqwestHttpSrc {
Some(chunk) => { Some(chunk) => {
/* do something with the chunk and store the body again in the state */ /* do something with the chunk and store the body again in the state */
gst_trace!( gst::trace!(
CAT, CAT,
obj: src, obj: src,
"Chunk of {} bytes received at offset {}", "Chunk of {} bytes received at offset {}",
@ -1256,7 +1255,7 @@ impl PushSrcImpl for ReqwestHttpSrc {
} }
None => { None => {
/* No further data, end of stream */ /* 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); *response = Some(current_response);
Err(gst::FlowError::Eos) Err(gst::FlowError::Eos)
} }

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

@ -8,7 +8,7 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::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 serde_derive::Deserialize;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -86,7 +86,7 @@ impl TranscribeParse {
_element: &super::TranscribeParse, _element: &super::TranscribeParse,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 mut state = self.state.lock().unwrap();
@ -228,7 +228,7 @@ impl TranscribeParse {
) -> bool { ) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::FlushStop(..) => { EventView::FlushStop(..) => {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
@ -238,7 +238,7 @@ impl TranscribeParse {
EventView::Eos(..) => match self.drain() { EventView::Eos(..) => match self.drain() {
Ok(()) => pad.event_default(Some(element), event), Ok(()) => pad.event_default(Some(element), event),
Err(err) => { 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_error!(
element, element,
gst::StreamError::Failed, gst::StreamError::Failed,
@ -348,7 +348,7 @@ impl ElementImpl for TranscribeParse {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{ use gst::{element_error, error_msg, loggable_error};
element_error, error_msg, gst_debug, gst_error, gst_info, gst_log, gst_trace, gst_warning,
loggable_error,
};
use std::default::Default; use std::default::Default;
@ -233,7 +230,7 @@ impl Transcriber {
while let Some(buf) = state.buffers.front() { while let Some(buf) = state.buffers.front() {
let pts = buf.pts().unwrap(); let pts = buf.pts().unwrap();
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Checking now {} if item is ready for dequeuing, PTS {}, threshold {} vs {}", "Checking now {} if item is ready for dequeuing, PTS {}, threshold {} vs {}",
@ -282,7 +279,7 @@ impl Transcriber {
.duration(pts - last_position) .duration(pts - last_position)
.seqnum(seqnum) .seqnum(seqnum)
.build(); .build();
gst_log!(CAT, "Pushing gap: {} -> {}", last_position, pts); gst::log!(CAT, "Pushing gap: {} -> {}", last_position, pts);
if !self.srcpad.push_event(gap_event) { if !self.srcpad.push_event(gap_event) {
return false; return false;
} }
@ -290,7 +287,7 @@ impl Transcriber {
Ordering::Less => { Ordering::Less => {
let delta = last_position - pts; let delta = last_position - pts;
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Updating item PTS ({} < {}), consider increasing latency", "Updating item PTS ({} < {}), consider increasing latency",
@ -313,7 +310,7 @@ impl Transcriber {
last_position = pts + duration; 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() { if self.srcpad.push(buf).is_err() {
return false; return false;
@ -321,7 +318,7 @@ impl Transcriber {
} }
/* next, push a gap if we're lagging behind the target position */ /* next, push a gap if we're lagging behind the target position */
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Checking now: {} if we need to push a gap, last_position: {}, threshold: {}", "Checking now: {} if we need to push a gap, last_position: {}, threshold: {}",
@ -338,7 +335,7 @@ impl Transcriber {
.seqnum(seqnum) .seqnum(seqnum)
.build(); .build();
gst_log!( gst::log!(
CAT, CAT,
"Pushing gap: {} -> {}", "Pushing gap: {} -> {}",
last_position, last_position,
@ -371,7 +368,7 @@ impl Transcriber {
let lateness = self.settings.lock().unwrap().lateness; let lateness = self.settings.lock().unwrap().lateness;
if alternative.items.len() <= state.partial_index { if alternative.items.len() <= state.partial_index {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"sanity check failed, alternative length {} < partial_index {}", "sanity check failed, alternative length {} < partial_index {}",
@ -399,7 +396,7 @@ impl Transcriber {
} }
/* Should be sent now */ /* Should be sent now */
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Item is ready for queuing: {}, PTS {}", "Item is ready for queuing: {}, PTS {}",
@ -469,7 +466,7 @@ impl Transcriber {
}; };
for event in events.drain(..) { for event in events.drain(..) {
gst_info!(CAT, obj: element, "Sending {:?}", event); gst::info!(CAT, obj: element, "Sending {:?}", event);
self.srcpad.push_event(event); self.srcpad.push_event(event);
} }
@ -486,7 +483,7 @@ impl Transcriber {
match msg { match msg {
Message::Binary(buf) => { Message::Binary(buf) => {
let (_, pkt) = parse_packet(&buf).map_err(|err| { 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!( error_msg!(
gst::StreamError::Failed, gst::StreamError::Failed,
["Failed to parse packet: {}", err] ["Failed to parse packet: {}", err]
@ -498,7 +495,7 @@ impl Transcriber {
if packet_is_exception(&pkt) { if packet_is_exception(&pkt) {
let message: ExceptionMessage = let message: ExceptionMessage =
serde_json::from_str(payload).map_err(|err| { serde_json::from_str(payload).map_err(|err| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Unexpected exception message: {} ({})", "Unexpected exception message: {} ({})",
@ -510,7 +507,7 @@ impl Transcriber {
["Unexpected exception message: {} ({})", payload, err] ["Unexpected exception message: {} ({})", payload, err]
) )
})?; })?;
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"AWS raised an error: {}", "AWS raised an error: {}",
@ -531,7 +528,7 @@ impl Transcriber {
})?; })?;
if let Some(result) = transcript.transcript.results.get(0) { if let Some(result) = transcript.transcript.results.get(0) {
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"result: {}", "result: {}",
@ -557,7 +554,7 @@ impl Transcriber {
match tokio::time::timeout(GRANULARITY.into(), future).await { match tokio::time::timeout(GRANULARITY.into(), future).await {
Err(_) => { Err(_) => {
if !self.dequeue(element) { 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(); let _ = self.srcpad.pause_task();
} }
@ -565,7 +562,7 @@ impl Transcriber {
} }
Ok(res) => { Ok(res) => {
if !self.dequeue(element) { 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(); let _ = self.srcpad.pause_task();
} }
@ -644,7 +641,7 @@ impl Transcriber {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Latency(q) => { QueryViewMut::Latency(q) => {
@ -679,23 +676,23 @@ impl Transcriber {
fn sink_event(&self, pad: &gst::Pad, element: &super::Transcriber, event: gst::Event) -> bool { fn sink_event(&self, pad: &gst::Pad, element: &super::Transcriber, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Eos(_) => match self.handle_buffer(pad, element, None) { EventView::Eos(_) => match self.handle_buffer(pad, element, None) {
Err(err) => { Err(err) => {
gst_error!(CAT, "Failed to send EOS to AWS: {}", err); gst::error!(CAT, "Failed to send EOS to AWS: {}", err);
false false
} }
Ok(_) => true, Ok(_) => true,
}, },
EventView::FlushStart(_) => { 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); let mut ret = pad.event_default(Some(element), event);
match self.srcpad.stop_task() { match self.srcpad.stop_task() {
Err(err) => { 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); self.disconnect(element);
@ -709,12 +706,12 @@ impl Transcriber {
ret ret
} }
EventView::FlushStop(_) => { 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) { if pad.event_default(Some(element), event) {
match self.start_task(element) { match self.start_task(element) {
Err(err) => { 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 false
} }
Ok(_) => true, Ok(_) => true,
@ -745,7 +742,7 @@ impl Transcriber {
} }
EventView::Tag(_) => true, EventView::Tag(_) => true,
EventView::Caps(e) => { EventView::Caps(e) => {
gst_info!(CAT, "Received caps {:?}", e); gst::info!(CAT, "Received caps {:?}", e);
true true
} }
EventView::StreamStart(_) => true, EventView::StreamStart(_) => true,
@ -781,7 +778,7 @@ impl Transcriber {
for chunk in data.chunks(8192) { for chunk in data.chunks(8192) {
let packet = build_packet(chunk); let packet = build_packet(chunk);
ws_sink.send(Message::Binary(packet)).await.map_err(|err| { 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 gst::FlowError::Error
})?; })?;
} }
@ -789,7 +786,7 @@ impl Transcriber {
// EOS // EOS
let packet = build_packet(&[]); let packet = build_packet(&[]);
ws_sink.send(Message::Binary(packet)).await.map_err(|err| { 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 gst::FlowError::Error
})?; })?;
} }
@ -804,7 +801,7 @@ impl Transcriber {
element: &super::Transcriber, element: &super::Transcriber,
buffer: Option<gst::Buffer>, buffer: Option<gst::Buffer>,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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| { self.ensure_connection(element).map_err(|err| {
element_error!( element_error!(
@ -853,7 +850,7 @@ impl Transcriber {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
if settings.latency + settings.lateness <= 2 * GRANULARITY { if settings.latency + settings.lateness <= 2 * GRANULARITY {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"latency + lateness must be greater than 200 milliseconds" "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 ( let creds = match (
settings.access_key.as_ref(), settings.access_key.as_ref(),
@ -876,7 +873,7 @@ impl Transcriber {
StaticProvider::new_minimal(access_key.clone(), secret_access_key.clone()) StaticProvider::new_minimal(access_key.clone(), secret_access_key.clone())
.credentials() .credentials()
.map_err(|err| { .map_err(|err| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to generate credentials: {}", "Failed to generate credentials: {}",
@ -892,7 +889,7 @@ impl Transcriber {
_ => { _ => {
let _enter = RUNTIME.enter(); let _enter = RUNTIME.enter();
futures::executor::block_on(ChainProvider::new().credentials()).map_err(|err| { 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!( error_msg!(
gst::CoreError::Failed, gst::CoreError::Failed,
["Failed to generate credentials: {}", err] ["Failed to generate credentials: {}", err]
@ -927,7 +924,7 @@ impl Transcriber {
} }
if let Some(ref session_id) = settings.session_id { 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); signed.add_param("session-id", session_id);
} }
@ -950,7 +947,7 @@ impl Transcriber {
let _enter = RUNTIME.enter(); let _enter = RUNTIME.enter();
futures::executor::block_on(connect_async(format!("wss{}", &url[5..]))).map_err( futures::executor::block_on(connect_async(format!("wss{}", &url[5..]))).map_err(
|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]) error_msg!(gst::CoreError::Failed, ["Failed to connect: {}", err])
}, },
)? )?
@ -976,7 +973,7 @@ impl Transcriber {
let msg = match msg { let msg = match msg {
Ok(msg) => msg, Ok(msg) => msg,
Err(err) => { Err(err) => {
gst_error!(CAT, "Failed to receive data: {}", err); gst::error!(CAT, "Failed to receive data: {}", err);
element_error!( element_error!(
element, element,
gst::StreamError::Failed, gst::StreamError::Failed,
@ -1006,7 +1003,7 @@ impl Transcriber {
state.connected = true; state.connected = true;
gst_info!(CAT, obj: element, "Connected"); gst::info!(CAT, obj: element, "Connected");
Ok(()) Ok(())
} }
@ -1014,7 +1011,7 @@ impl Transcriber {
fn disconnect(&self, element: &super::Transcriber) { fn disconnect(&self, element: &super::Transcriber) {
let mut state = self.state.lock().unwrap(); 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() { if let Some(abort_handle) = state.recv_abort_handle.take() {
abort_handle.abort(); abort_handle.abort();
@ -1026,7 +1023,7 @@ impl Transcriber {
*state = State::default(); *state = State::default();
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Unprepared, connected: {}!", "Unprepared, connected: {}!",
@ -1316,7 +1313,7 @@ impl ElementImpl for Transcriber {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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)?; 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log, gst_trace, gst_warning};
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -132,10 +131,10 @@ impl Settings {
for (key, value) in structure.iter() { for (key, value) in structure.iter() {
if let Ok(Ok(value_str)) = value.transform::<String>().map(|v| v.get()) { 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); hash.insert(key.to_string(), value_str);
} else { } else {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Failed to convert metadata '{}' to string ('{:?}')", "Failed to convert metadata '{}' to string ('{:?}')",
@ -207,7 +206,7 @@ impl S3Sink {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match settings.multipart_upload_on_error { match settings.multipart_upload_on_error {
OnError::Abort => { OnError::Abort => {
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Aborting multipart upload request with id: {}", "Aborting multipart upload request with id: {}",
@ -215,13 +214,13 @@ impl S3Sink {
); );
match self.abort_multipart_upload_request(state) { match self.abort_multipart_upload_request(state) {
Ok(()) => { Ok(()) => {
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Aborting multipart upload request succeeded." "Aborting multipart upload request succeeded."
); );
} }
Err(err) => gst_error!( Err(err) => gst::error!(
CAT, CAT,
obj: element, obj: element,
"Aborting multipart upload failed: {}", "Aborting multipart upload failed: {}",
@ -230,7 +229,7 @@ impl S3Sink {
} }
} }
OnError::Complete => { OnError::Complete => {
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Completing multipart upload request with id: {}", "Completing multipart upload request with id: {}",
@ -238,13 +237,13 @@ impl S3Sink {
); );
match self.complete_multipart_upload_request(state) { match self.complete_multipart_upload_request(state) {
Ok(()) => { Ok(()) => {
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Complete multipart upload request succeeded." "Complete multipart upload request succeeded."
); );
} }
Err(err) => gst_error!( Err(err) => gst::error!(
CAT, CAT,
obj: element, obj: element,
"Completing multipart upload failed: {}", "Completing multipart upload failed: {}",
@ -266,7 +265,7 @@ impl S3Sink {
e_tag: output.e_tag, e_tag: output.e_tag,
part_number: Some(part_number), part_number: Some(part_number),
}); });
gst_info!(CAT, obj: element, "Uploaded part {}", part_number); gst::info!(CAT, obj: element, "Uploaded part {}", part_number);
Ok(()) Ok(())
} }
@ -547,7 +546,7 @@ impl S3Sink {
return Ok(()); 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(); let url_str = url_str.unwrap();
match parse_s3_url(url_str) { match parse_s3_url(url_str) {
@ -656,7 +655,7 @@ impl ObjectImpl for S3Sink {
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
gst_debug!( gst::debug!(
CAT, CAT,
obj: obj, obj: obj,
"Setting property '{}' to '{:?}'", "Setting property '{}' to '{:?}'",
@ -804,7 +803,7 @@ impl BaseSinkImpl for S3Sink {
fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
*state = State::Stopped; *state = State::Stopped;
gst_info!(CAT, obj: element, "Stopped"); gst::info!(CAT, obj: element, "Stopped");
Ok(()) Ok(())
} }
@ -819,7 +818,7 @@ impl BaseSinkImpl for S3Sink {
return Err(gst::FlowError::Error); 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(|_| { let map = buffer.map_readable().map_err(|_| {
gst::element_error!(element, gst::CoreError::Failed, ["Failed to map buffer"]); gst::element_error!(element, gst::CoreError::Failed, ["Failed to map buffer"]);
gst::FlowError::Error gst::FlowError::Error
@ -829,7 +828,7 @@ impl BaseSinkImpl for S3Sink {
Ok(_) => Ok(gst::FlowSuccess::Ok), Ok(_) => Ok(gst::FlowSuccess::Ok),
Err(err) => match err { Err(err) => match err {
Some(error_message) => { Some(error_message) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Multipart upload failed: {}", "Multipart upload failed: {}",
@ -839,7 +838,7 @@ impl BaseSinkImpl for S3Sink {
Err(gst::FlowError::Error) Err(gst::FlowError::Error)
} }
_ => { _ => {
gst_info!(CAT, obj: element, "Upload interrupted. Flushing..."); gst::info!(CAT, obj: element, "Upload interrupted. Flushing...");
Err(gst::FlowError::Flushing) Err(gst::FlowError::Flushing)
} }
}, },
@ -855,7 +854,7 @@ impl BaseSinkImpl for S3Sink {
fn event(&self, element: &Self::Type, event: gst::Event) -> bool { fn event(&self, element: &Self::Type, event: gst::Event) -> bool {
if let gst::EventView::Eos(_) = event.view() { if let gst::EventView::Eos(_) = event.view() {
if let Err(error_message) = self.finalize_upload(element) { if let Err(error_message) = self.finalize_upload(element) {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to finalize the upload: {}", "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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info};
use gst_base::prelude::*; use gst_base::prelude::*;
use gst_base::subclass::base_src::CreateSuccess; use gst_base::subclass::base_src::CreateSuccess;
@ -150,7 +149,7 @@ impl S3Src {
})?; })?;
if let Some(size) = output.content_length { 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) Ok(size as u64)
} else { } else {
Err(gst::error_msg!( Err(gst::error_msg!(
@ -191,7 +190,7 @@ impl S3Src {
..Default::default() ..Default::default()
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: src, obj: src,
"Requesting range: {}-{}", "Requesting range: {}-{}",
@ -209,7 +208,7 @@ impl S3Src {
WaitError::Cancelled => None, WaitError::Cancelled => None,
})?; })?;
gst_debug!( gst::debug!(
CAT, CAT,
obj: src, obj: src,
"Read {} bytes", "Read {} bytes",
@ -466,7 +465,7 @@ impl BaseSrcImpl for S3Src {
Err(None) => Err(gst::FlowError::Flushing), Err(None) => Err(gst::FlowError::Flushing),
/* Actual Error */ /* Actual Error */
Err(Some(err)) => { 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) 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_log};
static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| { static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
gst::DebugCategory::new( gst::DebugCategory::new(
@ -272,7 +271,7 @@ impl TextAhead {
// queue buffer // queue buffer
let mut state = self.state.lock().unwrap(); 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 { state.pending.push(Input {
text, text,
@ -299,7 +298,7 @@ impl TextAhead {
gst::EventView::Eos(_) => { gst::EventView::Eos(_) => {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
gst_debug!(CAT, obj: element, "eos"); gst::debug!(CAT, obj: element, "eos");
while !state.pending.is_empty() { while !state.pending.is_empty() {
let _ = self.push_pending(element, &mut state); 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()); 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_log, gst_trace};
use once_cell::sync::Lazy; 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 { fn sink_event(&self, pad: &gst::Pad, element: &super::JsonGstEnc, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(e) => { EventView::Caps(e) => {
@ -270,7 +269,7 @@ impl ElementImpl for JsonGstEnc {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => {

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

@ -9,7 +9,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log, gst_trace, gst_warning};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -156,7 +155,7 @@ impl State {
let caps = caps_builder.build(); let caps = caps_builder.build();
events.push(gst::event::Caps::new(&caps)); 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; self.need_caps = false;
} }
@ -237,7 +236,7 @@ impl JsonGstParse {
duration, duration,
data, data,
})) => { })) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Got buffer with timestamp {} and duration {}", "Got buffer with timestamp {} and duration {}",
@ -273,13 +272,13 @@ impl JsonGstParse {
drop(state); drop(state);
for event in events { 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_event(event);
} }
self.srcpad.push(buffer).map_err(|err| { self.srcpad.push(buffer).map_err(|err| {
if err != gst::FlowError::Flushing { if err != gst::FlowError::Flushing {
gst_error!(CAT, obj: element, "Pushing buffer returned {:?}", err); gst::error!(CAT, obj: element, "Pushing buffer returned {:?}", err);
} }
err err
})?; })?;
@ -297,11 +296,11 @@ impl JsonGstParse {
if state.format.is_none() { if state.format.is_none() {
state.format = Some(format); state.format = Some(format);
} else { } else {
gst_warning!(CAT, obj: element, "Ignoring format change",); gst::warning!(CAT, obj: element, "Ignoring format change",);
} }
} }
Err((line, err)) => { Err((line, err)) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Couldn't parse line '{:?}': {:?}", "Couldn't parse line '{:?}': {:?}",
@ -340,7 +339,7 @@ impl JsonGstParse {
state.replay_last_line = true; state.replay_last_line = true;
state.need_flush_stop = true; state.need_flush_stop = true;
gst_debug!(CAT, obj: element, "Done seeking"); gst::debug!(CAT, obj: element, "Done seeking");
} }
drop(state); drop(state);
@ -360,18 +359,18 @@ impl JsonGstParse {
state.pull = None; state.pull = None;
if !pad.peer_query(&mut query) { 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 gst::PadMode::Push
} else if query } else if query
.has_scheduling_mode_with_flags(gst::PadMode::Pull, gst::SchedulingFlags::SEEKABLE) .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)); state.pull = Some(PullState::new(element, &self.srcpad));
gst::PadMode::Pull gst::PadMode::Pull
} else { } else {
gst_debug!(CAT, obj: pad, "Activating in Push mode"); gst::debug!(CAT, obj: pad, "Activating in Push mode");
gst::PadMode::Push gst::PadMode::Push
} }
}; };
@ -425,7 +424,7 @@ impl JsonGstParse {
&self, &self,
element: &super::JsonGstParse, element: &super::JsonGstParse,
) -> Result<Option<gst::ClockTime>, gst::LoggableError> { ) -> 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 */ /* First let's query the bytes duration upstream */
let mut q = gst::query::Duration::new(gst::Format::Bytes); let mut q = gst::query::Duration::new(gst::Format::Bytes);
@ -492,7 +491,7 @@ impl JsonGstParse {
} }
if last_pts.is_some() || offset == 0 { if last_pts.is_some() || offset == 0 {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Duration scan done, last_pts: {:?}", "Duration scan done, last_pts: {:?}",
@ -523,7 +522,7 @@ impl JsonGstParse {
drop(state); drop(state);
for event in events { 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_event(event);
} }
} }
@ -564,13 +563,13 @@ impl JsonGstParse {
Ok(buffer) => Some(buffer), Ok(buffer) => Some(buffer),
Err(gst::FlowError::Eos) => None, Err(gst::FlowError::Eos) => None,
Err(gst::FlowError::Flushing) => { 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(); self.sinkpad.pause_task().unwrap();
return; return;
} }
Err(flow) => { 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!( gst::element_error!(
element, element,
@ -586,17 +585,17 @@ impl JsonGstParse {
if let Err(flow) = self.handle_buffer(element, buffer) { if let Err(flow) = self.handle_buffer(element, buffer) {
match flow { match flow {
gst::FlowError::Flushing => { gst::FlowError::Flushing => {
gst_debug!(CAT, obj: element, "Pausing after flow {:?}", flow); gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow);
} }
gst::FlowError::Eos => { gst::FlowError::Eos => {
self.push_eos(element); 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); 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!( gst::element_error!(
element, element,
@ -616,7 +615,7 @@ impl JsonGstParse {
element: &super::JsonGstParse, element: &super::JsonGstParse,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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)) 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 { fn sink_event(&self, pad: &gst::Pad, element: &super::JsonGstParse, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(_) => { EventView::Caps(_) => {
// We send a proper caps event from the chain function later // 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 true
} }
EventView::Segment(_) => { EventView::Segment(_) => {
// We send a gst::Format::Time segment event later when needed // 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 true
} }
EventView::FlushStop(_) => { EventView::FlushStop(_) => {
@ -659,9 +658,9 @@ impl JsonGstParse {
pad.event_default(Some(element), event) pad.event_default(Some(element), event)
} }
EventView::Eos(_) => { EventView::Eos(_) => {
gst_log!(CAT, obj: pad, "Draining"); gst::log!(CAT, obj: pad, "Draining");
if let Err(err) = self.handle_buffer(element, None) { 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) pad.event_default(Some(element), event)
} }
@ -670,7 +669,7 @@ impl JsonGstParse {
&& !self.srcpad.has_current_caps() && !self.srcpad.has_current_caps()
&& event.type_() > gst::EventType::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(); let mut state = self.state.lock().unwrap();
state.pending_events.push(event); state.pending_events.push(event);
true true
@ -683,7 +682,7 @@ impl JsonGstParse {
fn perform_seek(&self, event: &gst::event::Seek, element: &super::JsonGstParse) -> bool { fn perform_seek(&self, event: &gst::event::Seek, element: &super::JsonGstParse) -> bool {
if self.state.lock().unwrap().pull.is_none() { 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; return false;
} }
@ -692,7 +691,7 @@ impl JsonGstParse {
let mut start: Option<gst::ClockTime> = match start.try_into() { let mut start: Option<gst::ClockTime> = match start.try_into() {
Ok(start) => start, Ok(start) => start,
Err(_) => { Err(_) => {
gst_error!(CAT, obj: element, "seek has invalid format"); gst::error!(CAT, obj: element, "seek has invalid format");
return false; return false;
} }
}; };
@ -700,18 +699,18 @@ impl JsonGstParse {
let mut stop: Option<gst::ClockTime> = match stop.try_into() { let mut stop: Option<gst::ClockTime> = match stop.try_into() {
Ok(stop) => stop, Ok(stop) => stop,
Err(_) => { Err(_) => {
gst_error!(CAT, obj: element, "seek has invalid format"); gst::error!(CAT, obj: element, "seek has invalid format");
return false; return false;
} }
}; };
if !flags.contains(gst::SeekFlags::FLUSH) { 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; return false;
} }
if start_type == gst::SeekType::End || stop_type == gst::SeekType::End { 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; return false;
} }
@ -721,14 +720,14 @@ impl JsonGstParse {
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
.build(); .build();
gst_debug!(CAT, obj: element, "Sending event {:?} upstream", event); gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event);
self.sinkpad.push_event(event); self.sinkpad.push_event(event);
let event = gst::event::FlushStart::builder() let event = gst::event::FlushStart::builder()
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
.build(); .build();
gst_debug!(CAT, obj: element, "Pushing event {:?}", event); gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
self.srcpad.push_event(event); self.srcpad.push_event(event);
self.sinkpad.pause_task().unwrap(); self.sinkpad.pause_task().unwrap();
@ -756,7 +755,7 @@ impl JsonGstParse {
/* Drop our state while we push a serialized event upstream */ /* Drop our state while we push a serialized event upstream */
drop(state); 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); self.sinkpad.push_event(event);
state = self.state.lock().unwrap(); 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 { fn src_event(&self, pad: &gst::Pad, element: &super::JsonGstParse, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Seek(e) => self.perform_seek(e, element), EventView::Seek(e) => self.perform_seek(e, element),
_ => pad.event_default(Some(element), event), _ => pad.event_default(Some(element), event),
@ -792,7 +791,7 @@ impl JsonGstParse {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Seeking(q) => { QueryViewMut::Seeking(q) => {
@ -974,7 +973,7 @@ impl ElementImpl for JsonGstParse {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { 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 // SPDX-License-Identifier: MPL-2.0
use gst::glib; use gst::glib;
use gst::gst_error;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
@ -54,14 +53,14 @@ impl RegEx {
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
let data = buffer.map_readable().map_err(|_| { 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::element_error!(element, gst::CoreError::Failed, ["Failed to map buffer"]);
gst::FlowError::Error gst::FlowError::Error
})?; })?;
let mut data = std::str::from_utf8(&data) let mut data = std::str::from_utf8(&data)
.map_err(|err| { .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!( gst::element_error!(
element, element,
gst::StreamError::Decode, gst::StreamError::Decode,
@ -194,7 +193,7 @@ impl ObjectImpl for RegEx {
let pattern = match s.get::<Option<String>>("pattern") { let pattern = match s.get::<Option<String>>("pattern") {
Ok(Some(pattern)) => pattern, Ok(Some(pattern)) => pattern,
Ok(None) | Err(_) => { 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; continue;
} }
}; };
@ -202,7 +201,7 @@ impl ObjectImpl for RegEx {
let regex = match Regex::new(&pattern) { let regex = match Regex::new(&pattern) {
Ok(regex) => regex, Ok(regex) => regex,
Err(err) => { Err(err) => {
gst_error!(CAT, "Failed to compile regex: {:?}", err); gst::error!(CAT, "Failed to compile regex: {:?}", err);
continue; continue;
} }
}; };
@ -212,7 +211,7 @@ impl ObjectImpl for RegEx {
let replacement = match s.get::<Option<String>>("replacement") { let replacement = match s.get::<Option<String>>("replacement") {
Ok(Some(pattern)) => pattern, Ok(Some(pattern)) => pattern,
Ok(None) | Err(_) => { Ok(None) | Err(_) => {
gst_error!( gst::error!(
CAT, CAT,
"Replace operations require a replacement field as a string" "Replace operations require a replacement field as a string"
); );
@ -226,7 +225,7 @@ impl ObjectImpl for RegEx {
}); });
} }
val => { 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log};
use std::default::Default; use std::default::Default;
use std::fs::File; use std::fs::File;
@ -124,7 +123,7 @@ impl TextWrap {
state.options = if let Some(dictionary) = &settings.dictionary { state.options = if let Some(dictionary) = &settings.dictionary {
let dict_file = match File::open(dictionary) { let dict_file = match File::open(dictionary) {
Err(err) => { 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; return;
} }
Ok(dict_file) => dict_file, Ok(dict_file) => dict_file,
@ -133,7 +132,7 @@ impl TextWrap {
let mut reader = io::BufReader::new(dict_file); let mut reader = io::BufReader::new(dict_file);
let standard = match Standard::any_from_reader(&mut reader) { let standard = match Standard::any_from_reader(&mut reader) {
Err(err) => { Err(err) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to load standard from file: {}", "Failed to load standard from file: {}",
@ -165,22 +164,22 @@ impl TextWrap {
self.update_wrapper(element); self.update_wrapper(element);
let mut pts = buffer.pts().ok_or_else(|| { 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 gst::FlowError::Error
})?; })?;
let duration = buffer.duration().ok_or_else(|| { 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 gst::FlowError::Error
})?; })?;
let data = buffer.map_readable().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
let data = std::str::from_utf8(&data).map_err(|err| { 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 gst::FlowError::Error
})?; })?;
@ -254,7 +253,7 @@ impl TextWrap {
.map(|l| l.to_string()) .map(|l| l.to_string())
.collect::<Vec<String>>() .collect::<Vec<String>>()
.join("\n"); .join("\n");
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Outputting contents {}, ts: {}, duration: {}", "Outputting contents {}, ts: {}, duration: {}",
@ -315,7 +314,7 @@ impl TextWrap {
let data = chunk.join("\n"); let data = chunk.join("\n");
let duration: gst::ClockTime = let duration: gst::ClockTime =
duration_per_word * data.split_whitespace().count() as u64; 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()); 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 { 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; use gst::EventView;
@ -408,7 +407,7 @@ impl TextWrap {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Latency(q) => { QueryViewMut::Latency(q) => {
@ -419,7 +418,7 @@ impl TextWrap {
if ret { if ret {
let (live, min, _) = peer_query.result(); let (live, min, _) = peer_query.result();
let our_latency: gst::ClockTime = self.settings.lock().unwrap().accumulate_time; let our_latency: gst::ClockTime = self.settings.lock().unwrap().accumulate_time;
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Reporting our latency {} + {}", "Reporting our latency {} + {}",
@ -567,7 +566,7 @@ impl ObjectImpl for TextWrap {
settings.accumulate_time = settings.accumulate_time =
gst::ClockTime::from_nseconds(value.get().expect("type checked upstream")); gst::ClockTime::from_nseconds(value.get().expect("type checked upstream"));
if settings.accumulate_time != old_accumulate_time { if settings.accumulate_time != old_accumulate_time {
gst_debug!( gst::debug!(
CAT, CAT,
obj: obj, obj: obj,
"Accumulate time changed: {}", "Accumulate time changed: {}",
@ -652,7 +651,7 @@ impl ElementImpl for TextWrap {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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 { if let gst::StateChange::PausedToReady = transition {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();

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

@ -11,7 +11,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_log, gst_trace};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -44,7 +43,7 @@ impl Identity {
_element: &super::Identity, _element: &super::Identity,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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) 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 // 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. // events, and especially the gst::EventView type for inspecting events.
fn sink_event(&self, pad: &gst::Pad, _element: &super::Identity, event: gst::Event) -> bool { 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) self.srcpad.push_event(event)
} }
@ -75,7 +74,7 @@ impl Identity {
_element: &super::Identity, _element: &super::Identity,
query: &mut gst::QueryRef, query: &mut gst::QueryRef,
) -> bool { ) -> bool {
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
self.srcpad.peer_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 // 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. // events, and especially the gst::EventView type for inspecting events.
fn src_event(&self, pad: &gst::Pad, _element: &super::Identity, event: gst::Event) -> bool { 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) self.sinkpad.push_event(event)
} }
@ -107,7 +106,7 @@ impl Identity {
_element: &super::Identity, _element: &super::Identity,
query: &mut gst::QueryRef, query: &mut gst::QueryRef,
) -> bool { ) -> bool {
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
self.sinkpad.peer_query(query) self.sinkpad.peer_query(query)
} }
} }
@ -259,7 +258,7 @@ impl ElementImpl for Identity {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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() // Call the parent class' implementation of ::change_state()
self.parent_change_state(element, transition) 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 // SPDX-License-Identifier: MIT/Apache-2.0
use gst::glib; use gst::glib;
use gst::gst_info;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use std::sync::Mutex; use std::sync::Mutex;
@ -111,7 +110,7 @@ impl ObjectImpl for ProgressBin {
let new_output_type = value let new_output_type = value
.get::<ProgressBinOutput>() .get::<ProgressBinOutput>()
.expect("type checked upstream"); .expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing output from {:?} to {:?}", "Changing output from {:?} to {:?}",
@ -238,7 +237,7 @@ impl BinImpl for ProgressBin {
match output_type { match output_type {
ProgressBinOutput::Println => println!("progress: {:5.1}%", percent), ProgressBinOutput::Println => println!("progress: {:5.1}%", percent),
ProgressBinOutput::DebugCategory => { 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_info};
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
use gst_video::subclass::prelude::*; use gst_video::subclass::prelude::*;
@ -134,7 +133,7 @@ impl ObjectImpl for Rgb2Gray {
"invert" => { "invert" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let invert = value.get().expect("type checked upstream"); let invert = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing invert from {} to {}", "Changing invert from {} to {}",
@ -146,7 +145,7 @@ impl ObjectImpl for Rgb2Gray {
"shift" => { "shift" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let shift = value.get().expect("type checked upstream"); let shift = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing shift from {} to {}", "Changing shift from {} to {}",
@ -322,7 +321,7 @@ impl BaseTransformImpl for Rgb2Gray {
gray_caps gray_caps
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Transformed caps from {} to {} in direction {:?}", "Transformed caps from {} to {} in direction {:?}",

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

@ -11,7 +11,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log};
use gst_base::prelude::*; use gst_base::prelude::*;
use gst_base::subclass::base_src::CreateSuccess; use gst_base::subclass::base_src::CreateSuccess;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -240,7 +239,7 @@ impl ObjectImpl for SineSrc {
"samples-per-buffer" => { "samples-per-buffer" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let samples_per_buffer = value.get().expect("type checked upstream"); let samples_per_buffer = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing samples-per-buffer from {} to {}", "Changing samples-per-buffer from {} to {}",
@ -255,7 +254,7 @@ impl ObjectImpl for SineSrc {
"freq" => { "freq" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let freq = value.get().expect("type checked upstream"); let freq = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing freq from {} to {}", "Changing freq from {} to {}",
@ -267,7 +266,7 @@ impl ObjectImpl for SineSrc {
"volume" => { "volume" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let volume = value.get().expect("type checked upstream"); let volume = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing volume from {} to {}", "Changing volume from {} to {}",
@ -279,7 +278,7 @@ impl ObjectImpl for SineSrc {
"mute" => { "mute" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let mute = value.get().expect("type checked upstream"); let mute = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing mute from {} to {}", "Changing mute from {} to {}",
@ -291,7 +290,7 @@ impl ObjectImpl for SineSrc {
"is-live" => { "is-live" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let is_live = value.get().expect("type checked upstream"); let is_live = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing is-live from {} to {}", "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::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); 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.state.lock().unwrap() = Default::default();
self.unlock_stop(element)?; self.unlock_stop(element)?;
gst_info!(CAT, obj: element, "Started"); gst::info!(CAT, obj: element, "Started");
Ok(()) Ok(())
} }
@ -482,7 +481,7 @@ impl BaseSrcImpl for SineSrc {
*self.state.lock().unwrap() = Default::default(); *self.state.lock().unwrap() = Default::default();
self.unlock(element)?; self.unlock(element)?;
gst_info!(CAT, obj: element, "Stopped"); gst::info!(CAT, obj: element, "Stopped");
Ok(()) Ok(())
} }
@ -502,7 +501,7 @@ impl BaseSrcImpl for SineSrc {
let latency = gst::ClockTime::SECOND let latency = gst::ClockTime::SECOND
.mul_div_floor(settings.samples_per_buffer as u64, info.rate() as u64) .mul_div_floor(settings.samples_per_buffer as u64, info.rate() as u64)
.unwrap(); .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); q.set(settings.is_live, latency, gst::ClockTime::NONE);
true true
} else { } else {
@ -547,7 +546,7 @@ impl BaseSrcImpl for SineSrc {
// and for calculating the timestamps, etc. // and for calculating the timestamps, etc.
if segment.rate() < 0.0 { 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; return false;
} }
@ -579,7 +578,7 @@ impl BaseSrcImpl for SineSrc {
let accumulator = let accumulator =
(sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64)); (sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64));
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Seeked to {}-{:?} (accum: {}) for segment {:?}", "Seeked to {}-{:?} (accum: {}) for segment {:?}",
@ -601,7 +600,7 @@ impl BaseSrcImpl for SineSrc {
use std::f64::consts::PI; use std::f64::consts::PI;
if state.info.is_none() { if state.info.is_none() {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Can only seek in Default format if sample rate is known" "Can only seek in Default format if sample rate is known"
@ -615,7 +614,7 @@ impl BaseSrcImpl for SineSrc {
let accumulator = let accumulator =
(sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64)); (sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64));
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Seeked to {}-{:?} (accum: {}) for segment {:?}", "Seeked to {}-{:?} (accum: {}) for segment {:?}",
@ -634,7 +633,7 @@ impl BaseSrcImpl for SineSrc {
true true
} else { } else {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Can't seek in format {:?}", "Can't seek in format {:?}",
@ -648,7 +647,7 @@ impl BaseSrcImpl for SineSrc {
fn unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn unlock(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
// This should unblock the create() function ASAP, so we // This should unblock the create() function ASAP, so we
// just unschedule the clock it here, if any. // 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(); let mut clock_wait = self.clock_wait.lock().unwrap();
if let Some(clock_id) = clock_wait.clock_id.take() { if let Some(clock_id) = clock_wait.clock_id.take() {
clock_id.unschedule(); clock_id.unschedule();
@ -661,7 +660,7 @@ impl BaseSrcImpl for SineSrc {
fn unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn unlock_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
// This signals that unlocking is done, so we can reset // This signals that unlocking is done, so we can reset
// all values again. // 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(); let mut clock_wait = self.clock_wait.lock().unwrap();
clock_wait.flushing = false; clock_wait.flushing = false;
@ -695,7 +694,7 @@ impl PushSrcImpl for SineSrc {
// point but at most samples_per_buffer samples per buffer // point but at most samples_per_buffer samples per buffer
let n_samples = if let Some(sample_stop) = state.sample_stop { let n_samples = if let Some(sample_stop) = state.sample_stop {
if sample_stop <= state.sample_offset { 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); return Err(gst::FlowError::Eos);
} }
@ -785,7 +784,7 @@ impl PushSrcImpl for SineSrc {
// so that we immediately stop waiting on e.g. shutdown. // so that we immediately stop waiting on e.g. shutdown.
let mut clock_wait = self.clock_wait.lock().unwrap(); let mut clock_wait = self.clock_wait.lock().unwrap();
if clock_wait.flushing { if clock_wait.flushing {
gst_debug!(CAT, obj: element, "Flushing"); gst::debug!(CAT, obj: element, "Flushing");
return Err(gst::FlowError::Flushing); return Err(gst::FlowError::Flushing);
} }
@ -793,7 +792,7 @@ impl PushSrcImpl for SineSrc {
clock_wait.clock_id = Some(id.clone()); clock_wait.clock_id = Some(id.clone());
drop(clock_wait); drop(clock_wait);
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Waiting until {}, now {}", "Waiting until {}, now {}",
@ -801,18 +800,18 @@ impl PushSrcImpl for SineSrc {
clock.time().display(), clock.time().display(),
); );
let (res, jitter) = id.wait(); 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(); self.clock_wait.lock().unwrap().clock_id.take();
// If the clock ID was unscheduled, unlock() was called // If the clock ID was unscheduled, unlock() was called
// and we should return Flushing immediately. // and we should return Flushing immediately.
if res == Err(gst::ClockError::Unscheduled) { if res == Err(gst::ClockError::Unscheduled) {
gst_debug!(CAT, obj: element, "Flushing"); gst::debug!(CAT, obj: element, "Flushing");
return Err(gst::FlowError::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)) 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 ```rust
use gst::glib; use gst::glib;
use gst::{gst_debug, gst_info};
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
use std::i32; use std::i32;
@ -438,7 +437,7 @@ impl BaseTransformImpl for Rgb2Gray {
Some(info) => info, Some(info) => info,
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Configured for caps {} to {}", "Configured for caps {} to {}",
@ -455,14 +454,14 @@ impl BaseTransformImpl for Rgb2Gray {
// Drop state // Drop state
let _ = self.state.lock().unwrap().take(); let _ = self.state.lock().unwrap().take();
gst_info!(CAT, obj: element, "Stopped"); gst::info!(CAT, obj: element, "Stopped");
Ok(()) 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. 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 gray_caps
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Transformed caps from {} to {} in direction {:?}", "Transformed caps from {} to {} in direction {:?}",
@ -778,7 +777,7 @@ impl ObjectImpl for Rgb2Gray {
"invert" => { "invert" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let invert = value.get_some().expect("type checked upstream"); let invert = value.get_some().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing invert from {} to {}", "Changing invert from {} to {}",
@ -790,7 +789,7 @@ impl ObjectImpl for Rgb2Gray {
"shift" => { "shift" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let shift = value.get_some().expect("type checked upstream"); let shift = value.get_some().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing shift from {} to {}", "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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log};
use gst_base::prelude::*; use gst_base::prelude::*;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -240,7 +239,7 @@ impl ObjectImpl for SineSrc {
"samples-per-buffer" => { "samples-per-buffer" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let samples_per_buffer = value.get_some().expect("type checked upstream"); let samples_per_buffer = value.get_some().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing samples-per-buffer from {} to {}", "Changing samples-per-buffer from {} to {}",
@ -255,7 +254,7 @@ impl ObjectImpl for SineSrc {
"freq" => { "freq" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let freq = value.get_some().expect("type checked upstream"); let freq = value.get_some().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing freq from {} to {}", "Changing freq from {} to {}",
@ -267,7 +266,7 @@ impl ObjectImpl for SineSrc {
"volume" => { "volume" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let volume = value.get_some().expect("type checked upstream"); let volume = value.get_some().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing volume from {} to {}", "Changing volume from {} to {}",
@ -279,7 +278,7 @@ impl ObjectImpl for SineSrc {
"mute" => { "mute" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let mute = value.get_some().expect("type checked upstream"); let mute = value.get_some().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing mute from {} to {}", "Changing mute from {} to {}",
@ -291,7 +290,7 @@ impl ObjectImpl for SineSrc {
"is-live" => { "is-live" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let is_live = value.get_some().expect("type checked upstream"); let is_live = value.get_some().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing is-live from {} to {}", "Changing is-live from {} to {}",
@ -342,7 +341,7 @@ impl BaseSrcImpl for SineSrc {
// Reset state // Reset state
*self.state.lock().unwrap() = Default::default(); *self.state.lock().unwrap() = Default::default();
gst_info!(CAT, obj: element, "Started"); gst::info!(CAT, obj: element, "Started");
true true
} }
@ -352,7 +351,7 @@ impl BaseSrcImpl for SineSrc {
// Reset state // Reset state
*self.state.lock().unwrap() = Default::default(); *self.state.lock().unwrap() = Default::default();
gst_info!(CAT, obj: element, "Stopped"); gst::info!(CAT, obj: element, "Stopped");
true 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::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); 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 // point but at most samples_per_buffer samples per buffer
let n_samples = if let Some(sample_stop) = state.sample_stop { let n_samples = if let Some(sample_stop) = state.sample_stop {
if sample_stop <= state.sample_offset { 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); 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; state.sample_offset += n_samples;
drop(state); drop(state);
gst_debug!(CAT, obj: element, "Produced buffer {:?}", buffer); gst::debug!(CAT, obj: element, "Produced buffer {:?}", buffer);
Ok(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); let id = clock.new_single_shot_id(wait_until);
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Waiting until {}, now {}", "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(), clock.get_time().display(),
); );
let (res, jitter) = id.wait(); let (res, jitter) = id.wait();
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Waited res {:?} jitter {}", "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) 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 let latency = gst::ClockTime::SECOND
.mul_div_floor(settings.samples_per_buffer as u64, info.rate() as u64) .mul_div_floor(settings.samples_per_buffer as u64, info.rate() as u64)
.unwrap(); .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); q.set(settings.is_live, latency, gst::ClockTime::NONE);
true true
} else { } else {
@ -837,7 +836,7 @@ struct SineSrc {
fn unlock(&self, element: &Self::Type) -> bool { fn unlock(&self, element: &Self::Type) -> bool {
// This should unblock the create() function ASAP, so we // This should unblock the create() function ASAP, so we
// just unschedule the clock it here, if any. // 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(); let mut clock_wait = self.clock_wait.lock().unwrap();
if let Some(clock_id) = clock_wait.clock_id.take() { if let Some(clock_id) = clock_wait.clock_id.take() {
clock_id.unschedule(); 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 { fn unlock_stop(&self, element: &Self::Type) -> bool {
// This signals that unlocking is done, so we can reset // This signals that unlocking is done, so we can reset
// all values again. // 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(); let mut clock_wait = self.clock_wait.lock().unwrap();
clock_wait.flushing = false; 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. // so that we immediately stop waiting on e.g. shutdown.
let mut clock_wait = self.clock_wait.lock().unwrap(); let mut clock_wait = self.clock_wait.lock().unwrap();
if clock_wait.flushing { if clock_wait.flushing {
gst_debug!(CAT, obj: element, "Flushing"); gst::debug!(CAT, obj: element, "Flushing");
return Err(gst::FlowReturn::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()); clock_wait.clock_id = Some(id.clone());
drop(clock_wait); drop(clock_wait);
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Waiting until {}, now {}", "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(), clock.get_time().display(),
); );
let (res, jitter) = id.wait(); let (res, jitter) = id.wait();
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Waited res {:?} jitter {}", "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 // If the clock ID was unscheduled, unlock() was called
// and we should return Flushing immediately. // and we should return Flushing immediately.
if res == gst::ClockReturn::Unscheduled { if res == gst::ClockReturn::Unscheduled {
gst_debug!(CAT, obj: element, "Flushing"); gst::debug!(CAT, obj: element, "Flushing");
return Err(gst::FlowReturn::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. // and for calculating the timestamps, etc.
if segment.get_rate() < 0.0 { 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; return false;
} }
@ -962,7 +961,7 @@ Seeking is implemented in the `BaseSrc::do_seek` virtual method, and signallin
let accumulator = let accumulator =
(sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64)); (sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64));
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Seeked to {}-{:?} (accum: {}) for segment {:?}", "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; use std::f64::consts::PI;
if state.info.is_none() { if state.info.is_none() {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Can only seek in Default format if sample rate is known" "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 = let accumulator =
(sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64)); (sample_offset as f64).rem(2.0 * PI * (settings.freq as f64) / (rate as f64));
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Seeked to {}-{:?} (accum: {}) for segment {:?}", "Seeked to {}-{:?} (accum: {}) for segment {:?}",
@ -1017,7 +1016,7 @@ Seeking is implemented in the `BaseSrc::do_seek` virtual method, and signallin
true true
} else { } else {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Can't seek in format {:?}", "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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error};
use std::{mem, sync::Mutex}; use std::{mem, sync::Mutex};
@ -167,7 +166,7 @@ impl CustomSource {
&self, &self,
element: &super::CustomSource, element: &super::CustomSource,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_debug!(CAT, obj: element, "Starting"); gst::debug!(CAT, obj: element, "Starting");
let source = self.source.get().unwrap(); let source = self.source.get().unwrap();
let templates = source.pad_template_list(); let templates = source.pad_template_list();
@ -176,7 +175,7 @@ impl CustomSource {
.iter() .iter()
.any(|templ| templ.presence() == gst::PadPresence::Request) .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!( gst::element_error!(
element, element,
gst::LibraryError::Settings, gst::LibraryError::Settings,
@ -200,7 +199,7 @@ impl CustomSource {
if !has_sometimes_pads { if !has_sometimes_pads {
self.handle_source_no_more_pads(element); self.handle_source_no_more_pads(element);
} else { } else {
gst_debug!(CAT, obj: element, "Found sometimes pads"); gst::debug!(CAT, obj: element, "Found sometimes pads");
let element_weak = element.downgrade(); let element_weak = element.downgrade();
source.connect_pad_added(move |_, pad| { source.connect_pad_added(move |_, pad| {
@ -245,7 +244,7 @@ impl CustomSource {
element: &super::CustomSource, element: &super::CustomSource,
pad: &gst::Pad, pad: &gst::Pad,
) -> Result<(), gst::ErrorMessage> { ) -> 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(); 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)) { let caps = match pad.current_caps().unwrap_or_else(|| pad.query_caps(None)) {
caps if !caps.is_any() && !caps.is_empty() => caps, 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!( return Err(gst::error_msg!(
gst::CoreError::Negotiation, gst::CoreError::Negotiation,
["Pad had no caps"] ["Pad had no caps"]
@ -312,7 +311,7 @@ impl CustomSource {
} }
fn handle_source_pad_removed(&self, element: &super::CustomSource, pad: &gst::Pad) { 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 mut state = self.state.lock().unwrap();
let (i, stream) = match state let (i, stream) = match state
@ -335,7 +334,7 @@ impl CustomSource {
} }
fn handle_source_no_more_pads(&self, element: &super::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 state = self.state.lock().unwrap();
let streams = state let streams = state
@ -358,7 +357,7 @@ impl CustomSource {
} }
fn stop(&self, element: &super::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 mut state = self.state.lock().unwrap();
let pads = mem::take(&mut state.pads); 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_warning};
use std::mem; use std::mem;
use std::sync::Mutex; use std::sync::Mutex;
@ -319,7 +318,7 @@ impl ObjectImpl for FallbackSrc {
"enable-audio" => { "enable-audio" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing enable-audio from {:?} to {:?}", "Changing enable-audio from {:?} to {:?}",
@ -331,7 +330,7 @@ impl ObjectImpl for FallbackSrc {
"enable-video" => { "enable-video" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing enable-video from {:?} to {:?}", "Changing enable-video from {:?} to {:?}",
@ -343,7 +342,7 @@ impl ObjectImpl for FallbackSrc {
"uri" => { "uri" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing URI from {:?} to {:?}", "Changing URI from {:?} to {:?}",
@ -355,7 +354,7 @@ impl ObjectImpl for FallbackSrc {
"source" => { "source" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing source from {:?} to {:?}", "Changing source from {:?} to {:?}",
@ -367,7 +366,7 @@ impl ObjectImpl for FallbackSrc {
"fallback-uri" => { "fallback-uri" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing Fallback URI from {:?} to {:?}", "Changing Fallback URI from {:?} to {:?}",
@ -379,7 +378,7 @@ impl ObjectImpl for FallbackSrc {
"timeout" => { "timeout" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing timeout from {:?} to {:?}", "Changing timeout from {:?} to {:?}",
@ -391,7 +390,7 @@ impl ObjectImpl for FallbackSrc {
"restart-timeout" => { "restart-timeout" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing Restart Timeout from {:?} to {:?}", "Changing Restart Timeout from {:?} to {:?}",
@ -403,7 +402,7 @@ impl ObjectImpl for FallbackSrc {
"retry-timeout" => { "retry-timeout" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing Retry Timeout from {:?} to {:?}", "Changing Retry Timeout from {:?} to {:?}",
@ -415,7 +414,7 @@ impl ObjectImpl for FallbackSrc {
"restart-on-eos" => { "restart-on-eos" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing restart-on-eos from {:?} to {:?}", "Changing restart-on-eos from {:?} to {:?}",
@ -427,7 +426,7 @@ impl ObjectImpl for FallbackSrc {
"min-latency" => { "min-latency" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing Minimum Latency from {:?} to {:?}", "Changing Minimum Latency from {:?} to {:?}",
@ -439,7 +438,7 @@ impl ObjectImpl for FallbackSrc {
"buffer-duration" => { "buffer-duration" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing Buffer Duration from {:?} to {:?}", "Changing Buffer Duration from {:?} to {:?}",
@ -451,7 +450,7 @@ impl ObjectImpl for FallbackSrc {
"immediate-fallback" => { "immediate-fallback" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing immediate-fallback from {:?} to {:?}", "Changing immediate-fallback from {:?} to {:?}",
@ -463,7 +462,7 @@ impl ObjectImpl for FallbackSrc {
"manual-unblock" => { "manual-unblock" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing manual-unblock from {:?} to {:?}", "Changing manual-unblock from {:?} to {:?}",
@ -729,7 +728,7 @@ impl ElementImpl for FallbackSrc {
fn send_event(&self, _element: &Self::Type, event: gst::Event) -> bool { fn send_event(&self, _element: &Self::Type, event: gst::Event) -> bool {
match event.view() { match event.view() {
gst::EventView::Eos(..) => { 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 mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard { let state = match &mut *state_guard {
@ -984,7 +983,7 @@ impl FallbackSrc {
} }
fn start(&self, element: &super::FallbackSrc) -> Result<(), gst::StateChangeError> { 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(); let mut state_guard = self.state.lock().unwrap();
if state_guard.is_some() { if state_guard.is_some() {
return Err(gst::StateChangeError); return Err(gst::StateChangeError);
@ -1000,7 +999,7 @@ impl FallbackSrc {
{ {
Some(source) => source, Some(source) => source,
None => { 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!( gst::element_error!(
element, element,
gst::LibraryError::Settings, gst::LibraryError::Settings,
@ -1077,12 +1076,12 @@ impl FallbackSrc {
element.notify("status"); element.notify("status");
gst_debug!(CAT, obj: element, "Started"); gst::debug!(CAT, obj: element, "Started");
Ok(()) Ok(())
} }
fn stop(&self, element: &super::FallbackSrc) { 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_guard = self.state.lock().unwrap();
let mut state = match state_guard.take() { let mut state = match state_guard.take() {
Some(state) => state, Some(state) => state,
@ -1134,11 +1133,11 @@ impl FallbackSrc {
timeout.unschedule(); 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) { 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 mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard { let state = match &mut *state_guard {
Some(state) => state, Some(state) => state,
@ -1146,14 +1145,14 @@ impl FallbackSrc {
}; };
if transition.current() <= transition.next() && state.source_pending_restart { if transition.current() <= transition.next() && state.source_pending_restart {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Not starting source because pending restart" "Not starting source because pending restart"
); );
return; return;
} else if transition.next() <= gst::State::Ready && state.source_pending_restart { } else if transition.next() <= gst::State::Ready && state.source_pending_restart {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Unsetting pending restart because shutting down" "Unsetting pending restart because shutting down"
@ -1171,7 +1170,7 @@ impl FallbackSrc {
let res = source.set_state(transition.next()); let res = source.set_state(transition.next());
match res { match res {
Err(_) => { 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 // Try again later if we're not shutting down
if transition != gst::StateChange::ReadyToNull { if transition != gst::StateChange::ReadyToNull {
let _ = source.set_state(gst::State::Null); let _ = source.set_state(gst::State::Null);
@ -1183,7 +1182,7 @@ impl FallbackSrc {
} }
} }
Ok(res) => { Ok(res) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Source changed state successfully: {:?}", "Source changed state successfully: {:?}",
@ -1231,7 +1230,7 @@ impl FallbackSrc {
element: &super::FallbackSrc, element: &super::FallbackSrc,
pad: &gst::Pad, pad: &gst::Pad,
) -> Result<(), gst::ErrorMessage> { ) -> 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 mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard { let state = match &mut *state_guard {
@ -1297,14 +1296,14 @@ impl FallbackSrc {
let stream = match stream { let stream = match stream {
None => { None => {
gst_debug!(CAT, obj: element, "No {} stream enabled", type_); gst::debug!(CAT, obj: element, "No {} stream enabled", type_);
return Ok(()); return Ok(());
} }
Some(Stream { Some(Stream {
source_srcpad: Some(_), 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(()); return Ok(());
} }
Some(ref mut stream) => stream, Some(ref mut stream) => stream,
@ -1314,11 +1313,11 @@ impl FallbackSrc {
let imagefreeze = let imagefreeze =
gst::ElementFactory::make("imagefreeze", None).expect("no imagefreeze found"); 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(); element.add(&imagefreeze).unwrap();
imagefreeze.set_property("is-live", true); imagefreeze.set_property("is-live", true);
if imagefreeze.sync_state_with_parent().is_err() { 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!( return Err(gst::error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Failed to change imagefreeze state"] ["Failed to change imagefreeze state"]
@ -1331,7 +1330,7 @@ impl FallbackSrc {
}; };
pad.link(&sinkpad).map_err(|err| { pad.link(&sinkpad).map_err(|err| {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Failed to link source pad to clocksync: {}", "Failed to link source pad to clocksync: {}",
@ -1354,7 +1353,7 @@ impl FallbackSrc {
match info.data { match info.data {
Some(gst::PadProbeData::Event(ref ev)) if ev.type_() == gst::EventType::Eos => { Some(gst::PadProbeData::Event(ref ev)) if ev.type_() == gst::EventType::Eos => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: &element, obj: &element,
"Received EOS from source on pad {}", "Received EOS from source on pad {}",
@ -1418,7 +1417,7 @@ impl FallbackSrc {
// a workaround until // a workaround until
// https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/-/issues/800 // https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/-/issues/800
// is fixed. // is fixed.
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Adding probe to pad {}", "Adding probe to pad {}",
@ -1488,7 +1487,7 @@ impl FallbackSrc {
.as_mut() .as_mut()
.filter(|s| &s.clocksync_queue_srcpad == pad) .filter(|s| &s.clocksync_queue_srcpad == pad)
{ {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Called probe on pad {}", "Called probe on pad {}",
@ -1500,7 +1499,7 @@ impl FallbackSrc {
.as_mut() .as_mut()
.filter(|s| &s.clocksync_queue_srcpad == pad) .filter(|s| &s.clocksync_queue_srcpad == pad)
{ {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Called probe on pad {}", "Called probe on pad {}",
@ -1524,7 +1523,7 @@ impl FallbackSrc {
} }
}) })
{ {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Removing pad probe for pad {}", "Removing pad probe for pad {}",
@ -1533,7 +1532,7 @@ impl FallbackSrc {
block.pad.remove_probe(block.probe_id); 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); drop(state_guard);
element.notify("status"); element.notify("status");
@ -1550,13 +1549,13 @@ impl FallbackSrc {
let segment = match pad.sticky_event::<gst::event::Segment>(0) { let segment = match pad.sticky_event::<gst::event::Segment>(0) {
Some(ev) => ev.segment().clone(), Some(ev) => ev.segment().clone(),
None => { None => {
gst_warning!(CAT, obj: element, "Have no segment event yet"); gst::warning!(CAT, obj: element, "Have no segment event yet");
return Ok(()); return Ok(());
} }
}; };
let segment = segment.downcast::<gst::ClockTime>().map_err(|_| { 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"]) gst::error_msg!(gst::CoreError::Clock, ["Have no time segment"])
})?; })?;
@ -1571,7 +1570,7 @@ impl FallbackSrc {
segment.to_running_time(pts) segment.to_running_time(pts)
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Have block running time {}", "Have block running time {}",
@ -1590,14 +1589,14 @@ impl FallbackSrc {
fn unblock_pads(&self, element: &super::FallbackSrc, state: &mut State) { fn unblock_pads(&self, element: &super::FallbackSrc, state: &mut State) {
if state.manually_blocked { 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; return;
} }
// Check if all streams are blocked and have a running time and we have // Check if all streams are blocked and have a running time and we have
// 100% buffering // 100% buffering
if state.stats.buffering_percent < 100 { if state.stats.buffering_percent < 100 {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Not unblocking yet: buffering {}%", "Not unblocking yet: buffering {}%",
@ -1608,7 +1607,7 @@ impl FallbackSrc {
let streams = match state.streams { let streams = match state.streams {
None => { None => {
gst_debug!(CAT, obj: element, "Have no stream collection yet"); gst::debug!(CAT, obj: element, "Have no stream collection yet");
return; return;
} }
Some(ref streams) => streams, Some(ref streams) => streams,
@ -1660,7 +1659,7 @@ impl FallbackSrc {
let current_running_time = match element.current_running_time() { let current_running_time = match element.current_running_time() {
Some(current_running_time) => current_running_time, Some(current_running_time) => current_running_time,
None => { None => {
gst_debug!(CAT, obj: element, "Waiting for current_running_time"); gst::debug!(CAT, obj: element, "Waiting for current_running_time");
return; return;
} }
}; };
@ -1671,17 +1670,17 @@ impl FallbackSrc {
&& video_running_time.is_none() && video_running_time.is_none()
&& !video_is_eos && !video_is_eos
{ {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Waiting for audio and video pads to block" "Waiting for audio and video pads to block"
); );
return; return;
} else if audio_running_time.is_none() && !audio_is_eos { } 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; return;
} else if video_running_time.is_none() && !video_is_eos { } 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; return;
} }
@ -1702,7 +1701,7 @@ impl FallbackSrc {
-((min_running_time - current_running_time).nseconds() as i64) -((min_running_time - current_running_time).nseconds() as i64)
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Unblocking at {} with pad offset {} (audio: {} eos {}, video {} eos {})", "Unblocking at {} with pad offset {} (audio: {} eos {}, video {} eos {})",
@ -1739,7 +1738,7 @@ impl FallbackSrc {
let audio_running_time = match audio_running_time { let audio_running_time = match audio_running_time {
Some(audio_running_time) => audio_running_time, Some(audio_running_time) => audio_running_time,
None => { None => {
gst_debug!(CAT, obj: element, "Waiting for audio pad to block"); gst::debug!(CAT, obj: element, "Waiting for audio pad to block");
return; return;
} }
}; };
@ -1750,7 +1749,7 @@ impl FallbackSrc {
-((audio_running_time - current_running_time).nseconds() as i64) -((audio_running_time - current_running_time).nseconds() as i64)
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Unblocking at {} with pad offset {} (audio: {} eos {})", "Unblocking at {} with pad offset {} (audio: {} eos {})",
@ -1774,7 +1773,7 @@ impl FallbackSrc {
let video_running_time = match video_running_time { let video_running_time = match video_running_time {
Some(video_running_time) => video_running_time, Some(video_running_time) => video_running_time,
None => { None => {
gst_debug!(CAT, obj: element, "Waiting for video pad to block"); gst::debug!(CAT, obj: element, "Waiting for video pad to block");
return; return;
} }
}; };
@ -1785,7 +1784,7 @@ impl FallbackSrc {
-((video_running_time - current_running_time).nseconds() as i64) -((video_running_time - current_running_time).nseconds() as i64)
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Unblocking at {} with pad offset {} (video: {} eos {})", "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) { 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 mut state_guard = self.state.lock().unwrap();
let state = match &mut *state_guard { let state = match &mut *state_guard {
@ -1856,11 +1855,11 @@ impl FallbackSrc {
}; };
if state.source_pending_restart { if state.source_pending_restart {
gst_debug!(CAT, obj: element, "Has pending restart"); gst::debug!(CAT, obj: element, "Has pending restart");
return; 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(); state.stats.buffering_percent = m.percent();
if state.stats.buffering_percent < 100 { if state.stats.buffering_percent < 100 {
@ -1901,7 +1900,7 @@ impl FallbackSrc {
let streams = m.stream_collection(); let streams = m.stream_collection();
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Got stream collection {:?}", "Got stream collection {:?}",
@ -1916,7 +1915,7 @@ impl FallbackSrc {
} }
if !have_audio && state.settings.enable_audio { if !have_audio && state.settings.enable_audio {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Have no audio streams but audio is enabled" "Have no audio streams but audio is enabled"
@ -1924,7 +1923,7 @@ impl FallbackSrc {
} }
if !have_video && state.settings.enable_video { if !have_video && state.settings.enable_video {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Have no video streams but video is enabled" "Have no video streams but video is enabled"
@ -1964,7 +1963,7 @@ impl FallbackSrc {
Some(src) => src, Some(src) => src,
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Got error message from {}", "Got error message from {}",
@ -1985,7 +1984,7 @@ impl FallbackSrc {
if src == video_stream.fallback_input if src == video_stream.fallback_input
|| src.has_as_ancestor(&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 let prev_fallback_uri = video_stream
.fallback_input .fallback_input
@ -2009,7 +2008,7 @@ impl FallbackSrc {
} }
} }
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Give up for error message from {}", "Give up for error message from {}",
@ -2025,11 +2024,11 @@ impl FallbackSrc {
state: &mut State, state: &mut State,
reason: RetryReason, 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; state.stats.last_retry_reason = reason;
if state.source_pending_restart { 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; return;
} }
@ -2082,7 +2081,7 @@ impl FallbackSrc {
source_pending_restart: false, 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; return;
} }
Some(state) => state, Some(state) => state,
@ -2098,7 +2097,7 @@ impl FallbackSrc {
} }
}) })
{ {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Removing pad probe for pad {}", "Removing pad probe for pad {}",
@ -2108,7 +2107,7 @@ impl FallbackSrc {
} }
drop(state_guard); 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); let _ = source.set_state(gst::State::Null);
// Sleep for 1s before retrying // Sleep for 1s before retrying
@ -2120,7 +2119,7 @@ impl FallbackSrc {
source_pending_restart: false, 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; return;
} }
Some(state) => state, Some(state) => state,
@ -2134,7 +2133,7 @@ impl FallbackSrc {
stream.source_srcpad = None; 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 clock = gst::SystemClock::obtain();
let wait_time = clock.time().unwrap() + gst::ClockTime::SECOND; let wait_time = clock.time().unwrap() + gst::ClockTime::SECOND;
assert!(state.source_pending_restart_timeout.is_none()); assert!(state.source_pending_restart_timeout.is_none());
@ -2148,7 +2147,7 @@ impl FallbackSrc {
Some(element) => element, Some(element) => element,
}; };
gst_debug!(CAT, obj: &element, "Woke up, retrying"); gst::debug!(CAT, obj: &element, "Woke up, retrying");
element.call_async(|element| { element.call_async(|element| {
let src = element.imp(); let src = element.imp();
@ -2159,7 +2158,7 @@ impl FallbackSrc {
source_pending_restart: false, source_pending_restart: false,
.. ..
}) => { }) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Restarting source not needed anymore" "Restarting source not needed anymore"
@ -2195,7 +2194,7 @@ impl FallbackSrc {
state.last_buffering_update = None; state.last_buffering_update = None;
if let Some(timeout) = state.source_restart_timeout.take() { 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(); timeout.unschedule();
} }
drop(state_guard); drop(state_guard);
@ -2207,7 +2206,7 @@ impl FallbackSrc {
} }
if source.sync_state_with_parent().is_err() { 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 _ = source.set_state(gst::State::Null);
let mut state_guard = src.state.lock().unwrap(); let mut state_guard = src.state.lock().unwrap();
let state = state_guard.as_mut().expect("no state"); let state = state_guard.as_mut().expect("no state");
@ -2243,7 +2242,7 @@ impl FallbackSrc {
elapsed: gst::ClockTime, elapsed: gst::ClockTime,
) { ) {
if state.source_pending_restart { if state.source_pending_restart {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Not scheduling source restart timeout because source is pending restart already", "Not scheduling source restart timeout because source is pending restart already",
@ -2252,7 +2251,7 @@ impl FallbackSrc {
} }
if state.is_image { if state.is_image {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Not scheduling source restart timeout because we are playing back an image", "Not scheduling source restart timeout because we are playing back an image",
@ -2261,7 +2260,7 @@ impl FallbackSrc {
} }
if state.manually_blocked { if state.manually_blocked {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Not scheduling source restart timeout because we are manually blocked", "Not scheduling source restart timeout because we are manually blocked",
@ -2271,7 +2270,7 @@ impl FallbackSrc {
let clock = gst::SystemClock::obtain(); let clock = gst::SystemClock::obtain();
let wait_time = clock.time().unwrap() + state.settings.restart_timeout - elapsed; let wait_time = clock.time().unwrap() + state.settings.restart_timeout - elapsed;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Scheduling source restart timeout for {}", "Scheduling source restart timeout for {}",
@ -2290,11 +2289,11 @@ impl FallbackSrc {
element.call_async(move |element| { element.call_async(move |element| {
let src = element.imp(); 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 mut state_guard = src.state.lock().unwrap();
let state = match &mut *state_guard { let state = match &mut *state_guard {
None => { None => {
gst_debug!(CAT, obj: element, "Restarting source not needed anymore"); gst::debug!(CAT, obj: element, "Restarting source not needed anymore");
return; return;
} }
Some(state) => state, Some(state) => state,
@ -2310,13 +2309,13 @@ impl FallbackSrc {
.map(|i| i.elapsed() >= state.settings.restart_timeout.into()) .map(|i| i.elapsed() >= state.settings.restart_timeout.into())
.unwrap_or(state.stats.buffering_percent == 100) .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); src.handle_source_error(element, state, RetryReason::Timeout);
drop(state_guard); drop(state_guard);
element.notify("statistics"); element.notify("statistics");
} else { } else {
gst_debug!(CAT, obj: element, "Buffering, restarting source later"); gst::debug!(CAT, obj: element, "Buffering, restarting source later");
let elapsed = state let elapsed = state
.last_buffering_update .last_buffering_update
.and_then(|last_buffering_update| { .and_then(|last_buffering_update| {
@ -2327,7 +2326,7 @@ impl FallbackSrc {
src.schedule_source_restart_timeout(element, state, elapsed); src.schedule_source_restart_timeout(element, state, elapsed);
} }
} else { } 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 // If we have the fallback activated then start the retry timeout unless it was started
// already. Otherwise cancel the retry timeout. // already. Otherwise cancel the retry timeout.
if self.have_fallback_activated(element, state) { 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() { if state.source_restart_timeout.is_none() {
self.schedule_source_restart_timeout(element, state, gst::ClockTime::ZERO); self.schedule_source_restart_timeout(element, state, gst::ClockTime::ZERO);
} }
} else { } 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() { 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(); timeout.unschedule();
} }
if let Some(timeout) = state.source_restart_timeout.take() { 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(); timeout.unschedule();
} }
} }

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

@ -10,7 +10,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_warning};
use std::sync::{atomic::AtomicBool, atomic::Ordering, Mutex}; use std::sync::{atomic::AtomicBool, atomic::Ordering, Mutex};
@ -107,7 +106,7 @@ impl ObjectImpl for VideoFallbackSource {
"uri" => { "uri" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing URI from {:?} to {:?}", "Changing URI from {:?} to {:?}",
@ -119,7 +118,7 @@ impl ObjectImpl for VideoFallbackSource {
"min-latency" => { "min-latency" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing Minimum Latency from {} to {}", "Changing Minimum Latency from {} to {}",
@ -212,13 +211,13 @@ impl BinImpl for VideoFallbackSource {
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
.is_err() .is_err()
{ {
gst_warning!(CAT, obj: bin, "Got error {:?}", err); gst::warning!(CAT, obj: bin, "Got error {:?}", err);
self.parent_handle_message(bin, msg) self.parent_handle_message(bin, msg)
} else { } else {
// Suppress error message if we posted error previously. // Suppress error message if we posted error previously.
// Otherwise parent fallbacksrc would be confused by // Otherwise parent fallbacksrc would be confused by
// multiple error message. // 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), _ => self.parent_handle_message(bin, msg),
@ -243,12 +242,12 @@ impl VideoFallbackSource {
.unwrap() .unwrap()
.set_uri(uri) .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; return None;
} }
if filesrc.set_state(gst::State::Ready).is_err() { 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); let _ = filesrc.set_state(gst::State::Null);
return None; return None;
} }
@ -258,7 +257,7 @@ impl VideoFallbackSource {
// via open() and fstat() in there. // via open() and fstat() in there.
let pad = filesrc.static_pad("src").unwrap(); let pad = filesrc.static_pad("src").unwrap();
if pad.set_active(true).is_err() { 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); let _ = filesrc.set_state(gst::State::Null);
return None; return None;
} }
@ -272,7 +271,7 @@ impl VideoFallbackSource {
min_latency: gst::ClockTime, min_latency: gst::ClockTime,
uri: Option<&str>, uri: Option<&str>,
) -> gst::Element { ) -> 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 source = gst::Bin::new(None);
let filesrc = self.file_src_for_uri(element, uri); let filesrc = self.file_src_for_uri(element, uri);
@ -331,7 +330,7 @@ impl VideoFallbackSource {
.unwrap(); .unwrap();
if imagefreeze.try_set_property("is-live", true).is_err() { if imagefreeze.try_set_property("is-live", true).is_err() {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"imagefreeze does not support live mode, this will probably misbehave" "imagefreeze does not support live mode, this will probably misbehave"
@ -375,7 +374,7 @@ impl VideoFallbackSource {
decoder = gst::ElementFactory::make("pngdec", Some("decoder")) decoder = gst::ElementFactory::make("pngdec", Some("decoder"))
.expect("pngdec not found"); .expect("pngdec not found");
} else { } else {
gst_error!(CAT, obj: &element, "Unsupported caps {}", caps); gst::error!(CAT, obj: &element, "Unsupported caps {}", caps);
gst::element_error!( gst::element_error!(
element, element,
gst::StreamError::Format, gst::StreamError::Format,
@ -389,7 +388,7 @@ impl VideoFallbackSource {
if let Err(_err) = if let Err(_err) =
gst::Element::link_many(&[&typefind, &decoder, &videoconvert]) 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!( gst::element_error!(
element, element,
gst::StreamError::Format, gst::StreamError::Format,
@ -431,11 +430,11 @@ impl VideoFallbackSource {
&self, &self,
element: &super::VideoFallbackSource, element: &super::VideoFallbackSource,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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(); let mut state_guard = self.state.lock().unwrap();
if state_guard.is_some() { 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); return Err(gst::StateChangeError);
} }
@ -454,7 +453,7 @@ impl VideoFallbackSource {
} }
fn stop(&self, element: &super::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 mut state_guard = self.state.lock().unwrap();
let state = match state_guard.take() { let state = match state_guard.take() {
@ -468,6 +467,6 @@ impl VideoFallbackSource {
let _ = self.srcpad.set_target(None::<&gst::Pad>); let _ = self.srcpad.set_target(None::<&gst::Pad>);
element.remove(&state.source).unwrap(); element.remove(&state.source).unwrap();
self.got_error.store(false, Ordering::Relaxed); 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::prelude::*;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log, gst_warning};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use std::sync::{Mutex, RwLock}; use std::sync::{Mutex, RwLock};
@ -179,7 +177,7 @@ impl FallbackSwitch {
} }
let segment = segment.downcast::<gst::ClockTime>().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
@ -194,7 +192,7 @@ impl FallbackSwitch {
.opt_le(target_running_time.into()) .opt_le(target_running_time.into())
.unwrap_or(false) .unwrap_or(false)
{ {
gst_debug!(CAT, obj: pad, "Dropping trailing buffer {:?}", buffer); gst::debug!(CAT, obj: pad, "Dropping trailing buffer {:?}", buffer);
pad.drop_buffer(); pad.drop_buffer();
running_time = new_running_time; running_time = new_running_time;
} else { } else {
@ -223,7 +221,7 @@ impl FallbackSwitch {
cur_running_time: impl Into<Option<gst::ClockTime>>, cur_running_time: impl Into<Option<gst::ClockTime>>,
) -> Result<Option<(gst::Buffer, gst::Caps, bool)>, gst::FlowError> { ) -> Result<Option<(gst::Buffer, gst::Caps, bool)>, gst::FlowError> {
// If we got a buffer on the sinkpad just handle it // If we got a buffer on the sinkpad just handle it
gst_debug!( gst::debug!(
CAT, CAT,
obj: preferred_pad, obj: preferred_pad,
"Got buffer on pad {} - {:?}", "Got buffer on pad {} - {:?}",
@ -232,7 +230,7 @@ impl FallbackSwitch {
); );
if buffer.pts().is_none() { 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); return Err(gst::FlowError::Error);
} }
@ -240,7 +238,7 @@ impl FallbackSwitch {
.segment() .segment()
.downcast::<gst::ClockTime>() .downcast::<gst::ClockTime>()
.map_err(|_| { .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 gst::FlowError::Error
})?; })?;
@ -269,7 +267,7 @@ impl FallbackSwitch {
}; };
if is_late { if is_late {
gst_debug!( gst::debug!(
CAT, CAT,
obj: preferred_pad, obj: preferred_pad,
"Buffer is too late: {} > {}", "Buffer is too late: {} > {}",
@ -285,7 +283,7 @@ impl FallbackSwitch {
if let Some(true) = is_late { if let Some(true) = is_late {
/* This buffer arrived too late - we either already switched /* This buffer arrived too late - we either already switched
* to the other pad or there's no point outputting this anyway */ * to the other pad or there's no point outputting this anyway */
gst_debug!( gst::debug!(
CAT, CAT,
obj: preferred_pad, obj: preferred_pad,
"Buffer is too late and timeout reached: {} + {} <= {}", "Buffer is too late and timeout reached: {} + {} <= {}",
@ -304,7 +302,7 @@ impl FallbackSwitch {
if pad_change { if pad_change {
if buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) { if buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) {
gst_info!( gst::info!(
CAT, CAT,
obj: preferred_pad, obj: preferred_pad,
"Can't change back to sinkpad {}, waiting for keyframe", "Can't change back to sinkpad {}, waiting for keyframe",
@ -318,7 +316,7 @@ impl FallbackSwitch {
return Ok(None); 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()); *active_sinkpad = Some(preferred_pad.clone().upcast());
} }
drop(active_sinkpad); drop(active_sinkpad);
@ -356,7 +354,7 @@ impl FallbackSwitch {
.pop_buffer() .pop_buffer()
.ok_or(gst_base::AGGREGATOR_FLOW_NEED_DATA)?; .ok_or(gst_base::AGGREGATOR_FLOW_NEED_DATA)?;
gst_debug!( gst::debug!(
CAT, CAT,
obj: backup_pad, obj: backup_pad,
"Got buffer on fallback sinkpad {:?}", "Got buffer on fallback sinkpad {:?}",
@ -364,7 +362,7 @@ impl FallbackSwitch {
); );
if buffer.pts().is_none() { 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); return Err(gst::FlowError::Error);
} }
@ -373,7 +371,7 @@ impl FallbackSwitch {
.segment() .segment()
.downcast::<gst::ClockTime>() .downcast::<gst::ClockTime>()
.map_err(|_| { .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 gst::FlowError::Error
})?; })?;
let running_time = backup_segment.to_running_time(buffer.dts_or_pts()); 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 // Get the next one if this one is before the timeout
if !timed_out { if !timed_out {
gst_debug!( gst::debug!(
CAT, CAT,
obj: backup_pad, obj: backup_pad,
"Timeout not reached yet: {} + {} > {}", "Timeout not reached yet: {} + {} > {}",
@ -423,7 +421,7 @@ impl FallbackSwitch {
); );
continue; continue;
} }
gst_debug!( gst::debug!(
CAT, CAT,
obj: backup_pad, obj: backup_pad,
"Timeout reached: {} + {} <= {}", "Timeout reached: {} + {} <= {}",
@ -432,7 +430,7 @@ impl FallbackSwitch {
running_time.display(), running_time.display(),
); );
} else { } else {
gst_debug!( gst::debug!(
CAT, CAT,
obj: backup_pad, obj: backup_pad,
"Consuming buffer as we haven't yet received a buffer on the other 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>()); && active_sinkpad.as_ref() != Some(backup_pad.upcast_ref::<gst::Pad>());
if pad_change { if pad_change {
if buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) { if buffer.flags().contains(gst::BufferFlags::DELTA_UNIT) {
gst_info!( gst::info!(
CAT, CAT,
obj: backup_pad, obj: backup_pad,
"Can't change to sinkpad {} yet, waiting for keyframe", "Can't change to sinkpad {} yet, waiting for keyframe",
@ -458,7 +456,7 @@ impl FallbackSwitch {
continue; continue;
} }
gst_info!( gst::info!(
CAT, CAT,
obj: backup_pad, obj: backup_pad,
"Active pad changed to fallback sinkpad" "Active pad changed to fallback sinkpad"
@ -501,10 +499,10 @@ impl FallbackSwitch {
let settings = self.settings.lock().unwrap().clone(); let settings = self.settings.lock().unwrap().clone();
let mut state = self.output_state.lock().unwrap(); 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() { 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)); 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 we can't auto-switch, then can't fetch anything from the backup pad */
if !settings.auto_switch { if !settings.auto_switch {
/* Not switching, but backup pad needs draining of late buffers still */ /* Not switching, but backup pad needs draining of late buffers still */
gst_log!( gst::log!(
CAT, CAT,
obj: agg, obj: agg,
"No primary buffer, but can't autoswitch - draining backup pad" "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) { 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), Err(gst_base::AGGREGATOR_FLOW_NEED_DATA),
state.check_health_changes( state.check_health_changes(
@ -628,7 +626,7 @@ impl FallbackSwitch {
) )
} else { } else {
// Otherwise there's not much we can do at this point // Otherwise there's not much we can do at this point
gst_debug!( gst::debug!(
CAT, CAT,
obj: agg, obj: agg,
"Got no buffer on sinkpad and have no fallback sinkpad" "Got no buffer on sinkpad and have no fallback sinkpad"
@ -742,7 +740,7 @@ impl ObjectImpl for FallbackSwitch {
"timeout" => { "timeout" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let timeout = value.get().expect("type checked upstream"); let timeout = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing timeout from {} to {}", "Changing timeout from {} to {}",
@ -755,7 +753,7 @@ impl ObjectImpl for FallbackSwitch {
"active-pad" => { "active-pad" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
if settings.auto_switch { if settings.auto_switch {
gst_warning!( gst::warning!(
CAT, CAT,
obj: obj, obj: obj,
"active-pad property setting ignored, because auto-switch=true" "active-pad property setting ignored, because auto-switch=true"
@ -883,13 +881,13 @@ impl ElementImpl for FallbackSwitch {
if templ != &fallback_sink_templ if templ != &fallback_sink_templ
|| (name.is_some() && name.as_deref() != Some("fallback_sink")) || (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; return None;
} }
let mut fallback_sinkpad = self.fallback_sinkpad.write().unwrap(); let mut fallback_sinkpad = self.fallback_sinkpad.write().unwrap();
if fallback_sinkpad.is_some() { 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; return None;
} }
@ -916,7 +914,7 @@ impl ElementImpl for FallbackSwitch {
*fallback_sinkpad = None; *fallback_sinkpad = None;
drop(fallback_sinkpad); drop(fallback_sinkpad);
element.remove_pad(pad).unwrap(); 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.fallback_state.write().unwrap() = PadInputState::default();
*self.active_sinkpad.lock().unwrap() = None; *self.active_sinkpad.lock().unwrap() = None;
@ -951,7 +949,7 @@ impl AggregatorImpl for FallbackSwitch {
match event.view() { match event.view() {
EventView::Gap(gap) => { EventView::Gap(gap) => {
if gap.gap_flags().contains(gst::GapFlags::DATA) { 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) Ok(gst::FlowSuccess::Ok)
} else { } else {
self.parent_sink_event_pre_queue(agg, agg_pad, event) self.parent_sink_event_pre_queue(agg, agg_pad, event)
@ -972,7 +970,7 @@ impl AggregatorImpl for FallbackSwitch {
match event.view() { match event.view() {
EventView::Caps(caps) => { EventView::Caps(caps) => {
let caps = caps.caps_owned(); 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 audio_info;
let video_info; let video_info;
@ -1035,7 +1033,7 @@ impl AggregatorImpl for FallbackSwitch {
}; };
if preferred_pad.peek_buffer().is_some() { if preferred_pad.peek_buffer().is_some() {
gst_debug!( gst::debug!(
CAT, CAT,
obj: agg, obj: agg,
"Have buffer on sinkpad {}, immediate timeout", "Have buffer on sinkpad {}, immediate timeout",
@ -1043,14 +1041,14 @@ impl AggregatorImpl for FallbackSwitch {
); );
Some(gst::ClockTime::ZERO) Some(gst::ClockTime::ZERO)
} else if self.primary_sinkpad.is_eos() { } 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) Some(gst::ClockTime::ZERO)
} else if let Some((buffer, backup_sinkpad)) = backup_pad } else if let Some((buffer, backup_sinkpad)) = backup_pad
.as_ref() .as_ref()
.and_then(|p| p.peek_buffer().map(|buffer| (buffer, p))) .and_then(|p| p.peek_buffer().map(|buffer| (buffer, p)))
{ {
if buffer.pts().is_none() { 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 // Trigger aggregate immediately to error out immediately
return Some(gst::ClockTime::ZERO); return Some(gst::ClockTime::ZERO);
} }
@ -1058,14 +1056,14 @@ impl AggregatorImpl for FallbackSwitch {
let segment = match backup_sinkpad.segment().downcast::<gst::ClockTime>() { let segment = match backup_sinkpad.segment().downcast::<gst::ClockTime>() {
Ok(segment) => segment, Ok(segment) => segment,
Err(_) => { 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 // Trigger aggregate immediately to error out immediately
return Some(gst::ClockTime::ZERO); return Some(gst::ClockTime::ZERO);
} }
}; };
let running_time = segment.to_running_time(buffer.dts_or_pts()); let running_time = segment.to_running_time(buffer.dts_or_pts());
gst_debug!( gst::debug!(
CAT, CAT,
obj: agg, obj: agg,
"Have buffer on {} pad, timeout at {}", "Have buffer on {} pad, timeout at {}",
@ -1074,7 +1072,7 @@ impl AggregatorImpl for FallbackSwitch {
); );
running_time running_time
} else { } 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 gst::ClockTime::NONE
} }
} }
@ -1090,14 +1088,14 @@ impl AggregatorImpl for FallbackSwitch {
let segment = match agg_pad.segment().downcast::<gst::ClockTime>() { let segment = match agg_pad.segment().downcast::<gst::ClockTime>() {
Ok(segment) => segment, Ok(segment) => segment,
Err(_) => { Err(_) => {
gst_error!(CAT, obj: agg, "Only TIME segments supported"); gst::error!(CAT, obj: agg, "Only TIME segments supported");
return Some(buffer); return Some(buffer);
} }
}; };
let pts = buffer.pts(); let pts = buffer.pts();
if pts.is_none() { 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); return Some(buffer);
} }
@ -1137,7 +1135,7 @@ impl AggregatorImpl for FallbackSwitch {
unreachable!() unreachable!()
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: agg_pad, obj: agg_pad,
"Clipping buffer {:?} with PTS {} and duration {}", "Clipping buffer {:?} with PTS {} and duration {}",
@ -1175,12 +1173,12 @@ impl AggregatorImpl for FallbackSwitch {
agg: &Self::Type, agg: &Self::Type,
timeout: bool, timeout: bool,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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); let (res, (primary_health_change, fallback_health_change)) = self.next_buffer(agg, timeout);
if primary_health_change { if primary_health_change {
gst_debug!( gst::debug!(
CAT, CAT,
obj: agg, obj: agg,
"Primary pad health now {}", "Primary pad health now {}",
@ -1189,7 +1187,7 @@ impl AggregatorImpl for FallbackSwitch {
agg.notify("primary-health"); agg.notify("primary-health");
} }
if fallback_health_change { if fallback_health_change {
gst_debug!( gst::debug!(
CAT, CAT,
obj: agg, obj: agg,
"Fallback pad health now {}", "Fallback pad health now {}",
@ -1202,7 +1200,7 @@ impl AggregatorImpl for FallbackSwitch {
let current_src_caps = agg.static_pad("src").unwrap().current_caps(); let current_src_caps = agg.static_pad("src").unwrap().current_caps();
if Some(&active_caps) != current_src_caps.as_ref() { if Some(&active_caps) != current_src_caps.as_ref() {
gst_info!( gst::info!(
CAT, CAT,
obj: agg, obj: agg,
"Caps change from {:?} to {:?}", "Caps change from {:?} to {:?}",
@ -1216,7 +1214,7 @@ impl AggregatorImpl for FallbackSwitch {
agg.notify("active-pad"); agg.notify("active-pad");
buffer.make_mut().set_flags(gst::BufferFlags::DISCONT); 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) agg.finish_buffer(buffer)
} }

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

@ -6,7 +6,6 @@
// //
// SPDX-License-Identifier: MPL-2.0 // SPDX-License-Identifier: MPL-2.0
use gst::gst_debug;
use gst::prelude::*; use gst::prelude::*;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -345,7 +344,7 @@ impl std::ops::Deref for Pipeline {
fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline { fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline {
init(); init();
gst_debug!(TEST_CAT, "Setting up pipeline"); gst::debug!(TEST_CAT, "Setting up pipeline");
let clock = gst_check::TestClock::new(); let clock = gst_check::TestClock::new();
clock.set_time(gst::ClockTime::ZERO); clock.set_time(gst::ClockTime::ZERO);
@ -430,11 +429,11 @@ fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline {
None 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() { 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() { if clock_id.time().is_zero() {
gst_debug!(TEST_CAT, "Stopping clock thread"); gst::debug!(TEST_CAT, "Stopping clock thread");
return; return;
} }
} }
@ -529,7 +528,7 @@ fn set_time(pipeline: &Pipeline, time: gst::ClockTime) {
.downcast::<gst_check::TestClock>() .downcast::<gst_check::TestClock>()
.unwrap(); .unwrap();
gst_debug!(TEST_CAT, "Setting time to {}", time); gst::debug!(TEST_CAT, "Setting time to {}", time);
clock.set_time(gst::ClockTime::SECOND + time); clock.set_time(gst::ClockTime::SECOND + time);
} }
@ -544,7 +543,7 @@ fn wait_eos(pipeline: &Pipeline) {
use std::{thread, time}; use std::{thread, time};
if sink.is_eos() { if sink.is_eos() {
gst_debug!(TEST_CAT, "Waited for EOS"); gst::debug!(TEST_CAT, "Waited for EOS");
break; break;
} }
thread::sleep(time::Duration::from_millis(10)); 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_log, gst_trace, gst_warning};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use parking_lot::{Condvar, Mutex}; use parking_lot::{Condvar, Mutex};
@ -353,7 +352,7 @@ impl ToggleRecord {
let data = match data.clip(&state, &state.in_segment) { let data = match data.clip(&state, &state.in_segment) {
Some(data) => data, Some(data) => data,
None => { 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); return Ok(HandleResult::Drop);
} }
}; };
@ -385,7 +384,7 @@ impl ToggleRecord {
// get the wrong state // get the wrong state
self.main_stream_cond.notify_all(); self.main_stream_cond.notify_all();
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Main stream current running time {}-{} (position: {}-{})", "Main stream current running time {}-{} (position: {}-{})",
@ -401,12 +400,12 @@ impl ToggleRecord {
let mut rec_state = self.state.lock(); let mut rec_state = self.state.lock();
let settings_changed = match rec_state.recording_state { let settings_changed = match rec_state.recording_state {
RecordingState::Recording if !settings.record => { 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; rec_state.recording_state = RecordingState::Stopping;
true true
} }
RecordingState::Stopped if settings.record => { 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; rec_state.recording_state = RecordingState::Starting;
true true
} }
@ -417,19 +416,19 @@ impl ToggleRecord {
RecordingState::Recording => { RecordingState::Recording => {
// Remember where we stopped last, in case of EOS // Remember where we stopped last, in case of EOS
rec_state.last_recording_stop = current_running_time_end; 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)) Ok(HandleResult::Pass(data))
} }
RecordingState::Stopping => { RecordingState::Stopping => {
if !data.is_keyframe() { if !data.is_keyframe() {
// Remember where we stopped last, in case of EOS // Remember where we stopped last, in case of EOS
rec_state.last_recording_stop = current_running_time_end; 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(rec_state);
drop(state); drop(state);
if settings_changed { if settings_changed {
gst_debug!(CAT, obj: pad, "Requesting a new keyframe"); gst::debug!(CAT, obj: pad, "Requesting a new keyframe");
stream stream
.sinkpad .sinkpad
.push_event(gst_video::UpstreamForceKeyUnitEvent::builder().build()); .push_event(gst_video::UpstreamForceKeyUnitEvent::builder().build());
@ -445,7 +444,7 @@ impl ToggleRecord {
.opt_checked_sub(rec_state.last_recording_start) .opt_checked_sub(rec_state.last_recording_start)
.ok() .ok()
.flatten(); .flatten();
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Stopping at {}, started at {}, current duration {}, previous accumulated recording duration {}", "Stopping at {}, started at {}, current duration {}, previous accumulated recording duration {}",
@ -469,12 +468,12 @@ impl ToggleRecord {
.unwrap_or(false) .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); self.main_stream_cond.wait(&mut state);
} }
if state.flushing { if state.flushing {
gst_debug!(CAT, obj: pad, "Flushing"); gst::debug!(CAT, obj: pad, "Flushing");
return Ok(HandleResult::Flushing); return Ok(HandleResult::Flushing);
} }
@ -485,7 +484,7 @@ impl ToggleRecord {
rec_state.last_recording_start = None; rec_state.last_recording_start = None;
rec_state.last_recording_stop = None; rec_state.last_recording_stop = None;
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Stopped at {}, recording duration {}", "Stopped at {}, recording duration {}",
@ -495,7 +494,7 @@ impl ToggleRecord {
// Then become Stopped and drop this buffer. We always stop right before // Then become Stopped and drop this buffer. We always stop right before
// a keyframe // a keyframe
gst_log!(CAT, obj: pad, "Dropping buffer (stopped)"); gst::log!(CAT, obj: pad, "Dropping buffer (stopped)");
drop(rec_state); drop(rec_state);
drop(state); drop(state);
@ -504,18 +503,18 @@ impl ToggleRecord {
Ok(HandleResult::Drop) Ok(HandleResult::Drop)
} }
RecordingState::Stopped => { RecordingState::Stopped => {
gst_log!(CAT, obj: pad, "Dropping buffer (stopped)"); gst::log!(CAT, obj: pad, "Dropping buffer (stopped)");
Ok(HandleResult::Drop) Ok(HandleResult::Drop)
} }
RecordingState::Starting => { RecordingState::Starting => {
// If this is no keyframe, we can directly go out again here and drop the frame // If this is no keyframe, we can directly go out again here and drop the frame
if !data.is_keyframe() { 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(rec_state);
drop(state); drop(state);
if settings_changed { if settings_changed {
gst_debug!(CAT, obj: pad, "Requesting a new keyframe"); gst::debug!(CAT, obj: pad, "Requesting a new keyframe");
stream stream
.sinkpad .sinkpad
.push_event(gst_video::UpstreamForceKeyUnitEvent::builder().build()); .push_event(gst_video::UpstreamForceKeyUnitEvent::builder().build());
@ -532,7 +531,7 @@ impl ToggleRecord {
.saturating_sub(rec_state.recording_duration) .saturating_sub(rec_state.recording_duration)
.nseconds() .nseconds()
}) as i64; }) as i64;
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Starting at {}, previous accumulated recording duration {}", "Starting at {}, previous accumulated recording duration {}",
@ -562,18 +561,18 @@ impl ToggleRecord {
.unwrap_or(false) .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); self.main_stream_cond.wait(&mut state);
} }
if state.flushing { if state.flushing {
gst_debug!(CAT, obj: pad, "Flushing"); gst::debug!(CAT, obj: pad, "Flushing");
return Ok(HandleResult::Flushing); return Ok(HandleResult::Flushing);
} }
let mut rec_state = self.state.lock(); let mut rec_state = self.state.lock();
rec_state.recording_state = RecordingState::Recording; rec_state.recording_state = RecordingState::Recording;
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Started at {}, recording duration {}", "Started at {}, recording duration {}",
@ -581,7 +580,7 @@ impl ToggleRecord {
rec_state.recording_duration rec_state.recording_duration
); );
gst_log!(CAT, obj: pad, "Passing buffer (recording)"); gst::log!(CAT, obj: pad, "Passing buffer (recording)");
drop(rec_state); drop(rec_state);
drop(state); drop(state);
@ -630,7 +629,7 @@ impl ToggleRecord {
let data = match data.clip(&state, &state.in_segment) { let data = match data.clip(&state, &state.in_segment) {
None => { 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); return Ok(HandleResult::Drop);
} }
Some(data) => data, Some(data) => data,
@ -653,7 +652,7 @@ impl ToggleRecord {
.opt_max(state.current_running_time_end) .opt_max(state.current_running_time_end)
.or(current_running_time_end); .or(current_running_time_end);
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Secondary stream current running time {}-{} (position: {}-{}", "Secondary stream current running time {}-{} (position: {}-{}",
@ -705,7 +704,7 @@ impl ToggleRecord {
&& !main_state.eos && !main_state.eos
&& !state.flushing && !state.flushing
{ {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Waiting at {}-{} in {:?} state, main stream at {}-{}", "Waiting at {}-{} in {:?} state, main stream at {}-{}",
@ -724,7 +723,7 @@ impl ToggleRecord {
} }
if state.flushing { if state.flushing {
gst_debug!(CAT, obj: pad, "Flushing"); gst::debug!(CAT, obj: pad, "Flushing");
return Ok(HandleResult::Flushing); return Ok(HandleResult::Flushing);
} }
@ -733,7 +732,7 @@ impl ToggleRecord {
if main_state.eos { if main_state.eos {
// If we have no start or stop position (we never recorded) then we're EOS too now // 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() { 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( return Ok(HandleResult::Eos(self.check_and_update_eos(
pad, pad,
stream, stream,
@ -754,7 +753,7 @@ impl ToggleRecord {
{ {
// Otherwise if we're before the recording start but the end of the buffer is after // 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. // the start and we can clip, clip the buffer and pass it onwards.
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Main stream EOS and we're not EOS yet (overlapping recording start, {} < {} < {})", "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_start(clip_start);
segment.set_stop(clip_stop); 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) { if let Some(data) = data.clip(&*state, &segment) {
return Ok(HandleResult::Pass(data)); return Ok(HandleResult::Pass(data));
} else { } else {
gst_warning!(CAT, obj: pad, "Complete buffer clipped!"); gst::warning!(CAT, obj: pad, "Complete buffer clipped!");
return Ok(HandleResult::Drop); return Ok(HandleResult::Drop);
} }
} else if current_running_time } else if current_running_time
@ -794,7 +793,7 @@ impl ToggleRecord {
// Otherwise if the buffer starts before the recording start, drop it. This // 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 // means that we either can't clip, or that the end is also before the
// recording start // recording start
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Main stream EOS and we're not EOS yet (before recording start, {} < {})", "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 // 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. // can clip, clip the buffer and pass it through.
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Main stream EOS and we're not EOS yet (overlapping recording end, {} < {} < {})", "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_start(clip_start);
segment.set_stop(clip_stop); 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) { if let Some(data) = data.clip(&*state, &segment) {
return Ok(HandleResult::Pass(data)); return Ok(HandleResult::Pass(data));
} else { } 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( return Ok(HandleResult::Eos(self.check_and_update_eos(
pad, pad,
stream, stream,
@ -857,7 +856,7 @@ impl ToggleRecord {
// Otherwise if the end of the buffer is after the recording stop, we're EOS // 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 // now. This means that we either couldn't clip or that the start is also after
// the recording stop // the recording stop
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Main stream EOS and we're EOS too (after recording end, {} > {})", "Main stream EOS and we're EOS too (after recording end, {} > {})",
@ -880,7 +879,7 @@ impl ToggleRecord {
.opt_le(rec_state.last_recording_stop) .opt_le(rec_state.last_recording_stop)
.unwrap_or(false)); .unwrap_or(false));
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Main stream EOS and we're not EOS yet (before recording end, {} <= {} <= {})", "Main stream EOS and we're not EOS yet (before recording end, {} <= {} <= {})",
@ -905,7 +904,7 @@ impl ToggleRecord {
assert!(current_running_time assert!(current_running_time
.opt_ge(rec_state.last_recording_start) .opt_ge(rec_state.last_recording_start)
.unwrap_or(false)); .unwrap_or(false));
gst_log!(CAT, obj: pad, "Passing buffer (recording)"); gst::log!(CAT, obj: pad, "Passing buffer (recording)");
Ok(HandleResult::Pass(data)) Ok(HandleResult::Pass(data))
} }
RecordingState::Stopping => { RecordingState::Stopping => {
@ -913,7 +912,7 @@ impl ToggleRecord {
let last_recording_stop = match rec_state.last_recording_stop { let last_recording_stop = match rec_state.last_recording_stop {
Some(last_recording_stop) => last_recording_stop, Some(last_recording_stop) => last_recording_stop,
None => { None => {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Passing buffer (stopping: waiting for keyframe)", "Passing buffer (stopping: waiting for keyframe)",
@ -930,7 +929,7 @@ impl ToggleRecord {
if current_running_time_end if current_running_time_end
.map_or(false, |cur_rt_end| cur_rt_end <= last_recording_stop) .map_or(false, |cur_rt_end| cur_rt_end <= last_recording_stop)
{ {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Passing buffer (stopping: {} <= {})", "Passing buffer (stopping: {} <= {})",
@ -943,7 +942,7 @@ impl ToggleRecord {
&& current_running_time_end && current_running_time_end
.map_or(false, |cur_rt_end| cur_rt_end > last_recording_stop) .map_or(false, |cur_rt_end| cur_rt_end > last_recording_stop)
{ {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Passing buffer (stopping: {} < {} < {})", "Passing buffer (stopping: {} < {} < {})",
@ -961,16 +960,16 @@ impl ToggleRecord {
let mut segment = state.in_segment.clone(); let mut segment = state.in_segment.clone();
segment.set_stop(clip_stop); 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) { if let Some(data) = data.clip(&*state, &segment) {
Ok(HandleResult::Pass(data)) Ok(HandleResult::Pass(data))
} else { } else {
gst_warning!(CAT, obj: pad, "Complete buffer clipped!"); gst::warning!(CAT, obj: pad, "Complete buffer clipped!");
Ok(HandleResult::Drop) Ok(HandleResult::Drop)
} }
} else { } else {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Dropping buffer (stopping: {} > {})", "Dropping buffer (stopping: {} > {})",
@ -988,7 +987,7 @@ impl ToggleRecord {
.unwrap_or(false)); .unwrap_or(false));
// We're properly stopped // We're properly stopped
gst_log!(CAT, obj: pad, "Dropping buffer (stopped)"); gst::log!(CAT, obj: pad, "Dropping buffer (stopped)");
Ok(HandleResult::Drop) Ok(HandleResult::Drop)
} }
RecordingState::Starting => { RecordingState::Starting => {
@ -996,7 +995,7 @@ impl ToggleRecord {
let last_recording_start = match rec_state.last_recording_start { let last_recording_start = match rec_state.last_recording_start {
Some(last_recording_start) => last_recording_start, Some(last_recording_start) => last_recording_start,
None => { None => {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Dropping buffer (starting: waiting for keyframe)", "Dropping buffer (starting: waiting for keyframe)",
@ -1011,7 +1010,7 @@ impl ToggleRecord {
let current_running_time = current_running_time.expect("checked_above"); let current_running_time = current_running_time.expect("checked_above");
if current_running_time >= last_recording_start { if current_running_time >= last_recording_start {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Passing buffer (starting: {} >= {})", "Passing buffer (starting: {} >= {})",
@ -1024,7 +1023,7 @@ impl ToggleRecord {
&& current_running_time_end && current_running_time_end
.map_or(false, |cur_rt_end| cur_rt_end > last_recording_start) .map_or(false, |cur_rt_end| cur_rt_end > last_recording_start)
{ {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Passing buffer (starting: {} < {} < {})", "Passing buffer (starting: {} < {} < {})",
@ -1042,16 +1041,16 @@ impl ToggleRecord {
let mut segment = state.in_segment.clone(); let mut segment = state.in_segment.clone();
segment.set_start(clip_start); 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) { if let Some(data) = data.clip(&*state, &segment) {
Ok(HandleResult::Pass(data)) Ok(HandleResult::Pass(data))
} else { } else {
gst_warning!(CAT, obj: pad, "Complete buffer clipped!"); gst::warning!(CAT, obj: pad, "Complete buffer clipped!");
Ok(HandleResult::Drop) Ok(HandleResult::Drop)
} }
} else { } else {
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Dropping buffer (starting: {} < {})", "Dropping buffer (starting: {} < {})",
@ -1093,7 +1092,7 @@ impl ToggleRecord {
}); });
if all_others_eos { if all_others_eos {
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"All streams are in EOS state, change state to Stopped" "All streams are in EOS state, change state to Stopped"
@ -1138,7 +1137,7 @@ impl ToggleRecord {
if !all_others_not_eos { if !all_others_not_eos {
let settings = self.settings.lock(); let settings = self.settings.lock();
if settings.record { 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; rec_state.recording_state = RecordingState::Starting;
} }
} }
@ -1162,7 +1161,7 @@ impl ToggleRecord {
gst::FlowError::Error gst::FlowError::Error
})?; })?;
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer); gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
{ {
let state = stream.state.lock(); let state = stream.state.lock();
@ -1216,7 +1215,7 @@ impl ToggleRecord {
let mut state = stream.state.lock(); let mut state = stream.state.lock();
if state.discont_pending { if state.discont_pending {
gst_debug!(CAT, obj: pad, "Pending discont"); gst::debug!(CAT, obj: pad, "Pending discont");
let buffer = buffer.make_mut(); let buffer = buffer.make_mut();
buffer.set_flags(gst::BufferFlags::DISCONT); buffer.set_flags(gst::BufferFlags::DISCONT);
state.discont_pending = false; state.discont_pending = false;
@ -1244,11 +1243,11 @@ impl ToggleRecord {
.build(), .build(),
); );
state.segment_pending = false; 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() { 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); events.append(&mut state.pending_events);
@ -1266,7 +1265,7 @@ impl ToggleRecord {
out_running_time out_running_time
}; };
gst_log!( gst::log!(
CAT, CAT,
obj: pad, obj: pad,
"Pushing buffer with running time {}: {:?}", "Pushing buffer with running time {}: {:?}",
@ -1296,7 +1295,7 @@ impl ToggleRecord {
Some(stream) => stream.clone(), 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 forward = true;
let mut send_pending = false; let mut send_pending = false;
@ -1330,12 +1329,12 @@ impl ToggleRecord {
let s = caps.structure(0).unwrap(); let s = caps.structure(0).unwrap();
if s.name().starts_with("audio/") { if s.name().starts_with("audio/") {
state.audio_info = gst_audio::AudioInfo::from_caps(caps).ok(); 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; state.video_info = None;
} else if s.name().starts_with("video/") { } else if s.name().starts_with("video/") {
state.audio_info = None; state.audio_info = None;
state.video_info = gst_video::VideoInfo::from_caps(caps).ok(); 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 { } else {
state.audio_info = None; state.audio_info = None;
state.video_info = None; state.video_info = None;
@ -1374,12 +1373,12 @@ impl ToggleRecord {
state.current_running_time = None; state.current_running_time = None;
state.current_running_time_end = 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; forward = false;
} }
EventView::Gap(e) => { 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 (pts, duration) = e.get();
let handle_result = if stream == self.main_stream { let handle_result = if stream == self.main_stream {
self.handle_main_stream(element, pad, &stream, (pts, duration)) self.handle_main_stream(element, pad, &stream, (pts, duration))
@ -1423,7 +1422,7 @@ impl ToggleRecord {
} }
self.main_stream_cond.notify_all(); 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(..) => { EventView::Eos(..) => {
let main_state = if stream != self.main_stream { let main_state = if stream != self.main_stream {
@ -1445,7 +1444,7 @@ impl ToggleRecord {
} }
self.main_stream_cond.notify_all(); self.main_stream_cond.notify_all();
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Stream is EOS now, sending any pending events" "Stream is EOS now, sending any pending events"
@ -1470,7 +1469,7 @@ impl ToggleRecord {
{ {
let mut state = stream.state.lock(); let mut state = stream.state.lock();
if state.segment_pending { 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); state.pending_events.push(event);
return true; return true;
} }
@ -1498,10 +1497,10 @@ impl ToggleRecord {
} }
if forward { if forward {
gst_log!(CAT, obj: pad, "Forwarding event {:?}", event); gst::log!(CAT, obj: pad, "Forwarding event {:?}", event);
stream.srcpad.push_event(event) stream.srcpad.push_event(event)
} else { } else {
gst_log!(CAT, obj: pad, "Dropping event {:?}", event); gst::log!(CAT, obj: pad, "Dropping event {:?}", event);
true true
} }
} }
@ -1524,7 +1523,7 @@ impl ToggleRecord {
Some(stream) => stream.clone(), 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) stream.srcpad.peer_query(query)
} }
@ -1552,7 +1551,7 @@ impl ToggleRecord {
Some(stream) => stream.clone(), 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(..)); let forward = !matches!(event.view(), EventView::Seek(..));
@ -1564,10 +1563,10 @@ impl ToggleRecord {
drop(rec_state); drop(rec_state);
if forward { if forward {
gst_log!(CAT, obj: pad, "Forwarding event {:?}", event); gst::log!(CAT, obj: pad, "Forwarding event {:?}", event);
stream.sinkpad.push_event(event) stream.sinkpad.push_event(event)
} else { } else {
gst_log!(CAT, obj: pad, "Dropping event {:?}", event); gst::log!(CAT, obj: pad, "Dropping event {:?}", event);
false false
} }
} }
@ -1592,7 +1591,7 @@ impl ToggleRecord {
Some(stream) => stream.clone(), Some(stream) => stream.clone(),
}; };
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Scheduling(q) => { QueryViewMut::Scheduling(q) => {
let mut new_query = gst::query::Scheduling::new(); let mut new_query = gst::query::Scheduling::new();
@ -1601,7 +1600,7 @@ impl ToggleRecord {
return res; 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(); let (flags, min, max, align) = new_query.result();
q.set(flags, min, max, align); q.set(flags, min, max, align);
@ -1613,7 +1612,7 @@ impl ToggleRecord {
.filter(|m| m != &gst::PadMode::Pull) .filter(|m| m != &gst::PadMode::Pull)
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
); );
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut()); gst::log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true true
} }
QueryViewMut::Seeking(q) => { QueryViewMut::Seeking(q) => {
@ -1625,7 +1624,7 @@ impl ToggleRecord {
gst::GenericFormattedValue::new(format, -1), gst::GenericFormattedValue::new(format, -1),
); );
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut()); gst::log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true true
} }
// Position and duration is always the current recording position // Position and duration is always the current recording position
@ -1643,7 +1642,7 @@ impl ToggleRecord {
.ok() .ok()
.flatten() .flatten()
{ {
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Returning position {} = {} - ({} + {})", "Returning position {} = {} - ({} + {})",
@ -1655,7 +1654,7 @@ impl ToggleRecord {
recording_duration += delta; recording_duration += delta;
} }
} else { } else {
gst_debug!(CAT, obj: pad, "Returning position {}", recording_duration); gst::debug!(CAT, obj: pad, "Returning position {}", recording_duration);
} }
q.set(recording_duration); q.set(recording_duration);
true true
@ -1677,7 +1676,7 @@ impl ToggleRecord {
.ok() .ok()
.flatten() .flatten()
{ {
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Returning duration {} = {} - ({} + {})", "Returning duration {} = {} - ({} + {})",
@ -1689,7 +1688,7 @@ impl ToggleRecord {
recording_duration += delta; recording_duration += delta;
} }
} else { } else {
gst_debug!(CAT, obj: pad, "Returning duration {}", recording_duration); gst::debug!(CAT, obj: pad, "Returning duration {}", recording_duration);
} }
q.set(recording_duration); q.set(recording_duration);
true 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) stream.sinkpad.peer_query(query)
} }
} }
@ -1852,7 +1851,7 @@ impl ObjectImpl for ToggleRecord {
"record" => { "record" => {
let mut settings = self.settings.lock(); let mut settings = self.settings.lock();
let record = value.get().expect("type checked upstream"); let record = value.get().expect("type checked upstream");
gst_debug!( gst::debug!(
CAT, CAT,
obj: obj, obj: obj,
"Setting record from {:?} to {:?}", "Setting record from {:?} to {:?}",
@ -1865,7 +1864,7 @@ impl ObjectImpl for ToggleRecord {
"is-live" => { "is-live" => {
let mut settings = self.settings.lock(); let mut settings = self.settings.lock();
let live = value.get().expect("type checked upstream"); let live = value.get().expect("type checked upstream");
gst_debug!( gst::debug!(
CAT, CAT,
obj: obj, obj: obj,
"Setting live from {:?} to {:?}", "Setting live from {:?} to {:?}",
@ -1972,7 +1971,7 @@ impl ElementImpl for ToggleRecord {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused => { 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_fixme, gst_info, gst_log, gst_warning};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -177,7 +176,7 @@ impl State {
if let Some(blocked) = self.blocked.take() { if let Some(blocked) = self.blocked.take() {
let (messages, sender) = blocked.set_streaming(self.streams_topology.n_streams()); let (messages, sender) = blocked.set_streaming(self.streams_topology.n_streams());
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"send pending message of item #{} and unblock its pads", "send pending message of item #{} and unblock its pads",
@ -758,7 +757,7 @@ impl ObjectImpl for UriPlaylistBin {
"uris" => { "uris" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing uris from {:?} to {:?}", "Changing uris from {:?} to {:?}",
@ -770,7 +769,7 @@ impl ObjectImpl for UriPlaylistBin {
"iterations" => { "iterations" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get().expect("type checked upstream"); let new_value = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing iterations from {:?} to {:?}", "Changing iterations from {:?} to {:?}",
@ -942,7 +941,7 @@ impl ElementImpl for UriPlaylistBin {
impl UriPlaylistBin { impl UriPlaylistBin {
fn start(&self, element: &super::UriPlaylistBin) -> Result<(), PlaylistError> { 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(); let mut state_guard = self.state.lock().unwrap();
assert!(state_guard.is_none()); 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 // 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() { while let Some(done) = state.done.pop() {
let uridecodebin = done.uridecodebin(); 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() { for (concat, sink_pad) in done.concat_sink_pads() {
// calling release_request_pad() while holding the pad stream lock would deadlock // calling release_request_pad() while holding the pad stream lock would deadlock
@ -1002,7 +1001,7 @@ impl UriPlaylistBin {
let n_streaming = state.streaming.len(); let n_streaming = state.streaming.len();
if n_streaming > MAX_STREAMING_ITEMS { if n_streaming > MAX_STREAMING_ITEMS {
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"Too many items streaming ({}), wait before starting the next one", "Too many items streaming ({}), wait before starting the next one",
@ -1015,7 +1014,7 @@ impl UriPlaylistBin {
let item = match state.playlist.next()? { let item = match state.playlist.next()? {
Some(item) => item, Some(item) => item,
None => { None => {
gst_debug!(CAT, obj: element, "no more item to queue",); gst::debug!(CAT, obj: element, "no more item to queue",);
// unblock last item // unblock last item
state.unblock_item(element); state.unblock_item(element);
@ -1026,7 +1025,7 @@ impl UriPlaylistBin {
} }
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"start decoding item #{}: {}", "start decoding item #{}: {}",
@ -1063,7 +1062,7 @@ impl UriPlaylistBin {
let element_weak = element.downgrade(); let element_weak = element.downgrade();
let receiver = item.receiver(); let receiver = item.receiver();
gst_debug!( gst::debug!(
CAT, CAT,
obj: &element, obj: &element,
"Block pad {} until streamsynchronizer is flushed", "Block pad {} until streamsynchronizer is flushed",
@ -1079,7 +1078,7 @@ impl UriPlaylistBin {
let _ = receiver.recv(); let _ = receiver.recv();
gst_log!( gst::log!(
CAT, CAT,
obj: &element, obj: &element,
"pad {}:{} has been unblocked", "pad {}:{} has been unblocked",
@ -1124,7 +1123,7 @@ impl UriPlaylistBin {
if src.has_as_ancestor(&uridecodebin) { if src.has_as_ancestor(&uridecodebin) {
let topology = StreamsTopology::from(stream_collection_msg.stream_collection()); let topology = StreamsTopology::from(stream_collection_msg.stream_collection());
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"got stream collection from {}: {:?}", "got stream collection from {}: {:?}",
@ -1139,7 +1138,7 @@ impl UriPlaylistBin {
assert!(state.waiting_for_pads.is_none()); assert!(state.waiting_for_pads.is_none());
if state.streams_topology != topology { if state.streams_topology != topology {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, "streams topoly changed ('{:?}' -> '{:?}'), waiting for streamsynchronize to be flushed", obj: element, "streams topoly changed ('{:?}' -> '{:?}'), waiting for streamsynchronize to be flushed",
state.streams_topology, topology); state.streams_topology, topology);
@ -1179,7 +1178,7 @@ impl UriPlaylistBin {
if src.has_as_ancestor(&uridecodebin) { if src.has_as_ancestor(&uridecodebin) {
// stream-selected message is from the blocked item, queue the message until it's unblocked // stream-selected message is from the blocked item, queue the message until it's unblocked
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"queue stream-selected message from {} as item is currently blocked", "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) { let (stream_type, stream_index) = match stream_type_from_pad_name(&pad_name) {
Ok((stream_type, stream_index)) => (stream_type, stream_index), Ok((stream_type, stream_index)) => (stream_type, stream_index),
Err(e) => { Err(e) => {
gst_warning!(CAT, obj: &element, "Ignoring pad {}: {}", pad_name, e); gst::warning!(CAT, obj: &element, "Ignoring pad {}: {}", pad_name, e);
return; return;
} }
}; };
@ -1230,7 +1229,7 @@ impl UriPlaylistBin {
let concat = match concat { let concat = match concat {
None => { None => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: &element, obj: &element,
"stream {} from item #{}: creating concat element", "stream {} from item #{}: creating concat element",
@ -1299,7 +1298,7 @@ impl UriPlaylistBin {
if let Some(item) = item { if let Some(item) = item {
if item.dec_waiting_eos_ss() { 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); imp.handle_topology_change(&element);
gst::PadProbeReturn::Drop gst::PadProbeReturn::Drop
} else { } else {
@ -1331,7 +1330,7 @@ impl UriPlaylistBin {
gst::EventView::SelectStreams(_) => { gst::EventView::SelectStreams(_) => {
// TODO: handle select-streams event // TODO: handle select-streams event
let element = parent.unwrap(); let element = parent.unwrap();
gst_fixme!( gst::fixme!(
CAT, CAT,
obj: element, obj: element,
"select-streams event not supported ('{:?}')", "select-streams event not supported ('{:?}')",
@ -1361,7 +1360,7 @@ impl UriPlaylistBin {
concat concat
} }
Some(concat) => { Some(concat) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: &element, obj: &element,
"stream {} from item #{}: re-using concat element {}", "stream {} from item #{}: re-using concat element {}",
@ -1394,7 +1393,7 @@ impl UriPlaylistBin {
if !item.is_streaming() { if !item.is_streaming() {
// block pad until next item is ready // block pad until next item is ready
gst_log!( gst::log!(
CAT, CAT,
obj: &element, obj: &element,
"blocking pad {}:{} until next item is ready", "blocking pad {}:{} until next item is ready",
@ -1404,7 +1403,7 @@ impl UriPlaylistBin {
let _ = receiver.recv(); let _ = receiver.recv();
gst_log!( gst::log!(
CAT, CAT,
obj: &element, obj: &element,
"pad {}:{} has been unblocked", "pad {}:{} has been unblocked",
@ -1420,7 +1419,7 @@ impl UriPlaylistBin {
{ {
if item.dec_waiting_eos() { if item.dec_waiting_eos() {
// all the streams are eos, item is now done // all the streams are eos, item is now done
gst_log!( gst::log!(
CAT, CAT,
obj: &element, obj: &element,
"all streams of item #{} are eos", "all streams of item #{} are eos",
@ -1460,7 +1459,7 @@ impl UriPlaylistBin {
if item.dec_n_pads_pending() == 0 { if item.dec_n_pads_pending() == 0 {
// we got all the pads // we got all the pads
gst_debug!( gst::debug!(
CAT, CAT,
obj: &element, obj: &element,
"got all the pads for item #{}", "got all the pads for item #{}",
@ -1484,7 +1483,7 @@ impl UriPlaylistBin {
}; };
if start_next { if start_next {
gst_debug!( gst::debug!(
CAT, CAT,
obj: &element, obj: &element,
"got all pending streams, queue next item" "got all pending streams, queue next item"
@ -1519,7 +1518,7 @@ impl UriPlaylistBin {
while n_stream < concats.len() { while n_stream < concats.len() {
// need to remove concat elements // need to remove concat elements
let concat = concats.pop().unwrap(); 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 concat_src = concat.static_pad("src").unwrap();
let ss_sink = concat_src.peer().unwrap(); let ss_sink = concat_src.peer().unwrap();
@ -1592,7 +1591,7 @@ impl UriPlaylistBin {
} }
} }
let error_msg = error.to_string(); let error_msg = error.to_string();
gst_error!(CAT, obj: element, "{}", error_msg); gst::error!(CAT, obj: element, "{}", error_msg);
match error { match error {
PlaylistError::PluginMissing { .. } => { PlaylistError::PluginMissing { .. } => {

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

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

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

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

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

@ -9,7 +9,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_error, gst_info, gst_log, gst_trace, gst_warning};
use gst_video::prelude::*; use gst_video::prelude::*;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -249,7 +248,7 @@ impl Cea608Overlay {
let buffer = match render_buffer() { let buffer = match render_buffer() {
Some(buffer) => buffer, Some(buffer) => buffer,
None => { None => {
gst_error!(CAT, obj: element, "Failed to render buffer"); gst::error!(CAT, obj: element, "Failed to render buffer");
state.composition = None; state.composition = None;
return; return;
} }
@ -329,7 +328,7 @@ impl Cea608Overlay {
pts: gst::ClockTime, pts: gst::ClockTime,
) { ) {
if data.len() % 3 != 0 { 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) { for triple in data.chunks_exact(3) {
@ -340,7 +339,7 @@ impl Cea608Overlay {
if cc_type == 0x00 || cc_type == 0x01 { if cc_type == 0x00 || cc_type == 0x01 {
if state.selected_field.is_none() { if state.selected_field.is_none() {
state.selected_field = Some(cc_type); state.selected_field = Some(cc_type);
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Selected field {} automatically", "Selected field {} automatically",
@ -356,7 +355,7 @@ impl Cea608Overlay {
let text = match state.caption_frame.to_text(true) { let text = match state.caption_frame.to_text(true) {
Ok(text) => text, Ok(text) => text,
Err(_) => { Err(_) => {
gst_error!( gst::error!(
CAT, CAT,
obj: pad, obj: pad,
"Failed to convert caption frame to text" "Failed to convert caption frame to text"
@ -386,14 +385,14 @@ impl Cea608Overlay {
pts: gst::ClockTime, pts: gst::ClockTime,
) { ) {
if data.len() % 3 != 0 { 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) { for triple in data.chunks_exact(3) {
let cc_type = triple[0] & 0x01; let cc_type = triple[0] & 0x01;
if state.selected_field.is_none() { if state.selected_field.is_none() {
state.selected_field = Some(cc_type); state.selected_field = Some(cc_type);
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Selected field {} automatically", "Selected field {} automatically",
@ -409,7 +408,7 @@ impl Cea608Overlay {
let text = match state.caption_frame.to_text(true) { let text = match state.caption_frame.to_text(true) {
Ok(text) => text, Ok(text) => text,
Err(_) => { 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; continue;
} }
}; };
@ -432,10 +431,10 @@ impl Cea608Overlay {
element: &super::Cea608Overlay, element: &super::Cea608Overlay,
mut buffer: gst::Buffer, mut buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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(|| { 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 gst::FlowError::Error
})?; })?;
@ -456,7 +455,7 @@ impl Cea608Overlay {
self.decode_cc_data(pad, element, &mut state, data, pts); self.decode_cc_data(pad, element, &mut state, data, pts);
} }
Err(e) => { Err(e) => {
gst_warning!(CAT, "{}", &e.to_string()); gst::warning!(CAT, "{}", &e.to_string());
gst::element_warning!(element, gst::StreamError::Decode, [&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) { let text = match state.caption_frame.to_text(true) {
Ok(text) => text, Ok(text) => text,
Err(_) => { Err(_) => {
gst_error!( gst::error!(
CAT, CAT,
obj: pad, obj: pad,
"Failed to convert caption frame to text" "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(timeout) = self.settings.lock().unwrap().timeout {
if let Some(interval) = pts.opt_saturating_sub(state.last_cc_pts) { if let Some(interval) = pts.opt_saturating_sub(state.last_cc_pts) {
if interval > timeout { 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.composition.take();
state.last_cc_pts.take(); state.last_cc_pts.take();
} }
@ -514,7 +513,7 @@ impl Cea608Overlay {
.unwrap(); .unwrap();
if composition.blend(&mut frame).is_err() { 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 { ) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(c) => { EventView::Caps(c) => {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
@ -751,7 +750,7 @@ impl ElementImpl for Cea608Overlay {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => {

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

@ -28,7 +28,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace, gst_warning};
use crate::ffi; use crate::ffi;
use crate::ttutils::{Cea608Mode, Chunk, Line, Lines, TextStyle}; use crate::ttutils::{Cea608Mode, Chunk, Line, Lines, TextStyle};
@ -403,7 +402,7 @@ fn dump(
let end = pts.opt_add(duration.into()); let end = pts.opt_add(duration.into());
if cc_data != 0x8080 { if cc_data != 0x8080 {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"{} -> {}: {}", "{} -> {}: {}",
@ -412,7 +411,7 @@ fn dump(
eia608_to_text(cc_data) eia608_to_text(cc_data)
); );
} else { } else {
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"{} -> {}: padding", "{} -> {}: padding",
@ -461,7 +460,7 @@ impl State {
} }
fn drain(&mut self, element: &super::Cea608ToJson, flush: bool) -> Option<TimestampedLines> { 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 { let pts = if self.settings.unbuffered {
self.current_pts self.current_pts
@ -536,7 +535,7 @@ impl State {
fn drain_pending(&mut self, element: &super::Cea608ToJson) -> Option<TimestampedLines> { fn drain_pending(&mut self, element: &super::Cea608ToJson) -> Option<TimestampedLines> {
if let Some(mut pending) = self.pending_lines.take() { 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 pending.duration = self
.current_pts .current_pts
.opt_add(self.current_duration) .opt_add(self.current_duration)
@ -560,7 +559,7 @@ impl State {
return None; 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; let drain_roll_up = self.cursor.row != preamble.row as u32;
@ -646,7 +645,7 @@ impl State {
) -> Option<TimestampedLines> { ) -> Option<TimestampedLines> {
let (cmd, chan) = parse_control(cc_data); 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 { if chan != 0 {
return None; return None;
@ -679,7 +678,7 @@ impl State {
return self.update_mode(element, Cea608Mode::RollUp4); return self.update_mode(element, Cea608Mode::RollUp4);
} }
ffi::eia608_control_t_eia608_control_carriage_return => { 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 { if let Some(mode) = self.mode {
// https://www.law.cornell.edu/cfr/text/47/79.101 (f)(2)(i) (f)(3)(i) // 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_restart
| ffi::eia608_control_t_eia608_control_text_resume_text_display => {} | 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); row.push(&mut self.cursor, c);
} }
} else { } 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, cc_data: u16,
) -> Option<TimestampedLines> { ) -> Option<TimestampedLines> {
if (is_specialna(cc_data) || is_control(cc_data)) && Some(cc_data) == self.last_cc_data { 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; return None;
} }
@ -821,14 +820,14 @@ impl State {
self.current_duration = duration; self.current_duration = duration;
if is_xds(cc_data) { 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) { } 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); return self.decode_control(element, cc_data);
} else if is_basicna(cc_data) || is_specialna(cc_data) || is_westeu(cc_data) { } else if is_basicna(cc_data) || is_specialna(cc_data) || is_westeu(cc_data) {
if let Some(mode) = self.mode { if let Some(mode) = self.mode {
self.mode?; self.mode?;
gst_log!(CAT, obj: element, "text"); gst::log!(CAT, obj: element, "text");
self.decode_text(element, cc_data); self.decode_text(element, cc_data);
if mode.is_rollup() && self.settings.unbuffered { if mode.is_rollup() && self.settings.unbuffered {
@ -836,10 +835,10 @@ impl State {
} }
} }
} else if is_preamble(cc_data) { } 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); return self.decode_preamble(element, cc_data);
} else if is_midrowchange(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); self.decode_midrowchange(cc_data);
} }
None None
@ -852,7 +851,7 @@ impl Cea608ToJson {
element: &super::Cea608ToJson, element: &super::Cea608ToJson,
lines: TimestampedLines, lines: TimestampedLines,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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| { let json = serde_json::to_string(&lines.lines).map_err(|err| {
gst::element_error!( gst::element_error!(
@ -871,7 +870,7 @@ impl Cea608ToJson {
buf_mut.set_duration(lines.duration); buf_mut.set_duration(lines.duration);
} }
gst_log!(CAT, obj: element, "Pushing {:?}", buf); gst::log!(CAT, obj: element, "Pushing {:?}", buf);
self.srcpad.push(buf) self.srcpad.push(buf)
} }
@ -882,30 +881,30 @@ impl Cea608ToJson {
element: &super::Cea608ToJson, element: &super::Cea608ToJson,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 mut state = self.state.borrow_mut();
let pts = buffer.pts(); let pts = buffer.pts();
if pts.is_none() { 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); return Err(gst::FlowError::Error);
} }
let duration = buffer.duration(); let duration = buffer.duration();
if duration.is_none() { 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); return Err(gst::FlowError::Error);
} }
let data = buffer.map_readable().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
if data.len() < 2 { 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); 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 { fn sink_event(&self, pad: &gst::Pad, element: &super::Cea608ToJson, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(..) => { EventView::Caps(..) => {
// We send our own caps downstream // We send our own caps downstream
@ -1107,7 +1106,7 @@ impl ElementImpl for Cea608ToJson {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused => { gst::StateChange::ReadyToPaused => {

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

@ -9,7 +9,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace};
use crate::caption_frame::{CaptionFrame, Status}; use crate::caption_frame::{CaptionFrame, Status};
use atomic_refcell::AtomicRefCell; use atomic_refcell::AtomicRefCell;
@ -65,32 +64,32 @@ impl Cea608ToTt {
_element: &super::Cea608ToTt, _element: &super::Cea608ToTt,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 mut state = self.state.borrow_mut();
let format = match state.format { let format = match state.format {
Some(format) => format, Some(format) => format,
None => { None => {
gst_error!(CAT, obj: pad, "Not negotiated yet"); gst::error!(CAT, obj: pad, "Not negotiated yet");
return Err(gst::FlowError::NotNegotiated); return Err(gst::FlowError::NotNegotiated);
} }
}; };
let buffer_pts = buffer.pts().ok_or_else(|| { 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 gst::FlowError::Error
})?; })?;
let pts = (buffer_pts.nseconds() as f64) / 1_000_000_000.0; let pts = (buffer_pts.nseconds() as f64) / 1_000_000_000.0;
let data = buffer.map_readable().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
if data.len() < 2 { 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); return Ok(gst::FlowSuccess::Ok);
} }
@ -101,19 +100,19 @@ impl Cea608ToTt {
{ {
Ok(Status::Ok) => return Ok(gst::FlowSuccess::Ok), Ok(Status::Ok) => return Ok(gst::FlowSuccess::Ok),
Err(_) => { 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); return Ok(gst::FlowSuccess::Ok);
} }
Ok(Status::Clear) => { 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() state.previous_text.take()
} }
Ok(Status::Ready) => { 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) { let text = match state.caption_frame.to_text(false) {
Ok(text) => text, Ok(text) => text,
Err(_) => { 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); return Ok(gst::FlowSuccess::Ok);
} }
}; };
@ -125,7 +124,7 @@ impl Cea608ToTt {
let previous_text = match previous_text { let previous_text = match previous_text {
Some(previous_text) => previous_text, Some(previous_text) => previous_text,
None => { None => {
gst_debug!(CAT, obj: pad, "Have no previous text"); gst::debug!(CAT, obj: pad, "Have no previous text");
return Ok(gst::FlowSuccess::Ok); 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 { fn sink_event(&self, pad: &gst::Pad, element: &super::Cea608ToTt, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(..) => { EventView::Caps(..) => {
let mut state = self.state.borrow_mut(); let mut state = self.state.borrow_mut();
@ -286,13 +285,13 @@ impl Cea608ToTt {
}; };
if downstream_caps.is_empty() { if downstream_caps.is_empty() {
gst_error!(CAT, obj: pad, "Empty downstream caps"); gst::error!(CAT, obj: pad, "Empty downstream caps");
return false; return false;
} }
downstream_caps.fixate(); downstream_caps.fixate();
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Negotiating for downstream caps {}", "Negotiating for downstream caps {}",
@ -327,7 +326,7 @@ impl Cea608ToTt {
EventView::Eos(..) => { EventView::Eos(..) => {
let mut state = self.state.borrow_mut(); let mut state = self.state.borrow_mut();
if let Some((timestamp, text)) = state.previous_text.take() { 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(); let format = state.format.unwrap();
@ -490,7 +489,7 @@ impl ElementImpl for Cea608ToTt {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused => { gst::StateChange::ReadyToPaused => {

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

@ -7,10 +7,10 @@
// //
// SPDX-License-Identifier: MPL-2.0 // SPDX-License-Identifier: MPL-2.0
use gst::element_error;
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::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::jsontovtt::fku::ForceKeyUnitRequest;
use crate::ttutils::Lines; use crate::ttutils::Lines;
@ -248,31 +248,31 @@ impl State {
let mut ret = vec![]; let mut ret = vec![];
let data = buffer.map_readable().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
let lines: Lines = serde_json::from_slice(&data).map_err(|err| { 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 gst::FlowError::Error
})?; })?;
let pts = buffer.pts().ok_or_else(|| { 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 gst::FlowError::Error
})?; })?;
let duration = buffer.duration().ok_or_else(|| { 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 gst::FlowError::Error
})?; })?;
let (pts, duration) = match clamp(&self.segment, pts, Some(duration)) { let (pts, duration) = match clamp(&self.segment, pts, Some(duration)) {
Some((pts, duration)) => (pts, duration.unwrap()), Some((pts, duration)) => (pts, duration.unwrap()),
None => { None => {
gst_warning!( gst::warning!(
CAT, CAT,
obj: pad, obj: pad,
"Dropping buffer outside segment: {:?}", "Dropping buffer outside segment: {:?}",
@ -307,7 +307,7 @@ impl State {
let (pts, duration) = match clamp(&self.segment, pts, duration) { let (pts, duration) = match clamp(&self.segment, pts, duration) {
Some((pts, duration)) => (pts, duration), Some((pts, duration)) => (pts, duration),
None => { None => {
gst_warning!(CAT, "Ignoring gap outside segment"); gst::warning!(CAT, "Ignoring gap outside segment");
return ret; return ret;
} }
}; };
@ -326,7 +326,7 @@ impl State {
fn handle_eos(&mut self) -> Vec<gst::Buffer> { fn handle_eos(&mut self) -> Vec<gst::Buffer> {
let mut ret = vec![]; 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); self.drain(&mut ret, None);
ret ret
@ -340,7 +340,7 @@ impl JsonToVtt {
_element: &super::JsonToVtt, _element: &super::JsonToVtt,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 mut state = self.state.lock().unwrap();
let buffers = state.handle_buffer(pad, buffer)?; 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 { fn src_event(&self, pad: &gst::Pad, element: &super::JsonToVtt, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::CustomUpstream(ev) => { EventView::CustomUpstream(ev) => {
if gst_video::ForceKeyUnitEvent::is(ev) { if gst_video::ForceKeyUnitEvent::is(ev) {
match gst_video::UpstreamForceKeyUnitEvent::parse(ev) { match gst_video::UpstreamForceKeyUnitEvent::parse(ev) {
Ok(fku_event) => { 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() { if fku_event.running_time.is_some() {
self.handle_fku(ForceKeyUnitRequest::new_from_event(&fku_event)); self.handle_fku(ForceKeyUnitRequest::new_from_event(&fku_event));
} }
} }
Err(_) => gst_warning!( Err(_) => gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Invalid force-key-unit event received from downstream: {:?}", "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 { fn sink_event(&self, pad: &gst::Pad, element: &super::JsonToVtt, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Eos(..) => { EventView::Eos(..) => {
gst_log!(CAT, obj: pad, "Handling EOS"); gst::log!(CAT, obj: pad, "Handling EOS");
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
let buffers = state.handle_eos(); let buffers = state.handle_eos();
drop(state); drop(state);
@ -407,13 +407,13 @@ impl JsonToVtt {
}; };
if downstream_caps.is_empty() { if downstream_caps.is_empty() {
gst_error!(CAT, obj: pad, "Empty downstream caps"); gst::error!(CAT, obj: pad, "Empty downstream caps");
return false; return false;
} }
downstream_caps.fixate(); downstream_caps.fixate();
gst_debug!( gst::debug!(
CAT, CAT,
obj: pad, obj: pad,
"Negotiating for downstream caps {}", "Negotiating for downstream caps {}",
@ -454,7 +454,7 @@ impl JsonToVtt {
pad.event_default(Some(element), event) pad.event_default(Some(element), event)
} }
EventView::Gap(ev) => { 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 mut state = self.state.lock().unwrap();
let buffers = state.handle_gap(ev); let buffers = state.handle_gap(ev);
drop(state); drop(state);
@ -582,7 +582,7 @@ impl ElementImpl for JsonToVtt {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> 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 { if transition == gst::StateChange::ReadyToPaused {
let mut state = self.state.lock().unwrap(); 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::prelude::*;
use gst::structure; use gst::structure;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_error, gst_log, gst_trace};
use chrono::prelude::*; use chrono::prelude::*;
use uuid::Uuid; use uuid::Uuid;
@ -318,7 +317,7 @@ impl MccEnc {
element: &super::MccEnc, element: &super::MccEnc,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 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 { fn sink_event(&self, pad: &gst::Pad, element: &super::MccEnc, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(ev) => { EventView::Caps(ev) => {
@ -351,7 +350,7 @@ impl MccEnc {
let framerate = match s.get::<gst::Fraction>("framerate") { let framerate = match s.get::<gst::Fraction>("framerate") {
Ok(framerate) => framerate, Ok(framerate) => framerate,
Err(structure::GetError::FieldNotFound { .. }) => { Err(structure::GetError::FieldNotFound { .. }) => {
gst_error!(CAT, obj: pad, "Caps without framerate"); gst::error!(CAT, obj: pad, "Caps without framerate");
return false; return false;
} }
err => panic!("MccEnc::sink_event caps: {:?}", err), 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 { fn src_event(&self, pad: &gst::Pad, element: &super::MccEnc, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Seek(_) => { EventView::Seek(_) => {
gst_log!(CAT, obj: pad, "Dropping seek event"); gst::log!(CAT, obj: pad, "Dropping seek event");
false false
} }
_ => pad.event_default(Some(element), event), _ => pad.event_default(Some(element), event),
@ -403,7 +402,7 @@ impl MccEnc {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Seeking(q) => { QueryViewMut::Seeking(q) => {
@ -611,7 +610,7 @@ impl ElementImpl for MccEnc {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{ use gst::{element_error, loggable_error};
element_error, gst_debug, gst_error, gst_fixme, gst_info, gst_log, gst_trace, gst_warning,
loggable_error,
};
use gst_video::ValidVideoTimeCode; use gst_video::ValidVideoTimeCode;
use std::cmp; use std::cmp;
@ -191,7 +188,7 @@ impl State {
gst::FlowError::Error gst::FlowError::Error
})?; })?;
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Invalid timecode {:?}, using previous {:?}", "Invalid timecode {:?}, using previous {:?}",
@ -218,7 +215,7 @@ impl State {
let start_position = self.start_position.expect("checked above"); let start_position = self.start_position.expect("checked above");
let nsecs = nsecs.checked_sub(start_position).unwrap_or_else(|| { let nsecs = nsecs.checked_sub(start_position).unwrap_or_else(|| {
gst_fixme!( gst::fixme!(
CAT, CAT,
obj: element, obj: element,
"New position {} < start position {}", "New position {} < start position {}",
@ -234,7 +231,7 @@ impl State {
{ {
self.last_position = Some(nsecs); self.last_position = Some(nsecs);
} else { } else {
gst_fixme!( gst::fixme!(
CAT, CAT,
obj: element, obj: element,
"New position {} < last position {}", "New position {} < last position {}",
@ -310,7 +307,7 @@ impl State {
}; };
events.push(gst::event::Caps::new(&caps)); 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)))) => { Ok(Some(MccLine::Caption(tc, Some(data)))) => {
assert!(!state.seeking); assert!(!state.seeking);
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Got caption buffer with timecode {:?} and size {}", "Got caption buffer with timecode {:?} and size {}",
@ -406,7 +403,7 @@ impl MccParse {
} }
if data.len() < 3 { if data.len() < 3 {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Too small caption packet: {}", "Too small caption packet: {}",
@ -419,14 +416,14 @@ impl MccParse {
(0x61, 0x01) => Format::Cea708Cdp, (0x61, 0x01) => Format::Cea708Cdp,
(0x61, 0x02) => Format::Cea608, (0x61, 0x02) => Format::Cea608,
(did, sdid) => { (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; continue;
} }
}; };
let len = data[2]; let len = data[2];
if data.len() < 3 + len as usize { if data.len() < 3 + len as usize {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Too small caption packet: {} < {}", "Too small caption packet: {} < {}",
@ -454,7 +451,7 @@ impl MccParse {
state = self.handle_skipped_line(element, tc, state)?; state = self.handle_skipped_line(element, tc, state)?;
} }
Ok(Some(MccLine::TimeCodeRate(rate, df))) => { Ok(Some(MccLine::TimeCodeRate(rate, df))) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Got timecode rate {} (drop frame {})", "Got timecode rate {} (drop frame {})",
@ -468,7 +465,7 @@ impl MccParse {
} }
} }
Ok(Some(line)) => { Ok(Some(line)) => {
gst_debug!(CAT, obj: element, "Got line '{:?}'", line); gst::debug!(CAT, obj: element, "Got line '{:?}'", line);
} }
Err((line, err)) => { Err((line, err)) => {
element_error!( element_error!(
@ -562,13 +559,13 @@ impl MccParse {
drop(state); drop(state);
for event in events { 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_event(event);
} }
self.srcpad.push(buffer).map_err(|err| { self.srcpad.push(buffer).map_err(|err| {
if err != gst::FlowError::Flushing { if err != gst::FlowError::Flushing {
gst_error!(CAT, obj: element, "Pushing buffer returned {:?}", err); gst::error!(CAT, obj: element, "Pushing buffer returned {:?}", err);
} }
err err
})?; })?;
@ -592,18 +589,18 @@ impl MccParse {
state.pull = None; state.pull = None;
if !pad.peer_query(&mut query) { 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 gst::PadMode::Push
} else if query } else if query
.has_scheduling_mode_with_flags(gst::PadMode::Pull, gst::SchedulingFlags::SEEKABLE) .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)); state.pull = Some(PullState::new(element, &self.srcpad));
gst::PadMode::Pull gst::PadMode::Pull
} else { } else {
gst_debug!(CAT, obj: pad, "Activating in Push mode"); gst::debug!(CAT, obj: pad, "Activating in Push mode");
gst::PadMode::Push gst::PadMode::Push
} }
}; };
@ -657,7 +654,7 @@ impl MccParse {
&self, &self,
element: &super::MccParse, element: &super::MccParse,
) -> Result<Option<ValidVideoTimeCode>, gst::LoggableError> { ) -> 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 */ /* First let's query the bytes duration upstream */
let mut q = gst::query::Duration::new(gst::Format::Bytes); let mut q = gst::query::Duration::new(gst::Format::Bytes);
@ -724,7 +721,7 @@ impl MccParse {
} }
if last_tc.is_some() || offset == 0 { if last_tc.is_some() || offset == 0 {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Duration scan done, last_tc: {:?}", "Duration scan done, last_tc: {:?}",
@ -757,7 +754,7 @@ impl MccParse {
drop(state); drop(state);
for event in events { 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_event(event);
} }
} }
@ -790,13 +787,13 @@ impl MccParse {
Ok(buffer) => Some(buffer), Ok(buffer) => Some(buffer),
Err(gst::FlowError::Eos) => None, Err(gst::FlowError::Eos) => None,
Err(gst::FlowError::Flushing) => { 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(); let _ = self.sinkpad.pause_task();
return; return;
} }
Err(flow) => { 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_error!(
element, element,
@ -841,17 +838,17 @@ impl MccParse {
Err(flow) => { Err(flow) => {
match flow { match flow {
gst::FlowError::Flushing => { gst::FlowError::Flushing => {
gst_debug!(CAT, obj: element, "Pausing after flow {:?}", flow); gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow);
} }
gst::FlowError::Eos => { gst::FlowError::Eos => {
self.push_eos(element); 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); 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_error!(
element, element,
@ -872,7 +869,7 @@ impl MccParse {
element: &super::MccParse, element: &super::MccParse,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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) 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 { fn sink_event(&self, pad: &gst::Pad, element: &super::MccParse, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(_) => { EventView::Caps(_) => {
// We send a proper caps event from the chain function later // 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 true
} }
EventView::Segment(_) => { EventView::Segment(_) => {
// We send a gst::Format::Time segment event later when needed // 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 true
} }
EventView::FlushStop(_) => { EventView::FlushStop(_) => {
@ -921,9 +918,9 @@ impl MccParse {
pad.event_default(Some(element), event) pad.event_default(Some(element), event)
} }
EventView::Eos(_) => { EventView::Eos(_) => {
gst_log!(CAT, obj: pad, "Draining"); gst::log!(CAT, obj: pad, "Draining");
if let Err(err) = self.handle_buffer(element, None, false) { 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) pad.event_default(Some(element), event)
} }
@ -932,7 +929,7 @@ impl MccParse {
&& !self.srcpad.has_current_caps() && !self.srcpad.has_current_caps()
&& event.type_() > gst::EventType::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(); let mut state = self.state.lock().unwrap();
state.pending_events.push(event); state.pending_events.push(event);
true true
@ -945,7 +942,7 @@ impl MccParse {
fn perform_seek(&self, event: &gst::event::Seek, element: &super::MccParse) -> bool { fn perform_seek(&self, event: &gst::event::Seek, element: &super::MccParse) -> bool {
if self.state.lock().unwrap().pull.is_none() { 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; return false;
} }
@ -954,7 +951,7 @@ impl MccParse {
let mut start: Option<gst::ClockTime> = match start.try_into() { let mut start: Option<gst::ClockTime> = match start.try_into() {
Ok(start) => start, Ok(start) => start,
Err(_) => { Err(_) => {
gst_error!(CAT, obj: element, "seek has invalid format"); gst::error!(CAT, obj: element, "seek has invalid format");
return false; return false;
} }
}; };
@ -962,18 +959,18 @@ impl MccParse {
let mut stop: Option<gst::ClockTime> = match stop.try_into() { let mut stop: Option<gst::ClockTime> = match stop.try_into() {
Ok(stop) => stop, Ok(stop) => stop,
Err(_) => { Err(_) => {
gst_error!(CAT, obj: element, "seek has invalid format"); gst::error!(CAT, obj: element, "seek has invalid format");
return false; return false;
} }
}; };
if !flags.contains(gst::SeekFlags::FLUSH) { 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; return false;
} }
if start_type == gst::SeekType::End || stop_type == gst::SeekType::End { 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; return false;
} }
@ -983,14 +980,14 @@ impl MccParse {
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
.build(); .build();
gst_debug!(CAT, obj: element, "Sending event {:?} upstream", event); gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event);
self.sinkpad.push_event(event); self.sinkpad.push_event(event);
let event = gst::event::FlushStart::builder() let event = gst::event::FlushStart::builder()
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
.build(); .build();
gst_debug!(CAT, obj: element, "Pushing event {:?}", event); gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
self.srcpad.push_event(event); self.srcpad.push_event(event);
let _ = self.sinkpad.pause_task(); let _ = self.sinkpad.pause_task();
@ -1018,7 +1015,7 @@ impl MccParse {
/* Drop our state while we push a serialized event upstream */ /* Drop our state while we push a serialized event upstream */
drop(state); 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); self.sinkpad.push_event(event);
state = self.state.lock().unwrap(); 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 { fn src_event(&self, pad: &gst::Pad, element: &super::MccParse, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Seek(e) => self.perform_seek(e, element), EventView::Seek(e) => self.perform_seek(e, element),
_ => pad.event_default(Some(element), event), _ => pad.event_default(Some(element), event),
@ -1054,7 +1051,7 @@ impl MccParse {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Seeking(q) => { QueryViewMut::Seeking(q) => {
@ -1252,7 +1249,7 @@ impl ElementImpl for MccParse {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { 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::prelude::*;
use gst::structure; use gst::structure;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_error, gst_log, gst_trace};
use gst_video::{self, ValidVideoTimeCode}; use gst_video::{self, ValidVideoTimeCode};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -255,13 +254,13 @@ impl SccEnc {
element: &super::SccEnc, element: &super::SccEnc,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 mut state = self.state.lock().unwrap();
let res = state.generate_caption(element, buffer)?; let res = state.generate_caption(element, buffer)?;
if let Some(outbuf) = res { 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); drop(state);
self.srcpad.push(outbuf)?; self.srcpad.push(outbuf)?;
@ -273,7 +272,7 @@ impl SccEnc {
fn sink_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool { fn sink_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(ev) => { EventView::Caps(ev) => {
@ -282,7 +281,7 @@ impl SccEnc {
let framerate = match s.get::<gst::Fraction>("framerate") { let framerate = match s.get::<gst::Fraction>("framerate") {
Ok(framerate) => Some(framerate), Ok(framerate) => Some(framerate),
Err(structure::GetError::FieldNotFound { .. }) => { Err(structure::GetError::FieldNotFound { .. }) => {
gst_error!(CAT, obj: pad, "Caps without framerate"); gst::error!(CAT, obj: pad, "Caps without framerate");
return false; return false;
} }
err => panic!("SccEnc::sink_event caps: {:?}", err), err => panic!("SccEnc::sink_event caps: {:?}", err),
@ -301,15 +300,15 @@ impl SccEnc {
let outbuf = state.write_line(element); let outbuf = state.write_line(element);
if let Ok(Some(buffer)) = outbuf { 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); drop(state);
if self.srcpad.push(buffer).is_err() { 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; return false;
} }
} else if let Err(err) = outbuf { } 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; return false;
} }
pad.event_default(Some(element), event) 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 { fn src_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Seek(_) => { EventView::Seek(_) => {
gst_log!(CAT, obj: pad, "Dropping seek event"); gst::log!(CAT, obj: pad, "Dropping seek event");
false false
} }
_ => pad.event_default(Some(element), event), _ => pad.event_default(Some(element), event),
@ -339,7 +338,7 @@ impl SccEnc {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Seeking(q) => { QueryViewMut::Seeking(q) => {
@ -512,7 +511,7 @@ impl ElementImpl for SccEnc {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused => { gst::StateChange::ReadyToPaused => {

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

@ -10,10 +10,7 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{ use gst::{element_error, loggable_error};
element_error, gst_debug, gst_error, gst_fixme, gst_info, gst_log, gst_trace, gst_warning,
loggable_error,
};
use std::cmp; use std::cmp;
use std::sync::{Mutex, MutexGuard}; use std::sync::{Mutex, MutexGuard};
@ -164,7 +161,7 @@ impl State {
gst::FlowError::Error gst::FlowError::Error
})?; })?;
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Invalid timecode {:?}, using previous {:?}", "Invalid timecode {:?}, using previous {:?}",
@ -192,7 +189,7 @@ impl State {
{ {
self.last_position = Some(nsecs); self.last_position = Some(nsecs);
} else { } else {
gst_fixme!( gst::fixme!(
CAT, CAT,
obj: element, obj: element,
"New position {} < last position {}", "New position {} < last position {}",
@ -256,7 +253,7 @@ impl State {
self.framerate = Some(framerate); self.framerate = Some(framerate);
events.push(gst::event::Caps::new(&caps)); 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)?; state = self.handle_line(tc, data, element, state)?;
} }
Ok(Some(line)) => { Ok(Some(line)) => {
gst_debug!(CAT, obj: element, "Got line '{:?}'", line); gst::debug!(CAT, obj: element, "Got line '{:?}'", line);
} }
Err((line, err)) => { Err((line, err)) => {
element_error!( element_error!(
@ -342,7 +339,7 @@ impl SccParse {
element: &super::SccParse, element: &super::SccParse,
mut state: MutexGuard<State>, mut state: MutexGuard<State>,
) -> Result<MutexGuard<State>, gst::FlowError> { ) -> Result<MutexGuard<State>, gst::FlowError> {
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Got caption buffer with timecode {:?} and size {}", "Got caption buffer with timecode {:?} and size {}",
@ -370,7 +367,7 @@ impl SccParse {
end_timecode.add_frames(num_bufs + 1); end_timecode.add_frames(num_bufs + 1);
let stop_time = end_timecode.time_since_daily_jam(); let stop_time = end_timecode.time_since_daily_jam();
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Checking inside of segment, line start {} line stop {} segment start {} num bufs {}", "Checking inside of segment, line start {} line stop {} segment start {} num bufs {}",
@ -417,7 +414,7 @@ impl SccParse {
if clip_buffers { if clip_buffers {
let end_time = buffer.pts().opt_add(buffer.duration()); let end_time = buffer.pts().opt_add(buffer.duration());
if end_time.opt_lt(segment_start).unwrap_or(false) { if end_time.opt_lt(segment_start).unwrap_or(false) {
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Skip segment clipped buffer {:?}", "Skip segment clipped buffer {:?}",
@ -452,12 +449,12 @@ impl SccParse {
drop(state); drop(state);
for event in events { 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_event(event);
} }
self.srcpad.push_list(buffers).map_err(|err| { 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 err
})?; })?;
@ -480,18 +477,18 @@ impl SccParse {
state.pull = None; state.pull = None;
if !pad.peer_query(&mut query) { 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 gst::PadMode::Push
} else if query } else if query
.has_scheduling_mode_with_flags(gst::PadMode::Pull, gst::SchedulingFlags::SEEKABLE) .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)); state.pull = Some(PullState::new(element, &self.srcpad));
gst::PadMode::Pull gst::PadMode::Pull
} else { } else {
gst_debug!(CAT, obj: pad, "Activating in Push mode"); gst::debug!(CAT, obj: pad, "Activating in Push mode");
gst::PadMode::Push gst::PadMode::Push
} }
}; };
@ -545,7 +542,7 @@ impl SccParse {
&self, &self,
element: &super::SccParse, element: &super::SccParse,
) -> Result<Option<gst_video::ValidVideoTimeCode>, gst::LoggableError> { ) -> 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 */ /* First let's query the bytes duration upstream */
let mut q = gst::query::Duration::new(gst::Format::Bytes); let mut q = gst::query::Duration::new(gst::Format::Bytes);
@ -614,7 +611,7 @@ impl SccParse {
} }
if last_tc.is_some() || offset == 0 { if last_tc.is_some() || offset == 0 {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Duration scan done, last_tc: {:?}", "Duration scan done, last_tc: {:?}",
@ -645,7 +642,7 @@ impl SccParse {
drop(state); drop(state);
for event in events { 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_event(event);
} }
} }
@ -669,13 +666,13 @@ impl SccParse {
Ok(buffer) => Some(buffer), Ok(buffer) => Some(buffer),
Err(gst::FlowError::Eos) => None, Err(gst::FlowError::Eos) => None,
Err(gst::FlowError::Flushing) => { 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(); let _ = self.sinkpad.pause_task();
return; return;
} }
Err(flow) => { 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_error!(
element, element,
@ -719,17 +716,17 @@ impl SccParse {
Err(flow) => { Err(flow) => {
match flow { match flow {
gst::FlowError::Flushing => { gst::FlowError::Flushing => {
gst_debug!(CAT, obj: element, "Pausing after flow {:?}", flow); gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow);
} }
gst::FlowError::Eos => { gst::FlowError::Eos => {
self.push_eos(element); 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); 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_error!(
element, element,
@ -750,7 +747,7 @@ impl SccParse {
element: &super::SccParse, element: &super::SccParse,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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)) 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 { fn sink_event(&self, pad: &gst::Pad, element: &super::SccParse, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(_) => { EventView::Caps(_) => {
// We send a proper caps event from the chain function later // 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 true
} }
EventView::Segment(_) => { EventView::Segment(_) => {
// We send a gst::Format::Time segment event later when needed // 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 true
} }
EventView::FlushStop(_) => { EventView::FlushStop(_) => {
@ -796,9 +793,9 @@ impl SccParse {
pad.event_default(Some(element), event) pad.event_default(Some(element), event)
} }
EventView::Eos(_) => { EventView::Eos(_) => {
gst_log!(CAT, obj: pad, "Draining"); gst::log!(CAT, obj: pad, "Draining");
if let Err(err) = self.handle_buffer(element, None) { 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) pad.event_default(Some(element), event)
} }
@ -807,7 +804,7 @@ impl SccParse {
&& !self.srcpad.has_current_caps() && !self.srcpad.has_current_caps()
&& event.type_() > gst::EventType::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(); let mut state = self.state.lock().unwrap();
state.pending_events.push(event); state.pending_events.push(event);
true true
@ -820,7 +817,7 @@ impl SccParse {
fn perform_seek(&self, event: &gst::event::Seek, element: &super::SccParse) -> bool { fn perform_seek(&self, event: &gst::event::Seek, element: &super::SccParse) -> bool {
if self.state.lock().unwrap().pull.is_none() { 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; return false;
} }
@ -829,7 +826,7 @@ impl SccParse {
let mut start: Option<gst::ClockTime> = match start.try_into() { let mut start: Option<gst::ClockTime> = match start.try_into() {
Ok(start) => start, Ok(start) => start,
Err(_) => { Err(_) => {
gst_error!(CAT, obj: element, "seek has invalid format"); gst::error!(CAT, obj: element, "seek has invalid format");
return false; return false;
} }
}; };
@ -837,18 +834,18 @@ impl SccParse {
let mut stop: Option<gst::ClockTime> = match stop.try_into() { let mut stop: Option<gst::ClockTime> = match stop.try_into() {
Ok(stop) => stop, Ok(stop) => stop,
Err(_) => { Err(_) => {
gst_error!(CAT, obj: element, "seek has invalid format"); gst::error!(CAT, obj: element, "seek has invalid format");
return false; return false;
} }
}; };
if !flags.contains(gst::SeekFlags::FLUSH) { 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; return false;
} }
if start_type == gst::SeekType::End || stop_type == gst::SeekType::End { 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; return false;
} }
@ -858,14 +855,14 @@ impl SccParse {
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
.build(); .build();
gst_debug!(CAT, obj: element, "Sending event {:?} upstream", event); gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event);
self.sinkpad.push_event(event); self.sinkpad.push_event(event);
let event = gst::event::FlushStart::builder() let event = gst::event::FlushStart::builder()
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
.build(); .build();
gst_debug!(CAT, obj: element, "Pushing event {:?}", event); gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
self.srcpad.push_event(event); self.srcpad.push_event(event);
let _ = self.sinkpad.pause_task(); let _ = self.sinkpad.pause_task();
@ -893,7 +890,7 @@ impl SccParse {
/* Drop our state while we push a serialized event upstream */ /* Drop our state while we push a serialized event upstream */
drop(state); 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); self.sinkpad.push_event(event);
state = self.state.lock().unwrap(); 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 { fn src_event(&self, pad: &gst::Pad, element: &super::SccParse, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Seek(e) => self.perform_seek(e, element), EventView::Seek(e) => self.perform_seek(e, element),
_ => pad.event_default(Some(element), event), _ => pad.event_default(Some(element), event),
@ -929,7 +926,7 @@ impl SccParse {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Seeking(q) => { QueryViewMut::Seeking(q) => {
@ -1112,7 +1109,7 @@ impl ElementImpl for SccParse {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_log, gst_trace};
use std::sync::Mutex; use std::sync::Mutex;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -85,7 +84,7 @@ impl TranscriberBin {
element: &super::TranscriberBin, element: &super::TranscriberBin,
state: &mut State, state: &mut State,
) -> Result<(), Error> { ) -> 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 aqueue_transcription = gst::ElementFactory::make("queue", Some("transqueue"))?;
let ccconverter = gst::ElementFactory::make("ccconverter", None)?; let ccconverter = gst::ElementFactory::make("ccconverter", None)?;
@ -263,7 +262,7 @@ impl TranscriberBin {
let passthrough = self.settings.lock().unwrap().passthrough; let passthrough = self.settings.lock().unwrap().passthrough;
if 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(); let bin_sink_pad = state.transcription_bin.static_pad("sink").unwrap();
if let Some(audio_tee_pad) = bin_sink_pad.peer() { 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) { fn setup_cc_mode(&self, element: &super::TranscriberBin, state: &State) {
let mode = self.settings.lock().unwrap().mode; 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); state.tttocea608.set_property("mode", mode);
@ -353,7 +352,7 @@ impl TranscriberBin {
element: &super::TranscriberBin, element: &super::TranscriberBin,
old_transcriber: &gst::Element, old_transcriber: &gst::Element,
) -> Result<(), Error> { ) -> Result<(), Error> {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Relinking transcriber, old: {:?}, new: {:?}", "Relinking transcriber, old: {:?}, new: {:?}",
@ -386,7 +385,7 @@ impl TranscriberBin {
) -> bool { ) -> bool {
use gst::QueryViewMut; use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query); gst::log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() { match query.view_mut() {
QueryViewMut::Latency(q) => { QueryViewMut::Latency(q) => {
@ -463,7 +462,7 @@ impl TranscriberBin {
) -> bool { ) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(e) => { EventView::Caps(e) => {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
@ -481,7 +480,7 @@ impl TranscriberBin {
} }
if !had_framerate { if !had_framerate {
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Received video caps, setting up transcription" "Received video caps, setting up transcription"
@ -666,7 +665,7 @@ impl ObjectImpl for TranscriberBin {
match self.relink_transcriber(state, obj, &old_transcriber) { match self.relink_transcriber(state, obj, &old_transcriber) {
Ok(()) => (), Ok(()) => (),
Err(err) => { Err(err) => {
gst_error!(CAT, "invalid transcriber: {}", err); gst::error!(CAT, "invalid transcriber: {}", err);
drop(s); drop(s);
*self.state.lock().unwrap() = None; *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(mut state) => match self.construct_internal_bin(obj, &mut state) {
Ok(()) => Some(state), Ok(()) => Some(state),
Err(err) => { Err(err) => {
gst_error!(CAT, "Failed to build internal bin: {}", err); gst::error!(CAT, "Failed to build internal bin: {}", err);
None None
} }
}, },
Err(err) => { Err(err) => {
gst_error!(CAT, "Failed to build state: {}", err); gst::error!(CAT, "Failed to build state: {}", err);
None None
} }
} }
@ -804,7 +803,7 @@ impl ElementImpl for TranscriberBin {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused => { gst::StateChange::ReadyToPaused => {
@ -812,7 +811,7 @@ impl ElementImpl for TranscriberBin {
if let Some(ref mut state) = state.as_mut() { if let Some(ref mut state) = state.as_mut() {
if state.framerate.is_some() { if state.framerate.is_some() {
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Received video caps, setting up transcription" "Received video caps, setting up transcription"
@ -846,7 +845,7 @@ impl BinImpl for TranscriberBin {
if let Some(state) = s.as_ref() { if let Some(state) = s.as_ref() {
if msg.src().as_ref() == Some(state.transcriber.upcast_ref()) { if msg.src().as_ref() == Some(state.transcriber.upcast_ref()) {
gst_error!( gst::error!(
CAT, CAT,
obj: bin, obj: bin,
"Transcriber has posted an error ({:?}), going back to passthrough", "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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace, gst_warning};
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -160,7 +159,7 @@ fn cc_data_buffer(
let data = cc_data.to_be_bytes(); let data = cc_data.to_be_bytes();
if cc_data != 0x8080 { if cc_data != 0x8080 {
gst_log!( gst::log!(
CAT, CAT,
obj: element, obj: element,
"{} -> {}: {}", "{} -> {}: {}",
@ -169,7 +168,7 @@ fn cc_data_buffer(
eia608_to_text(cc_data) eia608_to_text(cc_data)
); );
} else { } 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(); buf_mut.copy_from_slice(0, &data).unwrap();
@ -213,7 +212,7 @@ impl State {
if self.last_frame_no < self.max_frame_no { if self.last_frame_no < self.max_frame_no {
self.last_frame_no += 1; self.last_frame_no += 1;
} else { } 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) 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(); let frame_no = pts.mul_div_round(fps_n, fps_d).unwrap().seconds();
if state.last_frame_no == 0 { 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(); 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; let mut prev_char = 0;
for line in &lines.lines { 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 { if let Some(line_row) = line.row {
row = line_row; row = line_row;
} }
if row > 14 { if row > 14 {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Dropping line after 15th row: {:?}", "Dropping line after 15th row: {:?}",
@ -687,7 +686,7 @@ impl TtToCea608 {
let mut cc_data = eia608_from_utf8_1(&encoded); let mut cc_data = eia608_from_utf8_1(&encoded);
if cc_data == 0 { 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; cc_data = *SPACE;
} }
@ -756,7 +755,7 @@ impl TtToCea608 {
} }
} else if col > 31 { } else if col > 31 {
if chars.peek().is_some() { if chars.peek().is_some() {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Dropping characters after 32nd column: {}", "Dropping characters after 32nd column: {}",
@ -805,7 +804,7 @@ impl TtToCea608 {
element: &super::TtToCea608, element: &super::TtToCea608,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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(|| { let pts = buffer.pts().ok_or_else(|| {
gst::element_error!( gst::element_error!(
@ -826,7 +825,7 @@ impl TtToCea608 {
})?; })?;
let data = buffer.map_readable().map_err(|_| { 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 gst::FlowError::Error
})?; })?;
@ -843,7 +842,7 @@ impl TtToCea608 {
match state.json_input { match state.json_input {
false => { false => {
let data = std::str::from_utf8(&data).map_err(|err| { 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 gst::FlowError::Error
})?; })?;
@ -877,7 +876,7 @@ impl TtToCea608 {
} }
true => { true => {
lines = serde_json::from_slice(&data).map_err(|err| { 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 gst::FlowError::Error
})?; })?;
@ -893,7 +892,7 @@ impl TtToCea608 {
} }
fn sink_event(&self, pad: &gst::Pad, element: &super::TtToCea608, event: gst::Event) -> bool { 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; use gst::EventView;
@ -905,7 +904,7 @@ impl TtToCea608 {
}; };
if downstream_caps.is_empty() { if downstream_caps.is_empty() {
gst_error!(CAT, obj: pad, "Empty downstream caps"); gst::error!(CAT, obj: pad, "Empty downstream caps");
return false; return false;
} }
@ -925,7 +924,7 @@ impl TtToCea608 {
let s = upstream_caps.structure(0).unwrap(); let s = upstream_caps.structure(0).unwrap();
state.json_input = s.name() == "application/x-json"; 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); let new_event = gst::event::Caps::new(&downstream_caps);
@ -946,7 +945,7 @@ impl TtToCea608 {
if state.last_frame_no == 0 { if state.last_frame_no == 0 {
state.last_frame_no = timestamp.mul_div_floor(fps_n, fps_d).unwrap().seconds(); state.last_frame_no = timestamp.mul_div_floor(fps_n, fps_d).unwrap().seconds();
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Initial skip to frame no {}", "Initial skip to frame no {}",
@ -1213,7 +1212,7 @@ impl ElementImpl for TtToCea608 {
element: &Self::Type, element: &Self::Type,
transition: gst::StateChange, transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> { ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst_trace!(CAT, obj: element, "Changing state {:?}", transition); gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
match transition { match transition {
gst::StateChange::ReadyToPaused => { gst::StateChange::ReadyToPaused => {

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

@ -7,7 +7,6 @@
// SPDX-License-Identifier: MPL-2.0 // SPDX-License-Identifier: MPL-2.0
use gst::glib; use gst::glib;
use gst::gst_log;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::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 { fn sink_event(&self, pad: &gst::Pad, element: &super::TtToJson, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Caps(_) => { EventView::Caps(_) => {

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

@ -11,7 +11,6 @@
use gst::glib; use gst::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_info, gst_trace, gst_warning};
use gst_video::prelude::*; use gst_video::prelude::*;
use gst_video::subclass::prelude::*; use gst_video::subclass::prelude::*;
@ -60,7 +59,7 @@ impl Dav1dDec {
(dav1d::PixelLayout::I422, _) => "I422", (dav1d::PixelLayout::I422, _) => "I422",
(dav1d::PixelLayout::I444, _) => "Y444", (dav1d::PixelLayout::I444, _) => "Y444",
(layout, bpc) => { (layout, bpc) => {
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Unsupported dav1d format {:?}/{:?}", "Unsupported dav1d format {:?}/{:?}",
@ -90,7 +89,7 @@ impl Dav1dDec {
} }
}; };
f.parse::<gst_video::VideoFormat>().unwrap_or_else(|_| { 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 gst_video::VideoFormat::Unknown
}) })
} }
@ -121,7 +120,7 @@ impl Dav1dDec {
return Ok(state_guard); return Ok(state_guard);
} }
gst_info!( gst::info!(
CAT, CAT,
obj: element, obj: element,
"Negotiating format {:?} picture dimensions {}x{}", "Negotiating format {:?} picture dimensions {}x{}",
@ -146,7 +145,7 @@ impl Dav1dDec {
} }
fn flush_decoder(&self, element: &super::Dav1dDec, state_guard: &mut Option<State>) { 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(); let state = state_guard.as_mut().unwrap();
state.decoder.flush(); state.decoder.flush();
@ -159,7 +158,7 @@ impl Dav1dDec {
input_buffer: gst::Buffer, input_buffer: gst::Buffer,
frame: gst_video::VideoCodecFrame, frame: gst_video::VideoCodecFrame,
) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> { ) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> {
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Sending data to decoder for frame {}", "Sending data to decoder for frame {}",
@ -182,15 +181,15 @@ impl Dav1dDec {
.send_data(input_data, frame_number, timestamp, duration) .send_data(input_data, frame_number, timestamp, duration)
{ {
Ok(()) => { Ok(()) => {
gst_trace!(CAT, obj: element, "Decoder returned OK"); gst::trace!(CAT, obj: element, "Decoder returned OK");
Ok(std::ops::ControlFlow::Break(())) Ok(std::ops::ControlFlow::Break(()))
} }
Err(err) if err.is_again() => { 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(())) Ok(std::ops::ControlFlow::Continue(()))
} }
Err(err) => { Err(err) => {
gst_error!(CAT, "Sending data failed (error code: {})", err); gst::error!(CAT, "Sending data failed (error code: {})", err);
element.release_frame(frame); element.release_frame(frame);
return gst_video::video_decoder_error!( return gst_video::video_decoder_error!(
element, element,
@ -208,21 +207,21 @@ impl Dav1dDec {
element: &super::Dav1dDec, element: &super::Dav1dDec,
state_guard: &mut AtomicRefMut<Option<State>>, state_guard: &mut AtomicRefMut<Option<State>>,
) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> { ) -> 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(); let state = state_guard.as_mut().unwrap();
match state.decoder.send_pending_data() { match state.decoder.send_pending_data() {
Ok(()) => { Ok(()) => {
gst_trace!(CAT, obj: element, "Decoder returned OK"); gst::trace!(CAT, obj: element, "Decoder returned OK");
Ok(std::ops::ControlFlow::Break(())) Ok(std::ops::ControlFlow::Break(()))
} }
Err(err) if err.is_again() => { 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(())) Ok(std::ops::ControlFlow::Continue(()))
} }
Err(err) => { 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!( return gst_video::video_decoder_error!(
element, element,
1, 1,
@ -274,7 +273,7 @@ impl Dav1dDec {
let mem = if video_meta_supported || src_stride == dest_stride { let mem = if video_meta_supported || src_stride == dest_stride {
gst::Memory::from_slice(plane) gst::Memory::from_slice(plane)
} else { } else {
gst_trace!( gst::trace!(
gst::CAT_PERFORMANCE, gst::CAT_PERFORMANCE,
obj: element, obj: element,
"Copying decoded video frame component {:?}", "Copying decoded video frame component {:?}",
@ -335,7 +334,7 @@ impl Dav1dDec {
mut state_guard: AtomicRefMut<'s, Option<State>>, mut state_guard: AtomicRefMut<'s, Option<State>>,
pic: &dav1d::Picture, pic: &dav1d::Picture,
) -> Result<AtomicRefMut<'s, Option<State>>, gst::FlowError> { ) -> 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)?; state_guard = self.handle_resolution_change(element, state_guard, pic)?;
@ -352,14 +351,14 @@ impl Dav1dDec {
element.finish_frame(frame)?; element.finish_frame(frame)?;
Ok(self.state.borrow_mut()) Ok(self.state.borrow_mut())
} else { } 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) Ok(state_guard)
} }
} }
fn drop_decoded_pictures(&self, element: &super::Dav1dDec, state_guard: &mut Option<State>) { fn drop_decoded_pictures(&self, element: &super::Dav1dDec, state_guard: &mut Option<State>) {
while let Ok(Some(pic)) = self.pending_pictures(element, state_guard) { 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); drop(pic);
} }
} }
@ -369,21 +368,21 @@ impl Dav1dDec {
element: &super::Dav1dDec, element: &super::Dav1dDec,
state_guard: &mut Option<State>, state_guard: &mut Option<State>,
) -> Result<Option<dav1d::Picture>, gst::FlowError> { ) -> 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(); let state = state_guard.as_mut().unwrap();
match state.decoder.get_picture() { match state.decoder.get_picture() {
Ok(pic) => { Ok(pic) => {
gst_trace!(CAT, obj: element, "Retrieved picture {}", pic.offset()); gst::trace!(CAT, obj: element, "Retrieved picture {}", pic.offset());
Ok(Some(pic)) Ok(Some(pic))
} }
Err(err) if err.is_again() => { 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) Ok(None)
} }
Err(err) => { Err(err) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Retrieving decoded picture failed (error code {})", "Retrieving decoded picture failed (error code {})",
@ -598,7 +597,7 @@ impl VideoDecoderImpl for Dav1dDec {
} }
fn flush(&self, element: &Self::Type) -> bool { 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(); 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> { 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(); 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> { 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(); 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"); .expect("Could not map input buffer for read");
let decoded_frame = decoder.decode_frame(input_buffer.as_slice()).map_err(|e| { 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 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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_log, gst_trace, gst_warning};
use num_rational::Rational32; use num_rational::Rational32;
@ -317,10 +316,10 @@ impl FlvDemux {
// gst::SchedulingFlags::SEEKABLE, // gst::SchedulingFlags::SEEKABLE,
// ) // )
// { // {
// gst_debug!(CAT, obj: pad, "Activating in Pull mode"); // gst::debug!(CAT, obj: pad, "Activating in Pull mode");
// gst::PadMode::Pull // gst::PadMode::Pull
// } else { // } else {
gst_debug!(CAT, obj: pad, "Activating in Push mode"); gst::debug!(CAT, obj: pad, "Activating in Push mode");
gst::PadMode::Push gst::PadMode::Push
// } // }
}; };
@ -378,7 +377,7 @@ impl FlvDemux {
fn sink_event(&self, pad: &gst::Pad, element: &super::FlvDemux, event: gst::Event) -> bool { fn sink_event(&self, pad: &gst::Pad, element: &super::FlvDemux, event: gst::Event) -> bool {
use gst::EventView; use gst::EventView;
gst_log!(CAT, obj: pad, "Handling event {:?}", event); gst::log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() { match event.view() {
EventView::Eos(..) => { EventView::Eos(..) => {
// TODO implement // TODO implement
@ -471,7 +470,7 @@ impl FlvDemux {
element: &super::FlvDemux, element: &super::FlvDemux,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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(); let mut adapter = self.adapter.lock().unwrap();
adapter.push(buffer); adapter.push(buffer);
@ -484,7 +483,7 @@ impl FlvDemux {
let header = match self.find_header(element, &mut *adapter) { let header = match self.find_header(element, &mut *adapter) {
Ok(header) => header, Ok(header) => header,
Err(_) => { Err(_) => {
gst_trace!(CAT, obj: element, "Need more data"); gst::trace!(CAT, obj: element, "Need more data");
return Ok(gst::FlowSuccess::Ok); return Ok(gst::FlowSuccess::Ok);
} }
}; };
@ -513,7 +512,7 @@ impl FlvDemux {
} => { } => {
let avail = adapter.available(); let avail = adapter.available();
if avail == 0 { if avail == 0 {
gst_trace!(CAT, obj: element, "Need more data"); gst::trace!(CAT, obj: element, "Need more data");
return Ok(gst::FlowSuccess::Ok); return Ok(gst::FlowSuccess::Ok);
} }
let skip = cmp::min(avail, *skip_left as usize); let skip = cmp::min(avail, *skip_left as usize);
@ -525,7 +524,7 @@ impl FlvDemux {
match res { match res {
Ok(None) => { Ok(None) => {
gst_trace!(CAT, obj: element, "Need more data"); gst::trace!(CAT, obj: element, "Need more data");
return Ok(gst::FlowSuccess::Ok); return Ok(gst::FlowSuccess::Ok);
} }
Ok(Some(events)) => { Ok(Some(events)) => {
@ -556,7 +555,7 @@ impl FlvDemux {
let data = adapter.map(9).unwrap(); let data = adapter.map(9).unwrap();
if let Ok((_, header)) = flavors::header(&*data) { 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); drop(data);
adapter.flush(9); adapter.flush(9);
@ -618,7 +617,7 @@ impl FlvDemux {
if let Some(pad) = pad { if let Some(pad) = pad {
let res = pad.push(buffer); let res = pad.push(buffer);
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Pushing buffer for stream {:?} returned {:?}", "Pushing buffer for stream {:?} returned {:?}",
@ -710,7 +709,7 @@ impl StreamingState {
match be_u32::<_, (_, nom::error::ErrorKind)>(&data[0..4]) { match be_u32::<_, (_, nom::error::ErrorKind)>(&data[0..4]) {
Err(_) => unreachable!(), Err(_) => unreachable!(),
Ok((_, previous_size)) => { 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 // Nothing to do here, we just consume it for now
} }
} }
@ -726,7 +725,7 @@ impl StreamingState {
Ok((_, tag_header)) => tag_header, 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); drop(data);
@ -738,17 +737,17 @@ impl StreamingState {
match tag_header.tag_type { match tag_header.tag_type {
flavors::TagType::Script => { 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)) Ok(self.handle_script_tag(element, &tag_header, adapter))
} }
flavors::TagType::Audio => { 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) self.handle_audio_tag(element, &tag_header, adapter)
} }
flavors::TagType::Video => { 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) self.handle_video_tag(element, &tag_header, adapter)
} }
@ -770,10 +769,10 @@ impl StreamingState {
match flavors::script_data(&*data) { match flavors::script_data(&*data) {
Ok((_, ref script_data)) if script_data.name == "onMetaData" => { 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); 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 let audio_changed = self
.audio .audio
@ -801,10 +800,10 @@ impl StreamingState {
} }
} }
Ok((_, ref script_data)) => { 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)) => { 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(_)) => { Err(nom::Err::Incomplete(_)) => {
// ignore // ignore
@ -824,7 +823,7 @@ impl StreamingState {
) -> SmallVec<[Event; 4]> { ) -> SmallVec<[Event; 4]> {
let mut events = SmallVec::new(); let mut events = SmallVec::new();
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Got audio data header: {:?}", "Got audio data header: {:?}",
@ -835,7 +834,7 @@ impl StreamingState {
AudioFormat::new(data_header, &self.metadata, &self.aac_sequence_header); AudioFormat::new(data_header, &self.metadata, &self.aac_sequence_header);
if self.audio.as_ref() != Some(&new_audio_format) { if self.audio.as_ref() != Some(&new_audio_format) {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Got new audio format: {:?}", "Got new audio format: {:?}",
@ -853,7 +852,7 @@ impl StreamingState {
if (!self.expect_video || self.video != None) && self.audio != None && !self.got_all_streams 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; self.got_all_streams = true;
events.push(Event::HaveAllStreams); events.push(Event::HaveAllStreams);
} }
@ -870,7 +869,7 @@ impl StreamingState {
// Not big enough for the AAC packet header, ship! // Not big enough for the AAC packet header, ship!
if tag_header.data_size < 1 + 1 { if tag_header.data_size < 1 + 1 {
adapter.flush((tag_header.data_size - 1) as usize); adapter.flush((tag_header.data_size - 1) as usize);
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Too small packet for AAC packet header {}", "Too small packet for AAC packet header {}",
@ -883,7 +882,7 @@ impl StreamingState {
match flavors::aac_audio_packet_header(&*data) { match flavors::aac_audio_packet_header(&*data) {
Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Invalid AAC audio packet header: {:?}", "Invalid AAC audio packet header: {:?}",
@ -895,7 +894,7 @@ impl StreamingState {
} }
Err(nom::Err::Incomplete(_)) => unreachable!(), Err(nom::Err::Incomplete(_)) => unreachable!(),
Ok((_, header)) => { 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 { match header.packet_type {
flavors::AACPacketType::SequenceHeader => { flavors::AACPacketType::SequenceHeader => {
drop(data); drop(data);
@ -903,7 +902,7 @@ impl StreamingState {
let buffer = adapter let buffer = adapter
.take_buffer((tag_header.data_size - 1 - 1) as usize) .take_buffer((tag_header.data_size - 1 - 1) as usize)
.unwrap(); .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); self.aac_sequence_header = Some(buffer);
Ok(true) Ok(true)
@ -929,7 +928,7 @@ impl StreamingState {
let data = adapter.map(1).unwrap(); let data = adapter.map(1).unwrap();
let data_header = match flavors::audio_data_header(&*data) { let data_header = match flavors::audio_data_header(&*data) {
Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { 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); drop(data);
adapter.flush(tag_header.data_size as usize); adapter.flush(tag_header.data_size as usize);
return Ok(SmallVec::new()); return Ok(SmallVec::new());
@ -972,7 +971,7 @@ impl StreamingState {
buffer.set_pts(gst::ClockTime::from_mseconds(tag_header.timestamp as u64)); buffer.set_pts(gst::ClockTime::from_mseconds(tag_header.timestamp as u64));
} }
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Outputting audio buffer {:?} for tag {:?}", "Outputting audio buffer {:?} for tag {:?}",
@ -994,7 +993,7 @@ impl StreamingState {
) -> SmallVec<[Event; 4]> { ) -> SmallVec<[Event; 4]> {
let mut events = SmallVec::new(); let mut events = SmallVec::new();
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Got video data header: {:?}", "Got video data header: {:?}",
@ -1005,7 +1004,7 @@ impl StreamingState {
VideoFormat::new(data_header, &self.metadata, &self.avc_sequence_header); VideoFormat::new(data_header, &self.metadata, &self.avc_sequence_header);
if self.video.as_ref() != Some(&new_video_format) { if self.video.as_ref() != Some(&new_video_format) {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Got new video format: {:?}", "Got new video format: {:?}",
@ -1023,7 +1022,7 @@ impl StreamingState {
if (!self.expect_audio || self.audio != None) && self.video != None && !self.got_all_streams 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; self.got_all_streams = true;
events.push(Event::HaveAllStreams); events.push(Event::HaveAllStreams);
} }
@ -1040,7 +1039,7 @@ impl StreamingState {
// Not big enough for the AVC packet header, skip! // Not big enough for the AVC packet header, skip!
if tag_header.data_size < 1 + 4 { if tag_header.data_size < 1 + 4 {
adapter.flush((tag_header.data_size - 1) as usize); adapter.flush((tag_header.data_size - 1) as usize);
gst_warning!( gst::warning!(
CAT, CAT,
obj: element, obj: element,
"Too small packet for AVC packet header {}", "Too small packet for AVC packet header {}",
@ -1052,7 +1051,7 @@ impl StreamingState {
let data = adapter.map(4).unwrap(); let data = adapter.map(4).unwrap();
match flavors::avc_video_packet_header(&*data) { match flavors::avc_video_packet_header(&*data) {
Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
gst_error!( gst::error!(
CAT, CAT,
obj: element, obj: element,
"Invalid AVC video packet header: {:?}", "Invalid AVC video packet header: {:?}",
@ -1064,7 +1063,7 @@ impl StreamingState {
} }
Err(nom::Err::Incomplete(_)) => unreachable!(), Err(nom::Err::Incomplete(_)) => unreachable!(),
Ok((_, header)) => { 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 { match header.packet_type {
flavors::AVCPacketType::SequenceHeader => { flavors::AVCPacketType::SequenceHeader => {
drop(data); drop(data);
@ -1072,7 +1071,7 @@ impl StreamingState {
let buffer = adapter let buffer = adapter
.take_buffer((tag_header.data_size - 1 - 4) as usize) .take_buffer((tag_header.data_size - 1 - 4) as usize)
.unwrap(); .unwrap();
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Got AVC sequence header {:?} of size {}", "Got AVC sequence header {:?} of size {}",
@ -1110,7 +1109,7 @@ impl StreamingState {
let data = adapter.map(1).unwrap(); let data = adapter.map(1).unwrap();
let data_header = match flavors::video_data_header(&*data) { let data_header = match flavors::video_data_header(&*data) {
Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { 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); drop(data);
adapter.flush(tag_header.data_size as usize); adapter.flush(tag_header.data_size as usize);
return Ok(SmallVec::new()); return Ok(SmallVec::new());
@ -1184,7 +1183,7 @@ impl StreamingState {
buffer.set_pts(gst::ClockTime::from_mseconds(pts)); buffer.set_pts(gst::ClockTime::from_mseconds(pts));
} }
gst_trace!( gst::trace!(
CAT, CAT,
obj: element, obj: element,
"Outputting video buffer {:?} for tag {:?}, keyframe: {}", "Outputting video buffer {:?} for tag {:?}, keyframe: {}",

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

@ -10,7 +10,6 @@
use atomic_refcell::AtomicRefCell; use atomic_refcell::AtomicRefCell;
use gst::glib; use gst::glib;
use gst::gst_debug;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst_video::prelude::*; use gst_video::prelude::*;
use gst_video::subclass::prelude::*; use gst_video::subclass::prelude::*;
@ -290,7 +289,7 @@ impl VideoEncoderImpl for GifEnc {
.map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?; .map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?;
let video_info = state.info(); 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); let mut state = State::new(video_info);
@ -321,7 +320,7 @@ impl VideoEncoderImpl for GifEnc {
let mut state_guard = self.state.borrow_mut(); let mut state_guard = self.state.borrow_mut();
let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?; let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Sending frame {}", "Sending frame {}",
@ -429,7 +428,7 @@ impl VideoEncoderImpl for GifEnc {
impl GifEnc { impl GifEnc {
fn flush_encoder(&self, element: &super::GifEnc) -> Result<gst::FlowSuccess, gst::FlowError> { 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| { let trailer_buffer = self.state.borrow_mut().as_mut().map(|state| {
// Drop encoder to flush and take flushed data (gif trailer) // 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 glib::Sender;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error, gst_trace};
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
use gst_video::subclass::prelude::*; use gst_video::subclass::prelude::*;
@ -92,7 +91,7 @@ impl ObjectImpl for PaintableSink {
let paintable = match &*paintable { let paintable = match &*paintable {
Some(ref paintable) => paintable, Some(ref paintable) => paintable,
None => { 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(); return None::<&gtk::gdk::Paintable>.to_value();
} }
}; };
@ -101,7 +100,7 @@ impl ObjectImpl for PaintableSink {
match paintable.try_get() { match paintable.try_get() {
Ok(paintable) => paintable.to_value(), Ok(paintable) => paintable.to_value(),
Err(_) => { Err(_) => {
gst_error!( gst::error!(
CAT, CAT,
obj: obj, obj: obj,
"Can't retrieve Paintable from non-main thread" "Can't retrieve Paintable from non-main thread"
@ -189,7 +188,7 @@ impl ElementImpl for PaintableSink {
} }
if paintable.is_none() { 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); return Err(gst::StateChangeError);
} }
} }
@ -212,7 +211,7 @@ impl ElementImpl for PaintableSink {
impl BaseSinkImpl for PaintableSink { impl BaseSinkImpl for PaintableSink {
fn set_caps(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> { 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) let video_info = gst_video::VideoInfo::from_caps(caps)
.map_err(|_| gst::loggable_error!(CAT, "Invalid caps"))?; .map_err(|_| gst::loggable_error!(CAT, "Invalid caps"))?;
@ -242,28 +241,28 @@ impl VideoSinkImpl for PaintableSink {
element: &Self::Type, element: &Self::Type,
buffer: &gst::Buffer, buffer: &gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> 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 = self.info.lock().unwrap();
let info = info.as_ref().ok_or_else(|| { 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 gst::FlowError::NotNegotiated
})?; })?;
let frame = Frame::new(buffer, info).map_err(|err| { 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 err
})?; })?;
self.pending_frame.lock().unwrap().replace(frame); self.pending_frame.lock().unwrap().replace(frame);
let sender = self.sender.lock().unwrap(); let sender = self.sender.lock().unwrap();
let sender = sender.as_ref().ok_or_else(|| { 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 gst::FlowError::Error
})?; })?;
sender.send(SinkEvent::FrameChanged).map_err(|_| { 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 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::glib::prelude::*;
use gtk::subclass::prelude::*; use gtk::subclass::prelude::*;
use gst::{gst_debug, gst_trace};
use fragile::Fragile; use fragile::Fragile;
use std::sync::{mpsc, MutexGuard}; use std::sync::{mpsc, MutexGuard};
@ -54,7 +52,7 @@ impl PaintableSink {
&self, &self,
paintable_storage: &mut MutexGuard<Option<Fragile<SinkPaintable>>>, 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(); let context = glib::MainContext::default();
@ -98,7 +96,7 @@ impl PaintableSink {
match action { match action {
SinkEvent::FrameChanged => { 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()) 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::subclass::prelude::*;
use gtk::{gdk, glib, graphene}; use gtk::{gdk, glib, graphene};
use gst::{gst_debug, gst_trace};
use crate::sink::frame::{Frame, Texture}; use crate::sink::frame::{Frame, Texture};
use std::cell::RefCell; use std::cell::RefCell;
@ -77,7 +75,7 @@ impl PaintableImpl for SinkPaintable {
let paintables = self.paintables.borrow(); let paintables = self.paintables.borrow();
if !paintables.is_empty() { if !paintables.is_empty() {
gst_trace!(CAT, obj: paintable, "Snapshotting frame"); gst::trace!(CAT, obj: paintable, "Snapshotting frame");
let (frame_width, frame_height) = let (frame_width, frame_height) =
paintables.first().map(|p| (p.width, p.height)).unwrap(); paintables.first().map(|p| (p.width, p.height)).unwrap();
@ -127,7 +125,7 @@ impl PaintableImpl for SinkPaintable {
snapshot.pop(); snapshot.pop();
} }
} else { } else {
gst_trace!(CAT, obj: paintable, "Snapshotting black frame"); gst::trace!(CAT, obj: paintable, "Snapshotting black frame");
snapshot.append_color( snapshot.append_color(
&gdk::RGBA::BLACK, &gdk::RGBA::BLACK,
&graphene::Rect::new(0f32, 0f32, width as f32, height as f32), &graphene::Rect::new(0f32, 0f32, width as f32, height as f32),
@ -139,7 +137,7 @@ impl PaintableImpl for SinkPaintable {
impl SinkPaintable { impl SinkPaintable {
pub(super) fn handle_frame_changed(&self, obj: &super::SinkPaintable, frame: Option<Frame>) { pub(super) fn handle_frame_changed(&self, obj: &super::SinkPaintable, frame: Option<Frame>) {
if let Some(frame) = 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_paintables = frame.into_textures(&mut *self.cached_textures.borrow_mut());
let new_size = new_paintables 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)); .map(|p| (f32::round(p.width) as u32, f32::round(p.height) as u32));
if Some(new_size) != old_size { if Some(new_size) != old_size {
gst_debug!( gst::debug!(
CAT, CAT,
obj: obj, obj: obj,
"Size changed from {:?} to {:?}", "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::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_info};
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
use gst_video::subclass::prelude::*; use gst_video::subclass::prelude::*;
@ -238,7 +237,7 @@ impl ObjectImpl for HsvDetector {
"hue-ref" => { "hue-ref" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let hue_ref = value.get().expect("type checked upstream"); let hue_ref = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing hue-ref from {} to {}", "Changing hue-ref from {} to {}",
@ -250,7 +249,7 @@ impl ObjectImpl for HsvDetector {
"hue-var" => { "hue-var" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let hue_var = value.get().expect("type checked upstream"); let hue_var = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing hue-var from {} to {}", "Changing hue-var from {} to {}",
@ -262,7 +261,7 @@ impl ObjectImpl for HsvDetector {
"saturation-ref" => { "saturation-ref" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let saturation_ref = value.get().expect("type checked upstream"); let saturation_ref = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing saturation-ref from {} to {}", "Changing saturation-ref from {} to {}",
@ -274,7 +273,7 @@ impl ObjectImpl for HsvDetector {
"saturation-var" => { "saturation-var" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let saturation_var = value.get().expect("type checked upstream"); let saturation_var = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing saturation-var from {} to {}", "Changing saturation-var from {} to {}",
@ -286,7 +285,7 @@ impl ObjectImpl for HsvDetector {
"value-ref" => { "value-ref" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let value_ref = value.get().expect("type checked upstream"); let value_ref = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing value-ref from {} to {}", "Changing value-ref from {} to {}",
@ -298,7 +297,7 @@ impl ObjectImpl for HsvDetector {
"value-var" => { "value-var" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let value_var = value.get().expect("type checked upstream"); let value_var = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing value-var from {} to {}", "Changing value-var from {} to {}",
@ -436,7 +435,7 @@ impl BaseTransformImpl for HsvDetector {
} }
}; };
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Transformed caps from {} to {} in direction {:?}", "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 // SPDX-License-Identifier: MIT/Apache-2.0
use gst::glib; use gst::glib;
use gst::gst_info;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
@ -187,7 +186,7 @@ impl ObjectImpl for HsvFilter {
"hue-shift" => { "hue-shift" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let hue_shift = value.get().expect("type checked upstream"); let hue_shift = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing hue-shift from {} to {}", "Changing hue-shift from {} to {}",
@ -199,7 +198,7 @@ impl ObjectImpl for HsvFilter {
"saturation-mul" => { "saturation-mul" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let saturation_mul = value.get().expect("type checked upstream"); let saturation_mul = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing saturation-mul from {} to {}", "Changing saturation-mul from {} to {}",
@ -211,7 +210,7 @@ impl ObjectImpl for HsvFilter {
"saturation-off" => { "saturation-off" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let saturation_off = value.get().expect("type checked upstream"); let saturation_off = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing saturation-off from {} to {}", "Changing saturation-off from {} to {}",
@ -223,7 +222,7 @@ impl ObjectImpl for HsvFilter {
"value-mul" => { "value-mul" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let value_mul = value.get().expect("type checked upstream"); let value_mul = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing value-mul from {} to {}", "Changing value-mul from {} to {}",
@ -235,7 +234,7 @@ impl ObjectImpl for HsvFilter {
"value-off" => { "value-off" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let value_off = value.get().expect("type checked upstream"); let value_off = value.get().expect("type checked upstream");
gst_info!( gst::info!(
CAT, CAT,
obj: obj, obj: obj,
"Changing value-off from {} to {}", "Changing value-off from {} to {}",

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

@ -10,7 +10,6 @@
use atomic_refcell::AtomicRefCell; use atomic_refcell::AtomicRefCell;
use gst::glib; use gst::glib;
use gst::gst_debug;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst_video::prelude::*; use gst_video::prelude::*;
use gst_video::subclass::prelude::*; use gst_video::subclass::prelude::*;
@ -634,7 +633,7 @@ impl VideoEncoderImpl for Rav1Enc {
.map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?; .map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?;
let video_info = state.info(); 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(); let settings = self.settings.lock().unwrap();
@ -884,13 +883,13 @@ impl VideoEncoderImpl for Rav1Enc {
} }
fn flush(&self, element: &Self::Type) -> bool { 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(); let mut state_guard = self.state.borrow_mut();
if let Some(ref mut state) = *state_guard { if let Some(ref mut state) = *state_guard {
state.context.flush(); state.context.flush();
while let Ok(_) | Err(data::EncoderStatus::Encoded) = state.context.receive_packet() { 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> { 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(); let mut state_guard = self.state.borrow_mut();
if let Some(ref mut state) = *state_guard { if let Some(ref mut state) = *state_guard {
@ -919,7 +918,7 @@ impl VideoEncoderImpl for Rav1Enc {
self.output_frames(element, state)?; self.output_frames(element, state)?;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Sending frame {}", "Sending frame {}",
@ -947,7 +946,7 @@ impl VideoEncoderImpl for Rav1Enc {
.contains(gst_video::VideoCodecFrameFlags::FORCE_KEYFRAME), .contains(gst_video::VideoCodecFrameFlags::FORCE_KEYFRAME),
) { ) {
Ok(_) => { Ok(_) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Sent frame {}", "Sent frame {}",
@ -974,7 +973,7 @@ impl Rav1Enc {
loop { loop {
match state.context.receive_packet() { match state.context.receive_packet() {
Ok((packet_type, packet_number, frame_number, packet_data)) => { Ok((packet_type, packet_number, frame_number, packet_data)) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Received packet {} of size {}, frame type {:?}", "Received packet {} of size {}, frame type {:?}",
@ -993,10 +992,10 @@ impl Rav1Enc {
element.finish_frame(Some(frame))?; element.finish_frame(Some(frame))?;
} }
Err(data::EncoderStatus::Encoded) => { 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) => { 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); return Ok(gst::FlowSuccess::Ok);
} }
Err(data::EncoderStatus::Failure) => { Err(data::EncoderStatus::Failure) => {
@ -1008,7 +1007,7 @@ impl Rav1Enc {
return Err(gst::FlowError::Error); return Err(gst::FlowError::Error);
} }
Err(err) => { Err(err) => {
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Soft error when receiving frame: {:?}", "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::glib;
use gst::prelude::*; use gst::prelude::*;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst::{gst_debug, gst_error};
use gst_video::prelude::*; use gst_video::prelude::*;
use gst_video::subclass::prelude::*; use gst_video::subclass::prelude::*;
@ -129,7 +128,7 @@ impl State {
gst_video::VideoFormat::Rgb => png::ColorType::Rgb, gst_video::VideoFormat::Rgb => png::ColorType::Rgb,
gst_video::VideoFormat::Rgba => png::ColorType::Rgba, gst_video::VideoFormat::Rgba => png::ColorType::Rgba,
_ => { _ => {
gst_error!(CAT, "format is not supported yet"); gst::error!(CAT, "format is not supported yet");
unreachable!() unreachable!()
} }
}; };
@ -310,7 +309,7 @@ impl VideoEncoderImpl for PngEncoder {
state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>, state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>,
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
let video_info = state.info(); 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 settings = self.settings.lock();
let mut state = State::new(video_info); let mut state = State::new(video_info);
@ -334,7 +333,7 @@ impl VideoEncoderImpl for PngEncoder {
let mut state_guard = self.state.lock(); let mut state_guard = self.state.lock();
let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?; let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?;
gst_debug!( gst::debug!(
CAT, CAT,
obj: element, obj: element,
"Sending frame {}", "Sending frame {}",

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

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

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

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