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-12-22 01:56:28 +00:00
Code Issues Projects Releases Wiki Activity

fix-getters-{def,calls} pass

Browse source
This commit is contained in:
François Laignel 2021-04-12 14:49:54 +02:00
parent c3fb55f235
commit 06accc8d98
107 changed files with 936 additions and 1003 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
audio/audiofx/src/audioecho/imp.rs
View file

@ -143,7 +143,7 @@ impl ObjectImpl for AudioEcho {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"max-delay" => { "max-delay" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
if self.state.lock().unwrap().is_none() { if self.state.lock().unwrap().is_none() {
@ -167,7 +167,7 @@ impl ObjectImpl for AudioEcho {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"max-delay" => { "max-delay" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.max_delay.to_value() settings.max_delay.to_value()

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

@ -252,7 +252,7 @@ impl State {
let outbuf = outbuf.get_mut().unwrap(); let outbuf = outbuf.get_mut().unwrap();
outbuf.set_pts(pts); outbuf.set_pts(pts);
outbuf.set_duration( outbuf.set_duration(
(outbuf.get_size() as u64) (outbuf.size() as u64)
.mul_div_floor(gst::SECOND_VAL, (self.info.bpf() * self.info.rate()) as u64) .mul_div_floor(gst::SECOND_VAL, (self.info.bpf() * self.info.rate()) as u64)
.into(), .into(),
); );
@ -309,7 +309,7 @@ impl State {
let outbuf = outbuf.get_mut().unwrap(); let outbuf = outbuf.get_mut().unwrap();
outbuf.set_pts(pts); outbuf.set_pts(pts);
outbuf.set_duration( outbuf.set_duration(
(outbuf.get_size() as u64) (outbuf.size() as u64)
.mul_div_floor(gst::SECOND_VAL, (self.info.bpf() * self.info.rate()) as u64) .mul_div_floor(gst::SECOND_VAL, (self.info.bpf() * self.info.rate()) as u64)
.into(), .into(),
); );
@ -1560,7 +1560,7 @@ impl AudioLoudNorm {
}; };
let mut outbufs = vec![]; let mut outbufs = vec![];
if buffer.get_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) => {
@ -1598,7 +1598,7 @@ impl AudioLoudNorm {
match event.view() { match event.view() {
EventView::Caps(c) => { EventView::Caps(c) => {
let caps = c.get_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) {
@ -1687,7 +1687,7 @@ impl AudioLoudNorm {
QueryView::Latency(ref mut q) => { QueryView::Latency(ref mut q) => {
let mut peer_query = gst::query::Latency::new(); let mut peer_query = gst::query::Latency::new();
if self.sinkpad.peer_query(&mut peer_query) { if self.sinkpad.peer_query(&mut peer_query) {
let (live, min_latency, max_latency) = peer_query.get_result(); let (live, min_latency, max_latency) = peer_query.result();
q.set( q.set(
live, live,
min_latency + 3 * gst::SECOND, min_latency + 3 * gst::SECOND,
@ -1810,7 +1810,7 @@ impl ObjectImpl for AudioLoudNorm {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"loudness-target" => { "loudness-target" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.loudness_target = value.get_some().expect("type checked upstream"); settings.loudness_target = value.get_some().expect("type checked upstream");
@ -1832,7 +1832,7 @@ impl ObjectImpl for AudioLoudNorm {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"loudness-target" => { "loudness-target" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.loudness_target.to_value() settings.loudness_target.to_value()

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

@ -61,7 +61,7 @@ impl State {
gst::ClockTime(samples.mul_div_round(gst::SECOND_VAL, self.in_info.rate() as u64)) gst::ClockTime(samples.mul_div_round(gst::SECOND_VAL, self.in_info.rate() as u64))
} }
fn get_current_pts(&self) -> gst::ClockTime { fn current_pts(&self) -> gst::ClockTime {
// get the last seen pts and the amount of bytes // get the last seen pts and the amount of bytes
// since then // since then
let (prev_pts, distance) = self.adapter.prev_pts(); let (prev_pts, distance) = self.adapter.prev_pts();
@ -137,7 +137,7 @@ impl AudioRNNoise {
})?; })?;
let duration = state.buffer_duration(available as _); let duration = state.buffer_duration(available as _);
let pts = state.get_current_pts(); let pts = state.current_pts();
{ {
let ibuffer = state.adapter.take_buffer(available).unwrap(); let ibuffer = state.adapter.take_buffer(available).unwrap();
@ -167,7 +167,7 @@ impl AudioRNNoise {
let bpf = state.in_info.bpf() as usize; let bpf = state.in_info.bpf() as usize;
let output_size = available - (available % (FRAME_SIZE * bpf)); let output_size = available - (available % (FRAME_SIZE * bpf));
let duration = state.buffer_duration(output_size as _); let duration = state.buffer_duration(output_size as _);
let pts = state.get_current_pts(); let pts = state.current_pts();
let mut buffer = gst::Buffer::with_size(output_size).map_err(|_| gst::FlowError::Error)?; let mut buffer = gst::Buffer::with_size(output_size).map_err(|_| gst::FlowError::Error)?;
@ -307,7 +307,7 @@ impl BaseTransformImpl for AudioRNNoise {
// if it is not the case, just notify the parent class to not generate // if it is not the case, just notify the parent class to not generate
// an output // an output
if let Some(buffer) = self.take_queued_buffer() { if let Some(buffer) = self.take_queued_buffer() {
if buffer.get_flags() == gst::BufferFlags::DISCONT { if buffer.flags() == gst::BufferFlags::DISCONT {
self.drain(element)?; self.drain(element)?;
} }
@ -352,7 +352,7 @@ impl BaseTransformImpl for AudioRNNoise {
let sink_pad = element.get_static_pad("sink").expect("Sink pad not found"); let sink_pad = element.get_static_pad("sink").expect("Sink pad not found");
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.get_result(); let (live, mut min, mut max) = upstream_query.result();
gst_debug!( gst_debug!(
CAT, CAT,
obj: element, obj: element,

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

@ -185,7 +185,7 @@ impl ObjectImpl for EbuR128Level {
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"mode" => { "mode" => {
let mode = value.get_some().expect("type checked upstream"); let mode = value.get_some().expect("type checked upstream");
gst_info!( gst_info!(
@ -225,7 +225,7 @@ impl ObjectImpl for EbuR128Level {
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"mode" => settings.mode.to_value(), "mode" => settings.mode.to_value(),
"post-messages" => settings.post_messages.to_value(), "post-messages" => settings.post_messages.to_value(),
"interval" => settings.interval.to_value(), "interval" => settings.interval.to_value(),
@ -432,8 +432,8 @@ impl BaseTransformImpl for EbuR128Level {
gst::FlowError::NotNegotiated gst::FlowError::NotNegotiated
})?; })?;
let mut timestamp = buf.get_pts(); let mut timestamp = buf.pts();
let segment = element.get_segment().downcast::<gst::ClockTime>().ok(); let segment = element.segment().downcast::<gst::ClockTime>().ok();
let buf = gst_audio::AudioBufferRef::from_buffer_ref_readable(&buf, &state.info).map_err( let buf = gst_audio::AudioBufferRef::from_buffer_ref_readable(&buf, &state.info).map_err(
|_| { |_| {

6
audio/audiofx/tests/audioloudnorm.rs
View file

@ -101,7 +101,7 @@ fn run_test(
pipeline.set_state(gst::State::Playing).unwrap(); pipeline.set_state(gst::State::Playing).unwrap();
let mut eos = false; let mut eos = false;
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
while let Some(msg) = bus.timed_pop(gst::CLOCK_TIME_NONE) { while let Some(msg) = bus.timed_pop(gst::CLOCK_TIME_NONE) {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
@ -131,9 +131,9 @@ fn run_test(
for sample in samples.iter() { for sample in samples.iter() {
use std::cmp::Ordering; use std::cmp::Ordering;
let buf = sample.get_buffer().unwrap(); let buf = sample.buffer().unwrap();
let ts = buf.get_pts(); let ts = buf.pts();
match ts.cmp(&expected_ts) { match ts.cmp(&expected_ts) {
Ordering::Greater => { Ordering::Greater => {
assert!( assert!(

6
audio/audiofx/tests/ebur128level.rs
View file

@ -104,7 +104,7 @@ fn run_test(layout: gst_audio::AudioLayout, format: gst_audio::AudioFormat) {
format.to_str() format.to_str()
)); ));
let bus = gst::Bus::new(); let bus = gst::Bus::new();
h.get_element().unwrap().set_bus(Some(&bus)); h.element().unwrap().set_bus(Some(&bus));
h.play(); h.play();
// Pull all buffers until EOS // Pull all buffers until EOS
@ -118,8 +118,8 @@ fn run_test(layout: gst_audio::AudioLayout, format: gst_audio::AudioFormat) {
while let Some(msg) = bus.pop() { while let Some(msg) = bus.pop() {
match msg.view() { match msg.view() {
gst::MessageView::Element(msg) => { gst::MessageView::Element(msg) => {
let s = msg.get_structure().unwrap(); let s = msg.structure().unwrap();
if s.get_name() == "ebur128-level" { if s.name() == "ebur128-level" {
num_msgs += 1; num_msgs += 1;
let timestamp = s.get_some::<u64>("timestamp").unwrap(); let timestamp = s.get_some::<u64>("timestamp").unwrap();
let running_time = s.get_some::<u64>("running-time").unwrap(); let running_time = s.get_some::<u64>("running-time").unwrap();

6
audio/claxon/tests/claxondec.rs
View file

@ -97,11 +97,11 @@ fn do_test(data: &'static [u8], packet_sizes: &[usize], decoded_samples: &[usize
continue; continue;
} }
let buffer = h.pull().unwrap(); let buffer = h.pull().unwrap();
assert_eq!(buffer.get_size(), 4 * samples); assert_eq!(buffer.size(), 4 * samples);
} }
h.get_sinkpad() h.sinkpad()
.expect("harness has no sinkpad") .expect("harness has no sinkpad")
.get_current_caps() .current_caps()
.expect("pad has no caps") .expect("pad has no caps")
} }

8
audio/csound/examples/effect_example.rs
View file

@ -104,7 +104,7 @@ fn main_loop(pipeline: gst::Pipeline) -> Result<(), Box<dyn Error>> {
pipeline.set_state(gst::State::Playing)?; pipeline.set_state(gst::State::Playing)?;
let bus = pipeline let bus = pipeline
.get_bus() .bus()
.expect("Pipeline without bus. Shouldn't happen!"); .expect("Pipeline without bus. Shouldn't happen!");
for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) { for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) {
@ -115,9 +115,9 @@ fn main_loop(pipeline: gst::Pipeline) -> Result<(), Box<dyn Error>> {
MessageView::Error(err) => { MessageView::Error(err) => {
println!( println!(
"Error from {:?}: {} ({:?})", "Error from {:?}: {} ({:?})",
msg.get_src().map(|s| s.get_path_string()), msg.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
break; break;
} }

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

@ -107,7 +107,7 @@ impl State {
gst::ClockTime(samples.mul_div_round(gst::SECOND_VAL, self.in_info.rate() as u64)) gst::ClockTime(samples.mul_div_round(gst::SECOND_VAL, self.in_info.rate() as u64))
} }
fn get_current_pts(&self) -> gst::ClockTime { fn current_pts(&self) -> gst::ClockTime {
// get the last seen pts and the amount of bytes // get the last seen pts and the amount of bytes
// since then // since then
let (prev_pts, distance) = self.adapter.prev_pts(); let (prev_pts, distance) = self.adapter.prev_pts();
@ -128,8 +128,8 @@ impl State {
impl CsoundFilter { impl CsoundFilter {
fn process(&self, csound: &mut Csound, idata: &[f64], odata: &mut [f64]) -> bool { fn process(&self, csound: &mut Csound, idata: &[f64], odata: &mut [f64]) -> bool {
let spin = csound.get_spin().unwrap(); let spin = csound.spin().unwrap();
let spout = csound.get_spout().unwrap(); let spout = csound.spout().unwrap();
let in_chunks = idata.chunks_exact(spin.len()); let in_chunks = idata.chunks_exact(spin.len());
let out_chuncks = odata.chunks_exact_mut(spout.len()); let out_chuncks = odata.chunks_exact_mut(spout.len());
@ -190,8 +190,8 @@ impl CsoundFilter {
return Ok(gst::FlowSuccess::Ok); return Ok(gst::FlowSuccess::Ok);
} }
let mut spin = csound.get_spin().unwrap(); let mut spin = csound.spin().unwrap();
let spout = csound.get_spout().unwrap(); let spout = csound.spout().unwrap();
let out_bytes = let out_bytes =
(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;
@ -208,7 +208,7 @@ impl CsoundFilter {
let buffer_mut = buffer.get_mut().ok_or(gst::FlowError::NotSupported)?; let buffer_mut = buffer.get_mut().ok_or(gst::FlowError::NotSupported)?;
let pts = state.get_current_pts(); let pts = state.current_pts();
let duration = state.buffer_duration(out_bytes as _); let duration = state.buffer_duration(out_bytes as _);
buffer_mut.set_pts(pts); buffer_mut.set_pts(pts);
@ -255,7 +255,7 @@ impl CsoundFilter {
let mut output = gst::Buffer::with_size(output_size).map_err(|_| gst::FlowError::Error)?; let mut output = gst::Buffer::with_size(output_size).map_err(|_| gst::FlowError::Error)?;
let outbuf = output.get_mut().ok_or(gst::FlowError::Error)?; let outbuf = output.get_mut().ok_or(gst::FlowError::Error)?;
let pts = state.get_current_pts(); let pts = state.current_pts();
let duration = state.buffer_duration(output_size as _); let duration = state.buffer_duration(output_size as _);
outbuf.set_pts(pts); outbuf.set_pts(pts);
@ -387,7 +387,7 @@ impl ObjectImpl for CsoundFilter {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"loop" => { "loop" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.loop_ = value.get_some().expect("type checked upstream"); settings.loop_ = value.get_some().expect("type checked upstream");
@ -419,7 +419,7 @@ impl ObjectImpl for CsoundFilter {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"loop" => { "loop" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.loop_.to_value() settings.loop_.to_value()
@ -547,7 +547,7 @@ impl BaseTransformImpl for CsoundFilter {
if compiled { if compiled {
let csound = self.csound.lock().unwrap(); let csound = self.csound.lock().unwrap();
// Use the sample rate and channels configured in the csound score // Use the sample rate and channels configured in the csound score
let sr = csound.get_sample_rate() as i32; let sr = csound.sample_rate() as i32;
let ichannels = csound.input_channels() as i32; let ichannels = csound.input_channels() as i32;
let ochannels = csound.output_channels() as i32; let ochannels = csound.output_channels() as i32;
for s in new_caps.make_mut().iter_mut() { for s in new_caps.make_mut().iter_mut() {
@ -608,7 +608,7 @@ impl BaseTransformImpl for CsoundFilter {
let rate = in_info.rate(); let rate = in_info.rate();
// Check if the negotiated caps are the right ones // Check if the negotiated caps are the right ones
if rate != out_info.rate() || rate != csound.get_sample_rate() as _ { if rate != out_info.rate() || rate != csound.sample_rate() as _ {
return Err(loggable_error!( return Err(loggable_error!(
CAT, CAT,
"Failed to negotiate caps: invalid sample rate {}", "Failed to negotiate caps: invalid sample rate {}",
@ -628,7 +628,7 @@ impl BaseTransformImpl for CsoundFilter {
)); ));
} }
let ksmps = csound.get_ksmps(); let ksmps = csound.ksmps();
let adapter = gst_base::UniqueAdapter::new(); let adapter = gst_base::UniqueAdapter::new();
@ -651,7 +651,7 @@ impl BaseTransformImpl for CsoundFilter {
// if it is not the case, just notify the parent class to not generate // if it is not the case, just notify the parent class to not generate
// an output // an output
if let Some(buffer) = self.take_queued_buffer() { if let Some(buffer) = self.take_queued_buffer() {
if buffer.get_flags() == gst::BufferFlags::DISCONT { if buffer.flags() == gst::BufferFlags::DISCONT {
self.drain(element)?; self.drain(element)?;
} }

25
audio/csound/tests/csound_filter.rs
View file

@ -147,10 +147,10 @@ fn csound_filter_eos() {
// Checks output buffer timestamp and duration // Checks output buffer timestamp and duration
assert_eq!( assert_eq!(
buffer.as_ref().get_duration(), buffer.as_ref().duration(),
duration_from_samples(in_process_samples, sr as _) duration_from_samples(in_process_samples, sr as _)
); );
assert_eq!(buffer.as_ref().get_pts(), expected_pts); assert_eq!(buffer.as_ref().pts(), expected_pts);
// Get the number of samples that were not processed // Get the number of samples that were not processed
samples_offset = in_samples % ksmps as u64; samples_offset = in_samples % ksmps as u64;
@ -177,7 +177,7 @@ fn csound_filter_eos() {
let samples_at_eos = (EOS_NUM_BUFFERS * EOS_NUM_SAMPLES) % ksmps; let samples_at_eos = (EOS_NUM_BUFFERS * EOS_NUM_SAMPLES) % ksmps;
assert_eq!( assert_eq!(
buffer.as_ref().get_pts(), buffer.as_ref().pts(),
in_pts - duration_from_samples(samples_at_eos as _, sr as _) in_pts - duration_from_samples(samples_at_eos as _, sr as _)
); );
@ -254,10 +254,10 @@ fn csound_filter_underflow() {
for _ in 0..expected_buffers { for _ in 0..expected_buffers {
let buffer = h.pull().unwrap(); let buffer = h.pull().unwrap();
let samples = buffer.get_size() / std::mem::size_of::<f64>(); let samples = buffer.size() / std::mem::size_of::<f64>();
assert_eq!(buffer.as_ref().get_pts(), expected_pts); assert_eq!(buffer.as_ref().pts(), expected_pts);
assert_eq!(buffer.as_ref().get_duration(), expected_duration); assert_eq!(buffer.as_ref().duration(), expected_duration);
assert_eq!(samples, UNDERFLOW_NUM_SAMPLES * 2); assert_eq!(samples, UNDERFLOW_NUM_SAMPLES * 2);
// Output data is produced after 2 input buffers // Output data is produced after 2 input buffers
// so that, the next output buffer's PTS should be // so that, the next output buffer's PTS should be
@ -329,18 +329,18 @@ fn csound_filter_caps_negotiation() {
let buffer = h.pull().unwrap(); let buffer = h.pull().unwrap();
// Pushing a buffer without a timestamp should produce a no timestamp output // Pushing a buffer without a timestamp should produce a no timestamp output
assert!(buffer.as_ref().get_pts().is_none()); assert!(buffer.as_ref().pts().is_none());
// But It should have a duration // But It should have a duration
assert_eq!( assert_eq!(
buffer.as_ref().get_duration(), buffer.as_ref().duration(),
duration_from_samples(1024 / std::mem::size_of::<f64>() as u64, sr as u64) duration_from_samples(1024 / std::mem::size_of::<f64>() as u64, sr as u64)
); );
// get the negotiated harness sink caps // get the negotiated harness sink caps
let harness_sink_caps = h let harness_sink_caps = h
.get_sinkpad() .sinkpad()
.expect("harness has no sinkpad") .expect("harness has no sinkpad")
.get_current_caps() .current_caps()
.expect("pad has no caps"); .expect("pad has no caps");
// our expected caps at the harness sinkpad // our expected caps at the harness sinkpad
@ -407,10 +407,7 @@ fn csound_filter_caps_negotiation_fail() {
// The harness sinkpad end up not having defined caps // The harness sinkpad end up not having defined caps
// so, the get_current_caps should be None // so, the get_current_caps should be None
let current_caps = h let current_caps = h.sinkpad().expect("harness has no sinkpad").current_caps();
.get_sinkpad()
.expect("harness has no sinkpad")
.get_current_caps();
assert!(current_caps.is_none()); assert!(current_caps.is_none());
} }

6
audio/lewton/tests/lewtondec.rs
View file

@ -81,13 +81,13 @@ fn run_test(inline_headers: bool) {
continue; continue;
} }
let buffer = h.pull().unwrap(); let buffer = h.pull().unwrap();
assert_eq!(buffer.get_size(), 4 * samples); assert_eq!(buffer.size(), 4 * samples);
} }
let caps = h let caps = h
.get_sinkpad() .sinkpad()
.expect("harness has no sinkpad") .expect("harness has no sinkpad")
.get_current_caps() .current_caps()
.expect("pad has no caps"); .expect("pad has no caps");
assert_eq!( assert_eq!(
caps, caps,

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

@ -136,7 +136,7 @@ impl ObjectImpl for FileSink {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"location" => { "location" => {
let res = match value.get::<String>() { let res = match value.get::<String>() {
Ok(Some(location)) => FileLocation::try_from_path_str(location) Ok(Some(location)) => FileLocation::try_from_path_str(location)
@ -154,7 +154,7 @@ impl ObjectImpl for FileSink {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"location" => { "location" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
let location = settings let location = settings

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

@ -150,7 +150,7 @@ impl ObjectImpl for FileSrc {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"location" => { "location" => {
let res = match value.get::<String>() { let res = match value.get::<String>() {
Ok(Some(location)) => FileLocation::try_from_path_str(location) Ok(Some(location)) => FileLocation::try_from_path_str(location)
@ -168,7 +168,7 @@ impl ObjectImpl for FileSrc {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"location" => { "location" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
let location = settings let location = settings

10
generic/sodium/examples/decrypt_example.rs
View file

@ -68,7 +68,7 @@ fn main() -> Result<(), Box<dyn Error>> {
.required(true) .required(true)
.takes_value(true), .takes_value(true),
) )
.get_matches(); .matches();
gst::init()?; gst::init()?;
gstsodium::plugin_register_static().expect("Failed to register sodium plugin"); gstsodium::plugin_register_static().expect("Failed to register sodium plugin");
@ -123,17 +123,17 @@ fn main() -> Result<(), Box<dyn Error>> {
.set_state(gst::State::Playing) .set_state(gst::State::Playing)
.expect("Unable to set the pipeline to the `Playing` state"); .expect("Unable to set the pipeline to the `Playing` state");
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) { for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
MessageView::Error(err) => { MessageView::Error(err) => {
eprintln!( eprintln!(
"Error received from element {:?}: {}", "Error received from element {:?}: {}",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error() err.error()
); );
eprintln!("Debugging information: {:?}", err.get_debug()); eprintln!("Debugging information: {:?}", err.debug());
break; break;
} }
MessageView::Eos(..) => break, MessageView::Eos(..) => break,

10
generic/sodium/examples/encrypt_example.rs
View file

@ -68,7 +68,7 @@ fn main() -> Result<(), Box<dyn Error>> {
.required(true) .required(true)
.takes_value(true), .takes_value(true),
) )
.get_matches(); .matches();
gst::init()?; gst::init()?;
gstsodium::plugin_register_static().expect("Failed to register sodium plugin"); gstsodium::plugin_register_static().expect("Failed to register sodium plugin");
@ -120,17 +120,17 @@ fn main() -> Result<(), Box<dyn Error>> {
pipeline.set_state(gst::State::Playing)?; pipeline.set_state(gst::State::Playing)?;
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) { for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
MessageView::Error(err) => { MessageView::Error(err) => {
eprintln!( eprintln!(
"Error received from element {:?}: {}", "Error received from element {:?}: {}",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error() err.error()
); );
eprintln!("Debugging information: {:?}", err.get_debug()); eprintln!("Debugging information: {:?}", err.debug());
break; break;
} }
MessageView::Eos(..) => break, MessageView::Eos(..) => break,

2
generic/sodium/examples/generate_keys.rs
View file

@ -92,7 +92,7 @@ fn main() {
.short("j") .short("j")
.help("Write a JSON file instead of a key.prv/key.pub pair"), .help("Write a JSON file instead of a key.prv/key.pub pair"),
) )
.get_matches(); .matches();
let keys = Keys::new(); let keys = Keys::new();

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

@ -301,16 +301,16 @@ impl Decrypter {
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.get_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.get_mut_query()); gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true true
} }
QueryView::Duration(ref mut q) => { QueryView::Duration(ref mut q) => {
use std::convert::TryInto; use std::convert::TryInto;
if q.get_format() != gst::Format::Bytes { if q.format() != gst::Format::Bytes {
return pad.query_default(Some(element), query); return pad.query_default(Some(element), query);
} }
@ -322,7 +322,7 @@ impl Decrypter {
return false; return false;
} }
let size = match peer_query.get_result().try_into().unwrap() { let size = match peer_query.result().try_into().unwrap() {
gst::format::Bytes(Some(size)) => size, gst::format::Bytes(Some(size)) => size,
gst::format::Bytes(None) => { gst::format::Bytes(None) => {
gst_error!(CAT, "Failed to query upstream duration"); gst_error!(CAT, "Failed to query upstream duration");
@ -381,7 +381,7 @@ impl Decrypter {
err err
})?; })?;
if buffer.get_size() != crate::HEADERS_SIZE { if buffer.size() != crate::HEADERS_SIZE {
let err = gst::loggable_error!(CAT, "Headers buffer has wrong size"); let err = gst::loggable_error!(CAT, "Headers buffer has wrong size");
err.log_with_object(element); err.log_with_object(element);
return Err(err); return Err(err);
@ -636,7 +636,7 @@ impl ObjectImpl for Decrypter {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"sender-key" => { "sender-key" => {
let mut props = self.props.lock().unwrap(); let mut props = self.props.lock().unwrap();
props.sender_key = value.get().expect("type checked upstream"); props.sender_key = value.get().expect("type checked upstream");
@ -652,7 +652,7 @@ impl ObjectImpl for Decrypter {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"receiver-key" => { "receiver-key" => {
let props = self.props.lock().unwrap(); let props = self.props.lock().unwrap();
props.receiver_key.to_value() props.receiver_key.to_value()

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

@ -275,19 +275,19 @@ impl Encrypter {
match query.view_mut() { match query.view_mut() {
QueryView::Seeking(mut q) => { QueryView::Seeking(mut q) => {
let format = q.get_format(); let format = q.format();
q.set( q.set(
false, false,
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.get_mut_query()); gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true true
} }
QueryView::Duration(ref mut q) => { QueryView::Duration(ref mut q) => {
use std::convert::TryInto; use std::convert::TryInto;
if q.get_format() != gst::Format::Bytes { if q.format() != gst::Format::Bytes {
return pad.query_default(Some(element), query); return pad.query_default(Some(element), query);
} }
@ -299,7 +299,7 @@ impl Encrypter {
return false; return false;
} }
let size = match peer_query.get_result().try_into().unwrap() { let size = match peer_query.result().try_into().unwrap() {
gst::format::Bytes(Some(size)) => size, gst::format::Bytes(Some(size)) => size,
gst::format::Bytes(None) => { gst::format::Bytes(None) => {
gst_error!(CAT, "Failed to query upstream duration"); gst_error!(CAT, "Failed to query upstream duration");
@ -436,7 +436,7 @@ impl ObjectImpl for Encrypter {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"sender-key" => { "sender-key" => {
let mut props = self.props.lock().unwrap(); let mut props = self.props.lock().unwrap();
props.sender_key = value.get().expect("type checked upstream"); props.sender_key = value.get().expect("type checked upstream");
@ -457,7 +457,7 @@ impl ObjectImpl for Encrypter {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"receiver-key" => { "receiver-key" => {
let props = self.props.lock().unwrap(); let props = self.props.lock().unwrap();
props.receiver_key.to_value() props.receiver_key.to_value()

26
generic/sodium/tests/decrypter.rs
View file

@ -104,7 +104,7 @@ fn test_pipeline() {
.new_sample(move |appsink| { .new_sample(move |appsink| {
// Pull the sample in question out of the appsink's buffer. // Pull the sample in question out of the appsink's buffer.
let sample = appsink.pull_sample().map_err(|_| gst::FlowError::Eos)?; let sample = appsink.pull_sample().map_err(|_| gst::FlowError::Eos)?;
let buffer = sample.get_buffer().ok_or(gst::FlowError::Error)?; let buffer = sample.buffer().ok_or(gst::FlowError::Error)?;
let mut adapter = adapter_clone.lock().unwrap(); let mut adapter = adapter_clone.lock().unwrap();
adapter.push(buffer.to_owned()); adapter.push(buffer.to_owned());
@ -118,17 +118,17 @@ fn test_pipeline() {
.set_state(gst::State::Playing) .set_state(gst::State::Playing)
.expect("Unable to set the pipeline to the `Playing` state"); .expect("Unable to set the pipeline to the `Playing` state");
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) { for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
MessageView::Error(err) => { MessageView::Error(err) => {
eprintln!( eprintln!(
"Error received from element {:?}: {}", "Error received from element {:?}: {}",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error() err.error()
); );
eprintln!("Debugging information: {:?}", err.get_debug()); eprintln!("Debugging information: {:?}", err.debug());
unreachable!(); unreachable!();
} }
MessageView::Eos(..) => break, MessageView::Eos(..) => break,
@ -196,7 +196,7 @@ fn test_pull_range() {
srcpad.query(&mut q); srcpad.query(&mut q);
// get the seeking capabilities // get the seeking capabilities
let (seekable, start, stop) = q.get_result(); let (seekable, start, stop) = q.result();
assert_eq!(seekable, true); assert_eq!(seekable, true);
assert_eq!( assert_eq!(
start, start,
@ -214,7 +214,7 @@ fn test_pull_range() {
61, 70, 175, 103, 127, 28, 0, 61, 70, 175, 103, 127, 28, 0,
]; ];
let buf1 = srcpad.get_range(0, 50).unwrap(); let buf1 = srcpad.get_range(0, 50).unwrap();
assert_eq!(buf1.get_size(), 50); assert_eq!(buf1.size(), 50);
let map1 = buf1.map_readable().unwrap(); let map1 = buf1.map_readable().unwrap();
assert_eq!(&map1[..], &expected_array_1[..]); assert_eq!(&map1[..], &expected_array_1[..]);
@ -226,7 +226,7 @@ fn test_pull_range() {
120, 121, 232, 0, 0, 12, 252, 195, 195, 199, 128, 0, 0, 0, 120, 121, 232, 0, 0, 12, 252, 195, 195, 199, 128, 0, 0, 0,
]; ];
let buf2 = srcpad.get_range(0, 100).unwrap(); let buf2 = srcpad.get_range(0, 100).unwrap();
assert_eq!(buf2.get_size(), 100); assert_eq!(buf2.size(), 100);
let map2 = buf2.map_readable().unwrap(); let map2 = buf2.map_readable().unwrap();
assert_eq!(&map2[..], &expected_array_2[..]); assert_eq!(&map2[..], &expected_array_2[..]);
@ -237,20 +237,20 @@ fn test_pull_range() {
// request in the middle of a block // request in the middle of a block
let buf = srcpad.get_range(853, 100).unwrap(); let buf = srcpad.get_range(853, 100).unwrap();
// result size doesn't include the block macs, // result size doesn't include the block macs,
assert_eq!(buf.get_size(), 100); assert_eq!(buf.size(), 100);
// read till eos, this also will pull multiple blocks // read till eos, this also will pull multiple blocks
let buf = srcpad.get_range(853, 42000).unwrap(); let buf = srcpad.get_range(853, 42000).unwrap();
// 6031 (size of file) - 883 (requersted offset) - headers size - (numbler of blcks * block mac) // 6031 (size of file) - 883 (requersted offset) - headers size - (numbler of blcks * block mac)
assert_eq!(buf.get_size(), 5054); assert_eq!(buf.size(), 5054);
// read 0 bytes from the start // read 0 bytes from the start
let buf = srcpad.get_range(0, 0).unwrap(); let buf = srcpad.get_range(0, 0).unwrap();
assert_eq!(buf.get_size(), 0); assert_eq!(buf.size(), 0);
// read 0 bytes somewhere in the middle // read 0 bytes somewhere in the middle
let buf = srcpad.get_range(4242, 0).unwrap(); let buf = srcpad.get_range(4242, 0).unwrap();
assert_eq!(buf.get_size(), 0); assert_eq!(buf.size(), 0);
// read 0 bytes to eos // read 0 bytes to eos
let res = srcpad.get_range(6003, 0); let res = srcpad.get_range(6003, 0);
@ -266,7 +266,7 @@ fn test_pull_range() {
// read 10 bytes at eos -1, should return a single byte // read 10 bytes at eos -1, should return a single byte
let buf = srcpad.get_range(5906, 10).unwrap(); let buf = srcpad.get_range(5906, 10).unwrap();
assert_eq!(buf.get_size(), 1); assert_eq!(buf.size(), 1);
pipeline pipeline
.set_state(gst::State::Null) .set_state(gst::State::Null)

8
generic/threadshare/examples/benchmark.rs
View file

@ -167,7 +167,7 @@ fn main() {
source.link(&sink).unwrap(); source.link(&sink).unwrap();
} }
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
let l_clone = l.clone(); let l_clone = l.clone();
bus.add_watch(move |_, msg| { bus.add_watch(move |_, msg| {
use gst::MessageView; use gst::MessageView;
@ -177,9 +177,9 @@ fn main() {
MessageView::Error(err) => { MessageView::Error(err) => {
println!( println!(
"Error from {:?}: {} ({:?})", "Error from {:?}: {} ({:?})",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
l_clone.quit(); l_clone.quit();
} }

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

@ -235,11 +235,11 @@ impl PadSrcHandler for AppSrcPadHandler {
} }
QueryView::Caps(ref mut q) => { QueryView::Caps(ref mut q) => {
let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() { let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() {
q.get_filter() q.filter()
.map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First)) .map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First))
.unwrap_or_else(|| caps.clone()) .unwrap_or_else(|| caps.clone())
} else { } else {
q.get_filter() q.filter()
.map(|f| f.to_owned()) .map(|f| f.to_owned())
.unwrap_or_else(gst::Caps::new_any) .unwrap_or_else(gst::Caps::new_any)
}; };
@ -386,9 +386,9 @@ impl AppSrc {
let do_timestamp = self.settings.lock().unwrap().do_timestamp; let do_timestamp = self.settings.lock().unwrap().do_timestamp;
if do_timestamp { if do_timestamp {
if let Some(clock) = element.get_clock() { if let Some(clock) = element.clock() {
let base_time = element.get_base_time(); let base_time = element.base_time();
let now = clock.get_time(); let now = clock.time();
let buffer = buffer.make_mut(); let buffer = buffer.make_mut();
buffer.set_dts(now - base_time); buffer.set_dts(now - base_time);
@ -623,7 +623,7 @@ impl ObjectImpl for AppSrc {
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"context" => { "context" => {
settings.context = value settings.context = value
.get() .get()
@ -648,7 +648,7 @@ impl ObjectImpl for AppSrc {
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"context" => settings.context.to_value(), "context" => settings.context.to_value(),
"context-wait" => settings.context_wait.to_value(), "context-wait" => settings.context_wait.to_value(),
"caps" => settings.caps.to_value(), "caps" => settings.caps.to_value(),

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

@ -45,10 +45,10 @@ pub enum DataQueueItem {
impl DataQueueItem { impl DataQueueItem {
fn size(&self) -> (u32, u32) { fn size(&self) -> (u32, u32) {
match *self { match *self {
DataQueueItem::Buffer(ref buffer) => (1, buffer.get_size() as u32), DataQueueItem::Buffer(ref buffer) => (1, buffer.size() as u32),
DataQueueItem::BufferList(ref list) => ( DataQueueItem::BufferList(ref list) => (
list.len() as u32, list.len() as u32,
list.iter().map(|b| b.get_size() as u32).sum::<u32>(), list.iter().map(|b| b.size() as u32).sum::<u32>(),
), ),
DataQueueItem::Event(_) => (0, 0), DataQueueItem::Event(_) => (0, 0),
} }
@ -56,9 +56,9 @@ impl DataQueueItem {
fn timestamp(&self) -> Option<u64> { fn timestamp(&self) -> Option<u64> {
match *self { match *self {
DataQueueItem::Buffer(ref buffer) => buffer.get_dts_or_pts().0, DataQueueItem::Buffer(ref buffer) => buffer.dts_or_pts().0,
DataQueueItem::BufferList(ref list) => { DataQueueItem::BufferList(ref list) => {
list.iter().filter_map(|b| b.get_dts_or_pts().0).next() list.iter().filter_map(|b| b.dts_or_pts().0).next()
} }
DataQueueItem::Event(_) => None, DataQueueItem::Event(_) => None,
} }
@ -156,8 +156,8 @@ impl DataQueue {
for item in inner.queue.drain(..) { for item in inner.queue.drain(..) {
if let DataQueueItem::Event(event) = item { if let DataQueueItem::Event(event) = item {
if event.is_sticky() if event.is_sticky()
&& event.get_type() != gst::EventType::Segment && event.type_() != gst::EventType::Segment
&& event.get_type() != gst::EventType::Eos && event.type_() != gst::EventType::Eos
{ {
let _ = src_pad.store_sticky_event(&event); let _ = src_pad.store_sticky_event(&event);
} }

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

@ -77,7 +77,7 @@ struct InputSelectorPadSinkHandler(Arc<Mutex<InputSelectorPadSinkHandlerInner>>)
impl InputSelectorPadSinkHandler { impl InputSelectorPadSinkHandler {
/* Wait until specified time */ /* Wait until specified time */
async fn sync(&self, element: &super::InputSelector, running_time: gst::ClockTime) { async fn sync(&self, element: &super::InputSelector, running_time: gst::ClockTime) {
let now = element.get_current_running_time(); let now = element.current_running_time();
if let Some(delay) = running_time if let Some(delay) = running_time
.saturating_sub(now) .saturating_sub(now)
@ -104,7 +104,7 @@ impl InputSelectorPadSinkHandler {
if let Some(segment) = &inner.segment { if let Some(segment) = &inner.segment {
if let Some(segment) = segment.downcast_ref::<gst::format::Time>() { if let Some(segment) = segment.downcast_ref::<gst::format::Time>() {
let rtime = segment.to_running_time(buffer.get_pts()); let rtime = segment.to_running_time(buffer.pts());
let (sync_fut, abort_handle) = abortable(self.sync(&element, rtime)); let (sync_fut, abort_handle) = abortable(self.sync(&element, rtime));
inner.abort_handle = Some(abort_handle); inner.abort_handle = Some(abort_handle);
sync_future = Some(sync_fut.map_err(|_| gst::FlowError::Flushing)); sync_future = Some(sync_fut.map_err(|_| gst::FlowError::Flushing));
@ -142,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.get_flags().contains(gst::BufferFlags::DISCONT) { if switched_pad && !buffer.flags().contains(gst::BufferFlags::DISCONT) {
let buffer = buffer.make_mut(); let buffer = buffer.make_mut();
buffer.set_flags(gst::BufferFlags::DISCONT); buffer.set_flags(gst::BufferFlags::DISCONT);
} }
@ -211,7 +211,7 @@ impl PadSinkHandler for InputSelectorPadSinkHandler {
// Remember the segment for later use // Remember the segment for later use
if let gst::EventView::Segment(e) = event.view() { if let gst::EventView::Segment(e) = event.view() {
inner.segment = Some(e.get_segment().clone()); inner.segment = Some(e.segment().clone());
} }
// We sent sticky events together with the next buffer once it becomes // We sent sticky events together with the next buffer once it becomes
@ -307,7 +307,7 @@ impl PadSrcHandler for InputSelectorPadSrcHandler {
ret = pad.peer_query(&mut peer_query); ret = pad.peer_query(&mut peer_query);
if ret { if ret {
let (live, min, max) = peer_query.get_result(); let (live, min, max) = peer_query.result();
if live { if live {
min_latency = min.max(min_latency).unwrap_or(min_latency); min_latency = min.max(min_latency).unwrap_or(min_latency);
max_latency = max.min(max_latency).unwrap_or(max); max_latency = max.min(max_latency).unwrap_or(max);
@ -449,7 +449,7 @@ impl ObjectImpl for InputSelector {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"context" => { "context" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.context = value settings.context = value
@ -494,7 +494,7 @@ impl ObjectImpl for InputSelector {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"context" => { "context" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.context.to_value() settings.context.to_value()

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

@ -81,8 +81,8 @@ struct GapPacket {
impl GapPacket { impl GapPacket {
fn new(buffer: gst::Buffer) -> Self { fn new(buffer: gst::Buffer) -> Self {
let rtp_buffer = RTPBuffer::from_buffer_readable(&buffer).unwrap(); let rtp_buffer = RTPBuffer::from_buffer_readable(&buffer).unwrap();
let seq = rtp_buffer.get_seq(); let seq = rtp_buffer.seq();
let pt = rtp_buffer.get_payload_type(); let pt = rtp_buffer.payload_type();
drop(rtp_buffer); drop(rtp_buffer);
Self { buffer, seq, pt } Self { buffer, seq, pt }
@ -318,14 +318,14 @@ impl SinkHandler {
let rtp_buffer = let rtp_buffer =
RTPBuffer::from_buffer_readable(&buffer).map_err(|_| gst::FlowError::Error)?; RTPBuffer::from_buffer_readable(&buffer).map_err(|_| gst::FlowError::Error)?;
( (
rtp_buffer.get_seq(), rtp_buffer.seq(),
rtp_buffer.get_timestamp(), rtp_buffer.timestamp(),
rtp_buffer.get_payload_type(), rtp_buffer.payload_type(),
) )
}; };
let mut pts = buffer.get_pts(); let mut pts = buffer.pts();
let mut dts = buffer.get_dts(); let mut dts = buffer.dts();
let mut estimated_dts = false; let mut estimated_dts = false;
gst_log!( gst_log!(
@ -344,7 +344,7 @@ impl SinkHandler {
} }
if dts.is_none() { if dts.is_none() {
dts = element.get_current_running_time(); dts = element.current_running_time();
pts = dts; pts = dts;
estimated_dts = state.clock_rate.is_some(); estimated_dts = state.clock_rate.is_some();
@ -363,7 +363,7 @@ impl SinkHandler {
gst_debug!(CAT, obj: pad, "New payload type: {}", pt); gst_debug!(CAT, obj: pad, "New payload type: {}", pt);
if let Some(caps) = pad.get_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 */
let _ = self.parse_caps(inner, &mut state, element, &caps, pt); let _ = self.parse_caps(inner, &mut state, element, &caps, pt);
} }
@ -400,7 +400,7 @@ impl SinkHandler {
dts, dts,
estimated_dts, estimated_dts,
rtptime, rtptime,
element.get_base_time(), element.base_time(),
0, 0,
false, false,
); );
@ -626,11 +626,7 @@ impl PadSinkHandler for SinkHandler {
match event.view() { match event.view() {
EventView::Segment(e) => { EventView::Segment(e) => {
let mut state = jb.state.lock().unwrap(); let mut state = jb.state.lock().unwrap();
state.segment = e state.segment = e.segment().clone().downcast::<gst::format::Time>().unwrap();
.get_segment()
.clone()
.downcast::<gst::format::Time>()
.unwrap();
} }
EventView::FlushStop(..) => { EventView::FlushStop(..) => {
if let Err(err) = jb.task.flush_stop() { if let Err(err) = jb.task.flush_stop() {
@ -797,9 +793,9 @@ impl SrcHandler {
Some(item) => item, Some(item) => item,
}; };
let dts = jb_item.get_dts(); let dts = jb_item.dts();
let pts = jb_item.get_pts(); let pts = jb_item.pts();
let seq = jb_item.get_seqnum(); let seq = jb_item.seqnum();
let mut buffer = jb_item.into_buffer(); let mut buffer = jb_item.into_buffer();
let lost_events = { let lost_events = {
@ -808,7 +804,7 @@ impl SrcHandler {
buffer.set_dts(state.segment.to_running_time(dts)); buffer.set_dts(state.segment.to_running_time(dts));
buffer.set_pts(state.segment.to_running_time(pts)); buffer.set_pts(state.segment.to_running_time(pts));
if state.last_popped_pts.is_some() && buffer.get_pts() < state.last_popped_pts { if state.last_popped_pts.is_some() && buffer.pts() < state.last_popped_pts {
buffer.set_pts(state.last_popped_pts) buffer.set_pts(state.last_popped_pts)
} }
@ -830,7 +826,7 @@ impl SrcHandler {
lost_events lost_events
}; };
state.last_popped_pts = buffer.get_pts(); state.last_popped_pts = buffer.pts();
if let Some(pts) = state.last_popped_pts.nseconds() { if let Some(pts) = state.last_popped_pts.nseconds() {
state.position = pts.into(); state.position = pts.into();
} }
@ -858,7 +854,7 @@ impl SrcHandler {
latency: gst::ClockTime, latency: gst::ClockTime,
context_wait: gst::ClockTime, context_wait: gst::ClockTime,
) -> (gst::ClockTime, Option<(gst::ClockTime, Duration)>) { ) -> (gst::ClockTime, Option<(gst::ClockTime, Duration)>) {
let now = element.get_current_running_time(); let now = element.current_running_time();
gst_debug!( gst_debug!(
CAT, CAT,
@ -965,7 +961,7 @@ impl PadSrcHandler for SrcHandler {
if ret { if ret {
let settings = jb.settings.lock().unwrap(); let settings = jb.settings.lock().unwrap();
let (_, mut min_latency, _) = peer_query.get_result(); let (_, mut min_latency, _) = peer_query.result();
min_latency += (settings.latency_ms as u64) * gst::SECOND; min_latency += (settings.latency_ms as u64) * gst::SECOND;
let max_latency = gst::CLOCK_TIME_NONE; let max_latency = gst::CLOCK_TIME_NONE;
@ -975,7 +971,7 @@ impl PadSrcHandler for SrcHandler {
ret ret
} }
QueryView::Position(ref mut q) => { QueryView::Position(ref mut q) => {
if q.get_format() != gst::Format::Time { if q.format() != gst::Format::Time {
jb.sink_pad.gst_pad().peer_query(query) jb.sink_pad.gst_pad().peer_query(query)
} else { } else {
let state = jb.state.lock().unwrap(); let state = jb.state.lock().unwrap();
@ -1459,7 +1455,7 @@ impl ObjectImpl for JitterBuffer {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"latency" => { "latency" => {
let latency_ms = { let latency_ms = {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
@ -1500,7 +1496,7 @@ impl ObjectImpl for JitterBuffer {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"latency" => { "latency" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.latency_ms.to_value() settings.latency_ms.to_value()

14
generic/threadshare/src/jitterbuffer/jitterbuffer.rs
View file

@ -112,7 +112,7 @@ impl RTPJitterBufferItem {
} }
} }
pub fn get_dts(&self) -> gst::ClockTime { pub fn dts(&self) -> gst::ClockTime {
unsafe { unsafe {
let item = self.0.as_ref().expect("Invalid wrapper"); let item = self.0.as_ref().expect("Invalid wrapper");
if item.as_ref().dts == gst::ffi::GST_CLOCK_TIME_NONE { if item.as_ref().dts == gst::ffi::GST_CLOCK_TIME_NONE {
@ -123,7 +123,7 @@ impl RTPJitterBufferItem {
} }
} }
pub fn get_pts(&self) -> gst::ClockTime { pub fn pts(&self) -> gst::ClockTime {
unsafe { unsafe {
let item = self.0.as_ref().expect("Invalid wrapper"); let item = self.0.as_ref().expect("Invalid wrapper");
if item.as_ref().pts == gst::ffi::GST_CLOCK_TIME_NONE { if item.as_ref().pts == gst::ffi::GST_CLOCK_TIME_NONE {
@ -134,7 +134,7 @@ impl RTPJitterBufferItem {
} }
} }
pub fn get_seqnum(&self) -> Option<u16> { pub fn seqnum(&self) -> Option<u16> {
unsafe { unsafe {
let item = self.0.as_ref().expect("Invalid wrapper"); let item = self.0.as_ref().expect("Invalid wrapper");
if item.as_ref().seqnum == std::u32::MAX { if item.as_ref().seqnum == std::u32::MAX {
@ -146,7 +146,7 @@ impl RTPJitterBufferItem {
} }
#[allow(dead_code)] #[allow(dead_code)]
pub fn get_rtptime(&self) -> u32 { pub fn rtptime(&self) -> u32 {
unsafe { unsafe {
let item = self.0.as_ref().expect("Invalid wrapper"); let item = self.0.as_ref().expect("Invalid wrapper");
item.as_ref().rtptime item.as_ref().rtptime
@ -223,7 +223,7 @@ impl RTPJitterBuffer {
} }
#[allow(dead_code)] #[allow(dead_code)]
pub fn get_mode(&self) -> RTPJitterBufferMode { pub fn mode(&self) -> RTPJitterBufferMode {
unsafe { from_glib(ffi::rtp_jitter_buffer_get_mode(self.to_glib_none().0)) } unsafe { from_glib(ffi::rtp_jitter_buffer_get_mode(self.to_glib_none().0)) }
} }
@ -233,7 +233,7 @@ impl RTPJitterBuffer {
} }
#[allow(dead_code)] #[allow(dead_code)]
pub fn get_delay(&self) -> gst::ClockTime { pub fn delay(&self) -> gst::ClockTime {
unsafe { from_glib(ffi::rtp_jitter_buffer_get_delay(self.to_glib_none().0)) } unsafe { from_glib(ffi::rtp_jitter_buffer_get_delay(self.to_glib_none().0)) }
} }
@ -246,7 +246,7 @@ impl RTPJitterBuffer {
} }
#[allow(dead_code)] #[allow(dead_code)]
pub fn get_clock_rate(&self) -> u32 { pub fn clock_rate(&self) -> u32 {
unsafe { ffi::rtp_jitter_buffer_get_clock_rate(self.to_glib_none().0) } unsafe { ffi::rtp_jitter_buffer_get_clock_rate(self.to_glib_none().0) }
} }

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

@ -456,9 +456,7 @@ impl ProxySink {
let pending_queue = shared_ctx.pending_queue.as_mut().unwrap(); let pending_queue = shared_ctx.pending_queue.as_mut().unwrap();
let schedule_now = match item { let schedule_now = match item {
DataQueueItem::Event(ref ev) if ev.get_type() != gst::EventType::Eos => { DataQueueItem::Event(ref ev) if ev.type_() != gst::EventType::Eos => false,
false
}
_ => true, _ => true,
}; };
@ -612,7 +610,7 @@ impl ObjectImpl for ProxySink {
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"proxy-context" => { "proxy-context" => {
settings.proxy_context = value settings.proxy_context = value
.get() .get()
@ -625,7 +623,7 @@ impl ObjectImpl for ProxySink {
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"proxy-context" => settings.proxy_context.to_value(), "proxy-context" => settings.proxy_context.to_value(),
_ => unimplemented!(), _ => unimplemented!(),
} }
@ -823,12 +821,12 @@ impl PadSrcHandler for ProxySrcPadHandler {
true true
} }
QueryView::Caps(ref mut q) => { QueryView::Caps(ref mut q) => {
let caps = if let Some(ref caps) = pad.gst_pad().get_current_caps() { let caps = if let Some(ref caps) = pad.gst_pad().current_caps() {
q.get_filter() q.filter()
.map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First)) .map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First))
.unwrap_or_else(|| caps.clone()) .unwrap_or_else(|| caps.clone())
} else { } else {
q.get_filter() q.filter()
.map(|f| f.to_owned()) .map(|f| f.to_owned())
.unwrap_or_else(gst::Caps::new_any) .unwrap_or_else(gst::Caps::new_any)
}; };
@ -1196,7 +1194,7 @@ impl ObjectImpl for ProxySrc {
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"max-size-buffers" => { "max-size-buffers" => {
settings.max_size_buffers = value.get_some().expect("type checked upstream"); settings.max_size_buffers = value.get_some().expect("type checked upstream");
} }
@ -1227,7 +1225,7 @@ impl ObjectImpl for ProxySrc {
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"max-size-buffers" => settings.max_size_buffers.to_value(), "max-size-buffers" => settings.max_size_buffers.to_value(),
"max-size-bytes" => settings.max_size_bytes.to_value(), "max-size-bytes" => settings.max_size_bytes.to_value(),
"max-size-time" => settings.max_size_time.to_value(), "max-size-time" => settings.max_size_time.to_value(),

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

@ -300,17 +300,17 @@ impl PadSrcHandler for QueuePadSrcHandler {
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.get_result(); let (flags, min, max, align) = new_query.result();
q.set(flags, min, max, align); q.set(flags, min, max, align);
q.add_scheduling_modes( q.add_scheduling_modes(
&new_query &new_query
.get_scheduling_modes() .scheduling_modes()
.iter() .iter()
.cloned() .cloned()
.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.get_mut_query()); gst_log!(CAT, obj: pad.gst_pad(), "Returning {:?}", q.query_mut());
return true; return true;
} }
@ -573,9 +573,7 @@ impl Queue {
} }
let schedule_now = match item { let schedule_now = match item {
DataQueueItem::Event(ref ev) if ev.get_type() != gst::EventType::Eos => { DataQueueItem::Event(ref ev) if ev.type_() != gst::EventType::Eos => false,
false
}
_ => true, _ => true,
}; };
@ -777,7 +775,7 @@ impl ObjectImpl for Queue {
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"max-size-buffers" => { "max-size-buffers" => {
settings.max_size_buffers = value.get_some().expect("type checked upstream"); settings.max_size_buffers = value.get_some().expect("type checked upstream");
} }
@ -802,7 +800,7 @@ impl ObjectImpl for Queue {
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"max-size-buffers" => settings.max_size_buffers.to_value(), "max-size-buffers" => settings.max_size_buffers.to_value(),
"max-size-bytes" => settings.max_size_bytes.to_value(), "max-size-bytes" => settings.max_size_bytes.to_value(),
"max-size-time" => settings.max_size_time.to_value(), "max-size-time" => settings.max_size_time.to_value(),

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

@ -131,7 +131,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
RUNTIME_CAT, RUNTIME_CAT,
obj: gst_pad, obj: gst_pad,
"Already activated in {:?} mode ", "Already activated in {:?} mode ",
gst_pad.get_mode() gst_pad.mode()
); );
return Ok(()); return Ok(());
} }
@ -180,7 +180,7 @@ pub trait PadSrcHandler: Clone + Send + Sync + 'static {
) -> Result<FlowSuccess, FlowError> { ) -> Result<FlowSuccess, FlowError> {
// default is to dispatch to `src_event` // default is to dispatch to `src_event`
// (as implemented in `gst_pad_send_event_unchecked`) // (as implemented in `gst_pad_send_event_unchecked`)
let event_type = event.get_type(); let event_type = event.type_();
event_to_event_full(self.src_event(pad, imp, element, event), event_type) event_to_event_full(self.src_event(pad, imp, element, event), event_type)
} }
@ -209,7 +209,7 @@ pub struct PadSrcInner {
impl PadSrcInner { impl PadSrcInner {
fn new(gst_pad: gst::Pad) -> Self { fn new(gst_pad: gst::Pad) -> Self {
if gst_pad.get_direction() != gst::PadDirection::Src { if gst_pad.direction() != gst::PadDirection::Src {
panic!("Wrong pad direction for PadSrc"); panic!("Wrong pad direction for PadSrc");
} }
@ -542,7 +542,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
RUNTIME_CAT, RUNTIME_CAT,
obj: gst_pad, obj: gst_pad,
"Already activated in {:?} mode ", "Already activated in {:?} mode ",
gst_pad.get_mode() gst_pad.mode()
); );
return Ok(()); return Ok(());
} }
@ -633,7 +633,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
assert!(!event.is_serialized()); assert!(!event.is_serialized());
// default is to dispatch to `sink_event` // default is to dispatch to `sink_event`
// (as implemented in `gst_pad_send_event_unchecked`) // (as implemented in `gst_pad_send_event_unchecked`)
let event_type = event.get_type(); let event_type = event.type_();
event_to_event_full(self.sink_event(pad, imp, element, event), event_type) event_to_event_full(self.sink_event(pad, imp, element, event), event_type)
} }
@ -647,7 +647,7 @@ pub trait PadSinkHandler: Clone + Send + Sync + 'static {
assert!(event.is_serialized()); assert!(event.is_serialized());
// default is to dispatch to `sink_event` // default is to dispatch to `sink_event`
// (as implemented in `gst_pad_send_event_unchecked`) // (as implemented in `gst_pad_send_event_unchecked`)
let event_type = event.get_type(); let event_type = event.type_();
event_to_event_full_serialized( event_to_event_full_serialized(
self.sink_event_serialized(pad, imp, element, event), self.sink_event_serialized(pad, imp, element, event),
event_type, event_type,
@ -680,7 +680,7 @@ pub struct PadSinkInner {
impl PadSinkInner { impl PadSinkInner {
fn new(gst_pad: gst::Pad) -> Self { fn new(gst_pad: gst::Pad) -> Self {
if gst_pad.get_direction() != gst::PadDirection::Sink { if gst_pad.direction() != gst::PadDirection::Sink {
panic!("Wrong pad direction for PadSink"); panic!("Wrong pad direction for PadSink");
} }

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

@ -141,7 +141,7 @@ impl<T: SocketRead> Socket<T> {
{ {
Ok((len, saddr)) => { Ok((len, saddr)) => {
let dts = if T::DO_TIMESTAMP { let dts = if T::DO_TIMESTAMP {
let time = self.clock.as_ref().unwrap().get_time(); let time = self.clock.as_ref().unwrap().time();
let running_time = time - self.base_time.unwrap(); let running_time = time - self.base_time.unwrap();
gst_debug!( gst_debug!(
SOCKET_CAT, SOCKET_CAT,
@ -160,7 +160,7 @@ impl<T: SocketRead> Socket<T> {
let mut buffer = self.mapped_buffer.take().unwrap().into_buffer(); let mut buffer = self.mapped_buffer.take().unwrap().into_buffer();
{ {
let buffer = buffer.get_mut().unwrap(); let buffer = buffer.get_mut().unwrap();
if len < buffer.get_size() { if len < buffer.size() {
buffer.set_size(len); buffer.set_size(len);
} }
buffer.set_dts(dts); buffer.set_dts(dts);
@ -226,7 +226,7 @@ impl GioSocketWrapper {
socket.set_option(IPPROTO_IP, IP_TOS, tos)?; socket.set_option(IPPROTO_IP, IP_TOS, tos)?;
if socket.get_family() == gio::SocketFamily::Ipv6 { if socket.family() == gio::SocketFamily::Ipv6 {
socket.set_option(IPPROTO_IPV6, IPV6_TCLASS, tos)?; socket.set_option(IPPROTO_IPV6, IPV6_TCLASS, tos)?;
} }

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

@ -174,7 +174,7 @@ impl TcpClientSrcPadHandler {
self.push_prelude(pad, element).await; self.push_prelude(pad, element).await;
if buffer.get_size() == 0 { if buffer.size() == 0 {
pad.push_event(gst::event::Eos::new()).await; pad.push_event(gst::event::Eos::new()).await;
return Ok(gst::FlowSuccess::Ok); return Ok(gst::FlowSuccess::Ok);
} }
@ -236,11 +236,11 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
} }
QueryView::Caps(ref mut q) => { QueryView::Caps(ref mut q) => {
let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() { let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() {
q.get_filter() q.filter()
.map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First)) .map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First))
.unwrap_or_else(|| caps.clone()) .unwrap_or_else(|| caps.clone())
} else { } else {
q.get_filter() q.filter()
.map(|f| f.to_owned()) .map(|f| f.to_owned())
.unwrap_or_else(gst::Caps::new_any) .unwrap_or_else(gst::Caps::new_any)
}; };
@ -480,7 +480,7 @@ impl TcpClientSrc {
let port = settings.port; let port = settings.port;
let buffer_pool = gst::BufferPool::new(); let buffer_pool = gst::BufferPool::new();
let mut config = buffer_pool.get_config(); let mut config = buffer_pool.config();
config.set_params(None, settings.blocksize, 0, 0); config.set_params(None, settings.blocksize, 0, 0);
buffer_pool.set_config(config).map_err(|_| { buffer_pool.set_config(config).map_err(|_| {
gst::error_msg!( gst::error_msg!(
@ -631,7 +631,7 @@ impl ObjectImpl for TcpClientSrc {
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"host" => { "host" => {
settings.host = value.get().expect("type checked upstream"); settings.host = value.get().expect("type checked upstream");
} }
@ -659,7 +659,7 @@ impl ObjectImpl for TcpClientSrc {
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"host" => settings.host.to_value(), "host" => settings.host.to_value(),
"port" => settings.port.to_value(), "port" => settings.port.to_value(),
"caps" => settings.caps.to_value(), "caps" => settings.caps.to_value(),

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

@ -256,7 +256,7 @@ impl UdpSinkPadHandler {
self.0.write().unwrap().add_client(gst_pad, addr); self.0.write().unwrap().add_client(gst_pad, addr);
} }
fn get_clients(&self) -> Vec<SocketAddr> { fn clients(&self) -> Vec<SocketAddr> {
(*self.0.read().unwrap().clients).clone() (*self.0.read().unwrap().clients).clone()
} }
@ -411,7 +411,7 @@ impl UdpSinkPadHandler {
if let Some(segment) = &inner.segment { if let Some(segment) = &inner.segment {
if let Some(segment) = segment.downcast_ref::<gst::format::Time>() { if let Some(segment) = segment.downcast_ref::<gst::format::Time>() {
rtime = segment.to_running_time(buffer.get_pts()); rtime = segment.to_running_time(buffer.pts());
if inner.latency.is_some() { if inner.latency.is_some() {
rtime += inner.latency; rtime += inner.latency;
} }
@ -522,7 +522,7 @@ impl UdpSinkPadHandler {
/* Wait until specified time */ /* Wait until specified time */
async fn sync(&self, element: &super::UdpSink, running_time: gst::ClockTime) { async fn sync(&self, element: &super::UdpSink, running_time: gst::ClockTime) {
let now = element.get_current_running_time(); let now = element.current_running_time();
if let Some(delay) = running_time if let Some(delay) = running_time
.saturating_sub(now) .saturating_sub(now)
@ -538,10 +538,10 @@ impl UdpSinkPadHandler {
let _ = element.post_message(gst::message::Eos::builder().src(element).build()); let _ = element.post_message(gst::message::Eos::builder().src(element).build());
} }
EventView::Segment(e) => { EventView::Segment(e) => {
self.0.write().unwrap().segment = Some(e.get_segment().clone()); self.0.write().unwrap().segment = Some(e.segment().clone());
} }
EventView::SinkMessage(e) => { EventView::SinkMessage(e) => {
let _ = element.post_message(e.get_message()); let _ = element.post_message(e.message());
} }
_ => (), _ => (),
} }
@ -1193,7 +1193,7 @@ impl ObjectImpl for UdpSink {
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"sync" => { "sync" => {
settings.sync = value.get_some().expect("type checked upstream"); settings.sync = value.get_some().expect("type checked upstream");
} }
@ -1288,7 +1288,7 @@ impl ObjectImpl for UdpSink {
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"sync" => settings.sync.to_value(), "sync" => settings.sync.to_value(),
"bind-address" => settings.bind_address.to_value(), "bind-address" => settings.bind_address.to_value(),
"bind-port" => settings.bind_port.to_value(), "bind-port" => settings.bind_port.to_value(),
@ -1324,7 +1324,7 @@ impl ObjectImpl for UdpSink {
let clients: Vec<String> = self let clients: Vec<String> = self
.sink_pad_handler .sink_pad_handler
.get_clients() .clients()
.iter() .iter()
.map(ToString::to_string) .map(ToString::to_string)
.collect(); .collect();
@ -1410,7 +1410,7 @@ impl ElementImpl for UdpSink {
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() {
EventView::Latency(ev) => { EventView::Latency(ev) => {
self.sink_pad_handler.set_latency(ev.get_latency()); self.sink_pad_handler.set_latency(ev.latency());
self.sink_pad.gst_pad().push_event(event) self.sink_pad.gst_pad().push_event(event)
} }
EventView::Step(..) => false, EventView::Step(..) => false,

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

@ -249,11 +249,11 @@ impl PadSrcHandler for UdpSrcPadHandler {
} }
QueryView::Caps(ref mut q) => { QueryView::Caps(ref mut q) => {
let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() { let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() {
q.get_filter() q.filter()
.map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First)) .map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First))
.unwrap_or_else(|| caps.clone()) .unwrap_or_else(|| caps.clone())
} else { } else {
q.get_filter() q.filter()
.map(|f| f.to_owned()) .map(|f| f.to_owned())
.unwrap_or_else(gst::Caps::new_any) .unwrap_or_else(gst::Caps::new_any)
}; };
@ -303,7 +303,7 @@ impl TaskImpl for UdpSrcTask {
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.get_clock(), Some(self.element.get_base_time())); .set_clock(self.element.clock(), Some(self.element.base_time()));
gst_log!(CAT, obj: &self.element, "Task started"); gst_log!(CAT, obj: &self.element, "Task started");
Ok(()) Ok(())
} }
@ -609,7 +609,7 @@ impl UdpSrc {
}; };
let buffer_pool = gst::BufferPool::new(); let buffer_pool = gst::BufferPool::new();
let mut config = buffer_pool.get_config(); let mut config = buffer_pool.config();
config.set_params(None, settings.mtu, 0, 0); config.set_params(None, settings.mtu, 0, 0);
buffer_pool.set_config(config).map_err(|err| { buffer_pool.set_config(config).map_err(|err| {
gst::error_msg!( gst::error_msg!(
@ -806,7 +806,7 @@ impl ObjectImpl for UdpSrc {
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"address" => { "address" => {
settings.address = value.get().expect("type checked upstream"); settings.address = value.get().expect("type checked upstream");
} }
@ -849,7 +849,7 @@ impl ObjectImpl for UdpSrc {
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"address" => settings.address.to_value(), "address" => settings.address.to_value(),
"port" => settings.port.to_value(), "port" => settings.port.to_value(),
"reuse" => settings.reuse.to_value(), "reuse" => settings.reuse.to_value(),

18
generic/threadshare/tests/appsrc.rs
View file

@ -36,7 +36,7 @@ fn push() {
let caps = gst::Caps::new_simple("foo/bar", &[]); let caps = gst::Caps::new_simple("foo/bar", &[]);
{ {
let appsrc = h.get_element().unwrap(); let appsrc = h.element().unwrap();
appsrc.set_property("caps", &caps).unwrap(); appsrc.set_property("caps", &caps).unwrap();
appsrc.set_property("do-timestamp", &true).unwrap(); appsrc.set_property("do-timestamp", &true).unwrap();
appsrc.set_property("context", &"appsrc-push").unwrap(); appsrc.set_property("context", &"appsrc-push").unwrap();
@ -45,7 +45,7 @@ fn push() {
h.play(); h.play();
{ {
let appsrc = h.get_element().unwrap(); let appsrc = h.element().unwrap();
for _ in 0..3 { for _ in 0..3 {
assert!(appsrc assert!(appsrc
.emit_by_name("push-buffer", &[&gst::Buffer::new()]) .emit_by_name("push-buffer", &[&gst::Buffer::new()])
@ -78,7 +78,7 @@ fn push() {
} }
EventView::Caps(ev) => { EventView::Caps(ev) => {
assert_eq!(n_events, 1); assert_eq!(n_events, 1);
let event_caps = ev.get_caps(); let event_caps = ev.caps();
assert_eq!(caps.as_ref(), event_caps); assert_eq!(caps.as_ref(), event_caps);
} }
EventView::Segment(..) => { EventView::Segment(..) => {
@ -102,7 +102,7 @@ fn pause_regular() {
let caps = gst::Caps::new_simple("foo/bar", &[]); let caps = gst::Caps::new_simple("foo/bar", &[]);
{ {
let appsrc = h.get_element().unwrap(); let appsrc = h.element().unwrap();
appsrc.set_property("caps", &caps).unwrap(); appsrc.set_property("caps", &caps).unwrap();
appsrc.set_property("do-timestamp", &true).unwrap(); appsrc.set_property("do-timestamp", &true).unwrap();
appsrc.set_property("context", &"appsrc-pause").unwrap(); appsrc.set_property("context", &"appsrc-pause").unwrap();
@ -110,7 +110,7 @@ fn pause_regular() {
h.play(); h.play();
let appsrc = h.get_element().unwrap(); let appsrc = h.element().unwrap();
// Initial buffer // Initial buffer
assert!(appsrc assert!(appsrc
@ -172,7 +172,7 @@ fn flush_regular() {
let caps = gst::Caps::new_simple("foo/bar", &[]); let caps = gst::Caps::new_simple("foo/bar", &[]);
{ {
let appsrc = h.get_element().unwrap(); let appsrc = h.element().unwrap();
appsrc.set_property("caps", &caps).unwrap(); appsrc.set_property("caps", &caps).unwrap();
appsrc.set_property("do-timestamp", &true).unwrap(); appsrc.set_property("do-timestamp", &true).unwrap();
appsrc.set_property("context", &"appsrc-flush").unwrap(); appsrc.set_property("context", &"appsrc-flush").unwrap();
@ -180,7 +180,7 @@ fn flush_regular() {
h.play(); h.play();
let appsrc = h.get_element().unwrap(); let appsrc = h.element().unwrap();
// Initial buffer // Initial buffer
assert!(appsrc assert!(appsrc
@ -231,7 +231,7 @@ fn pause_flush() {
let caps = gst::Caps::new_simple("foo/bar", &[]); let caps = gst::Caps::new_simple("foo/bar", &[]);
{ {
let appsrc = h.get_element().unwrap(); let appsrc = h.element().unwrap();
appsrc.set_property("caps", &caps).unwrap(); appsrc.set_property("caps", &caps).unwrap();
appsrc.set_property("do-timestamp", &true).unwrap(); appsrc.set_property("do-timestamp", &true).unwrap();
appsrc appsrc
@ -241,7 +241,7 @@ fn pause_flush() {
h.play(); h.play();
let appsrc = h.get_element().unwrap(); let appsrc = h.element().unwrap();
// Initial buffer // Initial buffer
assert!(appsrc assert!(appsrc

20
generic/threadshare/tests/inputselector.rs
View file

@ -42,16 +42,16 @@ fn test_active_pad() {
.unwrap() .unwrap()
.get::<gst::Pad>() .get::<gst::Pad>()
.unwrap(); .unwrap();
assert_eq!(active_pad, h1.get_srcpad().unwrap().get_peer()); assert_eq!(active_pad, h1.srcpad().unwrap().peer());
is.set_property("active-pad", &h2.get_srcpad().unwrap().get_peer()) is.set_property("active-pad", &h2.srcpad().unwrap().peer())
.unwrap(); .unwrap();
let active_pad = is let active_pad = is
.get_property("active-pad") .get_property("active-pad")
.unwrap() .unwrap()
.get::<gst::Pad>() .get::<gst::Pad>()
.unwrap(); .unwrap();
assert_eq!(active_pad, h2.get_srcpad().unwrap().get_peer()); assert_eq!(active_pad, h2.srcpad().unwrap().peer());
h1.set_src_caps_str("foo/bar"); h1.set_src_caps_str("foo/bar");
h2.set_src_caps_str("foo/bar"); h2.set_src_caps_str("foo/bar");
@ -71,11 +71,11 @@ fn test_active_pad() {
assert_eq!(h1.events_received(), 3); assert_eq!(h1.events_received(), 3);
let event = h1.pull_event().unwrap(); let event = h1.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::StreamStart); assert_eq!(event.type_(), gst::EventType::StreamStart);
let event = h1.pull_event().unwrap(); let event = h1.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::Caps); assert_eq!(event.type_(), gst::EventType::Caps);
let event = h1.pull_event().unwrap(); let event = h1.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::Segment); assert_eq!(event.type_(), gst::EventType::Segment);
/* Push another buffer on the active pad, there should be no new events */ /* Push another buffer on the active pad, there should be no new events */
let buf = gst::Buffer::new(); let buf = gst::Buffer::new();
@ -86,17 +86,17 @@ fn test_active_pad() {
/* Switch the active pad and push a buffer, we should receive stream-start, segment and caps /* Switch the active pad and push a buffer, we should receive stream-start, segment and caps
* again */ * again */
let buf = gst::Buffer::new(); let buf = gst::Buffer::new();
is.set_property("active-pad", &h1.get_srcpad().unwrap().get_peer()) is.set_property("active-pad", &h1.srcpad().unwrap().peer())
.unwrap(); .unwrap();
assert_eq!(h1.push(buf), Ok(gst::FlowSuccess::Ok)); assert_eq!(h1.push(buf), Ok(gst::FlowSuccess::Ok));
assert_eq!(h1.buffers_received(), 3); assert_eq!(h1.buffers_received(), 3);
assert_eq!(h1.events_received(), 6); assert_eq!(h1.events_received(), 6);
let event = h1.pull_event().unwrap(); let event = h1.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::StreamStart); assert_eq!(event.type_(), gst::EventType::StreamStart);
let event = h1.pull_event().unwrap(); let event = h1.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::Caps); assert_eq!(event.type_(), gst::EventType::Caps);
let event = h1.pull_event().unwrap(); let event = h1.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::Segment); assert_eq!(event.type_(), gst::EventType::Segment);
let _ = is.set_state(gst::State::Null); let _ = is.set_state(gst::State::Null);
} }

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

@ -342,7 +342,7 @@ mod imp_src {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"context" => { "context" => {
let context = value let context = value
.get() .get()
@ -672,7 +672,7 @@ mod imp_sink {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"sender" => { "sender" => {
let ItemSender { sender } = value let ItemSender { sender } = value
.get::<&ItemSender>() .get::<&ItemSender>()

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

@ -131,17 +131,17 @@ fn multiple_contexts_queue() {
l_clone.quit(); l_clone.quit();
}); });
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
let l_clone = l.clone(); let l_clone = l.clone();
bus.add_watch(move |_, msg| { bus.add_watch(move |_, msg| {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
MessageView::StateChanged(state_changed) => { MessageView::StateChanged(state_changed) => {
if let Some(source) = state_changed.get_src() { if let Some(source) = state_changed.src() {
if source.get_type() == gst::Pipeline::static_type() if source.type_() == gst::Pipeline::static_type()
&& state_changed.get_old() == gst::State::Paused && state_changed.old() == gst::State::Paused
&& state_changed.get_current() == gst::State::Playing && state_changed.current() == gst::State::Playing
{ {
if let Some(test_scenario) = test_scenario.take() { if let Some(test_scenario) = test_scenario.take() {
std::thread::spawn(test_scenario); std::thread::spawn(test_scenario);
@ -153,9 +153,9 @@ fn multiple_contexts_queue() {
gst_error!( gst_error!(
CAT, CAT,
"multiple_contexts_queue: Error from {:?}: {} ({:?})", "multiple_contexts_queue: Error from {:?}: {} ({:?})",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
l_clone.quit(); l_clone.quit();
} }
@ -290,17 +290,17 @@ fn multiple_contexts_proxy() {
l_clone.quit(); l_clone.quit();
}); });
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
let l_clone = l.clone(); let l_clone = l.clone();
bus.add_watch(move |_, msg| { bus.add_watch(move |_, msg| {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
MessageView::StateChanged(state_changed) => { MessageView::StateChanged(state_changed) => {
if let Some(source) = state_changed.get_src() { if let Some(source) = state_changed.src() {
if source.get_type() == gst::Pipeline::static_type() if source.type_() == gst::Pipeline::static_type()
&& state_changed.get_old() == gst::State::Paused && state_changed.old() == gst::State::Paused
&& state_changed.get_current() == gst::State::Playing && state_changed.current() == gst::State::Playing
{ {
if let Some(test_scenario) = test_scenario.take() { if let Some(test_scenario) = test_scenario.take() {
std::thread::spawn(test_scenario); std::thread::spawn(test_scenario);
@ -312,9 +312,9 @@ fn multiple_contexts_proxy() {
gst_error!( gst_error!(
CAT, CAT,
"multiple_contexts_proxy: Error from {:?}: {} ({:?})", "multiple_contexts_proxy: Error from {:?}: {} ({:?})",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
l_clone.quit(); l_clone.quit();
} }
@ -422,19 +422,19 @@ fn eos() {
let l_clone = l.clone(); let l_clone = l.clone();
pipeline pipeline
.get_bus() .bus()
.unwrap() .unwrap()
.add_watch(move |_, msg| { .add_watch(move |_, msg| {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
MessageView::StateChanged(state_changed) => { MessageView::StateChanged(state_changed) => {
if let Some(source) = state_changed.get_src() { if let Some(source) = state_changed.src() {
if source.get_type() != gst::Pipeline::static_type() { if source.type_() != gst::Pipeline::static_type() {
return glib::Continue(true); return glib::Continue(true);
} }
if state_changed.get_old() == gst::State::Paused if state_changed.old() == gst::State::Paused
&& state_changed.get_current() == gst::State::Playing && state_changed.current() == gst::State::Playing
{ {
if let Some(scenario) = scenario.take() { if let Some(scenario) = scenario.take() {
std::thread::spawn(scenario); std::thread::spawn(scenario);
@ -446,9 +446,9 @@ fn eos() {
gst_error!( gst_error!(
CAT, CAT,
"eos: Error from {:?}: {} ({:?})", "eos: Error from {:?}: {} ({:?})",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
l_clone.quit(); l_clone.quit();
} }
@ -582,19 +582,19 @@ fn premature_shutdown() {
let l_clone = l.clone(); let l_clone = l.clone();
pipeline pipeline
.get_bus() .bus()
.unwrap() .unwrap()
.add_watch(move |_, msg| { .add_watch(move |_, msg| {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
MessageView::StateChanged(state_changed) => { MessageView::StateChanged(state_changed) => {
if let Some(source) = state_changed.get_src() { if let Some(source) = state_changed.src() {
if source.get_type() != gst::Pipeline::static_type() { if source.type_() != gst::Pipeline::static_type() {
return glib::Continue(true); return glib::Continue(true);
} }
if state_changed.get_old() == gst::State::Paused if state_changed.old() == gst::State::Paused
&& state_changed.get_current() == gst::State::Playing && state_changed.current() == gst::State::Playing
{ {
if let Some(scenario) = scenario.take() { if let Some(scenario) = scenario.take() {
std::thread::spawn(scenario); std::thread::spawn(scenario);
@ -606,9 +606,9 @@ fn premature_shutdown() {
gst_error!( gst_error!(
CAT, CAT,
"premature_shutdown: Error from {:?}: {} ({:?})", "premature_shutdown: Error from {:?}: {} ({:?})",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
l_clone.quit(); l_clone.quit();
} }

8
generic/threadshare/tests/proxy.rs
View file

@ -73,7 +73,7 @@ fn test_push() {
pipeline.set_state(gst::State::Playing).unwrap(); pipeline.set_state(gst::State::Playing).unwrap();
let mut eos = false; let mut eos = false;
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
while let Some(msg) = bus.timed_pop(5 * gst::SECOND) { while let Some(msg) = bus.timed_pop(5 * gst::SECOND) {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
@ -91,7 +91,7 @@ fn test_push() {
assert_eq!(samples.len(), 3); assert_eq!(samples.len(), 3);
for sample in samples.iter() { for sample in samples.iter() {
assert!(sample.get_buffer().is_some()); assert!(sample.buffer().is_some());
} }
pipeline.set_state(gst::State::Null).unwrap(); pipeline.set_state(gst::State::Null).unwrap();
@ -121,8 +121,8 @@ fn test_from_pipeline_to_pipeline() {
pipe_1.set_state(gst::State::Paused).unwrap(); pipe_1.set_state(gst::State::Paused).unwrap();
pipe_2.set_state(gst::State::Paused).unwrap(); pipe_2.set_state(gst::State::Paused).unwrap();
let _ = pipe_1.get_state(gst::CLOCK_TIME_NONE); let _ = pipe_1.state(gst::CLOCK_TIME_NONE);
let _ = pipe_2.get_state(gst::CLOCK_TIME_NONE); let _ = pipe_2.state(gst::CLOCK_TIME_NONE);
pipe_1.set_state(gst::State::Null).unwrap(); pipe_1.set_state(gst::State::Null).unwrap();

4
generic/threadshare/tests/queue.rs
View file

@ -68,7 +68,7 @@ fn test_push() {
pipeline.set_state(gst::State::Playing).unwrap(); pipeline.set_state(gst::State::Playing).unwrap();
let mut eos = false; let mut eos = false;
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
while let Some(msg) = bus.timed_pop(5 * gst::SECOND) { while let Some(msg) = bus.timed_pop(5 * gst::SECOND) {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
@ -86,7 +86,7 @@ fn test_push() {
assert_eq!(samples.len(), 3); assert_eq!(samples.len(), 3);
for sample in samples.iter() { for sample in samples.iter() {
assert!(sample.get_buffer().is_some()); assert!(sample.buffer().is_some());
} }
pipeline.set_state(gst::State::Null).unwrap(); pipeline.set_state(gst::State::Null).unwrap();

10
generic/threadshare/tests/tcpclientsrc.rs
View file

@ -92,7 +92,7 @@ fn test_push() {
pipeline.set_state(gst::State::Playing).unwrap(); pipeline.set_state(gst::State::Playing).unwrap();
let mut eos = false; let mut eos = false;
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
while let Some(msg) = bus.timed_pop(5 * gst::SECOND) { while let Some(msg) = bus.timed_pop(5 * gst::SECOND) {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
@ -108,12 +108,12 @@ fn test_push() {
assert!(eos); assert!(eos);
let samples = samples.lock().unwrap(); let samples = samples.lock().unwrap();
for sample in samples.iter() { for sample in samples.iter() {
assert_eq!(Some(caps.as_ref()), sample.get_caps()); assert_eq!(Some(caps.as_ref()), sample.caps());
} }
let total_received_size = samples.iter().fold(0, |acc, sample| { let total_received_size = samples
acc + sample.get_buffer().unwrap().get_size() .iter()
}); .fold(0, |acc, sample| acc + sample.buffer().unwrap().size());
assert_eq!(total_received_size, 3 * 160); assert_eq!(total_received_size, 3 * 160);
pipeline.set_state(gst::State::Null).unwrap(); pipeline.set_state(gst::State::Null).unwrap();

4
generic/threadshare/tests/udpsink.rs
View file

@ -34,7 +34,7 @@ fn test_client_management() {
init(); init();
let h = gst_check::Harness::new("ts-udpsink"); let h = gst_check::Harness::new("ts-udpsink");
let udpsink = h.get_element().unwrap(); let udpsink = h.element().unwrap();
let clients = udpsink let clients = udpsink
.get_property("clients") .get_property("clients")
@ -132,7 +132,7 @@ fn test_chain() {
let mut h = gst_check::Harness::new("ts-udpsink"); let mut h = gst_check::Harness::new("ts-udpsink");
h.set_src_caps_str(&"foo/bar"); h.set_src_caps_str(&"foo/bar");
{ {
let udpsink = h.get_element().unwrap(); let udpsink = h.element().unwrap();
udpsink.set_property("clients", &"127.0.0.1:5005").unwrap(); udpsink.set_property("clients", &"127.0.0.1:5005").unwrap();
} }

16
generic/threadshare/tests/udpsrc.rs
View file

@ -37,7 +37,7 @@ fn test_push() {
let caps = gst::Caps::new_simple("foo/bar", &[]); let caps = gst::Caps::new_simple("foo/bar", &[]);
{ {
let udpsrc = h.get_element().unwrap(); let udpsrc = h.element().unwrap();
udpsrc.set_property("caps", &caps).unwrap(); udpsrc.set_property("caps", &caps).unwrap();
udpsrc.set_property("port", &5000i32).unwrap(); udpsrc.set_property("port", &5000i32).unwrap();
udpsrc.set_property("context", &"test-push").unwrap(); udpsrc.set_property("context", &"test-push").unwrap();
@ -66,7 +66,7 @@ fn test_push() {
for _ in 0..3 { for _ in 0..3 {
let buffer = h.pull().unwrap(); let buffer = h.pull().unwrap();
assert_eq!(buffer.get_size(), 160); assert_eq!(buffer.size(), 160);
} }
let mut n_events = 0; let mut n_events = 0;
@ -80,7 +80,7 @@ fn test_push() {
} }
EventView::Caps(ev) => { EventView::Caps(ev) => {
assert_eq!(n_events, 1); assert_eq!(n_events, 1);
let event_caps = ev.get_caps(); let event_caps = ev.caps();
assert_eq!(caps.as_ref(), event_caps); assert_eq!(caps.as_ref(), event_caps);
} }
EventView::Segment(..) => { EventView::Segment(..) => {
@ -104,7 +104,7 @@ fn test_socket_reuse() {
let mut ts_src_h2 = gst_check::Harness::new("ts-udpsrc"); let mut ts_src_h2 = gst_check::Harness::new("ts-udpsrc");
{ {
let udpsrc = ts_src_h.get_element().unwrap(); let udpsrc = ts_src_h.element().unwrap();
udpsrc.set_property("port", &6000i32).unwrap(); udpsrc.set_property("port", &6000i32).unwrap();
udpsrc udpsrc
.set_property("context", &"test-socket-reuse") .set_property("context", &"test-socket-reuse")
@ -113,14 +113,14 @@ fn test_socket_reuse() {
ts_src_h.play(); ts_src_h.play();
{ {
let udpsrc = ts_src_h.get_element().unwrap(); let udpsrc = ts_src_h.element().unwrap();
let socket = udpsrc let socket = udpsrc
.get_property("used-socket") .get_property("used-socket")
.unwrap() .unwrap()
.get::<gio::Socket>() .get::<gio::Socket>()
.unwrap(); .unwrap();
let udpsink = sink_h.get_element().unwrap(); let udpsink = sink_h.element().unwrap();
udpsink.set_property("socket", &socket).unwrap(); udpsink.set_property("socket", &socket).unwrap();
udpsink.set_property("host", &"127.0.0.1").unwrap(); udpsink.set_property("host", &"127.0.0.1").unwrap();
udpsink.set_property("port", &6001i32).unwrap(); udpsink.set_property("port", &6001i32).unwrap();
@ -129,7 +129,7 @@ fn test_socket_reuse() {
sink_h.set_src_caps_str("application/test"); sink_h.set_src_caps_str("application/test");
{ {
let udpsrc = ts_src_h2.get_element().unwrap(); let udpsrc = ts_src_h2.element().unwrap();
udpsrc.set_property("port", &6001i32).unwrap(); udpsrc.set_property("port", &6001i32).unwrap();
udpsrc udpsrc
.set_property("context", &"test-socket-reuse") .set_property("context", &"test-socket-reuse")
@ -161,6 +161,6 @@ fn test_socket_reuse() {
sink_h.push(buffer).unwrap(); sink_h.push(buffer).unwrap();
let buffer = ts_src_h2.pull().unwrap(); let buffer = ts_src_h2.pull().unwrap();
assert_eq!(buffer.get_size(), 160); assert_eq!(buffer.size(), 160);
} }
} }

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

@ -181,7 +181,7 @@ impl ReqwestHttpSrc {
let srcpad = src.get_static_pad("src").unwrap(); let srcpad = src.get_static_pad("src").unwrap();
let mut q = gst::query::Context::new(REQWEST_CLIENT_CONTEXT); let mut q = gst::query::Context::new(REQWEST_CLIENT_CONTEXT);
if srcpad.peer_query(&mut q) { if srcpad.peer_query(&mut q) {
if let Some(context) = q.get_context_owned() { if let Some(context) = q.context_owned() {
src.set_context(&context); src.set_context(&context);
} }
} else { } else {
@ -224,7 +224,7 @@ impl ReqwestHttpSrc {
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();
let s = context.get_mut_structure(); let s = context.structure_mut();
s.set("client", &client); s.set("client", &client);
} }
src.set_context(&context); src.set_context(&context);
@ -671,7 +671,7 @@ impl ObjectImpl for ReqwestHttpSrc {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"location" => { "location" => {
let location = value.get::<&str>().expect("type checked upstream"); let location = value.get::<&str>().expect("type checked upstream");
if let Err(err) = self.set_location(obj, location) { if let Err(err) = self.set_location(obj, location) {
@ -740,7 +740,7 @@ impl ObjectImpl for ReqwestHttpSrc {
} }
fn get_property(&self, obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"location" => { "location" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
let location = settings.location.as_ref().map(Url::to_string); let location = settings.location.as_ref().map(Url::to_string);
@ -827,9 +827,9 @@ impl ElementImpl for ReqwestHttpSrc {
} }
fn set_context(&self, element: &Self::Type, context: &gst::Context) { fn set_context(&self, element: &Self::Type, context: &gst::Context) {
if context.get_context_type() == REQWEST_CLIENT_CONTEXT { if context.context_type() == REQWEST_CLIENT_CONTEXT {
let mut external_client = self.external_client.lock().unwrap(); let mut external_client = self.external_client.lock().unwrap();
let s = context.get_structure(); let s = context.structure();
*external_client = s *external_client = s
.get_some::<&ClientContext>("client") .get_some::<&ClientContext>("client")
.map(|c| Some(c.clone())) .map(|c| Some(c.clone()))
@ -946,8 +946,8 @@ impl BaseSrcImpl for ReqwestHttpSrc {
} }
}; };
let start = segment.get_start().expect("No start position given"); let start = segment.start().expect("No start position given");
let stop = segment.get_stop(); let stop = segment.stop();
gst_debug!(CAT, obj: src, "Seeking to {}-{:?}", start, stop); gst_debug!(CAT, obj: src, "Seeking to {}-{:?}", start, stop);

88
net/reqwest/tests/reqwesthttpsrc.rs
View file

@ -172,7 +172,7 @@ impl Harness {
match msg.view() { match msg.view() {
MessageView::Error(err) => { MessageView::Error(err) => {
return err.get_error(); return err.error();
} }
_ => (), _ => (),
} }
@ -205,13 +205,13 @@ impl Harness {
match msg.view() { match msg.view() {
MessageView::StateChanged(state) => { MessageView::StateChanged(state) => {
return state.get_current(); return state.current();
} }
MessageView::Error(err) => { MessageView::Error(err) => {
panic!( panic!(
"Got error: {} ({})", "Got error: {} ({})",
err.get_error(), err.error(),
err.get_debug().unwrap_or_else(|| String::from("None")) err.debug().unwrap_or_else(|| String::from("None"))
); );
} }
_ => (), _ => (),
@ -239,7 +239,7 @@ impl Harness {
match ev.view() { match ev.view() {
EventView::Segment(seg) => { EventView::Segment(seg) => {
return seg return seg
.get_segment() .segment()
.clone() .clone()
.downcast::<gst::format::Bytes>() .downcast::<gst::format::Bytes>()
.unwrap(); .unwrap();
@ -254,8 +254,8 @@ impl Harness {
MessageView::Error(err) => { MessageView::Error(err) => {
panic!( panic!(
"Got error: {} ({})", "Got error: {} ({})",
err.get_error(), err.error(),
err.get_debug().unwrap_or_else(|| String::from("None")) err.debug().unwrap_or_else(|| String::from("None"))
); );
} }
_ => (), _ => (),
@ -294,8 +294,8 @@ impl Harness {
MessageView::Error(err) => { MessageView::Error(err) => {
panic!( panic!(
"Got error: {} ({})", "Got error: {} ({})",
err.get_error(), err.error(),
err.get_debug().unwrap_or_else(|| String::from("None")) err.debug().unwrap_or_else(|| String::from("None"))
); );
} }
_ => (), _ => (),
@ -316,7 +316,7 @@ impl Drop for Harness {
fn drop(&mut self) { fn drop(&mut self) {
// Shut down everything that was set up for this test harness // Shut down everything that was set up for this test harness
// and wait until the tokio runtime exited // and wait until the tokio runtime exited
let bus = self.src.get_bus().unwrap(); let bus = self.src.bus().unwrap();
bus.set_flushing(true); bus.set_flushing(true);
// Drop the receiver first before setting the state so that // Drop the receiver first before setting the state so that
@ -376,8 +376,8 @@ fn test_basic_request() {
// Map the buffer readable and check if it contains exactly the data we would expect at // Map the buffer readable and check if it contains exactly the data we would expect at
// this point after reading everything else we read in previous runs // this point after reading everything else we read in previous runs
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
@ -434,8 +434,8 @@ fn test_basic_request_inverted_defaults() {
// Map the buffer readable and check if it contains exactly the data we would expect at // Map the buffer readable and check if it contains exactly the data we would expect at
// this point after reading everything else we read in previous runs // this point after reading everything else we read in previous runs
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
@ -512,8 +512,8 @@ fn test_extra_headers() {
// Map the buffer readable and check if it contains exactly the data we would expect at // Map the buffer readable and check if it contains exactly the data we would expect at
// this point after reading everything else we read in previous runs // this point after reading everything else we read in previous runs
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
@ -572,8 +572,8 @@ fn test_cookies_property() {
// Map the buffer readable and check if it contains exactly the data we would expect at // Map the buffer readable and check if it contains exactly the data we would expect at
// this point after reading everything else we read in previous runs // this point after reading everything else we read in previous runs
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
@ -632,8 +632,8 @@ fn test_iradio_mode() {
// Map the buffer readable and check if it contains exactly the data we would expect at // Map the buffer readable and check if it contains exactly the data we would expect at
// this point after reading everything else we read in previous runs // this point after reading everything else we read in previous runs
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
@ -641,7 +641,7 @@ fn test_iradio_mode() {
assert_eq!(cursor.position(), 11); assert_eq!(cursor.position(), 11);
let srcpad = h.src.get_static_pad("src").unwrap(); let srcpad = h.src.get_static_pad("src").unwrap();
let caps = srcpad.get_current_caps().unwrap(); let caps = srcpad.current_caps().unwrap();
assert_eq!( assert_eq!(
caps, caps,
gst::Caps::builder("application/x-icy") gst::Caps::builder("application/x-icy")
@ -654,7 +654,7 @@ fn test_iradio_mode() {
use gst::EventView; use gst::EventView;
let tag_event = srcpad.get_sticky_event(gst::EventType::Tag, 0).unwrap(); let tag_event = srcpad.get_sticky_event(gst::EventType::Tag, 0).unwrap();
if let EventView::Tag(tags) = tag_event.view() { if let EventView::Tag(tags) = tag_event.view() {
let tags = tags.get_tag(); let tags = tags.tag();
assert_eq!( assert_eq!(
tags.get::<gst::tags::Organization>().unwrap().get(), tags.get::<gst::tags::Organization>().unwrap().get(),
Some("Name") Some("Name")
@ -713,8 +713,8 @@ fn test_audio_l16() {
// Map the buffer readable and check if it contains exactly the data we would expect at // Map the buffer readable and check if it contains exactly the data we would expect at
// this point after reading everything else we read in previous runs // this point after reading everything else we read in previous runs
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
@ -722,7 +722,7 @@ fn test_audio_l16() {
assert_eq!(cursor.position(), 11); assert_eq!(cursor.position(), 11);
let srcpad = h.src.get_static_pad("src").unwrap(); let srcpad = h.src.get_static_pad("src").unwrap();
let caps = srcpad.get_current_caps().unwrap(); let caps = srcpad.current_caps().unwrap();
assert_eq!( assert_eq!(
caps, caps,
gst::Caps::builder("audio/x-unaligned-raw") gst::Caps::builder("audio/x-unaligned-raw")
@ -787,8 +787,8 @@ fn test_authorization() {
// Map the buffer readable and check if it contains exactly the data we would expect at // Map the buffer readable and check if it contains exactly the data we would expect at
// this point after reading everything else we read in previous runs // this point after reading everything else we read in previous runs
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
@ -936,7 +936,7 @@ fn test_seek_after_ready() {
}); });
let segment = h.wait_for_segment(false); let segment = h.wait_for_segment(false);
assert_eq!(segment.get_start(), gst::format::Bytes::from(123)); assert_eq!(segment.start(), gst::format::Bytes::from(123));
let mut expected_output = vec![0; 8192 - 123]; let mut expected_output = vec![0; 8192 - 123];
for (i, d) in expected_output.iter_mut().enumerate() { for (i, d) in expected_output.iter_mut().enumerate() {
@ -945,12 +945,12 @@ fn test_seek_after_ready() {
let mut cursor = Cursor::new(expected_output); let mut cursor = Cursor::new(expected_output);
while let Some(buffer) = h.wait_buffer_or_eos() { while let Some(buffer) = h.wait_buffer_or_eos() {
assert_eq!(buffer.get_offset(), 123 + cursor.position()); assert_eq!(buffer.offset(), 123 + cursor.position());
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
} }
@ -1005,7 +1005,7 @@ fn test_seek_after_buffer_received() {
//wait for a buffer //wait for a buffer
let buffer = h.wait_buffer_or_eos().unwrap(); let buffer = h.wait_buffer_or_eos().unwrap();
assert_eq!(buffer.get_offset(), 0); assert_eq!(buffer.offset(), 0);
//seek to a position after a buffer is Received //seek to a position after a buffer is Received
h.run(|src| { h.run(|src| {
@ -1014,7 +1014,7 @@ fn test_seek_after_buffer_received() {
}); });
let segment = h.wait_for_segment(true); let segment = h.wait_for_segment(true);
assert_eq!(segment.get_start(), gst::format::Bytes::from(123)); assert_eq!(segment.start(), gst::format::Bytes::from(123));
let mut expected_output = vec![0; 8192 - 123]; let mut expected_output = vec![0; 8192 - 123];
for (i, d) in expected_output.iter_mut().enumerate() { for (i, d) in expected_output.iter_mut().enumerate() {
@ -1023,12 +1023,12 @@ fn test_seek_after_buffer_received() {
let mut cursor = Cursor::new(expected_output); let mut cursor = Cursor::new(expected_output);
while let Some(buffer) = h.wait_buffer_or_eos() { while let Some(buffer) = h.wait_buffer_or_eos() {
assert_eq!(buffer.get_offset(), 123 + cursor.position()); assert_eq!(buffer.offset(), 123 + cursor.position());
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
} }
@ -1083,7 +1083,7 @@ fn test_seek_with_stop_position() {
//wait for a buffer //wait for a buffer
let buffer = h.wait_buffer_or_eos().unwrap(); let buffer = h.wait_buffer_or_eos().unwrap();
assert_eq!(buffer.get_offset(), 0); assert_eq!(buffer.offset(), 0);
//seek to a position after a buffer is Received //seek to a position after a buffer is Received
h.run(|src| { h.run(|src| {
@ -1099,8 +1099,8 @@ fn test_seek_with_stop_position() {
}); });
let segment = h.wait_for_segment(true); let segment = h.wait_for_segment(true);
assert_eq!(segment.get_start(), gst::format::Bytes::from(123)); assert_eq!(segment.start(), gst::format::Bytes::from(123));
assert_eq!(segment.get_stop(), gst::format::Bytes::from(131)); assert_eq!(segment.stop(), gst::format::Bytes::from(131));
let mut expected_output = vec![0; 8]; let mut expected_output = vec![0; 8];
for (i, d) in expected_output.iter_mut().enumerate() { for (i, d) in expected_output.iter_mut().enumerate() {
@ -1109,12 +1109,12 @@ fn test_seek_with_stop_position() {
let mut cursor = Cursor::new(expected_output); let mut cursor = Cursor::new(expected_output);
while let Some(buffer) = h.wait_buffer_or_eos() { while let Some(buffer) = h.wait_buffer_or_eos() {
assert_eq!(buffer.get_offset(), 123 + cursor.position()); assert_eq!(buffer.offset(), 123 + cursor.position());
let map = buffer.map_readable().unwrap(); let map = buffer.map_readable().unwrap();
let mut read_buf = vec![0; map.get_size()]; let mut read_buf = vec![0; map.size()];
assert_eq!(cursor.read(&mut read_buf).unwrap(), map.get_size()); assert_eq!(cursor.read(&mut read_buf).unwrap(), map.size());
assert_eq!(&*map, &*read_buf); assert_eq!(&*map, &*read_buf);
} }
} }
@ -1146,7 +1146,7 @@ fn test_cookies() {
let mut num_bytes = 0; let mut num_bytes = 0;
while let Some(buffer) = h.wait_buffer_or_eos() { while let Some(buffer) = h.wait_buffer_or_eos() {
num_bytes += buffer.get_size(); num_bytes += buffer.size();
} }
assert_eq!(num_bytes, 11); assert_eq!(num_bytes, 11);
@ -1182,7 +1182,7 @@ fn test_cookies() {
let mut num_bytes = 0; let mut num_bytes = 0;
while let Some(buffer) = h2.wait_buffer_or_eos() { while let Some(buffer) = h2.wait_buffer_or_eos() {
num_bytes += buffer.get_size(); num_bytes += buffer.size();
} }
assert_eq!(num_bytes, 12); assert_eq!(num_bytes, 12);
} }

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

@ -212,7 +212,7 @@ impl Transcriber {
let latency: gst::ClockTime = (self.settings.lock().unwrap().latency_ms as u64 let latency: gst::ClockTime = (self.settings.lock().unwrap().latency_ms as u64
- (2 * GRANULARITY_MS) as u64) - (2 * GRANULARITY_MS) as u64)
* gst::MSECOND; * gst::MSECOND;
let now = element.get_current_running_time(); let now = element.current_running_time();
if let Some(alternative) = state.partial_alternative.take() { if let Some(alternative) = state.partial_alternative.take() {
self.enqueue(element, &mut state, &alternative, true, latency, now); self.enqueue(element, &mut state, &alternative, true, latency, now);
@ -221,7 +221,7 @@ impl Transcriber {
let send_eos = state.send_eos && state.buffers.is_empty(); let send_eos = state.send_eos && state.buffers.is_empty();
while let Some(buf) = state.buffers.front() { while let Some(buf) = state.buffers.front() {
if now - buf.get_pts() > latency { if now - buf.pts() > latency {
/* Safe unwrap, we know we have an item */ /* Safe unwrap, we know we have an item */
let buf = state.buffers.pop_front().unwrap(); let buf = state.buffers.pop_front().unwrap();
items.push(buf); items.push(buf);
@ -233,7 +233,7 @@ impl Transcriber {
( (
latency, latency,
now, now,
state.out_segment.get_position(), state.out_segment.position(),
send_eos, send_eos,
state.seqnum, state.seqnum,
) )
@ -249,31 +249,25 @@ impl Transcriber {
} }
for mut buf in items.drain(..) { for mut buf in items.drain(..) {
if buf.get_pts() > last_position { if buf.pts() > last_position {
let gap_event = let gap_event = gst::event::Gap::builder(last_position, buf.pts() - last_position)
gst::event::Gap::builder(last_position, buf.get_pts() - last_position) .seqnum(seqnum)
.seqnum(seqnum) .build();
.build(); gst_debug!(CAT, "Pushing gap: {} -> {}", last_position, buf.pts());
gst_debug!(
CAT,
"Pushing gap: {} -> {}",
last_position,
buf.get_pts()
);
if !self.srcpad.push_event(gap_event) { if !self.srcpad.push_event(gap_event) {
return false; return false;
} }
} }
last_position = buf.get_pts() + buf.get_duration(); last_position = buf.pts() + buf.duration();
{ {
let buf = buf.get_mut().unwrap(); let buf = buf.get_mut().unwrap();
buf.set_pts(buf.get_pts()); buf.set_pts(buf.pts());
} }
gst_debug!( gst_debug!(
CAT, CAT,
"Pushing buffer: {} -> {}", "Pushing buffer: {} -> {}",
buf.get_pts(), buf.pts(),
buf.get_pts() + buf.get_duration() buf.pts() + buf.duration()
); );
if self.srcpad.push(buf).is_err() { if self.srcpad.push(buf).is_err() {
return false; return false;
@ -341,15 +335,15 @@ impl Transcriber {
state.discont = false; state.discont = false;
} }
if start_time < state.out_segment.get_position() { if start_time < state.out_segment.position() {
gst_debug!( gst_debug!(
CAT, CAT,
obj: element, obj: element,
"Adjusting item timing({:?} < {:?})", "Adjusting item timing({:?} < {:?})",
start_time, start_time,
state.out_segment.get_position() state.out_segment.position()
); );
start_time = state.out_segment.get_position(); start_time = state.out_segment.position();
if end_time < start_time { if end_time < start_time {
end_time = start_time; end_time = start_time;
} }
@ -449,7 +443,7 @@ impl Transcriber {
((result.end_time as f64 * 1_000_000_000.0) as u64).into(); ((result.end_time as f64 * 1_000_000_000.0) as u64).into();
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
let position = state.out_segment.get_position(); let position = state.out_segment.position();
if end_time < position { if end_time < position {
gst_warning!(CAT, obj: element, gst_warning!(CAT, obj: element,
@ -617,7 +611,7 @@ impl Transcriber {
let ret = self.sinkpad.peer_query(&mut peer_query); let ret = self.sinkpad.peer_query(&mut peer_query);
if ret { if ret {
let (_, min, _) = peer_query.get_result(); let (_, min, _) = peer_query.result();
let our_latency: gst::ClockTime = let our_latency: gst::ClockTime =
self.settings.lock().unwrap().latency_ms as u64 * gst::MSECOND; self.settings.lock().unwrap().latency_ms as u64 * gst::MSECOND;
q.set(true, our_latency + min, gst::CLOCK_TIME_NONE); q.set(true, our_latency + min, gst::CLOCK_TIME_NONE);
@ -625,12 +619,12 @@ impl Transcriber {
ret ret
} }
QueryView::Position(ref mut q) => { QueryView::Position(ref mut q) => {
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
q.set( q.set(
state state
.out_segment .out_segment
.to_stream_time(state.out_segment.get_position()), .to_stream_time(state.out_segment.position()),
); );
true true
} else { } else {
@ -685,15 +679,12 @@ impl Transcriber {
} }
} }
EventView::Segment(e) => { EventView::Segment(e) => {
let segment = match e.get_segment().clone().downcast::<gst::ClockTime>() { let segment = match e.segment().clone().downcast::<gst::ClockTime>() {
Err(segment) => { Err(segment) => {
element_error!( element_error!(
element, element,
gst::StreamError::Format, gst::StreamError::Format,
[ ["Only Time segments supported, got {:?}", segment.format(),]
"Only Time segments supported, got {:?}",
segment.get_format(),
]
); );
return false; return false;
} }
@ -703,13 +694,13 @@ impl Transcriber {
let event = { let event = {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
state.out_segment.set_time(segment.get_time()); state.out_segment.set_time(segment.time());
state state
.out_segment .out_segment
.set_position(gst::ClockTime::from_nseconds(0)); .set_position(gst::ClockTime::from_nseconds(0));
state.in_segment = segment; state.in_segment = segment;
state.seqnum = e.get_seqnum(); state.seqnum = e.seqnum();
gst::event::Segment::builder(&state.out_segment) gst::event::Segment::builder(&state.out_segment)
.seqnum(state.seqnum) .seqnum(state.seqnum)
.build() .build()
@ -745,8 +736,8 @@ impl Transcriber {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
if let Some(buffer) = &buffer { if let Some(buffer) = &buffer {
let running_time = state.in_segment.to_running_time(buffer.get_pts()); let running_time = state.in_segment.to_running_time(buffer.pts());
let now = element.get_current_running_time(); let now = element.current_running_time();
if now.is_some() && now < running_time { if now.is_some() && now < running_time {
delay = Some(running_time - now); delay = Some(running_time - now);
@ -829,7 +820,7 @@ impl Transcriber {
return Ok(()); return Ok(());
} }
let in_caps = self.sinkpad.get_current_caps().unwrap(); let in_caps = self.sinkpad.current_caps().unwrap();
let s = in_caps.get_structure(0).unwrap(); let s = in_caps.get_structure(0).unwrap();
let sample_rate: i32 = s.get("rate").unwrap().unwrap(); let sample_rate: i32 = s.get("rate").unwrap().unwrap();
@ -1079,7 +1070,7 @@ impl ObjectImpl for Transcriber {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"language_code" => { "language_code" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.language_code = value.get().expect("type checked upstream"); settings.language_code = value.get().expect("type checked upstream");
@ -1101,7 +1092,7 @@ impl ObjectImpl for Transcriber {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"language-code" => { "language-code" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.language_code.to_value() settings.language_code.to_value()

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

@ -397,7 +397,7 @@ impl ObjectImpl for S3Sink {
) { ) {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"bucket" => { "bucket" => {
settings.bucket = value.get::<String>().expect("type checked upstream"); settings.bucket = value.get::<String>().expect("type checked upstream");
} }
@ -423,7 +423,7 @@ impl ObjectImpl for S3Sink {
fn get_property(&self, _: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
match pspec.get_name() { match pspec.name() {
"key" => settings.key.to_value(), "key" => settings.key.to_value(),
"bucket" => settings.bucket.to_value(), "bucket" => settings.bucket.to_value(),
"region" => settings.region.name().to_value(), "region" => settings.region.name().to_value(),

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

@ -232,7 +232,7 @@ impl ObjectImpl for S3Src {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"uri" => { "uri" => {
let _ = self.set_uri(obj, value.get().expect("type checked upstream")); let _ = self.set_uri(obj, value.get().expect("type checked upstream"));
} }
@ -241,7 +241,7 @@ impl ObjectImpl for S3Src {
} }
fn get_property(&self, _: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"uri" => { "uri" => {
let url = match *self.url.lock().unwrap() { let url = match *self.url.lock().unwrap() {
Some(ref url) => url.to_string(), Some(ref url) => url.to_string(),

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

@ -79,8 +79,8 @@ impl JsonGstEnc {
element: &super::JsonGstEnc, element: &super::JsonGstEnc,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
let pts = buffer.get_pts(); let pts = buffer.pts();
let duration = buffer.get_duration(); let duration = buffer.duration();
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
@ -182,7 +182,7 @@ impl JsonGstEnc {
EventView::Caps(e) => { EventView::Caps(e) => {
{ {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
let caps = e.get_caps(); let caps = e.caps();
let s = caps.get_structure(0).unwrap(); let s = caps.get_structure(0).unwrap();
state.format = match s.get::<String>("format") { state.format = match s.get::<String>("format") {
Err(_) => None, Err(_) => None,

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

@ -275,8 +275,8 @@ impl JsonGstParse {
state.add_buffer_metadata(element, &mut buffer, pts, duration); state.add_buffer_metadata(element, &mut buffer, pts, duration);
let send_eos = state.segment.get_stop().is_some() let send_eos = state.segment.stop().is_some()
&& buffer.get_pts() + buffer.get_duration() >= state.segment.get_stop(); && buffer.pts() + buffer.duration() >= state.segment.stop();
// Drop our state mutex while we push out buffers or events // Drop our state mutex while we push out buffers or events
drop(state); drop(state);
@ -343,7 +343,7 @@ impl JsonGstParse {
pts: gst::ClockTime, pts: gst::ClockTime,
mut state: MutexGuard<State>, mut state: MutexGuard<State>,
) -> MutexGuard<State> { ) -> MutexGuard<State> {
if pts >= state.segment.get_start() { if pts >= state.segment.start() {
state.seeking = false; state.seeking = false;
state.discont = true; state.discont = true;
state.replay_last_line = true; state.replay_last_line = true;
@ -446,7 +446,7 @@ impl JsonGstParse {
)); ));
} }
let size = match q.get_result().try_into().unwrap() { let size = match q.result().try_into().unwrap() {
gst::format::Bytes(Some(size)) => size, gst::format::Bytes(Some(size)) => size,
gst::format::Bytes(None) => { gst::format::Bytes(None) => {
return Err(gst::loggable_error!( return Err(gst::loggable_error!(
@ -682,7 +682,7 @@ impl JsonGstParse {
_ => { _ => {
if event.is_sticky() if event.is_sticky()
&& !self.srcpad.has_current_caps() && !self.srcpad.has_current_caps()
&& event.get_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();
@ -729,7 +729,7 @@ impl JsonGstParse {
return false; return false;
} }
let seek_seqnum = event.get_seqnum(); let seek_seqnum = event.seqnum();
let event = gst::event::FlushStart::builder() let event = gst::event::FlushStart::builder()
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
@ -812,7 +812,7 @@ impl JsonGstParse {
QueryView::Seeking(mut q) => { QueryView::Seeking(mut q) => {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
let fmt = q.get_format(); let fmt = q.format();
if fmt == gst::Format::Time { if fmt == gst::Format::Time {
if let Some(pull) = state.pull.as_ref() { if let Some(pull) = state.pull.as_ref() {
@ -831,7 +831,7 @@ impl JsonGstParse {
} }
QueryView::Position(ref mut q) => { QueryView::Position(ref mut q) => {
// For Time answer ourselfs, otherwise forward // For Time answer ourselfs, otherwise forward
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
q.set(state.last_position); q.set(state.last_position);
true true
@ -842,7 +842,7 @@ impl JsonGstParse {
QueryView::Duration(ref mut q) => { QueryView::Duration(ref mut q) => {
// For Time answer ourselfs, otherwise forward // For Time answer ourselfs, otherwise forward
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
if let Some(pull) = state.pull.as_ref() { if let Some(pull) = state.pull.as_ref() {
if pull.duration.is_some() { if pull.duration.is_some() {
q.set(state.pull.as_ref().unwrap().duration); q.set(state.pull.as_ref().unwrap().duration);

10
text/json/tests/json.rs
View file

@ -55,8 +55,8 @@ fn test_enc() {
); );
let buf = h.pull().expect("Couldn't pull buffer"); let buf = h.pull().expect("Couldn't pull buffer");
assert_eq!(buf.get_pts(), 0.into()); assert_eq!(buf.pts(), 0.into());
assert_eq!(buf.get_duration(), 2 * gst::SECOND); assert_eq!(buf.duration(), 2 * gst::SECOND);
let map = buf.map_readable().expect("Couldn't map buffer readable"); let map = buf.map_readable().expect("Couldn't map buffer readable");
assert_eq!( assert_eq!(
std::str::from_utf8(map.as_ref()), std::str::from_utf8(map.as_ref()),
@ -87,7 +87,7 @@ fn test_parse() {
match ev.view() { match ev.view() {
EventView::Caps(ev) => { EventView::Caps(ev) => {
assert!(ev.get_caps().is_strictly_equal(&gst::Caps::new_simple( assert!(ev.caps().is_strictly_equal(&gst::Caps::new_simple(
&"application/x-json", &"application/x-json",
&[(&"format", &"test")] &[(&"format", &"test")]
))); )));
@ -98,7 +98,7 @@ fn test_parse() {
let buf = h.pull().expect("Couldn't pull buffer"); let buf = h.pull().expect("Couldn't pull buffer");
let map = buf.map_readable().expect("Couldn't map buffer readable"); let map = buf.map_readable().expect("Couldn't map buffer readable");
assert_eq!(buf.get_pts(), 0.into()); assert_eq!(buf.pts(), 0.into());
assert_eq!(buf.get_duration(), 2 * gst::SECOND); assert_eq!(buf.duration(), 2 * gst::SECOND);
assert_eq!(std::str::from_utf8(map.as_ref()), Ok("{\"foo\":42}")); assert_eq!(std::str::from_utf8(map.as_ref()), Ok("{\"foo\":42}"));
} }

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

@ -187,7 +187,7 @@ impl ObjectImpl for RegEx {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"commands" => { "commands" => {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
state.commands = vec![]; state.commands = vec![];
@ -202,7 +202,7 @@ impl ObjectImpl for RegEx {
continue; continue;
} }
}; };
let operation = s.get_name(); let operation = s.name();
let pattern = match s.get::<String>("pattern") { let pattern = match s.get::<String>("pattern") {
Ok(Some(pattern)) => pattern, Ok(Some(pattern)) => pattern,
@ -249,7 +249,7 @@ impl ObjectImpl for RegEx {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"commands" => { "commands" => {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
let mut commands = vec![]; let mut commands = vec![];

6
text/regex/tests/regex.rs
View file

@ -38,7 +38,7 @@ fn test_replace_all() {
let mut h = gst_check::Harness::new("regex"); let mut h = gst_check::Harness::new("regex");
{ {
let regex = h.get_element().expect("Could not create regex"); let regex = h.element().expect("Could not create regex");
let command = gst::Structure::new( let command = gst::Structure::new(
"replace-all", "replace-all",
@ -64,8 +64,8 @@ fn test_replace_all() {
let buf = h.pull().expect("Couldn't pull buffer"); let buf = h.pull().expect("Couldn't pull buffer");
assert_eq!(buf.get_pts(), 0.into()); assert_eq!(buf.pts(), 0.into());
assert_eq!(buf.get_duration(), 2 * gst::SECOND); assert_eq!(buf.duration(), 2 * gst::SECOND);
let map = buf.map_readable().expect("Couldn't map buffer readable"); let map = buf.map_readable().expect("Couldn't map buffer readable");

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

@ -147,7 +147,7 @@ impl TextWrap {
self.update_wrapper(element); self.update_wrapper(element);
let mut pts: gst::ClockTime = buffer let mut pts: gst::ClockTime = buffer
.get_pts() .pts()
.ok_or_else(|| { .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
@ -155,7 +155,7 @@ impl TextWrap {
.into(); .into();
let duration: gst::ClockTime = buffer let duration: gst::ClockTime = buffer
.get_duration() .duration()
.ok_or_else(|| { .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
@ -181,7 +181,7 @@ impl TextWrap {
let mut bufferlist = gst::BufferList::new(); let mut bufferlist = gst::BufferList::new();
let n_lines = std::cmp::max(self.settings.lock().unwrap().lines, 1); let n_lines = std::cmp::max(self.settings.lock().unwrap().lines, 1);
if state.start_ts.is_some() && state.start_ts + accumulate_time < buffer.get_pts() { if state.start_ts.is_some() && state.start_ts + accumulate_time < buffer.pts() {
let mut buf = gst::Buffer::from_mut_slice( let mut buf = gst::Buffer::from_mut_slice(
mem::replace(&mut state.current_text, String::new()).into_bytes(), mem::replace(&mut state.current_text, String::new()).into_bytes(),
); );
@ -200,10 +200,10 @@ impl TextWrap {
duration / data.split_whitespace().count() as u64; duration / data.split_whitespace().count() as u64;
if state.start_ts.is_none() { if state.start_ts.is_none() {
state.start_ts = buffer.get_pts(); state.start_ts = buffer.pts();
} }
state.end_ts = buffer.get_pts(); state.end_ts = buffer.pts();
let words = data.split_whitespace(); let words = data.split_whitespace();
let mut current_text = state.current_text.to_string(); let mut current_text = state.current_text.to_string();
@ -397,7 +397,7 @@ impl TextWrap {
let ret = self.sinkpad.peer_query(&mut peer_query); let ret = self.sinkpad.peer_query(&mut peer_query);
if ret { if ret {
let (live, min, _) = peer_query.get_result(); let (live, min, _) = peer_query.result();
let our_latency: gst::ClockTime = self let our_latency: gst::ClockTime = self
.settings .settings
.lock() .lock()
@ -530,7 +530,7 @@ impl ObjectImpl for TextWrap {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"dictionary" => { "dictionary" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
@ -570,7 +570,7 @@ impl ObjectImpl for TextWrap {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"dictionary" => { "dictionary" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.dictionary.to_value() settings.dictionary.to_value()

16
text/wrap/tests/textwrap.rs
View file

@ -38,7 +38,7 @@ fn test_columns() {
let mut h = gst_check::Harness::new("textwrap"); let mut h = gst_check::Harness::new("textwrap");
{ {
let wrap = h.get_element().expect("Could not create textwrap"); let wrap = h.element().expect("Could not create textwrap");
wrap.set_property("columns", &5u32).unwrap(); wrap.set_property("columns", &5u32).unwrap();
} }
@ -56,8 +56,8 @@ fn test_columns() {
let buf = h.pull().expect("Couldn't pull buffer"); let buf = h.pull().expect("Couldn't pull buffer");
assert_eq!(buf.get_pts(), 0.into()); assert_eq!(buf.pts(), 0.into());
assert_eq!(buf.get_duration(), 2 * gst::SECOND); assert_eq!(buf.duration(), 2 * gst::SECOND);
let map = buf.map_readable().expect("Couldn't map buffer readable"); let map = buf.map_readable().expect("Couldn't map buffer readable");
@ -76,7 +76,7 @@ fn test_lines() {
let mut h = gst_check::Harness::new("textwrap"); let mut h = gst_check::Harness::new("textwrap");
{ {
let wrap = h.get_element().expect("Could not create textwrap"); let wrap = h.element().expect("Could not create textwrap");
wrap.set_property("columns", &5u32).unwrap(); wrap.set_property("columns", &5u32).unwrap();
wrap.set_property("lines", &2u32).unwrap(); wrap.set_property("lines", &2u32).unwrap();
} }
@ -95,8 +95,8 @@ fn test_lines() {
let buf = h.pull().expect("Couldn't pull buffer"); let buf = h.pull().expect("Couldn't pull buffer");
assert_eq!(buf.get_pts(), 0.into()); assert_eq!(buf.pts(), 0.into());
assert_eq!(buf.get_duration(), gst::SECOND); assert_eq!(buf.duration(), gst::SECOND);
let expected_output = "Split\nthis"; let expected_output = "Split\nthis";
@ -109,8 +109,8 @@ fn test_lines() {
let buf = h.pull().expect("Couldn't pull buffer"); let buf = h.pull().expect("Couldn't pull buffer");
assert_eq!(buf.get_pts(), gst::SECOND); assert_eq!(buf.pts(), gst::SECOND);
assert_eq!(buf.get_duration(), gst::SECOND); assert_eq!(buf.duration(), gst::SECOND);
let expected_output = "text\nup"; let expected_output = "text\nup";

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

@ -104,7 +104,7 @@ impl ObjectImpl for ProgressBin {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"output" => { "output" => {
let mut output_type = self.output_type.lock().unwrap(); let mut output_type = self.output_type.lock().unwrap();
let new_output_type = value let new_output_type = value
@ -126,7 +126,7 @@ impl ObjectImpl for ProgressBin {
// Called whenever a value of a property is read. It can be called // Called whenever a value of a property is read. It can be called
// at any time from any thread. // at any time from any thread.
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"output" => { "output" => {
let output_type = self.output_type.lock().unwrap(); let output_type = self.output_type.lock().unwrap();
output_type.to_value() output_type.to_value()
@ -223,13 +223,13 @@ impl BinImpl for ProgressBin {
// handling of the parent class, i.e. forwarding to the parent // handling of the parent class, i.e. forwarding to the parent
// bins and the application. // bins and the application.
MessageView::Element(ref msg) MessageView::Element(ref msg)
if msg.get_src().as_ref() == Some(self.progress.upcast_ref()) if msg.src().as_ref() == Some(self.progress.upcast_ref())
&& msg && msg
.get_structure() .structure()
.map(|s| s.get_name() == "progress") .map(|s| s.name() == "progress")
.unwrap_or(false) => .unwrap_or(false) =>
{ {
let s = msg.get_structure().unwrap(); let s = msg.structure().unwrap();
if let Ok(percent) = s.get_some::<f64>("percent-double") { if let Ok(percent) = s.get_some::<f64>("percent-double") {
let output_type = *self.output_type.lock().unwrap(); let output_type = *self.output_type.lock().unwrap();
match output_type { match output_type {

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

@ -134,7 +134,7 @@ impl ObjectImpl for Rgb2Gray {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"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");
@ -166,7 +166,7 @@ impl ObjectImpl for Rgb2Gray {
// Called whenever a value of a property is read. It can be called // Called whenever a value of a property is read. It can be called
// at any time from any thread. // at any time from any thread.
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"invert" => { "invert" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.invert.to_value() settings.invert.to_value()

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

@ -233,7 +233,7 @@ impl ObjectImpl for SineSrc {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"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");
@ -304,7 +304,7 @@ impl ObjectImpl for SineSrc {
// Called whenever a value of a property is read. It can be called // Called whenever a value of a property is read. It can be called
// at any time from any thread. // at any time from any thread.
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"samples-per-buffer" => { "samples-per-buffer" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.samples_per_buffer.to_value() settings.samples_per_buffer.to_value()
@ -544,7 +544,7 @@ impl BaseSrcImpl for SineSrc {
// reverse playback is requested. These values will all be used during buffer creation // reverse playback is requested. These values will all be used during buffer creation
// and for calculating the timestamps, etc. // and for calculating the timestamps, etc.
if segment.get_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;
} }
@ -564,13 +564,13 @@ impl BaseSrcImpl for SineSrc {
use std::f64::consts::PI; use std::f64::consts::PI;
let sample_offset = segment let sample_offset = segment
.get_start() .start()
.unwrap() .unwrap()
.mul_div_floor(rate, gst::SECOND_VAL) .mul_div_floor(rate, gst::SECOND_VAL)
.unwrap(); .unwrap();
let sample_stop = segment let sample_stop = segment
.get_stop() .stop()
.map(|v| v.mul_div_floor(rate, gst::SECOND_VAL).unwrap()); .map(|v| v.mul_div_floor(rate, gst::SECOND_VAL).unwrap());
let accumulator = let accumulator =
@ -606,8 +606,8 @@ impl BaseSrcImpl for SineSrc {
return false; return false;
} }
let sample_offset = segment.get_start().unwrap(); let sample_offset = segment.start().unwrap();
let sample_stop = segment.get_stop().0; let sample_stop = segment.stop().0;
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));
@ -635,7 +635,7 @@ impl BaseSrcImpl for SineSrc {
CAT, CAT,
obj: element, obj: element,
"Can't seek in format {:?}", "Can't seek in format {:?}",
segment.get_format() segment.format()
); );
false false
@ -757,17 +757,14 @@ impl PushSrcImpl for SineSrc {
// with its own clock would require various translations between the two clocks. // with its own clock would require various translations between the two clocks.
// This is out of scope for the tutorial though. // This is out of scope for the tutorial though.
if element.is_live() { if element.is_live() {
let clock = match element.get_clock() { let clock = match element.clock() {
None => return Ok(buffer), None => return Ok(buffer),
Some(clock) => clock, Some(clock) => clock,
}; };
let segment = element let segment = element.segment().downcast::<gst::format::Time>().unwrap();
.get_segment() let base_time = element.base_time();
.downcast::<gst::format::Time>() let running_time = segment.to_running_time(buffer.pts() + buffer.duration());
.unwrap();
let base_time = element.get_base_time();
let running_time = segment.to_running_time(buffer.get_pts() + buffer.get_duration());
// The last sample's clock time is the base time of the element plus the // The last sample's clock time is the base time of the element plus the
// running time of the last sample // running time of the last sample
@ -794,7 +791,7 @@ impl PushSrcImpl for SineSrc {
obj: element, obj: element,
"Waiting until {}, now {}", "Waiting until {}, now {}",
wait_until, wait_until,
clock.get_time() clock.time()
); );
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);

14
utils/fallbackswitch/examples/gtk_fallbackswitch.rs
View file

@ -49,12 +49,12 @@ fn create_pipeline() -> (gst::Pipeline, gst::Pad, gst::Element, gtk::Widget) {
let videoconvert_clone = videoconvert.clone(); let videoconvert_clone = videoconvert.clone();
decodebin.connect_pad_added(move |_, pad| { decodebin.connect_pad_added(move |_, pad| {
let caps = pad.get_current_caps().unwrap(); let caps = pad.current_caps().unwrap();
let s = caps.get_structure(0).unwrap(); let s = caps.get_structure(0).unwrap();
let sinkpad = videoconvert_clone.get_static_pad("sink").unwrap(); let sinkpad = videoconvert_clone.get_static_pad("sink").unwrap();
if s.get_name() == "video/x-raw" && !sinkpad.is_linked() { if s.name() == "video/x-raw" && !sinkpad.is_linked() {
pad.link(&sinkpad).unwrap(); pad.link(&sinkpad).unwrap();
} }
}); });
@ -147,7 +147,7 @@ fn create_ui(app: &gtk::Application) {
None => return, None => return,
}; };
let drop = drop_button.get_active(); let drop = drop_button.active();
if drop { if drop {
let mut drop_id = drop_id.borrow_mut(); let mut drop_id = drop_id.borrow_mut();
if drop_id.is_none() { if drop_id.is_none() {
@ -170,7 +170,7 @@ fn create_ui(app: &gtk::Application) {
Inhibit(false) Inhibit(false)
}); });
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
let app_weak = app.downgrade(); let app_weak = app.downgrade();
bus.add_watch_local(move |_, msg| { bus.add_watch_local(move |_, msg| {
use gst::MessageView; use gst::MessageView;
@ -185,9 +185,9 @@ fn create_ui(app: &gtk::Application) {
MessageView::Error(err) => { MessageView::Error(err) => {
println!( println!(
"Error from {:?}: {} ({:?})", "Error from {:?}: {} ({:?})",
msg.get_src().map(|s| s.get_path_string()), msg.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
app.quit(); app.quit();
} }

8
utils/fallbackswitch/src/base/aggregator.rs
View file

@ -18,10 +18,10 @@ use std::mem;
use std::ptr; use std::ptr;
pub trait AggregatorExtManual: 'static { pub trait AggregatorExtManual: 'static {
fn get_allocator(&self) -> (Option<gst::Allocator>, gst::AllocationParams); fn allocator(&self) -> (Option<gst::Allocator>, gst::AllocationParams);
fn finish_buffer(&self, buffer: gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError>; fn finish_buffer(&self, buffer: gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError>;
fn get_property_min_upstream_latency(&self) -> gst::ClockTime; fn property_min_upstream_latency(&self) -> gst::ClockTime;
fn set_property_min_upstream_latency(&self, min_upstream_latency: gst::ClockTime); fn set_property_min_upstream_latency(&self, min_upstream_latency: gst::ClockTime);
@ -32,7 +32,7 @@ pub trait AggregatorExtManual: 'static {
} }
impl<O: IsA<Aggregator>> AggregatorExtManual for O { impl<O: IsA<Aggregator>> AggregatorExtManual for O {
fn get_allocator(&self) -> (Option<gst::Allocator>, gst::AllocationParams) { fn allocator(&self) -> (Option<gst::Allocator>, gst::AllocationParams) {
unsafe { unsafe {
let mut allocator = ptr::null_mut(); let mut allocator = ptr::null_mut();
let mut params = mem::zeroed(); let mut params = mem::zeroed();
@ -55,7 +55,7 @@ impl<O: IsA<Aggregator>> AggregatorExtManual for O {
ret.into_result() ret.into_result()
} }
fn get_property_min_upstream_latency(&self) -> gst::ClockTime { fn property_min_upstream_latency(&self) -> gst::ClockTime {
unsafe { unsafe {
let mut value = Value::from_type(<gst::ClockTime as StaticType>::static_type()); let mut value = Value::from_type(<gst::ClockTime as StaticType>::static_type());
glib::gobject_ffi::g_object_get_property( glib::gobject_ffi::g_object_get_property(

4
utils/fallbackswitch/src/base/aggregator_pad.rs
View file

@ -12,11 +12,11 @@ use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
pub trait AggregatorPadExtManual: 'static { pub trait AggregatorPadExtManual: 'static {
fn get_segment(&self) -> gst::Segment; fn segment(&self) -> gst::Segment;
} }
impl<O: IsA<AggregatorPad>> AggregatorPadExtManual for O { impl<O: IsA<AggregatorPad>> AggregatorPadExtManual for O {
fn get_segment(&self) -> gst::Segment { fn segment(&self) -> gst::Segment {
unsafe { unsafe {
let ptr: &ffi::GstAggregatorPad = &*(self.as_ptr() as *const _); let ptr: &ffi::GstAggregatorPad = &*(self.as_ptr() as *const _);
let _guard = super::utils::MutexGuard::lock(&ptr.parent.object.lock); let _guard = super::utils::MutexGuard::lock(&ptr.parent.object.lock);

76
utils/fallbackswitch/src/base/subclass/aggregator.rs
View file

@ -245,7 +245,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
fn parent_flush(&self, aggregator: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> { fn parent_flush(&self, aggregator: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
(*parent_class) (*parent_class)
.flush .flush
.map(|f| { .map(|f| {
@ -267,7 +267,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> Option<gst::Buffer> { ) -> Option<gst::Buffer> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
match (*parent_class).clip { match (*parent_class).clip {
None => Some(buffer), None => Some(buffer),
Some(ref func) => from_glib_full(func( Some(ref func) => from_glib_full(func(
@ -286,7 +286,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.finish_buffer .finish_buffer
.expect("Missing parent function `finish_buffer`"); .expect("Missing parent function `finish_buffer`");
@ -306,7 +306,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> bool { ) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.sink_event .sink_event
.expect("Missing parent function `sink_event`"); .expect("Missing parent function `sink_event`");
@ -326,7 +326,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.sink_event_pre_queue .sink_event_pre_queue
.expect("Missing parent function `sink_event_pre_queue`"); .expect("Missing parent function `sink_event_pre_queue`");
@ -347,7 +347,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> bool { ) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.sink_query .sink_query
.expect("Missing parent function `sink_query`"); .expect("Missing parent function `sink_query`");
@ -367,7 +367,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> bool { ) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.sink_query_pre_queue .sink_query_pre_queue
.expect("Missing parent function `sink_query`"); .expect("Missing parent function `sink_query`");
@ -382,7 +382,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
fn parent_src_event(&self, aggregator: &Self::Type, event: gst::Event) -> bool { fn parent_src_event(&self, aggregator: &Self::Type, event: gst::Event) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.src_event .src_event
.expect("Missing parent function `src_event`"); .expect("Missing parent function `src_event`");
@ -396,7 +396,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
fn parent_src_query(&self, aggregator: &Self::Type, query: &mut gst::QueryRef) -> bool { fn parent_src_query(&self, aggregator: &Self::Type, query: &mut gst::QueryRef) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.src_query .src_query
.expect("Missing parent function `src_query`"); .expect("Missing parent function `src_query`");
@ -415,7 +415,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
match (*parent_class).src_activate { match (*parent_class).src_activate {
None => Ok(()), None => Ok(()),
Some(f) => gst::result_from_gboolean!( Some(f) => gst::result_from_gboolean!(
@ -438,7 +438,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.aggregate .aggregate
.expect("Missing parent function `aggregate`"); .expect("Missing parent function `aggregate`");
@ -453,7 +453,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
fn parent_start(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_start(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
(*parent_class) (*parent_class)
.start .start
.map(|f| { .map(|f| {
@ -477,7 +477,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
fn parent_stop(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_stop(&self, aggregator: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
(*parent_class) (*parent_class)
.stop .stop
.map(|f| { .map(|f| {
@ -501,7 +501,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
fn parent_get_next_time(&self, aggregator: &Self::Type) -> gst::ClockTime { fn parent_get_next_time(&self, aggregator: &Self::Type) -> gst::ClockTime {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
(*parent_class) (*parent_class)
.get_next_time .get_next_time
.map(|f| { .map(|f| {
@ -523,7 +523,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> Option<AggregatorPad> { ) -> Option<AggregatorPad> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.create_new_pad .create_new_pad
.expect("Missing parent function `create_new_pad`"); .expect("Missing parent function `create_new_pad`");
@ -543,7 +543,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> Result<gst::Caps, gst::FlowError> { ) -> Result<gst::Caps, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.update_src_caps .update_src_caps
.expect("Missing parent function `update_src_caps`"); .expect("Missing parent function `update_src_caps`");
@ -561,7 +561,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
fn parent_fixate_src_caps(&self, aggregator: &Self::Type, caps: gst::Caps) -> gst::Caps { fn parent_fixate_src_caps(&self, aggregator: &Self::Type, caps: gst::Caps) -> gst::Caps {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
let f = (*parent_class) let f = (*parent_class)
.fixate_src_caps .fixate_src_caps
@ -580,7 +580,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
(*parent_class) (*parent_class)
.negotiated_src_caps .negotiated_src_caps
.map(|f| { .map(|f| {
@ -600,7 +600,7 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
fn parent_negotiate(&self, aggregator: &Self::Type) -> bool { fn parent_negotiate(&self, aggregator: &Self::Type) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorClass;
(*parent_class) (*parent_class)
.negotiate .negotiate
.map(|f| { .map(|f| {
@ -650,7 +650,7 @@ unsafe extern "C" fn aggregator_flush<T: AggregatorImpl>(
ptr: *mut ffi::GstAggregator, ptr: *mut ffi::GstAggregator,
) -> gst::ffi::GstFlowReturn { ) -> gst::ffi::GstFlowReturn {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, { gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
@ -665,7 +665,7 @@ unsafe extern "C" fn aggregator_clip<T: AggregatorImpl>(
buffer: *mut gst::ffi::GstBuffer, buffer: *mut gst::ffi::GstBuffer,
) -> *mut gst::ffi::GstBuffer { ) -> *mut gst::ffi::GstBuffer {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
let ret = gst::panic_to_error!(&wrap, &imp.panicked(), None, { let ret = gst::panic_to_error!(&wrap, &imp.panicked(), None, {
@ -684,7 +684,7 @@ unsafe extern "C" fn aggregator_finish_buffer<T: AggregatorImpl>(
buffer: *mut gst::ffi::GstBuffer, buffer: *mut gst::ffi::GstBuffer,
) -> gst::ffi::GstFlowReturn { ) -> gst::ffi::GstFlowReturn {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, { gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
@ -700,7 +700,7 @@ unsafe extern "C" fn aggregator_sink_event<T: AggregatorImpl>(
event: *mut gst::ffi::GstEvent, event: *mut gst::ffi::GstEvent,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(wrap, &imp.panicked(), false, { gst::panic_to_error!(wrap, &imp.panicked(), false, {
@ -719,7 +719,7 @@ unsafe extern "C" fn aggregator_sink_event_pre_queue<T: AggregatorImpl>(
event: *mut gst::ffi::GstEvent, event: *mut gst::ffi::GstEvent,
) -> gst::ffi::GstFlowReturn { ) -> gst::ffi::GstFlowReturn {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, { gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
@ -739,7 +739,7 @@ unsafe extern "C" fn aggregator_sink_query<T: AggregatorImpl>(
query: *mut gst::ffi::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {
@ -758,7 +758,7 @@ unsafe extern "C" fn aggregator_sink_query_pre_queue<T: AggregatorImpl>(
query: *mut gst::ffi::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {
@ -776,7 +776,7 @@ unsafe extern "C" fn aggregator_src_event<T: AggregatorImpl>(
event: *mut gst::ffi::GstEvent, event: *mut gst::ffi::GstEvent,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {
@ -790,7 +790,7 @@ unsafe extern "C" fn aggregator_src_query<T: AggregatorImpl>(
query: *mut gst::ffi::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {
@ -805,7 +805,7 @@ unsafe extern "C" fn aggregator_src_activate<T: AggregatorImpl>(
active: glib::ffi::gboolean, active: glib::ffi::gboolean,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {
@ -825,7 +825,7 @@ unsafe extern "C" fn aggregator_aggregate<T: AggregatorImpl>(
timeout: glib::ffi::gboolean, timeout: glib::ffi::gboolean,
) -> gst::ffi::GstFlowReturn { ) -> gst::ffi::GstFlowReturn {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, { gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
@ -839,7 +839,7 @@ unsafe extern "C" fn aggregator_start<T: AggregatorImpl>(
ptr: *mut ffi::GstAggregator, ptr: *mut ffi::GstAggregator,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {
@ -858,7 +858,7 @@ unsafe extern "C" fn aggregator_stop<T: AggregatorImpl>(
ptr: *mut ffi::GstAggregator, ptr: *mut ffi::GstAggregator,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {
@ -877,7 +877,7 @@ unsafe extern "C" fn aggregator_get_next_time<T: AggregatorImpl>(
ptr: *mut ffi::GstAggregator, ptr: *mut ffi::GstAggregator,
) -> gst::ffi::GstClockTime { ) -> gst::ffi::GstClockTime {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::CLOCK_TIME_NONE, { gst::panic_to_error!(&wrap, &imp.panicked(), gst::CLOCK_TIME_NONE, {
@ -893,7 +893,7 @@ unsafe extern "C" fn aggregator_create_new_pad<T: AggregatorImpl>(
caps: *const gst::ffi::GstCaps, caps: *const gst::ffi::GstCaps,
) -> *mut ffi::GstAggregatorPad { ) -> *mut ffi::GstAggregatorPad {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), None, { gst::panic_to_error!(&wrap, &imp.panicked(), None, {
@ -917,7 +917,7 @@ unsafe extern "C" fn aggregator_update_src_caps<T: AggregatorImpl>(
res: *mut *mut gst::ffi::GstCaps, res: *mut *mut gst::ffi::GstCaps,
) -> gst::ffi::GstFlowReturn { ) -> gst::ffi::GstFlowReturn {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
*res = ptr::null_mut(); *res = ptr::null_mut();
@ -939,7 +939,7 @@ unsafe extern "C" fn aggregator_fixate_src_caps<T: AggregatorImpl>(
caps: *mut gst::ffi::GstCaps, caps: *mut gst::ffi::GstCaps,
) -> *mut gst::ffi::GstCaps { ) -> *mut gst::ffi::GstCaps {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), { gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
@ -953,7 +953,7 @@ unsafe extern "C" fn aggregator_negotiated_src_caps<T: AggregatorImpl>(
caps: *mut gst::ffi::GstCaps, caps: *mut gst::ffi::GstCaps,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {
@ -972,7 +972,7 @@ unsafe extern "C" fn aggregator_negotiate<T: AggregatorImpl>(
ptr: *mut ffi::GstAggregator, ptr: *mut ffi::GstAggregator,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr); let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, { gst::panic_to_error!(&wrap, &imp.panicked(), false, {

8
utils/fallbackswitch/src/base/subclass/aggregator_pad.rs
View file

@ -59,7 +59,7 @@ impl<T: AggregatorPadImpl> AggregatorPadImplExt for T {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorPadClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorPadClass;
(*parent_class) (*parent_class)
.flush .flush
.map(|f| { .map(|f| {
@ -84,7 +84,7 @@ impl<T: AggregatorPadImpl> AggregatorPadImplExt for T {
) -> bool { ) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstAggregatorPadClass; let parent_class = data.as_ref().parent_class() as *mut ffi::GstAggregatorPadClass;
(*parent_class) (*parent_class)
.skip_buffer .skip_buffer
.map(|f| { .map(|f| {
@ -119,7 +119,7 @@ unsafe extern "C" fn aggregator_pad_flush<T: AggregatorPadImpl>(
aggregator: *mut ffi::GstAggregator, aggregator: *mut ffi::GstAggregator,
) -> gst::ffi::GstFlowReturn { ) -> gst::ffi::GstFlowReturn {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<AggregatorPad> = from_glib_borrow(ptr); let wrap: Borrowed<AggregatorPad> = from_glib_borrow(ptr);
let res: gst::FlowReturn = imp let res: gst::FlowReturn = imp
@ -134,7 +134,7 @@ unsafe extern "C" fn aggregator_pad_skip_buffer<T: AggregatorPadImpl>(
buffer: *mut gst::ffi::GstBuffer, buffer: *mut gst::ffi::GstBuffer,
) -> glib::ffi::gboolean { ) -> glib::ffi::gboolean {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.impl_();
let wrap: Borrowed<AggregatorPad> = from_glib_borrow(ptr); let wrap: Borrowed<AggregatorPad> = from_glib_borrow(ptr);
imp.skip_buffer( imp.skip_buffer(

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

@ -83,7 +83,7 @@ impl ObjectImpl for CustomSource {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"source" => { "source" => {
let source = value.get::<gst::Element>().unwrap().unwrap(); let source = value.get::<gst::Element>().unwrap().unwrap();
self.source.set(source.clone()).unwrap(); self.source.set(source.clone()).unwrap();
@ -178,11 +178,11 @@ impl CustomSource {
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.get_pad_template_list(); let templates = source.pad_template_list();
if templates if templates
.iter() .iter()
.any(|templ| templ.get_property_presence() == gst::PadPresence::Request) .any(|templ| templ.property_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!(
@ -195,10 +195,10 @@ impl CustomSource {
let has_sometimes_pads = templates let has_sometimes_pads = templates
.iter() .iter()
.any(|templ| templ.get_property_presence() == gst::PadPresence::Sometimes); .any(|templ| templ.property_presence() == gst::PadPresence::Sometimes);
// Handle all source pads that already exist // Handle all source pads that already exist
for pad in source.get_src_pads() { for pad in source.src_pads() {
if let Err(msg) = self.handle_source_pad_added(&element, &pad) { if let Err(msg) = self.handle_source_pad_added(&element, &pad) {
element.post_error_message(msg); element.post_error_message(msg);
return Err(gst::StateChangeError); return Err(gst::StateChangeError);
@ -253,7 +253,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.get_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();
@ -262,19 +262,16 @@ impl CustomSource {
// Take stream type from stream-start event if we can // Take stream type from stream-start event if we can
if let Some(event) = pad.get_sticky_event(gst::EventType::StreamStart, 0) { if let Some(event) = pad.get_sticky_event(gst::EventType::StreamStart, 0) {
if let gst::EventView::StreamStart(ev) = event.view() { if let gst::EventView::StreamStart(ev) = event.view() {
stream_type = ev.get_stream().map(|s| s.get_stream_type()); stream_type = ev.stream().map(|s| s.stream_type());
} }
} }
// Otherwise from the caps // Otherwise from the caps
if stream_type.is_none() { if stream_type.is_none() {
let caps = match pad let caps = match pad.current_caps().unwrap_or_else(|| pad.query_caps(None)) {
.get_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.get_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"]
@ -284,9 +281,9 @@ impl CustomSource {
let s = caps.get_structure(0).unwrap(); let s = caps.get_structure(0).unwrap();
if s.get_name().starts_with("audio/") { if s.name().starts_with("audio/") {
stream_type = Some(gst::StreamType::AUDIO); stream_type = Some(gst::StreamType::AUDIO);
} else if s.get_name().starts_with("video/") { } else if s.name().starts_with("video/") {
stream_type = Some(gst::StreamType::VIDEO); stream_type = Some(gst::StreamType::VIDEO);
} else { } else {
return Ok(()); return Ok(());
@ -325,7 +322,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.get_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

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

@ -299,7 +299,7 @@ impl ObjectImpl for FallbackSrc {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"enable-audio" => { "enable-audio" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let new_value = value.get_some().expect("type checked upstream"); let new_value = value.get_some().expect("type checked upstream");
@ -440,7 +440,7 @@ impl ObjectImpl for FallbackSrc {
// at any time from any thread. // at any time from any thread.
#[allow(clippy::blocks_in_if_conditions)] #[allow(clippy::blocks_in_if_conditions)]
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"enable-audio" => { "enable-audio" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.enable_audio.to_value() settings.enable_audio.to_value()
@ -501,9 +501,9 @@ impl ObjectImpl for FallbackSrc {
if let Some(ref streams) = state.streams { if let Some(ref streams) = state.streams {
for stream in streams.iter() { for stream in streams.iter() {
have_audio = have_audio =
have_audio || stream.get_stream_type().contains(gst::StreamType::AUDIO); have_audio || stream.stream_type().contains(gst::StreamType::AUDIO);
have_video = have_video =
have_video || stream.get_stream_type().contains(gst::StreamType::VIDEO); have_video || stream.stream_type().contains(gst::StreamType::VIDEO);
} }
} }
@ -537,7 +537,7 @@ impl ObjectImpl for FallbackSrc {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.buffer_duration.to_value() settings.buffer_duration.to_value()
} }
"statistics" => self.get_stats().to_value(), "statistics" => self.stats().to_value(),
_ => unimplemented!(), _ => unimplemented!(),
} }
} }
@ -831,7 +831,7 @@ impl FallbackSrc {
let templ = element let templ = element
.get_pad_template(if is_audio { "audio" } else { "video" }) .get_pad_template(if is_audio { "audio" } else { "video" })
.unwrap(); .unwrap();
let ghostpad = gst::GhostPad::builder_with_template(&templ, Some(&templ.get_name())) let ghostpad = gst::GhostPad::builder_with_template(&templ, Some(&templ.name()))
.proxy_pad_chain_function({ .proxy_pad_chain_function({
let element_weak = element.downgrade(); let element_weak = element.downgrade();
move |pad, _parent, buffer| { move |pad, _parent, buffer| {
@ -1096,7 +1096,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.get_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 {
@ -1106,23 +1106,20 @@ impl FallbackSrc {
Some(state) => state, Some(state) => state,
}; };
let (type_, stream) = match pad.get_name() { let (type_, stream) = match pad.name() {
x if x.starts_with("audio_") => ("audio", &mut state.audio_stream), x if x.starts_with("audio_") => ("audio", &mut state.audio_stream),
x if x.starts_with("video_") => ("video", &mut state.video_stream), x if x.starts_with("video_") => ("video", &mut state.video_stream),
_ => { _ => {
let caps = match pad let caps = match pad.current_caps().unwrap_or_else(|| pad.query_caps(None)) {
.get_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,
_ => return Ok(()), _ => return Ok(()),
}; };
let s = caps.get_structure(0).unwrap(); let s = caps.get_structure(0).unwrap();
if s.get_name().starts_with("audio/") { if s.name().starts_with("audio/") {
("audio", &mut state.audio_stream) ("audio", &mut state.audio_stream)
} else if s.get_name().starts_with("video/") { } else if s.name().starts_with("video/") {
("video", &mut state.video_stream) ("video", &mut state.video_stream)
} else { } else {
// TODO: handle subtitles etc // TODO: handle subtitles etc
@ -1171,14 +1168,12 @@ impl FallbackSrc {
let src = FallbackSrc::from_instance(&element); let src = FallbackSrc::from_instance(&element);
match info.data { match info.data {
Some(gst::PadProbeData::Event(ref ev)) Some(gst::PadProbeData::Event(ref ev)) if ev.type_() == gst::EventType::Eos => {
if ev.get_type() == gst::EventType::Eos =>
{
gst_debug!( gst_debug!(
CAT, CAT,
obj: &element, obj: &element,
"Received EOS from source on pad {}, restarting", "Received EOS from source on pad {}, restarting",
pad.get_name() pad.name()
); );
let mut state_guard = src.state.lock().unwrap(); let mut state_guard = src.state.lock().unwrap();
@ -1218,7 +1213,7 @@ impl FallbackSrc {
CAT, CAT,
obj: element, obj: element,
"Adding probe to pad {}", "Adding probe to pad {}",
stream.source_srcpad.as_ref().unwrap().get_name() stream.source_srcpad.as_ref().unwrap().name()
); );
let element_weak = element.downgrade(); let element_weak = element.downgrade();
@ -1234,7 +1229,7 @@ impl FallbackSrc {
Some(element) => element, Some(element) => element,
}; };
let pts = match info.data { let pts = match info.data {
Some(gst::PadProbeData::Buffer(ref buffer)) => buffer.get_pts(), Some(gst::PadProbeData::Buffer(ref buffer)) => buffer.pts(),
Some(gst::PadProbeData::Event(ref ev)) => match ev.view() { Some(gst::PadProbeData::Event(ref ev)) => match ev.view() {
gst::EventView::Gap(ref ev) => ev.get().0, gst::EventView::Gap(ref ev) => ev.get().0,
_ => return gst::PadProbeReturn::Pass, _ => return gst::PadProbeReturn::Pass,
@ -1288,7 +1283,7 @@ impl FallbackSrc {
CAT, CAT,
obj: element, obj: element,
"Called probe on pad {}", "Called probe on pad {}",
stream.source_srcpad.as_ref().unwrap().get_name() stream.source_srcpad.as_ref().unwrap().name()
); );
stream stream
} else if let Some(stream) = state } else if let Some(stream) = state
@ -1300,7 +1295,7 @@ impl FallbackSrc {
CAT, CAT,
obj: element, obj: element,
"Called probe on pad {}", "Called probe on pad {}",
stream.source_srcpad.as_ref().unwrap().get_name() stream.source_srcpad.as_ref().unwrap().name()
); );
stream stream
} else { } else {
@ -1324,7 +1319,7 @@ impl FallbackSrc {
CAT, CAT,
obj: element, obj: element,
"Removing pad probe for pad {}", "Removing pad probe for pad {}",
source_srcpad.get_name() source_srcpad.name()
); );
block.pad.remove_probe(block.probe_id); block.pad.remove_probe(block.probe_id);
} }
@ -1352,7 +1347,7 @@ impl FallbackSrc {
}; };
let segment = match ev.view() { let segment = match ev.view() {
gst::EventView::Segment(s) => s.get_segment(), gst::EventView::Segment(s) => s.segment(),
_ => unreachable!(), _ => unreachable!(),
}; };
let segment = segment.downcast_ref::<gst::ClockTime>().ok_or_else(|| { let segment = segment.downcast_ref::<gst::ClockTime>().ok_or_else(|| {
@ -1360,10 +1355,10 @@ impl FallbackSrc {
gst::error_msg!(gst::CoreError::Clock, ["Have no time segment"]) gst::error_msg!(gst::CoreError::Clock, ["Have no time segment"])
})?; })?;
let running_time = if pts < segment.get_start() { let running_time = if pts < segment.start() {
segment.get_start() segment.start()
} else if segment.get_stop().is_some() && pts >= segment.get_stop() { } else if segment.stop().is_some() && pts >= segment.stop() {
segment.get_stop() segment.stop()
} else { } else {
segment.to_running_time(pts) segment.to_running_time(pts)
}; };
@ -1410,8 +1405,8 @@ impl FallbackSrc {
let mut have_audio = false; let mut have_audio = false;
let mut have_video = false; let mut have_video = false;
for stream in streams.iter() { for stream in streams.iter() {
have_audio = have_audio || stream.get_stream_type().contains(gst::StreamType::AUDIO); have_audio = have_audio || stream.stream_type().contains(gst::StreamType::AUDIO);
have_video = have_video || stream.get_stream_type().contains(gst::StreamType::VIDEO); have_video = have_video || stream.stream_type().contains(gst::StreamType::VIDEO);
} }
let want_audio = state.settings.enable_audio; let want_audio = state.settings.enable_audio;
@ -1439,18 +1434,18 @@ impl FallbackSrc {
let audio_is_eos = audio_srcpad let audio_is_eos = audio_srcpad
.as_ref() .as_ref()
.map(|p| p.get_pad_flags().contains(gst::PadFlags::EOS)) .map(|p| p.pad_flags().contains(gst::PadFlags::EOS))
.unwrap_or(false); .unwrap_or(false);
let video_is_eos = video_srcpad let video_is_eos = video_srcpad
.as_ref() .as_ref()
.map(|p| p.get_pad_flags().contains(gst::PadFlags::EOS)) .map(|p| p.pad_flags().contains(gst::PadFlags::EOS))
.unwrap_or(false); .unwrap_or(false);
// If we need both, wait for both and take the minimum, otherwise take the one we need. // If we need both, wait for both and take the minimum, otherwise take the one we need.
// Also consider EOS, we'd never get a new running time after EOS so don't need to wait. // Also consider EOS, we'd never get a new running time after EOS so don't need to wait.
// FIXME: All this surely can be simplified somehow // FIXME: All this surely can be simplified somehow
let current_running_time = element.get_current_running_time(); let current_running_time = element.current_running_time();
if have_audio && want_audio && have_video && want_video { if have_audio && want_audio && have_video && want_video {
if audio_running_time.is_none() if audio_running_time.is_none()
@ -1587,12 +1582,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!( gst_debug!(CAT, obj: element, "Pad {} removed from source", pad.name());
CAT,
obj: element,
"Pad {} removed from source",
pad.get_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 {
@ -1643,9 +1633,9 @@ impl FallbackSrc {
return; return;
} }
gst_debug!(CAT, obj: element, "Got buffering {}%", m.get_percent()); gst_debug!(CAT, obj: element, "Got buffering {}%", m.percent());
state.stats.buffering_percent = m.get_percent(); state.stats.buffering_percent = m.percent();
if state.stats.buffering_percent < 100 { if state.stats.buffering_percent < 100 {
state.last_buffering_update = Some(Instant::now()); state.last_buffering_update = Some(Instant::now());
// Block source pads if needed to pause // Block source pads if needed to pause
@ -1682,7 +1672,7 @@ impl FallbackSrc {
Some(state) => state, Some(state) => state,
}; };
let streams = m.get_stream_collection(); let streams = m.stream_collection();
gst_debug!( gst_debug!(
CAT, CAT,
@ -1694,8 +1684,8 @@ impl FallbackSrc {
let mut have_audio = false; let mut have_audio = false;
let mut have_video = false; let mut have_video = false;
for stream in streams.iter() { for stream in streams.iter() {
have_audio = have_audio || stream.get_stream_type().contains(gst::StreamType::AUDIO); have_audio = have_audio || stream.stream_type().contains(gst::StreamType::AUDIO);
have_video = have_video || stream.get_stream_type().contains(gst::StreamType::VIDEO); have_video = have_video || stream.stream_type().contains(gst::StreamType::VIDEO);
} }
if !have_audio && state.settings.enable_audio { if !have_audio && state.settings.enable_audio {
@ -1742,7 +1732,7 @@ impl FallbackSrc {
Some(state) => state, Some(state) => state,
}; };
let src = match m.get_src().and_then(|s| s.downcast::<gst::Element>().ok()) { let src = match m.src().and_then(|s| s.downcast::<gst::Element>().ok()) {
None => return false, None => return false,
Some(src) => src, Some(src) => src,
}; };
@ -1751,7 +1741,7 @@ impl FallbackSrc {
CAT, CAT,
obj: element, obj: element,
"Got error message from {}", "Got error message from {}",
src.get_path_string() src.path_string()
); );
if src == state.source || src.has_as_ancestor(&state.source) { if src == state.source || src.has_as_ancestor(&state.source) {
@ -1799,7 +1789,7 @@ impl FallbackSrc {
CAT, CAT,
obj: element, obj: element,
"Give up for error message from {}", "Give up for error message from {}",
src.get_path_string() src.path_string()
); );
false false
@ -1833,12 +1823,12 @@ impl FallbackSrc {
// Drop any EOS events from any source pads of the source that might happen because of the // Drop any EOS events from any source pads of the source that might happen because of the
// error. We don't need to remove these pad probes because restarting the source will also // error. We don't need to remove these pad probes because restarting the source will also
// remove/add the pads again. // remove/add the pads again.
for pad in state.source.get_src_pads() { for pad in state.source.src_pads() {
pad.add_probe( pad.add_probe(
gst::PadProbeType::EVENT_DOWNSTREAM, gst::PadProbeType::EVENT_DOWNSTREAM,
|_pad, info| match info.data { |_pad, info| match info.data {
Some(gst::PadProbeData::Event(ref event)) => { Some(gst::PadProbeData::Event(ref event)) => {
if event.get_type() == gst::EventType::Eos { if event.type_() == gst::EventType::Eos {
gst::PadProbeReturn::Drop gst::PadProbeReturn::Drop
} else { } else {
gst::PadProbeReturn::Ok gst::PadProbeReturn::Ok
@ -1888,7 +1878,7 @@ impl FallbackSrc {
CAT, CAT,
obj: element, obj: element,
"Removing pad probe for pad {}", "Removing pad probe for pad {}",
source_srcpad.get_name() source_srcpad.name()
); );
block.pad.remove_probe(block.probe_id); block.pad.remove_probe(block.probe_id);
} }
@ -1922,7 +1912,7 @@ impl FallbackSrc {
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.get_time() + gst::SECOND; let wait_time = clock.time() + gst::SECOND;
assert!(wait_time.is_some()); assert!(wait_time.is_some());
assert!(state.source_pending_restart_timeout.is_none()); assert!(state.source_pending_restart_timeout.is_none());
@ -2035,9 +2025,8 @@ impl FallbackSrc {
} }
let clock = gst::SystemClock::obtain(); let clock = gst::SystemClock::obtain();
let wait_time = clock.get_time() let wait_time =
+ gst::ClockTime::from_nseconds(state.settings.restart_timeout) clock.time() + gst::ClockTime::from_nseconds(state.settings.restart_timeout) - elapsed;
- elapsed;
assert!(wait_time.is_some()); assert!(wait_time.is_some());
gst_debug!( gst_debug!(
CAT, CAT,
@ -2110,10 +2099,8 @@ impl FallbackSrc {
let mut have_video = false; let mut have_video = false;
if let Some(ref streams) = state.streams { if let Some(ref streams) = state.streams {
for stream in streams.iter() { for stream in streams.iter() {
have_audio = have_audio = have_audio || stream.stream_type().contains(gst::StreamType::AUDIO);
have_audio || stream.get_stream_type().contains(gst::StreamType::AUDIO); have_video = have_video || stream.stream_type().contains(gst::StreamType::VIDEO);
have_video =
have_video || stream.get_stream_type().contains(gst::StreamType::VIDEO);
} }
} }
@ -2132,7 +2119,7 @@ impl FallbackSrc {
.get::<gst::Pad>() .get::<gst::Pad>()
.unwrap() .unwrap()
}) })
.map(|p| p.get_name() == "fallback_sink") .map(|p| p.name() == "fallback_sink")
.unwrap_or(true)) .unwrap_or(true))
|| (have_video || (have_video
&& state.video_stream.is_some() && state.video_stream.is_some()
@ -2146,7 +2133,7 @@ impl FallbackSrc {
.get::<gst::Pad>() .get::<gst::Pad>()
.unwrap() .unwrap()
}) })
.map(|p| p.get_name() == "fallback_sink") .map(|p| p.name() == "fallback_sink")
.unwrap_or(true)) .unwrap_or(true))
} }
@ -2186,7 +2173,7 @@ impl FallbackSrc {
} }
} }
fn get_stats(&self) -> gst::Structure { fn stats(&self) -> gst::Structure {
let state_guard = self.state.lock().unwrap(); let state_guard = self.state.lock().unwrap();
let state = match &*state_guard { let state = match &*state_guard {

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

@ -69,7 +69,7 @@ impl ObjectSubclass for VideoFallbackSource {
fn with_class(klass: &Self::Class) -> Self { fn with_class(klass: &Self::Class) -> Self {
let templ = klass.get_pad_template("src").unwrap(); let templ = klass.get_pad_template("src").unwrap();
let srcpad = gst::GhostPad::builder_with_template(&templ, Some(&templ.get_name())).build(); let srcpad = gst::GhostPad::builder_with_template(&templ, Some(&templ.name())).build();
Self { Self {
srcpad, srcpad,
@ -113,7 +113,7 @@ impl ObjectImpl for VideoFallbackSource {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"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");
@ -143,7 +143,7 @@ impl ObjectImpl for VideoFallbackSource {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"uri" => { "uri" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.uri.to_value() settings.uri.to_value()
@ -379,10 +379,10 @@ impl VideoFallbackSource {
let s = caps.get_structure(0).unwrap(); let s = caps.get_structure(0).unwrap();
let decoder; let decoder;
if s.get_name() == "image/jpeg" { if s.name() == "image/jpeg" {
decoder = gst::ElementFactory::make("jpegdec", Some("decoder")) decoder = gst::ElementFactory::make("jpegdec", Some("decoder"))
.expect("jpegdec not found"); .expect("jpegdec not found");
} else if s.get_name() == "image/png" { } else if s.name() == "image/png" {
decoder = gst::ElementFactory::make("pngdec", Some("decoder")) decoder = gst::ElementFactory::make("pngdec", Some("decoder"))
.expect("pngdec not found"); .expect("pngdec not found");
} else { } else {

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

@ -187,10 +187,10 @@ impl FallbackSwitch {
pad: &gst_base::AggregatorPad, pad: &gst_base::AggregatorPad,
target_running_time: gst::ClockTime, target_running_time: gst::ClockTime,
) -> Result<(), gst::FlowError> { ) -> Result<(), gst::FlowError> {
let segment = pad.get_segment(); let segment = pad.segment();
/* No segment yet - no data */ /* No segment yet - no data */
if segment.get_format() == gst::Format::Undefined { if segment.format() == gst::Format::Undefined {
return Ok(()); return Ok(());
} }
@ -202,7 +202,7 @@ impl FallbackSwitch {
let mut running_time = gst::ClockTime::none(); let mut running_time = gst::ClockTime::none();
while let Some(buffer) = pad.peek_buffer() { while let Some(buffer) = pad.peek_buffer() {
let pts = buffer.get_dts_or_pts(); let pts = buffer.dts_or_pts();
let new_running_time = segment.to_running_time(pts); let new_running_time = segment.to_running_time(pts);
if pts.is_none() || new_running_time <= target_running_time { if pts.is_none() || new_running_time <= target_running_time {
@ -239,30 +239,30 @@ impl FallbackSwitch {
CAT, CAT,
obj: preferred_pad, obj: preferred_pad,
"Got buffer on pad {} - {:?}", "Got buffer on pad {} - {:?}",
preferred_pad.get_name(), preferred_pad.name(),
buffer buffer
); );
if buffer.get_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);
} }
let segment = preferred_pad let segment = preferred_pad
.get_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
})?; })?;
let running_time = segment.to_running_time(buffer.get_dts_or_pts()); let running_time = segment.to_running_time(buffer.dts_or_pts());
{ {
// FIXME: This will not work correctly for negative DTS // FIXME: This will not work correctly for negative DTS
let buffer = buffer.make_mut(); let buffer = buffer.make_mut();
buffer.set_pts(segment.to_running_time(buffer.get_pts())); buffer.set_pts(segment.to_running_time(buffer.pts()));
buffer.set_dts(segment.to_running_time(buffer.get_dts())); buffer.set_dts(segment.to_running_time(buffer.dts()));
} }
if preferred_pad == &self.primary_sinkpad { if preferred_pad == &self.primary_sinkpad {
@ -273,7 +273,7 @@ impl FallbackSwitch {
let is_late = { let is_late = {
if cur_running_time != gst::ClockTime::none() { if cur_running_time != gst::ClockTime::none() {
let latency = agg.get_latency(); let latency = agg.latency();
if latency.is_some() { if latency.is_some() {
let deadline = running_time + latency + 40 * gst::MSECOND; let deadline = running_time + latency + 40 * gst::MSECOND;
@ -320,12 +320,12 @@ impl FallbackSwitch {
&& active_sinkpad.as_ref() != Some(preferred_pad.upcast_ref::<gst::Pad>()); && active_sinkpad.as_ref() != Some(preferred_pad.upcast_ref::<gst::Pad>());
if pad_change { if pad_change {
if buffer.get_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",
preferred_pad.get_name() preferred_pad.name()
); );
preferred_pad.push_event( preferred_pad.push_event(
gst_video::UpstreamForceKeyUnitEvent::builder() gst_video::UpstreamForceKeyUnitEvent::builder()
@ -380,25 +380,26 @@ impl FallbackSwitch {
buffer buffer
); );
if buffer.get_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);
} }
let backup_segment = backup_pad let backup_segment =
.get_segment() backup_pad
.downcast::<gst::ClockTime>() .segment()
.map_err(|_| { .downcast::<gst::ClockTime>()
gst_error!(CAT, obj: backup_pad, "Only TIME segments supported"); .map_err(|_| {
gst::FlowError::Error gst_error!(CAT, obj: backup_pad, "Only TIME segments supported");
})?; gst::FlowError::Error
let running_time = backup_segment.to_running_time(buffer.get_dts_or_pts()); })?;
let running_time = backup_segment.to_running_time(buffer.dts_or_pts());
{ {
// FIXME: This will not work correctly for negative DTS // FIXME: This will not work correctly for negative DTS
let buffer = buffer.make_mut(); let buffer = buffer.make_mut();
buffer.set_pts(backup_segment.to_running_time(buffer.get_pts())); buffer.set_pts(backup_segment.to_running_time(buffer.pts()));
buffer.set_dts(backup_segment.to_running_time(buffer.get_dts())); buffer.set_dts(backup_segment.to_running_time(buffer.dts()));
} }
// If we never had a real buffer, initialize with the running time of the fallback // If we never had a real buffer, initialize with the running time of the fallback
@ -439,12 +440,12 @@ impl FallbackSwitch {
let pad_change = settings.auto_switch let pad_change = settings.auto_switch
&& 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.get_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",
backup_pad.get_name() backup_pad.name()
); );
backup_pad.push_event( backup_pad.push_event(
gst_video::UpstreamForceKeyUnitEvent::builder() gst_video::UpstreamForceKeyUnitEvent::builder()
@ -522,11 +523,11 @@ impl FallbackSwitch {
) )
}; };
let clock = agg.get_clock(); let clock = agg.clock();
let base_time = agg.get_base_time(); let base_time = agg.base_time();
let cur_running_time = if let Some(clock) = clock { let cur_running_time = if let Some(clock) = clock {
clock.get_time() - base_time clock.time() - base_time
} else { } else {
gst::ClockTime::none() gst::ClockTime::none()
}; };
@ -727,7 +728,7 @@ impl ObjectImpl for FallbackSwitch {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"timeout" => { "timeout" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let timeout = value.get_some().expect("type checked upstream"); let timeout = value.get_some().expect("type checked upstream");
@ -769,7 +770,7 @@ impl ObjectImpl for FallbackSwitch {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"timeout" => { "timeout" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.timeout.to_value() settings.timeout.to_value()
@ -945,15 +946,15 @@ impl AggregatorImpl for FallbackSwitch {
match event.view() { match event.view() {
EventView::Caps(caps) => { EventView::Caps(caps) => {
let caps = caps.get_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;
if caps.get_structure(0).unwrap().get_name() == "audio/x-raw" { if caps.get_structure(0).unwrap().name() == "audio/x-raw" {
audio_info = gst_audio::AudioInfo::from_caps(&caps).ok(); audio_info = gst_audio::AudioInfo::from_caps(&caps).ok();
video_info = None; video_info = None;
} else if caps.get_structure(0).unwrap().get_name() == "video/x-raw" { } else if caps.get_structure(0).unwrap().name() == "video/x-raw" {
audio_info = None; audio_info = None;
video_info = gst_video::VideoInfo::from_caps(&caps).ok(); video_info = gst_video::VideoInfo::from_caps(&caps).ok();
} else { } else {
@ -1013,7 +1014,7 @@ impl AggregatorImpl for FallbackSwitch {
CAT, CAT,
obj: agg, obj: agg,
"Have buffer on sinkpad {}, immediate timeout", "Have buffer on sinkpad {}, immediate timeout",
preferred_pad.get_name() preferred_pad.name()
); );
0.into() 0.into()
} else if self.primary_sinkpad.is_eos() { } else if self.primary_sinkpad.is_eos() {
@ -1023,13 +1024,13 @@ impl AggregatorImpl for FallbackSwitch {
.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.get_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 0.into(); return 0.into();
} }
let segment = match backup_sinkpad.get_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");
@ -1038,12 +1039,12 @@ impl AggregatorImpl for FallbackSwitch {
} }
}; };
let running_time = segment.to_running_time(buffer.get_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 {}",
backup_sinkpad.get_name(), backup_sinkpad.name(),
running_time running_time
); );
running_time running_time
@ -1061,7 +1062,7 @@ impl AggregatorImpl for FallbackSwitch {
agg_pad: &gst_base::AggregatorPad, agg_pad: &gst_base::AggregatorPad,
mut buffer: gst::Buffer, mut buffer: gst::Buffer,
) -> Option<gst::Buffer> { ) -> Option<gst::Buffer> {
let segment = match agg_pad.get_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");
@ -1069,7 +1070,7 @@ impl AggregatorImpl for FallbackSwitch {
} }
}; };
let pts = buffer.get_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);
@ -1091,12 +1092,12 @@ impl AggregatorImpl for FallbackSwitch {
return Some(buffer); return Some(buffer);
} }
let duration = if buffer.get_duration().is_some() { let duration = if buffer.duration().is_some() {
buffer.get_duration() buffer.duration()
} else if let Some(ref audio_info) = pad_state.audio_info { } else if let Some(ref audio_info) = pad_state.audio_info {
gst::SECOND gst::SECOND
.mul_div_floor( .mul_div_floor(
buffer.get_size() as u64, buffer.size() as u64,
audio_info.rate() as u64 * audio_info.bpf() as u64, audio_info.rate() as u64 * audio_info.bpf() as u64,
) )
.unwrap() .unwrap()
@ -1178,7 +1179,7 @@ impl AggregatorImpl for FallbackSwitch {
let (mut buffer, active_caps, pad_change) = res?; let (mut buffer, active_caps, pad_change) = res?;
let current_src_caps = agg.get_static_pad("src").unwrap().get_current_caps(); let current_src_caps = agg.get_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,

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

@ -41,15 +41,15 @@ fn init() {
macro_rules! assert_fallback_buffer { macro_rules! assert_fallback_buffer {
($buffer:expr, $ts:expr) => { ($buffer:expr, $ts:expr) => {
assert_eq!($buffer.get_pts(), $ts); assert_eq!($buffer.pts(), $ts);
assert_eq!($buffer.get_size(), 160 * 120 * 4); assert_eq!($buffer.size(), 160 * 120 * 4);
}; };
} }
macro_rules! assert_buffer { macro_rules! assert_buffer {
($buffer:expr, $ts:expr) => { ($buffer:expr, $ts:expr) => {
assert_eq!($buffer.get_pts(), $ts); assert_eq!($buffer.pts(), $ts);
assert_eq!($buffer.get_size(), 320 * 240 * 4); assert_eq!($buffer.size(), 320 * 240 * 4);
}; };
} }
@ -412,16 +412,16 @@ fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline {
loop { loop {
while let Some(clock_id) = clock.peek_next_pending_id().and_then(|clock_id| { while let Some(clock_id) = clock.peek_next_pending_id().and_then(|clock_id| {
// Process if the clock ID is in the past or now // Process if the clock ID is in the past or now
if clock.get_time() >= clock_id.get_time() { if clock.time() >= clock_id.time() {
Some(clock_id) Some(clock_id)
} else { } else {
None None
} }
}) { }) {
gst_debug!(TEST_CAT, "Processing clock ID at {}", clock_id.get_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.get_time()); gst_debug!(TEST_CAT, "Processed clock ID at {}", clock_id.time());
if clock_id.get_time() == 0.into() { if clock_id.time() == 0.into() {
gst_debug!(TEST_CAT, "Stopping clock thread"); gst_debug!(TEST_CAT, "Stopping clock thread");
return; return;
} }
@ -432,7 +432,7 @@ fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline {
// at the top of the queue. We don't want to do a busy loop here. // at the top of the queue. We don't want to do a busy loop here.
while clock.peek_next_pending_id().iter().any(|clock_id| { while clock.peek_next_pending_id().iter().any(|clock_id| {
// Sleep if the clock ID is in the future // Sleep if the clock ID is in the future
clock.get_time() < clock_id.get_time() clock.time() < clock_id.time()
}) { }) {
use std::{thread, time}; use std::{thread, time};
@ -504,12 +504,12 @@ fn pull_buffer(pipeline: &Pipeline) -> gst::Buffer {
.downcast::<gst_app::AppSink>() .downcast::<gst_app::AppSink>()
.unwrap(); .unwrap();
let sample = sink.pull_sample().unwrap(); let sample = sink.pull_sample().unwrap();
sample.get_buffer_owned().unwrap() sample.buffer_owned().unwrap()
} }
fn set_time(pipeline: &Pipeline, time: gst::ClockTime) { fn set_time(pipeline: &Pipeline, time: gst::ClockTime) {
let clock = pipeline let clock = pipeline
.get_clock() .clock()
.unwrap() .unwrap()
.downcast::<gst_check::TestClock>() .downcast::<gst_check::TestClock>()
.unwrap(); .unwrap();
@ -540,7 +540,7 @@ fn stop_pipeline(mut pipeline: Pipeline) {
pipeline.set_state(gst::State::Null).unwrap(); pipeline.set_state(gst::State::Null).unwrap();
let clock = pipeline let clock = pipeline
.get_clock() .clock()
.unwrap() .unwrap()
.downcast::<gst_check::TestClock>() .downcast::<gst_check::TestClock>()
.unwrap(); .unwrap();

8
utils/togglerecord/examples/gtk_recording.rs
View file

@ -291,7 +291,7 @@ fn create_ui(app: &gtk::Application) {
Inhibit(false) Inhibit(false)
}); });
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
let app_weak = app.downgrade(); let app_weak = app.downgrade();
bus.add_watch_local(move |_, msg| { bus.add_watch_local(move |_, msg| {
use gst::MessageView; use gst::MessageView;
@ -306,9 +306,9 @@ fn create_ui(app: &gtk::Application) {
MessageView::Error(err) => { MessageView::Error(err) => {
println!( println!(
"Error from {:?}: {} ({:?})", "Error from {:?}: {} ({:?})",
msg.get_src().map(|s| s.get_path_string()), msg.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
app.quit(); app.quit();
} }

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

@ -158,14 +158,14 @@ enum HandleResult<T> {
} }
trait HandleData: Sized { trait HandleData: Sized {
fn get_pts(&self) -> gst::ClockTime; fn pts(&self) -> gst::ClockTime;
fn get_dts(&self) -> gst::ClockTime; fn dts(&self) -> gst::ClockTime;
fn get_dts_or_pts(&self) -> gst::ClockTime { fn dts_or_pts(&self) -> gst::ClockTime {
let dts = self.get_dts(); let dts = self.dts();
if dts.is_some() { if dts.is_some() {
dts dts
} else { } else {
self.get_pts() self.pts()
} }
} }
fn get_duration(&self, state: &StreamState) -> gst::ClockTime; fn get_duration(&self, state: &StreamState) -> gst::ClockTime;
@ -179,11 +179,11 @@ trait HandleData: Sized {
} }
impl HandleData for (gst::ClockTime, gst::ClockTime) { impl HandleData for (gst::ClockTime, gst::ClockTime) {
fn get_pts(&self) -> gst::ClockTime { fn pts(&self) -> gst::ClockTime {
self.0 self.0
} }
fn get_dts(&self) -> gst::ClockTime { fn dts(&self) -> gst::ClockTime {
self.0 self.0
} }
@ -217,11 +217,11 @@ impl HandleData for (gst::ClockTime, gst::ClockTime) {
} }
impl HandleData for gst::Buffer { impl HandleData for gst::Buffer {
fn get_pts(&self) -> gst::ClockTime { fn pts(&self) -> gst::ClockTime {
gst::BufferRef::get_pts(self) gst::BufferRef::get_pts(self)
} }
fn get_dts(&self) -> gst::ClockTime { fn dts(&self) -> gst::ClockTime {
gst::BufferRef::get_dts(self) gst::BufferRef::get_dts(self)
} }
@ -246,7 +246,7 @@ impl HandleData for gst::Buffer {
return gst::CLOCK_TIME_NONE; return gst::CLOCK_TIME_NONE;
} }
let size = self.get_size() as u64; let size = self.size() as u64;
let num_samples = size / audio_info.bpf() as u64; let num_samples = size / audio_info.bpf() as u64;
gst::SECOND gst::SECOND
.mul_div_floor(num_samples, audio_info.rate() as u64) .mul_div_floor(num_samples, audio_info.rate() as u64)
@ -273,7 +273,7 @@ impl HandleData for gst::Buffer {
} else if let Some(ref video_info) = state.video_info { } else if let Some(ref video_info) = state.video_info {
if video_info.format() == gst_video::VideoFormat::Unknown if video_info.format() == gst_video::VideoFormat::Unknown
|| video_info.format() == gst_video::VideoFormat::Encoded || video_info.format() == gst_video::VideoFormat::Encoded
|| self.get_dts_or_pts() != self.get_pts() || self.dts_or_pts() != self.pts()
{ {
return false; return false;
} }
@ -355,7 +355,7 @@ impl ToggleRecord {
) -> Result<HandleResult<T>, gst::FlowError> { ) -> Result<HandleResult<T>, gst::FlowError> {
let mut state = stream.state.lock(); let mut state = stream.state.lock();
let mut dts_or_pts = data.get_dts_or_pts(); let mut dts_or_pts = data.dts_or_pts();
let duration = data.get_duration(&state); let duration = data.get_duration(&state);
if !dts_or_pts.is_some() { if !dts_or_pts.is_some() {
@ -382,11 +382,11 @@ impl ToggleRecord {
}; };
// This will only do anything for non-raw data // This will only do anything for non-raw data
dts_or_pts = state.in_segment.get_start().max(dts_or_pts).unwrap(); dts_or_pts = state.in_segment.start().max(dts_or_pts).unwrap();
dts_or_pts_end = state.in_segment.get_start().max(dts_or_pts_end).unwrap(); dts_or_pts_end = state.in_segment.start().max(dts_or_pts_end).unwrap();
if state.in_segment.get_stop().is_some() { if state.in_segment.stop().is_some() {
dts_or_pts = state.in_segment.get_stop().min(dts_or_pts).unwrap(); dts_or_pts = state.in_segment.stop().min(dts_or_pts).unwrap();
dts_or_pts_end = state.in_segment.get_stop().min(dts_or_pts_end).unwrap(); dts_or_pts_end = state.in_segment.stop().min(dts_or_pts_end).unwrap();
} }
let current_running_time = state.in_segment.to_running_time(dts_or_pts); let current_running_time = state.in_segment.to_running_time(dts_or_pts);
@ -609,7 +609,7 @@ impl ToggleRecord {
// Calculate end pts & current running time and make sure we stay in the segment // Calculate end pts & current running time and make sure we stay in the segment
let mut state = stream.state.lock(); let mut state = stream.state.lock();
let mut pts = data.get_pts(); let mut pts = data.pts();
let duration = data.get_duration(&state); let duration = data.get_duration(&state);
if pts.is_none() { if pts.is_none() {
@ -617,7 +617,7 @@ impl ToggleRecord {
return Err(gst::FlowError::Error); return Err(gst::FlowError::Error);
} }
let dts = data.get_dts(); let dts = data.dts();
if dts.is_some() && pts.is_some() && dts != pts { if dts.is_some() && pts.is_some() && dts != pts {
gst::element_error!( gst::element_error!(
element, element,
@ -651,11 +651,11 @@ impl ToggleRecord {
}; };
// This will only do anything for non-raw data // This will only do anything for non-raw data
pts = state.in_segment.get_start().max(pts).unwrap(); pts = state.in_segment.start().max(pts).unwrap();
pts_end = state.in_segment.get_start().max(pts_end).unwrap(); pts_end = state.in_segment.start().max(pts_end).unwrap();
if state.in_segment.get_stop().is_some() { if state.in_segment.stop().is_some() {
pts = state.in_segment.get_stop().min(pts).unwrap(); pts = state.in_segment.stop().min(pts).unwrap();
pts_end = state.in_segment.get_stop().min(pts_end).unwrap(); pts_end = state.in_segment.stop().min(pts_end).unwrap();
} }
let current_running_time = state.in_segment.to_running_time(pts); let current_running_time = state.in_segment.to_running_time(pts);
@ -762,13 +762,13 @@ impl ToggleRecord {
.in_segment .in_segment
.position_from_running_time(rec_state.last_recording_start); .position_from_running_time(rec_state.last_recording_start);
if clip_start.is_none() { if clip_start.is_none() {
clip_start = state.in_segment.get_start(); clip_start = state.in_segment.start();
} }
let mut clip_stop = state let mut clip_stop = state
.in_segment .in_segment
.position_from_running_time(rec_state.last_recording_stop); .position_from_running_time(rec_state.last_recording_stop);
if clip_stop.is_none() { if clip_stop.is_none() {
clip_stop = state.in_segment.get_stop(); clip_stop = state.in_segment.stop();
} }
let mut segment = state.in_segment.clone(); let mut segment = state.in_segment.clone();
segment.set_start(clip_start); segment.set_start(clip_start);
@ -813,13 +813,13 @@ impl ToggleRecord {
.in_segment .in_segment
.position_from_running_time(rec_state.last_recording_start); .position_from_running_time(rec_state.last_recording_start);
if clip_start.is_none() { if clip_start.is_none() {
clip_start = state.in_segment.get_start(); clip_start = state.in_segment.start();
} }
let mut clip_stop = state let mut clip_stop = state
.in_segment .in_segment
.position_from_running_time(rec_state.last_recording_stop); .position_from_running_time(rec_state.last_recording_stop);
if clip_stop.is_none() { if clip_stop.is_none() {
clip_stop = state.in_segment.get_stop(); clip_stop = state.in_segment.stop();
} }
let mut segment = state.in_segment.clone(); let mut segment = state.in_segment.clone();
segment.set_start(clip_start); segment.set_start(clip_start);
@ -928,7 +928,7 @@ impl ToggleRecord {
.in_segment .in_segment
.position_from_running_time(rec_state.last_recording_stop); .position_from_running_time(rec_state.last_recording_stop);
if clip_stop.is_none() { if clip_stop.is_none() {
clip_stop = state.in_segment.get_stop(); clip_stop = state.in_segment.stop();
} }
let mut segment = state.in_segment.clone(); let mut segment = state.in_segment.clone();
segment.set_stop(clip_stop); segment.set_stop(clip_stop);
@ -1004,7 +1004,7 @@ impl ToggleRecord {
.in_segment .in_segment
.position_from_running_time(rec_state.last_recording_start); .position_from_running_time(rec_state.last_recording_start);
if clip_start.is_none() { if clip_start.is_none() {
clip_start = state.in_segment.get_start(); clip_start = state.in_segment.start();
} }
let mut segment = state.in_segment.clone(); let mut segment = state.in_segment.clone();
segment.set_start(clip_start); segment.set_start(clip_start);
@ -1084,7 +1084,7 @@ impl ToggleRecord {
gst::element_error!( gst::element_error!(
element, element,
gst::CoreError::Pad, gst::CoreError::Pad,
["Unknown pad {:?}", pad.get_name()] ["Unknown pad {:?}", pad.name()]
); );
gst::FlowError::Error gst::FlowError::Error
})?; })?;
@ -1172,7 +1172,7 @@ impl ToggleRecord {
events.append(&mut state.pending_events); events.append(&mut state.pending_events);
let out_running_time = state.out_segment.to_running_time(buffer.get_pts()); let out_running_time = state.out_segment.to_running_time(buffer.pts());
// Unlock before pushing // Unlock before pushing
drop(state); drop(state);
@ -1207,7 +1207,7 @@ impl ToggleRecord {
gst::element_error!( gst::element_error!(
element, element,
gst::CoreError::Pad, gst::CoreError::Pad,
["Unknown pad {:?}", pad.get_name()] ["Unknown pad {:?}", pad.name()]
); );
return false; return false;
} }
@ -1244,13 +1244,13 @@ impl ToggleRecord {
} }
EventView::Caps(c) => { EventView::Caps(c) => {
let mut state = stream.state.lock(); let mut state = stream.state.lock();
let caps = c.get_caps(); let caps = c.caps();
let s = caps.get_structure(0).unwrap(); let s = caps.get_structure(0).unwrap();
if s.get_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.get_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);
@ -1262,35 +1262,32 @@ impl ToggleRecord {
EventView::Segment(e) => { EventView::Segment(e) => {
let mut state = stream.state.lock(); let mut state = stream.state.lock();
let segment = match e.get_segment().clone().downcast::<gst::ClockTime>() { let segment = match e.segment().clone().downcast::<gst::ClockTime>() {
Err(segment) => { Err(segment) => {
gst::element_error!( gst::element_error!(
element, element,
gst::StreamError::Format, gst::StreamError::Format,
[ ["Only Time segments supported, got {:?}", segment.format(),]
"Only Time segments supported, got {:?}",
segment.get_format(),
]
); );
return false; return false;
} }
Ok(segment) => segment, Ok(segment) => segment,
}; };
if (segment.get_rate() - 1.0).abs() > f64::EPSILON { if (segment.rate() - 1.0).abs() > f64::EPSILON {
gst::element_error!( gst::element_error!(
element, element,
gst::StreamError::Format, gst::StreamError::Format,
[ [
"Only rate==1.0 segments supported, got {:?}", "Only rate==1.0 segments supported, got {:?}",
segment.get_rate(), segment.rate(),
] ]
); );
return false; return false;
} }
state.in_segment = segment; state.in_segment = segment;
state.segment_seqnum = event.get_seqnum(); state.segment_seqnum = event.seqnum();
state.segment_pending = true; state.segment_pending = true;
state.current_running_time = gst::CLOCK_TIME_NONE; state.current_running_time = gst::CLOCK_TIME_NONE;
state.current_running_time_end = gst::CLOCK_TIME_NONE; state.current_running_time_end = gst::CLOCK_TIME_NONE;
@ -1358,7 +1355,7 @@ impl ToggleRecord {
// If a serialized event and coming after Segment and a new Segment is pending, // If a serialized event and coming after Segment and a new Segment is pending,
// queue up and send at a later time (buffer/gap) after we sent the Segment // queue up and send at a later time (buffer/gap) after we sent the Segment
let type_ = event.get_type(); let type_ = event.type_();
if forward if forward
&& type_ != gst::EventType::Eos && type_ != gst::EventType::Eos
&& type_.is_serialized() && type_.is_serialized()
@ -1413,7 +1410,7 @@ impl ToggleRecord {
gst::element_error!( gst::element_error!(
element, element,
gst::CoreError::Pad, gst::CoreError::Pad,
["Unknown pad {:?}", pad.get_name()] ["Unknown pad {:?}", pad.name()]
); );
return false; return false;
} }
@ -1441,7 +1438,7 @@ impl ToggleRecord {
gst::element_error!( gst::element_error!(
element, element,
gst::CoreError::Pad, gst::CoreError::Pad,
["Unknown pad {:?}", pad.get_name()] ["Unknown pad {:?}", pad.name()]
); );
return false; return false;
} }
@ -1454,7 +1451,7 @@ impl ToggleRecord {
let rec_state = self.state.lock(); let rec_state = self.state.lock();
let running_time_offset = rec_state.running_time_offset.unwrap_or(0) as i64; let running_time_offset = rec_state.running_time_offset.unwrap_or(0) as i64;
let offset = event.get_running_time_offset(); let offset = event.running_time_offset();
event event
.make_mut() .make_mut()
.set_running_time_offset(offset + running_time_offset); .set_running_time_offset(offset + running_time_offset);
@ -1482,7 +1479,7 @@ impl ToggleRecord {
gst::element_error!( gst::element_error!(
element, element,
gst::CoreError::Pad, gst::CoreError::Pad,
["Unknown pad {:?}", pad.get_name()] ["Unknown pad {:?}", pad.name()]
); );
return false; return false;
} }
@ -1500,34 +1497,34 @@ impl ToggleRecord {
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.get_result(); let (flags, min, max, align) = new_query.result();
q.set(flags, min, max, align); q.set(flags, min, max, align);
q.add_scheduling_modes( q.add_scheduling_modes(
&new_query &new_query
.get_scheduling_modes() .scheduling_modes()
.iter() .iter()
.cloned() .cloned()
.filter(|m| m != &gst::PadMode::Pull) .filter(|m| m != &gst::PadMode::Pull)
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
); );
gst_log!(CAT, obj: pad, "Returning {:?}", q.get_mut_query()); gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true true
} }
QueryView::Seeking(ref mut q) => { QueryView::Seeking(ref mut q) => {
// Seeking is not possible here // Seeking is not possible here
let format = q.get_format(); let format = q.format();
q.set( q.set(
false, false,
gst::GenericFormattedValue::new(format, -1), gst::GenericFormattedValue::new(format, -1),
gst::GenericFormattedValue::new(format, -1), gst::GenericFormattedValue::new(format, -1),
); );
gst_log!(CAT, obj: pad, "Returning {:?}", q.get_mut_query()); 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
QueryView::Position(ref mut q) => { QueryView::Position(ref mut q) => {
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
let state = stream.state.lock(); let state = stream.state.lock();
let rec_state = self.state.lock(); let rec_state = self.state.lock();
let mut recording_duration = rec_state.recording_duration; let mut recording_duration = rec_state.recording_duration;
@ -1556,7 +1553,7 @@ impl ToggleRecord {
} }
} }
QueryView::Duration(ref mut q) => { QueryView::Duration(ref mut q) => {
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
let state = stream.state.lock(); let state = stream.state.lock();
let rec_state = self.state.lock(); let rec_state = self.state.lock();
let mut recording_duration = rec_state.recording_duration; let mut recording_duration = rec_state.recording_duration;
@ -1601,7 +1598,7 @@ impl ToggleRecord {
gst::element_error!( gst::element_error!(
element, element,
gst::CoreError::Pad, gst::CoreError::Pad,
["Unknown pad {:?}", pad.get_name()] ["Unknown pad {:?}", pad.name()]
); );
return gst::Iterator::from_vec(vec![]); return gst::Iterator::from_vec(vec![]);
} }
@ -1728,7 +1725,7 @@ impl ObjectImpl for ToggleRecord {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"record" => { "record" => {
let mut settings = self.settings.lock(); let mut settings = self.settings.lock();
let record = value.get_some().expect("type checked upstream"); let record = value.get_some().expect("type checked upstream");
@ -1747,7 +1744,7 @@ impl ObjectImpl for ToggleRecord {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"record" => { "record" => {
let settings = self.settings.lock(); let settings = self.settings.lock();
settings.record.to_value() settings.record.to_value()

16
utils/togglerecord/tests/tests.rs
View file

@ -214,9 +214,9 @@ fn recv_buffers(
match val { match val {
Left(buffer) => { Left(buffer) => {
res.push(( res.push((
segment.to_running_time(buffer.get_pts()), segment.to_running_time(buffer.pts()),
buffer.get_pts(), buffer.pts(),
buffer.get_duration(), buffer.duration(),
)); ));
n_buffers += 1; n_buffers += 1;
if wait_buffers > 0 && n_buffers == wait_buffers { if wait_buffers > 0 && n_buffers == wait_buffers {
@ -241,7 +241,7 @@ fn recv_buffers(
return (res, saw_eos); return (res, saw_eos);
} }
EventView::Segment(ref e) => { EventView::Segment(ref e) => {
*segment = e.get_segment().clone().downcast().unwrap(); *segment = e.segment().clone().downcast().unwrap();
} }
_ => (), _ => (),
} }
@ -266,12 +266,12 @@ fn test_create_pads() {
let sinkpad = togglerecord.get_request_pad("sink_%u").unwrap(); let sinkpad = togglerecord.get_request_pad("sink_%u").unwrap();
let srcpad = sinkpad.iterate_internal_links().next().unwrap().unwrap(); let srcpad = sinkpad.iterate_internal_links().next().unwrap().unwrap();
assert_eq!(sinkpad.get_name(), "sink_0"); assert_eq!(sinkpad.name(), "sink_0");
assert_eq!(srcpad.get_name(), "src_0"); assert_eq!(srcpad.name(), "src_0");
togglerecord.release_request_pad(&sinkpad); togglerecord.release_request_pad(&sinkpad);
assert!(sinkpad.get_parent().is_none()); assert!(sinkpad.parent().is_none());
assert!(srcpad.get_parent().is_none()); assert!(srcpad.parent().is_none());
} }
#[test] #[test]

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

@ -119,13 +119,13 @@ impl VideoDecoderImpl for CdgDec {
element.negotiate(output_state)?; element.negotiate(output_state)?;
let out_state = element.get_output_state().unwrap(); let out_state = element.output_state().unwrap();
*out_info = Some(out_state.get_info()); *out_info = Some(out_state.info());
} }
} }
let cmd = { let cmd = {
let input = frame.get_input_buffer().unwrap(); let input = frame.input_buffer().unwrap();
let map = input.map_readable().map_err(|_| { let map = input.map_readable().map_err(|_| {
gst::element_error!( gst::element_error!(
element, element,
@ -153,7 +153,7 @@ impl VideoDecoderImpl for CdgDec {
element.allocate_output_frame(&mut frame, None)?; element.allocate_output_frame(&mut frame, None)?;
{ {
let output = frame.get_output_buffer_mut().unwrap(); let output = frame.output_buffer_mut().unwrap();
let info = self.output_info.lock().unwrap(); let info = self.output_info.lock().unwrap();
let mut out_frame = let mut out_frame =
@ -187,7 +187,7 @@ impl VideoDecoderImpl for CdgDec {
} }
} }
gst_debug!(CAT, obj: element, "Finish frame pts={}", frame.get_pts()); gst_debug!(CAT, obj: element, "Finish frame pts={}", frame.pts());
element.finish_frame(frame) element.finish_frame(frame)
} }
@ -202,9 +202,9 @@ impl VideoDecoderImpl for CdgDec {
.find_allocation_meta::<gst_video::VideoMeta>() .find_allocation_meta::<gst_video::VideoMeta>()
.is_some() .is_some()
{ {
let pools = allocation.get_allocation_pools(); let pools = allocation.allocation_pools();
if let Some((Some(ref pool), _, _, _)) = pools.first() { if let Some((Some(ref pool), _, _, _)) = pools.first() {
let mut config = pool.get_config(); let mut config = pool.config();
config.add_option(&gst_video::BUFFER_POOL_OPTION_VIDEO_META); config.add_option(&gst_video::BUFFER_POOL_OPTION_VIDEO_META);
pool.set_config(config) pool.set_config(config)
.map_err(|e| gst::error_msg!(gst::CoreError::Negotiation, [&e.message]))?; .map_err(|e| gst::error_msg!(gst::CoreError::Negotiation, [&e.message]))?;

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

@ -119,9 +119,9 @@ impl BaseParseImpl for CdgParse {
/* Set duration */ /* Set duration */
let mut query = gst::query::Duration::new(gst::Format::Bytes); let mut query = gst::query::Duration::new(gst::Format::Bytes);
let pad = element.get_src_pad(); let pad = element.src_pad();
if pad.query(&mut query) { if pad.query(&mut query) {
let size = query.get_result(); let size = query.result();
let duration = bytes_to_time(size.try_into().unwrap()); let duration = bytes_to_time(size.try_into().unwrap());
element.set_duration(duration, 0); element.set_duration(duration, 0);
} }
@ -134,8 +134,8 @@ impl BaseParseImpl for CdgParse {
element: &Self::Type, element: &Self::Type,
mut frame: gst_base::BaseParseFrame, mut frame: gst_base::BaseParseFrame,
) -> Result<(gst::FlowSuccess, u32), gst::FlowError> { ) -> Result<(gst::FlowSuccess, u32), gst::FlowError> {
let pad = element.get_src_pad(); let pad = element.src_pad();
if pad.get_current_caps().is_none() { if pad.current_caps().is_none() {
// Set src pad caps // Set src pad caps
let src_caps = gst::Caps::new_simple( let src_caps = gst::Caps::new_simple(
"video/x-cdg", "video/x-cdg",
@ -151,7 +151,7 @@ impl BaseParseImpl for CdgParse {
} }
// Scan for CDG instruction // Scan for CDG instruction
let input = frame.get_buffer().unwrap(); let input = frame.buffer().unwrap();
let skip = { let skip = {
let map = input.map_readable().map_err(|_| { let map = input.map_readable().map_err(|_| {
gst::element_error!( gst::element_error!(
@ -167,7 +167,7 @@ impl BaseParseImpl for CdgParse {
.enumerate() .enumerate()
.find(|(_, byte)| (*byte & CDG_MASK == CDG_COMMAND)) .find(|(_, byte)| (*byte & CDG_MASK == CDG_COMMAND))
.map(|(i, _)| i) .map(|(i, _)| i)
.unwrap_or_else(|| input.get_size()) // skip the whole buffer .unwrap_or_else(|| input.size()) // skip the whole buffer
as u32 as u32
}; };
@ -198,8 +198,8 @@ impl BaseParseImpl for CdgParse {
} }
}; };
let pts = bytes_to_time(Bytes(Some(frame.get_offset()))); let pts = bytes_to_time(Bytes(Some(frame.offset())));
let buffer = frame.get_buffer_mut().unwrap(); let buffer = frame.buffer_mut().unwrap();
buffer.set_pts(pts); buffer.set_pts(pts);
if !keyframe { if !keyframe {

2
video/cdg/src/typefind.rs
View file

@ -43,7 +43,7 @@ fn compute_probability(typefind: &mut TypeFind) -> TypeFindProbability {
let mut best = TypeFindProbability::None; let mut best = TypeFindProbability::None;
// Try looking at the start of the file if its length isn't available // Try looking at the start of the file if its length isn't available
let len = typefind let len = typefind
.get_length() .length()
.unwrap_or(TYPEFIND_SEARCH_WINDOW as u64 * NB_WINDOWS); .unwrap_or(TYPEFIND_SEARCH_WINDOW as u64 * NB_WINDOWS);
let step = len / NB_WINDOWS; let step = len / NB_WINDOWS;

10
video/cdg/tests/cdgdec.rs
View file

@ -66,7 +66,7 @@ fn test_cdgdec() {
.new_sample(move |appsink| { .new_sample(move |appsink| {
// Pull the sample in question out of the appsink's buffer. // Pull the sample in question out of the appsink's buffer.
let sample = appsink.pull_sample().map_err(|_| gst::FlowError::Eos)?; let sample = appsink.pull_sample().map_err(|_| gst::FlowError::Eos)?;
let buffer = sample.get_buffer().ok_or(gst::FlowError::Error)?; let buffer = sample.buffer().ok_or(gst::FlowError::Error)?;
let map = buffer.map_readable().map_err(|_| gst::FlowError::Error)?; let map = buffer.map_readable().map_err(|_| gst::FlowError::Error)?;
// First frame fully blue // First frame fully blue
@ -83,17 +83,17 @@ fn test_cdgdec() {
.set_state(gst::State::Playing) .set_state(gst::State::Playing)
.expect("Unable to set the pipeline to the `Playing` state"); .expect("Unable to set the pipeline to the `Playing` state");
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) { for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) {
use gst::MessageView; use gst::MessageView;
match msg.view() { match msg.view() {
MessageView::Error(err) => { MessageView::Error(err) => {
eprintln!( eprintln!(
"Error received from element {:?}: {}", "Error received from element {:?}: {}",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error() err.error()
); );
eprintln!("Debugging information: {:?}", err.get_debug()); eprintln!("Debugging information: {:?}", err.debug());
unreachable!(); unreachable!();
} }
MessageView::Eos(..) => break, MessageView::Eos(..) => break,

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

@ -261,7 +261,7 @@ impl ObjectImpl for CCDetect {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"window" => { "window" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.window = value.get_some().expect("type checked upstream"); settings.window = value.get_some().expect("type checked upstream");
@ -271,7 +271,7 @@ impl ObjectImpl for CCDetect {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"window" => { "window" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.window.to_value() settings.window.to_value()
@ -350,7 +350,7 @@ impl BaseTransformImpl for CCDetect {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
let map = buf.map_readable().map_err(|_| gst::FlowError::Error)?; let map = buf.map_readable().map_err(|_| gst::FlowError::Error)?;
if buf.get_pts().is_none() { if buf.pts().is_none() {
gst::element_error!( gst::element_error!(
element, element,
gst::ResourceError::Read, gst::ResourceError::Read,
@ -377,7 +377,7 @@ impl BaseTransformImpl for CCDetect {
} }
}; };
self.maybe_update_properties(element, buf.get_pts(), cc_packet) self.maybe_update_properties(element, buf.pts(), cc_packet)
.map_err(|_| gst::FlowError::Error)?; .map_err(|_| gst::FlowError::Error)?;
Ok(gst::FlowSuccess::Ok) Ok(gst::FlowSuccess::Ok)

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

@ -138,7 +138,7 @@ impl Cea608Overlay {
layout.set_text( layout.set_text(
&"12345678901234567890123456789012\n2\n3\n4\n5\n6\n7\n8\n9\n0\n1\n2\n3\n4\n5", &"12345678901234567890123456789012\n2\n3\n4\n5\n6\n7\n8\n9\n0\n1\n2\n3\n4\n5",
); );
let (_ink_rect, logical_rect) = layout.get_extents(); let (_ink_rect, logical_rect) = layout.extents();
if logical_rect.width > video_info.width() as i32 * pango::SCALE if logical_rect.width > video_info.width() as i32 * pango::SCALE
|| logical_rect.height > video_info.height() as i32 * pango::SCALE || logical_rect.height > video_info.height() as i32 * pango::SCALE
{ {
@ -160,7 +160,7 @@ impl Cea608Overlay {
let video_info = state.video_info.as_ref().unwrap(); let video_info = state.video_info.as_ref().unwrap();
let layout = state.layout.as_ref().unwrap(); let layout = state.layout.as_ref().unwrap();
layout.set_text(text); layout.set_text(text);
let (_ink_rect, logical_rect) = layout.get_extents(); let (_ink_rect, logical_rect) = layout.extents();
let height = logical_rect.height / pango::SCALE; let height = logical_rect.height / pango::SCALE;
let width = logical_rect.width / pango::SCALE; let width = logical_rect.width / pango::SCALE;
@ -189,7 +189,7 @@ impl Cea608Overlay {
// Pass ownership of the buffer to the cairo surface but keep around // Pass ownership of the buffer to the cairo surface but keep around
// a raw pointer so we can later retrieve it again when the surface // a raw pointer so we can later retrieve it again when the surface
// is done // is done
let buffer_ptr = unsafe { buffer.get_buffer().as_ptr() }; let buffer_ptr = unsafe { buffer.buffer().as_ptr() };
let surface = cairo::ImageSurface::create_for_data( let surface = cairo::ImageSurface::create_for_data(
buffer, buffer,
cairo::Format::ARgb32, cairo::Format::ARgb32,
@ -436,8 +436,8 @@ impl Cea608Overlay {
} }
for meta in buffer.iter_meta::<gst_video::VideoCaptionMeta>() { for meta in buffer.iter_meta::<gst_video::VideoCaptionMeta>() {
if meta.get_caption_type() == gst_video::VideoCaptionType::Cea708Cdp { if meta.caption_type() == gst_video::VideoCaptionType::Cea708Cdp {
match extract_cdp(meta.get_data()) { match extract_cdp(meta.data()) {
Ok(data) => { Ok(data) => {
self.decode_cc_data(pad, element, &mut state, data); self.decode_cc_data(pad, element, &mut state, data);
} }
@ -446,12 +446,12 @@ impl Cea608Overlay {
gst::element_warning!(element, gst::StreamError::Decode, [&e.to_string()]); gst::element_warning!(element, gst::StreamError::Decode, [&e.to_string()]);
} }
} }
} else if meta.get_caption_type() == gst_video::VideoCaptionType::Cea708Raw { } else if meta.caption_type() == gst_video::VideoCaptionType::Cea708Raw {
self.decode_cc_data(pad, element, &mut state, meta.get_data()); self.decode_cc_data(pad, element, &mut state, meta.data());
} else if meta.get_caption_type() == gst_video::VideoCaptionType::Cea608S3341a { } else if meta.caption_type() == gst_video::VideoCaptionType::Cea608S3341a {
self.decode_s334_1a(pad, element, &mut state, meta.get_data()); self.decode_s334_1a(pad, element, &mut state, meta.data());
} else if meta.get_caption_type() == gst_video::VideoCaptionType::Cea608Raw { } else if meta.caption_type() == gst_video::VideoCaptionType::Cea608Raw {
let data = meta.get_data(); let data = meta.data();
assert!(data.len() % 2 == 0); assert!(data.len() % 2 == 0);
for i in 0..data.len() / 2 { for i in 0..data.len() / 2 {
match state match state
@ -514,7 +514,7 @@ impl Cea608Overlay {
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();
state.video_info = gst_video::VideoInfo::from_caps(c.get_caps()).ok(); state.video_info = gst_video::VideoInfo::from_caps(c.caps()).ok();
self.srcpad.check_reconfigure(); self.srcpad.check_reconfigure();
match self.negotiate(element, &mut state) { match self.negotiate(element, &mut state) {
Ok(_) => true, Ok(_) => true,
@ -599,7 +599,7 @@ impl ObjectImpl for Cea608Overlay {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"field" => { "field" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
@ -615,7 +615,7 @@ impl ObjectImpl for Cea608Overlay {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"field" => { "field" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.field.to_value() settings.field.to_value()

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

@ -748,13 +748,13 @@ impl Cea608ToJson {
let mut state = self.state.borrow_mut(); let mut state = self.state.borrow_mut();
let pts = buffer.get_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.get_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);

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

@ -76,7 +76,7 @@ impl Cea608ToTt {
} }
}; };
let buffer_pts = buffer.get_pts(); let buffer_pts = buffer.pts();
if buffer_pts.is_none() { if buffer_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);
@ -284,8 +284,8 @@ impl Cea608ToTt {
return true; return true;
} }
let mut downstream_caps = match self.srcpad.get_allowed_caps() { let mut downstream_caps = match self.srcpad.allowed_caps() {
None => self.srcpad.get_pad_template_caps(), None => self.srcpad.pad_template_caps(),
Some(caps) => caps, Some(caps) => caps,
}; };
@ -304,13 +304,13 @@ impl Cea608ToTt {
); );
let s = downstream_caps.get_structure(0).unwrap(); let s = downstream_caps.get_structure(0).unwrap();
let new_caps = if s.get_name() == "application/x-subtitle-vtt" { let new_caps = if s.name() == "application/x-subtitle-vtt" {
state.format = Some(Format::Vtt); state.format = Some(Format::Vtt);
gst::Caps::builder("application/x-subtitle-vtt").build() gst::Caps::builder("application/x-subtitle-vtt").build()
} else if s.get_name() == "application/x-subtitle" { } else if s.name() == "application/x-subtitle" {
state.format = Some(Format::Srt); state.format = Some(Format::Srt);
gst::Caps::builder("application/x-subtitle").build() gst::Caps::builder("application/x-subtitle").build()
} else if s.get_name() == "text/x-raw" { } else if s.name() == "text/x-raw" {
state.format = Some(Format::Raw); state.format = Some(Format::Raw);
gst::Caps::builder("text/x-raw") gst::Caps::builder("text/x-raw")
.field("format", &"utf8") .field("format", &"utf8")

68
video/closedcaption/src/line_reader.rs
View file

@ -61,12 +61,12 @@ impl<T: AsRef<[u8]>> LineReader<T> {
} }
#[allow(unused)] #[allow(unused)]
pub fn get_line_or_drain(&mut self) -> Option<&[u8]> { pub fn line_or_drain(&mut self) -> Option<&[u8]> {
self.get_line_with_drain(true) self.get_line_with_drain(true)
} }
#[allow(unused)] #[allow(unused)]
pub fn get_line(&mut self) -> Option<&[u8]> { pub fn line(&mut self) -> Option<&[u8]> {
self.get_line_with_drain(false) self.get_line_with_drain(false)
} }
@ -247,10 +247,10 @@ mod tests {
let mut r = LineReader::new(); let mut r = LineReader::new();
r.push(Vec::from(b"abcd\nefgh\nijkl\n".as_ref())); r.push(Vec::from(b"abcd\nefgh\nijkl\n".as_ref()));
assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); assert_eq!(r.line(), Some(b"abcd\n".as_ref()));
assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); assert_eq!(r.line(), Some(b"efgh\n".as_ref()));
assert_eq!(r.get_line(), Some(b"ijkl\n".as_ref())); assert_eq!(r.line(), Some(b"ijkl\n".as_ref()));
assert_eq!(r.get_line(), None); assert_eq!(r.line(), None);
} }
#[test] #[test]
@ -258,11 +258,11 @@ mod tests {
let mut r = LineReader::new(); let mut r = LineReader::new();
r.push(Vec::from(b"abcd\nefgh\n\nijkl\n".as_ref())); r.push(Vec::from(b"abcd\nefgh\n\nijkl\n".as_ref()));
assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); assert_eq!(r.line(), Some(b"abcd\n".as_ref()));
assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); assert_eq!(r.line(), Some(b"efgh\n".as_ref()));
assert_eq!(r.get_line(), Some(b"\n".as_ref())); assert_eq!(r.line(), Some(b"\n".as_ref()));
assert_eq!(r.get_line(), Some(b"ijkl\n".as_ref())); assert_eq!(r.line(), Some(b"ijkl\n".as_ref()));
assert_eq!(r.get_line(), None); assert_eq!(r.line(), None);
} }
#[test] #[test]
@ -271,10 +271,10 @@ mod tests {
r.push(Vec::from(b"abcd\nef".as_ref())); r.push(Vec::from(b"abcd\nef".as_ref()));
r.push(Vec::from(b"gh\nijkl\n".as_ref())); r.push(Vec::from(b"gh\nijkl\n".as_ref()));
assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); assert_eq!(r.line(), Some(b"abcd\n".as_ref()));
assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); assert_eq!(r.line(), Some(b"efgh\n".as_ref()));
assert_eq!(r.get_line(), Some(b"ijkl\n".as_ref())); assert_eq!(r.line(), Some(b"ijkl\n".as_ref()));
assert_eq!(r.get_line(), None); assert_eq!(r.line(), None);
} }
#[test] #[test]
@ -285,10 +285,10 @@ mod tests {
r.push(Vec::from(b"g".as_ref())); r.push(Vec::from(b"g".as_ref()));
r.push(Vec::from(b"h\nijkl\n".as_ref())); r.push(Vec::from(b"h\nijkl\n".as_ref()));
assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); assert_eq!(r.line(), Some(b"abcd\n".as_ref()));
assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); assert_eq!(r.line(), Some(b"efgh\n".as_ref()));
assert_eq!(r.get_line(), Some(b"ijkl\n".as_ref())); assert_eq!(r.line(), Some(b"ijkl\n".as_ref()));
assert_eq!(r.get_line(), None); assert_eq!(r.line(), None);
} }
#[test] #[test]
@ -296,11 +296,11 @@ mod tests {
let mut r = LineReader::new(); let mut r = LineReader::new();
r.push(Vec::from(b"abcd\nefgh\nijkl".as_ref())); r.push(Vec::from(b"abcd\nefgh\nijkl".as_ref()));
assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); assert_eq!(r.line(), Some(b"abcd\n".as_ref()));
assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); assert_eq!(r.line(), Some(b"efgh\n".as_ref()));
assert_eq!(r.get_line(), None); assert_eq!(r.line(), None);
assert_eq!(r.get_line_or_drain(), Some(b"ijkl".as_ref())); assert_eq!(r.line_or_drain(), Some(b"ijkl".as_ref()));
assert_eq!(r.get_line_or_drain(), None); assert_eq!(r.line_or_drain(), None);
} }
#[test] #[test]
@ -309,11 +309,11 @@ mod tests {
r.push(Vec::from(b"abcd\nefgh\n".as_ref())); r.push(Vec::from(b"abcd\nefgh\n".as_ref()));
r.push(Vec::from(b"ijkl".as_ref())); r.push(Vec::from(b"ijkl".as_ref()));
assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); assert_eq!(r.line(), Some(b"abcd\n".as_ref()));
assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); assert_eq!(r.line(), Some(b"efgh\n".as_ref()));
assert_eq!(r.get_line(), None); assert_eq!(r.line(), None);
assert_eq!(r.get_line_or_drain(), Some(b"ijkl".as_ref())); assert_eq!(r.line_or_drain(), Some(b"ijkl".as_ref()));
assert_eq!(r.get_line_or_drain(), None); assert_eq!(r.line_or_drain(), None);
} }
#[test] #[test]
@ -324,10 +324,10 @@ mod tests {
r.push(Vec::from(b"k".as_ref())); r.push(Vec::from(b"k".as_ref()));
r.push(Vec::from(b"l".as_ref())); r.push(Vec::from(b"l".as_ref()));
assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); assert_eq!(r.line(), Some(b"abcd\n".as_ref()));
assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); assert_eq!(r.line(), Some(b"efgh\n".as_ref()));
assert_eq!(r.get_line(), None); assert_eq!(r.line(), None);
assert_eq!(r.get_line_or_drain(), Some(b"ijkl".as_ref())); assert_eq!(r.line_or_drain(), Some(b"ijkl".as_ref()));
assert_eq!(r.get_line_or_drain(), None); assert_eq!(r.line_or_drain(), None);
} }
} }

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

@ -90,7 +90,7 @@ impl MccEnc {
let caps = self let caps = self
.sinkpad .sinkpad
.get_current_caps() .current_caps()
.ok_or(gst::FlowError::NotNegotiated)?; .ok_or(gst::FlowError::NotNegotiated)?;
let framerate = match caps let framerate = match caps
.get_structure(0) .get_structure(0)
@ -125,17 +125,17 @@ impl MccEnc {
if let Some(ref creation_date) = settings.creation_date { if let Some(ref creation_date) = settings.creation_date {
let creation_date = Utc let creation_date = Utc
.ymd( .ymd(
creation_date.get_year() as i32, creation_date.year() as i32,
creation_date.get_month() as u32, creation_date.month() as u32,
creation_date.get_day_of_month() as u32, creation_date.day_of_month() as u32,
) )
.and_hms( .and_hms(
creation_date.get_hour() as u32, creation_date.hour() as u32,
creation_date.get_minute() as u32, creation_date.minute() as u32,
creation_date.get_seconds() as u32, creation_date.seconds() as u32,
) )
.with_timezone(&FixedOffset::east( .with_timezone(&FixedOffset::east(
(creation_date.get_utc_offset() / 1_000_000) as i32, (creation_date.utc_offset() / 1_000_000) as i32,
)); ));
let _ = write!( let _ = write!(
@ -287,7 +287,7 @@ impl MccEnc {
gst::FlowError::Error gst::FlowError::Error
})?; })?;
let _ = write!(outbuf, "{}\t", meta.get_tc()); let _ = write!(outbuf, "{}\t", meta.tc());
let map = buffer.map_readable().map_err(|_| { let map = buffer.map_readable().map_err(|_| {
gst::element_error!( gst::element_error!(
@ -369,7 +369,7 @@ impl MccEnc {
match event.view() { match event.view() {
EventView::Caps(ev) => { EventView::Caps(ev) => {
let caps = ev.get_caps(); let caps = ev.caps();
let s = caps.get_structure(0).unwrap(); let s = caps.get_structure(0).unwrap();
let framerate = match s.get_some::<gst::Fraction>("framerate") { let framerate = match s.get_some::<gst::Fraction>("framerate") {
Ok(framerate) => framerate, Ok(framerate) => framerate,
@ -381,7 +381,7 @@ impl MccEnc {
}; };
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
if s.get_name() == "closedcaption/x-cea-608" { if s.name() == "closedcaption/x-cea-608" {
state.format = Some(Format::Cea608); state.format = Some(Format::Cea608);
} else { } else {
state.format = Some(Format::Cea708Cdp); state.format = Some(Format::Cea708Cdp);
@ -431,7 +431,7 @@ impl MccEnc {
match query.view_mut() { match query.view_mut() {
QueryView::Seeking(mut q) => { QueryView::Seeking(mut q) => {
// We don't support any seeking at all // We don't support any seeking at all
let fmt = q.get_format(); let fmt = q.format();
q.set( q.set(
false, false,
gst::GenericFormattedValue::Other(fmt, -1), gst::GenericFormattedValue::Other(fmt, -1),
@ -527,7 +527,7 @@ impl ObjectImpl for MccEnc {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"uuid" => { "uuid" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.uuid = value.get().expect("type checked upstream"); settings.uuid = value.get().expect("type checked upstream");
@ -541,7 +541,7 @@ impl ObjectImpl for MccEnc {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"uuid" => { "uuid" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.uuid.to_value() settings.uuid.to_value()

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

@ -526,7 +526,7 @@ impl MccParse {
state.last_timecode = Some(timecode); state.last_timecode = Some(timecode);
if nsecs >= state.segment.get_start() { if nsecs >= state.segment.start() {
state.seeking = false; state.seeking = false;
state.discont = true; state.discont = true;
state.replay_last_line = true; state.replay_last_line = true;
@ -562,8 +562,8 @@ impl MccParse {
// Update the last_timecode to the current one // Update the last_timecode to the current one
state.last_timecode = Some(timecode); state.last_timecode = Some(timecode);
let send_eos = state.segment.get_stop().is_some() let send_eos = state.segment.stop().is_some()
&& buffer.get_pts() + buffer.get_duration() >= state.segment.get_stop(); && buffer.pts() + buffer.duration() >= state.segment.stop();
// Drop our state mutex while we push out buffers or events // Drop our state mutex while we push out buffers or events
drop(state); drop(state);
@ -673,7 +673,7 @@ impl MccParse {
return Err(loggable_error!(CAT, "Failed to query upstream duration")); return Err(loggable_error!(CAT, "Failed to query upstream duration"));
} }
let size = match q.get_result().try_into().unwrap() { let size = match q.result().try_into().unwrap() {
gst::format::Bytes(Some(size)) => size, gst::format::Bytes(Some(size)) => size,
gst::format::Bytes(None) => { gst::format::Bytes(None) => {
return Err(loggable_error!(CAT, "Failed to query upstream duration")); return Err(loggable_error!(CAT, "Failed to query upstream duration"));
@ -937,7 +937,7 @@ impl MccParse {
_ => { _ => {
if event.is_sticky() if event.is_sticky()
&& !self.srcpad.has_current_caps() && !self.srcpad.has_current_caps()
&& event.get_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();
@ -984,7 +984,7 @@ impl MccParse {
return false; return false;
} }
let seek_seqnum = event.get_seqnum(); let seek_seqnum = event.seqnum();
let event = gst::event::FlushStart::builder() let event = gst::event::FlushStart::builder()
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
@ -1067,7 +1067,7 @@ impl MccParse {
QueryView::Seeking(mut q) => { QueryView::Seeking(mut q) => {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
let fmt = q.get_format(); let fmt = q.format();
if fmt == gst::Format::Time { if fmt == gst::Format::Time {
if let Some(pull) = state.pull.as_ref() { if let Some(pull) = state.pull.as_ref() {
@ -1086,7 +1086,7 @@ impl MccParse {
} }
QueryView::Position(ref mut q) => { QueryView::Position(ref mut q) => {
// For Time answer ourselfs, otherwise forward // For Time answer ourselfs, otherwise forward
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
q.set(state.last_position); q.set(state.last_position);
true true
@ -1097,7 +1097,7 @@ impl MccParse {
QueryView::Duration(ref mut q) => { QueryView::Duration(ref mut q) => {
// For Time answer ourselfs, otherwise forward // For Time answer ourselfs, otherwise forward
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
if let Some(pull) = state.pull.as_ref() { if let Some(pull) = state.pull.as_ref() {
if pull.duration.is_some() { if pull.duration.is_some() {
q.set(state.pull.as_ref().unwrap().duration); q.set(state.pull.as_ref().unwrap().duration);

2
video/closedcaption/src/mcc_parse/parser.rs
View file

@ -688,7 +688,7 @@ mod tests {
reader.push(Vec::from(mcc_file.as_ref())); reader.push(Vec::from(mcc_file.as_ref()));
while let Some(line) = reader.get_line() { while let Some(line) = reader.line() {
let res = match parser.parse_line(line, true) { let res = match parser.parse_line(line, true) {
Ok(res) => res, Ok(res) => res,
Err(err) => panic!("Couldn't parse line {}: {:?}", line_cnt, err), Err(err) => panic!("Couldn't parse line {}: {:?}", line_cnt, err),

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

@ -78,11 +78,11 @@ impl State {
assert!(self.internal_buffer.len() < MAXIMUM_PACKETES_PER_LINE); assert!(self.internal_buffer.len() < MAXIMUM_PACKETES_PER_LINE);
if buffer.get_size() != 2 { if buffer.size() != 2 {
gst::element_error!( gst::element_error!(
element, element,
gst::StreamError::Format, gst::StreamError::Format,
["Wrongly sized CEA608 packet: {}", buffer.get_size()] ["Wrongly sized CEA608 packet: {}", buffer.size()]
); );
return Err(gst::FlowError::Error); return Err(gst::FlowError::Error);
@ -105,7 +105,7 @@ impl State {
gst::FlowError::Error gst::FlowError::Error
})? })?
.get_tc(); .tc();
if self.expected_timecode.is_none() { if self.expected_timecode.is_none() {
self.expected_timecode = Some(timecode.clone()); self.expected_timecode = Some(timecode.clone());
@ -173,7 +173,7 @@ impl State {
// Checked already before the buffer has been pushed to the // Checked already before the buffer has been pushed to the
// internal_buffer // internal_buffer
.expect("Buffer without timecode") .expect("Buffer without timecode")
.get_tc(); .tc();
let _ = write!(outbuf, "{}\t", timecode); let _ = write!(outbuf, "{}\t", timecode);
line_start = false; line_start = false;
@ -206,7 +206,7 @@ impl State {
first_buf first_buf
.copy_into(buf_mut, gst::BUFFER_COPY_METADATA, 0, None) .copy_into(buf_mut, gst::BUFFER_COPY_METADATA, 0, None)
.expect("Failed to copy buffer metadata"); .expect("Failed to copy buffer metadata");
buf_mut.set_pts(first_buf.get_pts()); buf_mut.set_pts(first_buf.pts());
buffer buffer
}; };
@ -252,7 +252,7 @@ impl SccEnc {
match event.view() { match event.view() {
EventView::Caps(ev) => { EventView::Caps(ev) => {
let caps = ev.get_caps(); let caps = ev.caps();
let s = caps.get_structure(0).unwrap(); let s = caps.get_structure(0).unwrap();
let framerate = match s.get_some::<gst::Fraction>("framerate") { let framerate = match s.get_some::<gst::Fraction>("framerate") {
Ok(framerate) => Some(framerate), Ok(framerate) => Some(framerate),
@ -319,7 +319,7 @@ impl SccEnc {
match query.view_mut() { match query.view_mut() {
QueryView::Seeking(mut q) => { QueryView::Seeking(mut q) => {
// We don't support any seeking at all // We don't support any seeking at all
let fmt = q.get_format(); let fmt = q.format();
q.set( q.set(
false, false,
gst::GenericFormattedValue::Other(fmt, -1), gst::GenericFormattedValue::Other(fmt, -1),

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

@ -375,7 +375,7 @@ impl SccParse {
let mut timecode = state.handle_timecode(&tc, framerate, element)?; let mut timecode = state.handle_timecode(&tc, framerate, element)?;
let start_time = gst::ClockTime::from(timecode.nsec_since_daily_jam()); let start_time = gst::ClockTime::from(timecode.nsec_since_daily_jam());
let segment_start = state.segment.get_start(); let segment_start = state.segment.start();
let clip_buffers = if state.seeking { let clip_buffers = if state.seeking {
// If we are in the middle of seeking, check whether this line // If we are in the middle of seeking, check whether this line
// contains start frame, and if so, unset seeking flag // contains start frame, and if so, unset seeking flag
@ -430,7 +430,7 @@ impl SccParse {
timecode.increment_frame(); timecode.increment_frame();
if clip_buffers { if clip_buffers {
let end_time = buffer.get_pts() + buffer.get_duration(); let end_time = buffer.pts() + buffer.duration();
if end_time < segment_start { if end_time < segment_start {
gst_trace!( gst_trace!(
CAT, CAT,
@ -443,8 +443,8 @@ impl SccParse {
} }
} }
send_eos = state.segment.get_stop().is_some() send_eos = state.segment.stop().is_some()
&& buffer.get_pts() + buffer.get_duration() >= state.segment.get_stop(); && buffer.pts() + buffer.duration() >= state.segment.stop();
let buffers = buffers.get_mut().unwrap(); let buffers = buffers.get_mut().unwrap();
buffers.add(buffer); buffers.add(buffer);
@ -566,7 +566,7 @@ impl SccParse {
return Err(loggable_error!(CAT, "Failed to query upstream duration")); return Err(loggable_error!(CAT, "Failed to query upstream duration"));
} }
let size = match q.get_result().try_into().unwrap() { let size = match q.result().try_into().unwrap() {
gst::format::Bytes(Some(size)) => size, gst::format::Bytes(Some(size)) => size,
gst::format::Bytes(None) => { gst::format::Bytes(None) => {
return Err(loggable_error!(CAT, "Failed to query upstream duration")); return Err(loggable_error!(CAT, "Failed to query upstream duration"));
@ -817,7 +817,7 @@ impl SccParse {
_ => { _ => {
if event.is_sticky() if event.is_sticky()
&& !self.srcpad.has_current_caps() && !self.srcpad.has_current_caps()
&& event.get_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();
@ -864,7 +864,7 @@ impl SccParse {
return false; return false;
} }
let seek_seqnum = event.get_seqnum(); let seek_seqnum = event.seqnum();
let event = gst::event::FlushStart::builder() let event = gst::event::FlushStart::builder()
.seqnum(seek_seqnum) .seqnum(seek_seqnum)
@ -947,7 +947,7 @@ impl SccParse {
QueryView::Seeking(mut q) => { QueryView::Seeking(mut q) => {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
let fmt = q.get_format(); let fmt = q.format();
if fmt == gst::Format::Time { if fmt == gst::Format::Time {
if let Some(pull) = state.pull.as_ref() { if let Some(pull) = state.pull.as_ref() {
@ -966,7 +966,7 @@ impl SccParse {
} }
QueryView::Position(ref mut q) => { QueryView::Position(ref mut q) => {
// For Time answer ourselfs, otherwise forward // For Time answer ourselfs, otherwise forward
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
q.set(state.last_position); q.set(state.last_position);
true true
@ -977,7 +977,7 @@ impl SccParse {
QueryView::Duration(ref mut q) => { QueryView::Duration(ref mut q) => {
// For Time answer ourselfs, otherwise forward // For Time answer ourselfs, otherwise forward
let state = self.state.lock().unwrap(); let state = self.state.lock().unwrap();
if q.get_format() == gst::Format::Time { if q.format() == gst::Format::Time {
if let Some(pull) = state.pull.as_ref() { if let Some(pull) = state.pull.as_ref() {
if pull.duration.is_some() { if pull.duration.is_some() {
q.set(state.pull.as_ref().unwrap().duration); q.set(state.pull.as_ref().unwrap().duration);

2
video/closedcaption/src/scc_parse/parser.rs
View file

@ -346,7 +346,7 @@ mod tests {
reader.push(Vec::from(scc_file.as_ref())); reader.push(Vec::from(scc_file.as_ref()));
while let Some(line) = reader.get_line() { while let Some(line) = reader.line() {
let res = match parser.parse_line(line) { let res = match parser.parse_line(line) {
Ok(res) => res, Ok(res) => res,
Err(err) => panic!("Couldn't parse line {}: {:?}", line_cnt, err), Err(err) => panic!("Couldn't parse line {}: {:?}", line_cnt, err),

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

@ -789,7 +789,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> {
let pts = match buffer.get_pts() { let pts = match buffer.pts() {
gst::CLOCK_TIME_NONE => { gst::CLOCK_TIME_NONE => {
gst::element_error!( gst::element_error!(
element, element,
@ -801,7 +801,7 @@ impl TtToCea608 {
pts => Ok(pts), pts => Ok(pts),
}?; }?;
let duration = match buffer.get_duration() { let duration = match buffer.duration() {
gst::CLOCK_TIME_NONE => { gst::CLOCK_TIME_NONE => {
gst::element_error!( gst::element_error!(
element, element,
@ -884,8 +884,8 @@ impl TtToCea608 {
match event.view() { match event.view() {
EventView::Caps(e) => { EventView::Caps(e) => {
let mut downstream_caps = match self.srcpad.get_allowed_caps() { let mut downstream_caps = match self.srcpad.allowed_caps() {
None => self.srcpad.get_pad_template_caps(), None => self.srcpad.pad_template_caps(),
Some(caps) => caps, Some(caps) => caps,
}; };
@ -906,9 +906,9 @@ impl TtToCea608 {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
state.framerate = s.get_some::<gst::Fraction>("framerate").unwrap(); state.framerate = s.get_some::<gst::Fraction>("framerate").unwrap();
let upstream_caps = e.get_caps(); let upstream_caps = e.caps();
let s = upstream_caps.get_structure(0).unwrap(); let s = upstream_caps.get_structure(0).unwrap();
state.json_input = s.get_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);
@ -1066,7 +1066,7 @@ impl ObjectImpl for TtToCea608 {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"mode" => { "mode" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.mode = value settings.mode = value
@ -1091,7 +1091,7 @@ impl ObjectImpl for TtToCea608 {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"mode" => { "mode" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.mode.to_value() settings.mode.to_value()

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

@ -60,8 +60,8 @@ impl TtToJson {
element: &super::TtToJson, element: &super::TtToJson,
buffer: gst::Buffer, buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
let pts = buffer.get_pts(); let pts = buffer.pts();
let duration = buffer.get_duration(); let duration = buffer.duration();
let buffer = buffer.into_mapped_buffer_readable().map_err(|_| { let buffer = buffer.into_mapped_buffer_readable().map_err(|_| {
gst::element_error!( gst::element_error!(
@ -253,7 +253,7 @@ impl ObjectImpl for TtToJson {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"mode" => { "mode" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.mode = value settings.mode = value
@ -265,7 +265,7 @@ impl ObjectImpl for TtToJson {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"mode" => { "mode" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.mode.to_value() settings.mode.to_value()

33
video/closedcaption/tests/ccdetect.rs
View file

@ -70,14 +70,14 @@ fn test_have_cc_data_notify() {
let mut h = gst_check::Harness::new("ccdetect"); let mut h = gst_check::Harness::new("ccdetect");
h.set_src_caps_str("closedcaption/x-cea-708,format=cc_data"); h.set_src_caps_str("closedcaption/x-cea-708,format=cc_data");
h.set_sink_caps_str("closedcaption/x-cea-708,format=cc_data"); h.set_sink_caps_str("closedcaption/x-cea-708,format=cc_data");
h.get_element() h.element()
.unwrap() .unwrap()
.set_property("window", &(500_000_000u64)) .set_property("window", &(500_000_000u64))
.unwrap(); .unwrap();
let state = Arc::new(Mutex::new(NotifyState::default())); let state = Arc::new(Mutex::new(NotifyState::default()));
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc608"), move |o, _pspec| { .connect_notify(Some("cc608"), move |o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
@ -85,7 +85,7 @@ fn test_have_cc_data_notify() {
o.get_property("cc608").unwrap(); o.get_property("cc608").unwrap();
}); });
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc708"), move |o, _pspec| { .connect_notify(Some("cc708"), move |o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
@ -115,21 +115,21 @@ fn test_cc_data_window() {
let mut h = gst_check::Harness::new("ccdetect"); let mut h = gst_check::Harness::new("ccdetect");
h.set_src_caps_str("closedcaption/x-cea-708,format=cc_data"); h.set_src_caps_str("closedcaption/x-cea-708,format=cc_data");
h.set_sink_caps_str("closedcaption/x-cea-708,format=cc_data"); h.set_sink_caps_str("closedcaption/x-cea-708,format=cc_data");
h.get_element() h.element()
.unwrap() .unwrap()
.set_property("window", &500_000_000u64) .set_property("window", &500_000_000u64)
.unwrap(); .unwrap();
let state = Arc::new(Mutex::new(NotifyState::default())); let state = Arc::new(Mutex::new(NotifyState::default()));
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc608"), move |_o, _pspec| { .connect_notify(Some("cc608"), move |_o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
state_guard.cc608_count += 1; state_guard.cc608_count += 1;
}); });
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc708"), move |_o, _pspec| { .connect_notify(Some("cc708"), move |_o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
@ -193,21 +193,21 @@ fn test_have_cdp_notify() {
let mut h = gst_check::Harness::new("ccdetect"); let mut h = gst_check::Harness::new("ccdetect");
h.set_src_caps_str("closedcaption/x-cea-708,format=cdp"); h.set_src_caps_str("closedcaption/x-cea-708,format=cdp");
h.set_sink_caps_str("closedcaption/x-cea-708,format=cdp"); h.set_sink_caps_str("closedcaption/x-cea-708,format=cdp");
h.get_element() h.element()
.unwrap() .unwrap()
.set_property("window", &500_000_000u64) .set_property("window", &500_000_000u64)
.unwrap(); .unwrap();
let state = Arc::new(Mutex::new(NotifyState::default())); let state = Arc::new(Mutex::new(NotifyState::default()));
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc608"), move |_o, _pspec| { .connect_notify(Some("cc608"), move |_o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
state_guard.cc608_count += 1; state_guard.cc608_count += 1;
}); });
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc708"), move |_o, _pspec| { .connect_notify(Some("cc708"), move |_o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
@ -257,21 +257,18 @@ fn test_malformed_cdp_notify() {
let mut h = gst_check::Harness::new("ccdetect"); let mut h = gst_check::Harness::new("ccdetect");
h.set_src_caps_str("closedcaption/x-cea-708,format=cdp"); h.set_src_caps_str("closedcaption/x-cea-708,format=cdp");
h.set_sink_caps_str("closedcaption/x-cea-708,format=cdp"); h.set_sink_caps_str("closedcaption/x-cea-708,format=cdp");
h.get_element() h.element().unwrap().set_property("window", &0u64).unwrap();
.unwrap()
.set_property("window", &0u64)
.unwrap();
let state = Arc::new(Mutex::new(NotifyState::default())); let state = Arc::new(Mutex::new(NotifyState::default()));
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc608"), move |_o, _pspec| { .connect_notify(Some("cc608"), move |_o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
state_guard.cc608_count += 1; state_guard.cc608_count += 1;
}); });
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc708"), move |_o, _pspec| { .connect_notify(Some("cc708"), move |_o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
@ -297,21 +294,21 @@ fn test_gap_events() {
let mut h = gst_check::Harness::new("ccdetect"); let mut h = gst_check::Harness::new("ccdetect");
h.set_src_caps_str("closedcaption/x-cea-708,format=cc_data"); h.set_src_caps_str("closedcaption/x-cea-708,format=cc_data");
h.set_sink_caps_str("closedcaption/x-cea-708,format=cc_data"); h.set_sink_caps_str("closedcaption/x-cea-708,format=cc_data");
h.get_element() h.element()
.unwrap() .unwrap()
.set_property("window", &500_000_000u64) .set_property("window", &500_000_000u64)
.unwrap(); .unwrap();
let state = Arc::new(Mutex::new(NotifyState::default())); let state = Arc::new(Mutex::new(NotifyState::default()));
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc608"), move |_o, _pspec| { .connect_notify(Some("cc608"), move |_o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();
state_guard.cc608_count += 1; state_guard.cc608_count += 1;
}); });
let state_c = state.clone(); let state_c = state.clone();
h.get_element() h.element()
.unwrap() .unwrap()
.connect_notify(Some("cc708"), move |_o, _pspec| { .connect_notify(Some("cc708"), move |_o, _pspec| {
let mut state_guard = state_c.lock().unwrap(); let mut state_guard = state_c.lock().unwrap();

8
video/closedcaption/tests/cea608tott.rs
View file

@ -68,10 +68,10 @@ fn test_parse() {
for (i, e) in expected.iter().enumerate() { for (i, e) in expected.iter().enumerate() {
let buf = h.try_pull().unwrap(); let buf = h.try_pull().unwrap();
assert_eq!(e.0, buf.get_pts(), "Unexpected PTS for {}th buffer", i + 1); assert_eq!(e.0, buf.pts(), "Unexpected PTS for {}th buffer", i + 1);
assert_eq!( assert_eq!(
e.1, e.1,
buf.get_duration(), buf.duration(),
"Unexpected duration for {}th buffer", "Unexpected duration for {}th buffer",
i + 1 i + 1
); );
@ -83,9 +83,9 @@ fn test_parse() {
} }
let caps = h let caps = h
.get_sinkpad() .sinkpad()
.expect("harness has no sinkpad") .expect("harness has no sinkpad")
.get_current_caps() .current_caps()
.expect("pad has no caps"); .expect("pad has no caps");
assert_eq!( assert_eq!(
caps, caps,

6
video/closedcaption/tests/mcc_enc.rs
View file

@ -91,7 +91,7 @@ Time Code Rate=30DF\r\n\
let mut h = gst_check::Harness::new("mccenc"); let mut h = gst_check::Harness::new("mccenc");
{ {
let enc = h.get_element().expect("could not create encoder"); let enc = h.element().expect("could not create encoder");
enc.set_property("uuid", &"14720C04-857D-40E2-86FC-F080DE44CE74") enc.set_property("uuid", &"14720C04-857D-40E2-86FC-F080DE44CE74")
.unwrap(); .unwrap();
enc.set_property( enc.set_property(
@ -132,10 +132,10 @@ Time Code Rate=30DF\r\n\
let timecode = buf let timecode = buf
.get_meta::<gst_video::VideoTimeCodeMeta>() .get_meta::<gst_video::VideoTimeCodeMeta>()
.expect("No timecode for buffer") .expect("No timecode for buffer")
.get_tc(); .tc();
assert_eq!(timecode, tc); assert_eq!(timecode, tc);
let pts = buf.get_pts(); let pts = buf.pts();
assert_eq!(pts, gst::ClockTime::from_seconds(0)); assert_eq!(pts, gst::ClockTime::from_seconds(0));
let map = buf.map_readable().expect("Couldn't map buffer readable"); let map = buf.map_readable().expect("Couldn't map buffer readable");

20
video/closedcaption/tests/mcc_parse.rs
View file

@ -64,10 +64,10 @@ fn test_parse() {
rnd.gen_range(1..=data.len()) rnd.gen_range(1..=data.len())
}; };
let buf = gst::Buffer::from_mut_slice(Vec::from(&data[0..l])); let buf = gst::Buffer::from_mut_slice(Vec::from(&data[0..l]));
input_len += buf.get_size(); input_len += buf.size();
assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok)); assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok));
while let Some(buf) = h.try_pull() { while let Some(buf) = h.try_pull() {
output_len += buf.get_size(); output_len += buf.size();
checksum = checksum.wrapping_add( checksum = checksum.wrapping_add(
buf.map_readable() buf.map_readable()
.unwrap() .unwrap()
@ -79,9 +79,9 @@ fn test_parse() {
.get_meta::<gst_video::VideoTimeCodeMeta>() .get_meta::<gst_video::VideoTimeCodeMeta>()
.expect("No timecode meta"); .expect("No timecode meta");
if let Some(ref timecode) = expected_timecode { if let Some(ref timecode) = expected_timecode {
assert_eq!(&tc_meta.get_tc(), timecode); assert_eq!(&tc_meta.tc(), timecode);
} else { } else {
expected_timecode = Some(tc_meta.get_tc()); expected_timecode = Some(tc_meta.tc());
} }
if let Some(ref mut tc) = expected_timecode { if let Some(ref mut tc) = expected_timecode {
tc.increment_frame(); tc.increment_frame();
@ -92,7 +92,7 @@ fn test_parse() {
h.push_event(gst::event::Eos::new()); h.push_event(gst::event::Eos::new());
while let Some(buf) = h.try_pull() { while let Some(buf) = h.try_pull() {
output_len += buf.get_size(); output_len += buf.size();
checksum = checksum.wrapping_add( checksum = checksum.wrapping_add(
buf.map_readable() buf.map_readable()
.unwrap() .unwrap()
@ -104,9 +104,9 @@ fn test_parse() {
.get_meta::<gst_video::VideoTimeCodeMeta>() .get_meta::<gst_video::VideoTimeCodeMeta>()
.expect("No timecode meta"); .expect("No timecode meta");
if let Some(ref timecode) = expected_timecode { if let Some(ref timecode) = expected_timecode {
assert_eq!(&tc_meta.get_tc(), timecode); assert_eq!(&tc_meta.tc(), timecode);
} else { } else {
expected_timecode = Some(tc_meta.get_tc()); expected_timecode = Some(tc_meta.tc());
} }
if let Some(ref mut tc) = expected_timecode { if let Some(ref mut tc) = expected_timecode {
tc.increment_frame(); tc.increment_frame();
@ -119,9 +119,9 @@ fn test_parse() {
assert_eq!(checksum, 3_988_480); assert_eq!(checksum, 3_988_480);
let caps = h let caps = h
.get_sinkpad() .sinkpad()
.expect("harness has no sinkpad") .expect("harness has no sinkpad")
.get_current_caps() .current_caps()
.expect("pad has no caps"); .expect("pad has no caps");
assert_eq!( assert_eq!(
caps, caps,
@ -185,7 +185,7 @@ fn test_pull() {
while h.buffers_in_queue() != 0 { while h.buffers_in_queue() != 0 {
if let Ok(buffer) = h.pull() { if let Ok(buffer) = h.pull() {
let pts = buffer.get_pts(); let pts = buffer.pts();
assert!(pts > gst::SECOND && pts < 2 * gst::SECOND); assert!(pts > gst::SECOND && pts < 2 * gst::SECOND);
} }
} }

12
video/closedcaption/tests/scc_enc.rs
View file

@ -66,10 +66,10 @@ fn test_encode_single_packet() {
let timecode = buf let timecode = buf
.get_meta::<gst_video::VideoTimeCodeMeta>() .get_meta::<gst_video::VideoTimeCodeMeta>()
.expect("No timecode for buffer") .expect("No timecode for buffer")
.get_tc(); .tc();
assert_eq!(timecode, tc); assert_eq!(timecode, tc);
let pts = buf.get_pts(); let pts = buf.pts();
assert_eq!(pts, gst::ClockTime::from_seconds(0)); assert_eq!(pts, gst::ClockTime::from_seconds(0));
let map = buf.map_readable().expect("Couldn't map buffer readable"); let map = buf.map_readable().expect("Couldn't map buffer readable");
@ -165,10 +165,10 @@ fn test_encode_multiple_packets() {
let timecode = buf let timecode = buf
.get_meta::<gst_video::VideoTimeCodeMeta>() .get_meta::<gst_video::VideoTimeCodeMeta>()
.expect("No timecode for buffer") .expect("No timecode for buffer")
.get_tc(); .tc();
assert_eq!(timecode, tc1); assert_eq!(timecode, tc1);
let pts = buf.get_pts(); let pts = buf.pts();
assert_eq!(pts, gst::ClockTime::from_seconds(0)); assert_eq!(pts, gst::ClockTime::from_seconds(0));
let map = buf.map_readable().expect("Couldn't map buffer readable"); let map = buf.map_readable().expect("Couldn't map buffer readable");
@ -183,7 +183,7 @@ fn test_encode_multiple_packets() {
let timecode = buf let timecode = buf
.get_meta::<gst_video::VideoTimeCodeMeta>() .get_meta::<gst_video::VideoTimeCodeMeta>()
.expect("No timecode for buffer") .expect("No timecode for buffer")
.get_tc(); .tc();
assert_eq!(timecode, tc2); assert_eq!(timecode, tc2);
// let pts = buf.get_pts(); // let pts = buf.get_pts();
@ -212,7 +212,7 @@ fn test_encode_multiple_packets() {
let timecode = buf let timecode = buf
.get_meta::<gst_video::VideoTimeCodeMeta>() .get_meta::<gst_video::VideoTimeCodeMeta>()
.expect("No timecode for buffer") .expect("No timecode for buffer")
.get_tc(); .tc();
assert_eq!(timecode, tc3); assert_eq!(timecode, tc3);
// let pts = buf.get_pts(); // let pts = buf.get_pts();

22
video/closedcaption/tests/scc_parse.rs
View file

@ -65,10 +65,10 @@ fn test_parse() {
rnd.gen_range(1..=data.len()) rnd.gen_range(1..=data.len())
}; };
let buf = gst::Buffer::from_mut_slice(Vec::from(&data[0..l])); let buf = gst::Buffer::from_mut_slice(Vec::from(&data[0..l]));
input_len += buf.get_size(); input_len += buf.size();
assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok)); assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok));
while let Some(buf) = h.try_pull() { while let Some(buf) = h.try_pull() {
output_len += buf.get_size(); output_len += buf.size();
checksum = checksum.wrapping_add( checksum = checksum.wrapping_add(
buf.map_readable() buf.map_readable()
.unwrap() .unwrap()
@ -81,7 +81,7 @@ fn test_parse() {
h.push_event(gst::event::Eos::new()); h.push_event(gst::event::Eos::new());
while let Some(buf) = h.try_pull() { while let Some(buf) = h.try_pull() {
output_len += buf.get_size(); output_len += buf.size();
checksum = checksum.wrapping_add( checksum = checksum.wrapping_add(
buf.map_readable() buf.map_readable()
.unwrap() .unwrap()
@ -95,9 +95,9 @@ fn test_parse() {
assert_eq!(checksum, 12_554_799); assert_eq!(checksum, 12_554_799);
let caps = h let caps = h
.get_sinkpad() .sinkpad()
.expect("harness has no sinkpad") .expect("harness has no sinkpad")
.get_current_caps() .current_caps()
.expect("pad has no caps"); .expect("pad has no caps");
assert_eq!( assert_eq!(
caps, caps,
@ -160,7 +160,7 @@ fn test_timecodes() {
let buf = gst::Buffer::from_mut_slice(Vec::from(data)); let buf = gst::Buffer::from_mut_slice(Vec::from(data));
assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok)); assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok));
while let Some(buf) = h.try_pull() { while let Some(buf) = h.try_pull() {
output_len += buf.get_size(); output_len += buf.size();
checksum = checksum.wrapping_add( checksum = checksum.wrapping_add(
buf.map_readable() buf.map_readable()
.unwrap() .unwrap()
@ -172,7 +172,7 @@ fn test_timecodes() {
let tc = buf let tc = buf
.get_meta::<gst_video::VideoTimeCodeMeta>() .get_meta::<gst_video::VideoTimeCodeMeta>()
.expect("No timecode meta") .expect("No timecode meta")
.get_tc(); .tc();
// if the timecode matches one of expected codes, // if the timecode matches one of expected codes,
// pop the valid_timecodes deque and set expected_timecode, // pop the valid_timecodes deque and set expected_timecode,
@ -189,9 +189,9 @@ fn test_timecodes() {
assert_eq!(checksum, 174_295); assert_eq!(checksum, 174_295);
let caps = h let caps = h
.get_sinkpad() .sinkpad()
.expect("harness has no sinkpad") .expect("harness has no sinkpad")
.get_current_caps() .current_caps()
.expect("pad has no caps"); .expect("pad has no caps");
assert_eq!( assert_eq!(
caps, caps,
@ -255,8 +255,8 @@ fn test_pull() {
while h.buffers_in_queue() != 0 { while h.buffers_in_queue() != 0 {
if let Ok(buffer) = h.pull() { if let Ok(buffer) = h.pull() {
let pts = buffer.get_pts(); let pts = buffer.pts();
let end_time = pts + buffer.get_duration(); let end_time = pts + buffer.duration();
assert!(end_time >= 18 * gst::SECOND && pts < 19 * gst::SECOND); assert!(end_time >= 18 * gst::SECOND && pts < 19 * gst::SECOND);
} }

59
video/closedcaption/tests/tttocea608.rs
View file

@ -69,7 +69,7 @@ fn test_one_timed_buffer_and_eos() {
loop { loop {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
if outbuf.get_pts() + outbuf.get_duration() >= gst::SECOND { if outbuf.pts() + outbuf.duration() >= gst::SECOND {
break; break;
} }
@ -90,15 +90,10 @@ fn test_one_timed_buffer_and_eos() {
for (i, e) in expected.iter().enumerate() { for (i, e) in expected.iter().enumerate() {
let outbuf = h.try_pull().unwrap(); let outbuf = h.try_pull().unwrap();
assert_eq!( assert_eq!(e.0, outbuf.pts(), "Unexpected PTS for {}th buffer", i + 1);
e.0,
outbuf.get_pts(),
"Unexpected PTS for {}th buffer",
i + 1
);
assert_eq!( assert_eq!(
e.1, e.1,
outbuf.get_duration(), outbuf.duration(),
"Unexpected duration for {}th buffer", "Unexpected duration for {}th buffer",
i + 1 i + 1
); );
@ -115,7 +110,7 @@ fn test_one_timed_buffer_and_eos() {
loop { loop {
let outbuf = h.try_pull().unwrap(); let outbuf = h.try_pull().unwrap();
let data = outbuf.map_readable().unwrap(); let data = outbuf.map_readable().unwrap();
if outbuf.get_pts() == 2_200_000_000.into() { if outbuf.pts() == 2_200_000_000.into() {
assert_eq!(&*data, &[0x94, 0x2c]); assert_eq!(&*data, &[0x94, 0x2c]);
break; break;
} else { } else {
@ -126,7 +121,7 @@ fn test_one_timed_buffer_and_eos() {
assert_eq!(h.events_in_queue() == 1, true); assert_eq!(h.events_in_queue() == 1, true);
let event = h.pull_event().unwrap(); let event = h.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::Eos); assert_eq!(event.type_(), gst::EventType::Eos);
} }
/* Here we test that the erase_display_memory control code /* Here we test that the erase_display_memory control code
@ -155,7 +150,7 @@ fn test_erase_display_memory_non_spliced() {
while h.buffers_in_queue() > 0 { while h.buffers_in_queue() > 0 {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
if outbuf.get_pts() == 2_200_000_000.into() { if outbuf.pts() == 2_200_000_000.into() {
let data = outbuf.map_readable().unwrap(); let data = outbuf.map_readable().unwrap();
assert_eq!(&*data, &[0x94, 0x2c]); assert_eq!(&*data, &[0x94, 0x2c]);
erase_display_buffers += 1; erase_display_buffers += 1;
@ -193,15 +188,15 @@ fn test_erase_display_memory_spliced() {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
/* Check that our timestamps are strictly ascending */ /* Check that our timestamps are strictly ascending */
assert!(outbuf.get_pts() >= prev_pts); assert!(outbuf.pts() >= prev_pts);
if outbuf.get_pts() == 2_000_000_000.into() { if outbuf.pts() == 2_000_000_000.into() {
let data = outbuf.map_readable().unwrap(); let data = outbuf.map_readable().unwrap();
assert_eq!(&*data, &[0x94, 0x2c]); assert_eq!(&*data, &[0x94, 0x2c]);
erase_display_buffers += 1; erase_display_buffers += 1;
} }
prev_pts = outbuf.get_pts(); prev_pts = outbuf.pts();
} }
assert_eq!(erase_display_buffers, 1); assert_eq!(erase_display_buffers, 1);
@ -232,7 +227,7 @@ fn test_output_gaps() {
/* Padding */ /* Padding */
loop { loop {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
if outbuf.get_pts() + outbuf.get_duration() >= gst::SECOND { if outbuf.pts() + outbuf.duration() >= gst::SECOND {
break; break;
} }
@ -243,7 +238,7 @@ fn test_output_gaps() {
/* Hello */ /* Hello */
loop { loop {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
if outbuf.get_pts() + outbuf.get_duration() >= 1_233_333_333.into() { if outbuf.pts() + outbuf.duration() >= 1_233_333_333.into() {
break; break;
} }
@ -254,12 +249,12 @@ fn test_output_gaps() {
/* Padding */ /* Padding */
loop { loop {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
if outbuf.get_pts() + outbuf.get_duration() >= 3_000_000_000.into() { if outbuf.pts() + outbuf.duration() >= 3_000_000_000.into() {
break; break;
} }
let data = outbuf.map_readable().unwrap(); let data = outbuf.map_readable().unwrap();
if outbuf.get_pts() == 2_200_000_000.into() { if outbuf.pts() == 2_200_000_000.into() {
/* Erase display one second after Hello */ /* Erase display one second after Hello */
assert_eq!(&*data, &[0x94, 0x2C]); assert_eq!(&*data, &[0x94, 0x2C]);
} else { } else {
@ -270,7 +265,7 @@ fn test_output_gaps() {
/* World */ /* World */
loop { loop {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
if outbuf.get_pts() + outbuf.get_duration() >= 3_233_333_333.into() { if outbuf.pts() + outbuf.duration() >= 3_233_333_333.into() {
break; break;
} }
@ -281,7 +276,7 @@ fn test_output_gaps() {
assert_eq!(h.events_in_queue(), 1); assert_eq!(h.events_in_queue(), 1);
let event = h.pull_event().unwrap(); let event = h.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::Eos); assert_eq!(event.type_(), gst::EventType::Eos);
} }
#[test] #[test]
@ -304,7 +299,7 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
/* Padding */ /* Padding */
loop { loop {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
if outbuf.get_pts() + outbuf.get_duration() >= gst::SECOND { if outbuf.pts() + outbuf.duration() >= gst::SECOND {
break; break;
} }
@ -323,15 +318,10 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
for (i, e) in expected.iter().enumerate() { for (i, e) in expected.iter().enumerate() {
let outbuf = h.try_pull().unwrap(); let outbuf = h.try_pull().unwrap();
assert_eq!( assert_eq!(e.0, outbuf.pts(), "Unexpected PTS for {}th buffer", i + 1);
e.0,
outbuf.get_pts(),
"Unexpected PTS for {}th buffer",
i + 1
);
assert_eq!( assert_eq!(
e.1, e.1,
outbuf.get_duration(), outbuf.duration(),
"Unexpected duration for {}th buffer", "Unexpected duration for {}th buffer",
i + 1 i + 1
); );
@ -343,7 +333,7 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
/* Padding */ /* Padding */
loop { loop {
let outbuf = h.pull().unwrap(); let outbuf = h.pull().unwrap();
if outbuf.get_pts() + outbuf.get_duration() >= 2 * gst::SECOND { if outbuf.pts() + outbuf.duration() >= 2 * gst::SECOND {
break; break;
} }
@ -360,15 +350,10 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
for (i, e) in expected.iter().enumerate() { for (i, e) in expected.iter().enumerate() {
let outbuf = h.try_pull().unwrap(); let outbuf = h.try_pull().unwrap();
assert_eq!( assert_eq!(e.0, outbuf.pts(), "Unexpected PTS for {}th buffer", i + 1);
e.0,
outbuf.get_pts(),
"Unexpected PTS for {}th buffer",
i + 1
);
assert_eq!( assert_eq!(
e.1, e.1,
outbuf.get_duration(), outbuf.duration(),
"Unexpected duration for {}th buffer", "Unexpected duration for {}th buffer",
i + 1 i + 1
); );
@ -384,5 +369,5 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
assert_eq!(h.events_in_queue(), 1); assert_eq!(h.events_in_queue(), 1);
let event = h.pull_event().unwrap(); let event = h.pull_event().unwrap();
assert_eq!(event.get_type(), gst::EventType::Eos); assert_eq!(event.type_(), gst::EventType::Eos);
} }

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

@ -118,10 +118,10 @@ impl Dav1dDec {
element.set_output_state(format, pic.width(), pic.height(), input_state) element.set_output_state(format, pic.width(), pic.height(), input_state)
}?; }?;
element.negotiate(output_state)?; element.negotiate(output_state)?;
let out_state = element.get_output_state().unwrap(); let out_state = element.output_state().unwrap();
{ {
let mut negotiation_infos = self.negotiation_infos.lock().unwrap(); let mut negotiation_infos = self.negotiation_infos.lock().unwrap();
negotiation_infos.output_info = Some(out_state.get_info()); negotiation_infos.output_info = Some(out_state.info());
} }
Ok(()) Ok(())
@ -138,16 +138,16 @@ impl Dav1dDec {
frame: &gst_video::VideoCodecFrame, frame: &gst_video::VideoCodecFrame,
) -> Result<Vec<(dav1d::Picture, gst_video::VideoFormat)>, gst::FlowError> { ) -> Result<Vec<(dav1d::Picture, gst_video::VideoFormat)>, gst::FlowError> {
let mut decoder = self.decoder.lock().unwrap(); let mut decoder = self.decoder.lock().unwrap();
let timestamp = match frame.get_dts().0 { let timestamp = match frame.dts().0 {
Some(ts) => Some(ts as i64), Some(ts) => Some(ts as i64),
None => None, None => None,
}; };
let duration = match frame.get_duration().0 { let duration = match frame.duration().0 {
Some(d) => Some(d as i64), Some(d) => Some(d as i64),
None => None, None => None,
}; };
let frame_number = Some(frame.get_system_frame_number() as i64); let frame_number = Some(frame.system_frame_number() as i64);
let input_data = input_buffer let input_data = input_buffer
.map_readable() .map_readable()
.map_err(|_| gst::FlowError::Error)?; .map_err(|_| gst::FlowError::Error)?;
@ -181,7 +181,7 @@ impl Dav1dDec {
let video_meta_supported = self.negotiation_infos.lock().unwrap().video_meta_supported; let video_meta_supported = self.negotiation_infos.lock().unwrap().video_meta_supported;
let info = output_state.get_info(); let info = output_state.info();
let mut out_buffer = gst::Buffer::new(); let mut out_buffer = gst::Buffer::new();
let mut_buffer = out_buffer.get_mut().unwrap(); let mut_buffer = out_buffer.get_mut().unwrap();
@ -222,7 +222,7 @@ impl Dav1dDec {
} }
writable_mem.into_memory() writable_mem.into_memory()
}; };
let mem_size = mem.get_size(); let mem_size = mem.size();
mut_buffer.append_memory(mem); mut_buffer.append_memory(mem);
strides.push(src_stride as i32); strides.push(src_stride as i32);
@ -262,7 +262,7 @@ impl Dav1dDec {
self.handle_resolution_change(element, &pic, format)?; self.handle_resolution_change(element, &pic, format)?;
let output_state = element let output_state = element
.get_output_state() .output_state()
.expect("Output state not set. Shouldn't happen!"); .expect("Output state not set. Shouldn't happen!");
let offset = pic.offset() as i32; let offset = pic.offset() as i32;
if let Some(mut frame) = element.get_frame(offset) { if let Some(mut frame) = element.get_frame(offset) {
@ -278,18 +278,18 @@ impl Dav1dDec {
fn drop_decoded_pictures(&self) { fn drop_decoded_pictures(&self) {
let mut decoder = self.decoder.lock().unwrap(); let mut decoder = self.decoder.lock().unwrap();
while let Ok(pic) = decoder.get_picture() { while let Ok(pic) = decoder.picture() {
gst_debug!(CAT, "Dropping picture"); gst_debug!(CAT, "Dropping picture");
drop(pic); drop(pic);
} }
} }
fn get_pending_pictures( fn pending_pictures(
&self, &self,
) -> Result<Vec<(dav1d::Picture, gst_video::VideoFormat)>, gst::FlowError> { ) -> Result<Vec<(dav1d::Picture, gst_video::VideoFormat)>, gst::FlowError> {
let mut decoder = self.decoder.lock().unwrap(); let mut decoder = self.decoder.lock().unwrap();
let mut pictures = vec![]; let mut pictures = vec![];
while let Ok(pic) = decoder.get_picture() { while let Ok(pic) = decoder.picture() {
let format = self.gst_video_format_from_dav1d_picture(&pic); let format = self.gst_video_format_from_dav1d_picture(&pic);
if format == gst_video::VideoFormat::Unknown { if format == gst_video::VideoFormat::Unknown {
return Err(gst::FlowError::NotNegotiated); return Err(gst::FlowError::NotNegotiated);
@ -303,7 +303,7 @@ impl Dav1dDec {
&self, &self,
element: &super::Dav1dDec, element: &super::Dav1dDec,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
for (pic, format) in self.get_pending_pictures()? { for (pic, format) in self.pending_pictures()? {
self.handle_picture(element, &pic, format)?; self.handle_picture(element, &pic, format)?;
} }
Ok(gst::FlowSuccess::Ok) Ok(gst::FlowSuccess::Ok)
@ -438,9 +438,7 @@ impl VideoDecoderImpl for Dav1dDec {
element: &Self::Type, element: &Self::Type,
frame: gst_video::VideoCodecFrame, frame: gst_video::VideoCodecFrame,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
let input_buffer = frame let input_buffer = frame.input_buffer().expect("frame without input buffer");
.get_input_buffer()
.expect("frame without input buffer");
for (pic, format) in self.decode(input_buffer, &frame)? { for (pic, format) in self.decode(input_buffer, &frame)? {
self.handle_picture(element, &pic, format)?; self.handle_picture(element, &pic, format)?;
} }
@ -479,9 +477,9 @@ impl VideoDecoderImpl for Dav1dDec {
.find_allocation_meta::<gst_video::VideoMeta>() .find_allocation_meta::<gst_video::VideoMeta>()
.is_some() .is_some()
{ {
let pools = allocation.get_allocation_pools(); let pools = allocation.allocation_pools();
if let Some((Some(ref pool), _, _, _)) = pools.first() { if let Some((Some(ref pool), _, _, _)) = pools.first() {
let mut config = pool.get_config(); let mut config = pool.config();
config.add_option(&gst_video::BUFFER_POOL_OPTION_VIDEO_META); config.add_option(&gst_video::BUFFER_POOL_OPTION_VIDEO_META);
pool.set_config(config) pool.set_config(config)
.map_err(|e| gst::error_msg!(gst::CoreError::Negotiation, [&e.message]))?; .map_err(|e| gst::error_msg!(gst::CoreError::Negotiation, [&e.message]))?;

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

@ -405,9 +405,9 @@ impl FlvDemux {
match query.view_mut() { match query.view_mut() {
QueryView::Position(ref mut q) => { QueryView::Position(ref mut q) => {
let fmt = q.get_format(); let fmt = q.format();
if fmt == gst::Format::Time { if fmt == gst::Format::Time {
if self.sinkpad.peer_query(q.get_mut_query()) { if self.sinkpad.peer_query(q.query_mut()) {
return true; return true;
} }
@ -424,9 +424,9 @@ impl FlvDemux {
} }
} }
QueryView::Duration(ref mut q) => { QueryView::Duration(ref mut q) => {
let fmt = q.get_format(); let fmt = q.format();
if fmt == gst::Format::Time { if fmt == gst::Format::Time {
if self.sinkpad.peer_query(q.get_mut_query()) { if self.sinkpad.peer_query(q.query_mut()) {
return true; return true;
} }
@ -637,7 +637,7 @@ impl FlvDemux {
} }
fn create_srcpad(&self, element: &super::FlvDemux, name: &str, caps: &gst::Caps) -> gst::Pad { fn create_srcpad(&self, element: &super::FlvDemux, name: &str, caps: &gst::Caps) -> gst::Pad {
let templ = element.get_element_class().get_pad_template(name).unwrap(); let templ = element.element_class().get_pad_template(name).unwrap();
let srcpad = gst::Pad::builder_with_template(&templ, Some(name)) let srcpad = gst::Pad::builder_with_template(&templ, Some(name))
.event_function(|pad, parent, event| { .event_function(|pad, parent, event| {
FlvDemux::catch_panic_pad_function( FlvDemux::catch_panic_pad_function(
@ -1196,11 +1196,11 @@ impl StreamingState {
} }
fn update_position(&mut self, buffer: &gst::Buffer) { fn update_position(&mut self, buffer: &gst::Buffer) {
if buffer.get_pts().is_some() { if buffer.pts().is_some() {
let pts = buffer.get_pts(); let pts = buffer.pts();
self.last_position = self.last_position.max(pts).unwrap_or(pts); self.last_position = self.last_position.max(pts).unwrap_or(pts);
} else if buffer.get_dts().is_some() { } else if buffer.dts().is_some() {
let dts = buffer.get_dts(); let dts = buffer.dts();
self.last_position = self.last_position.max(dts).unwrap_or(dts); self.last_position = self.last_position.max(dts).unwrap_or(dts);
} }
} }

8
video/gif/examples/testvideosrc2gif.rs
View file

@ -24,7 +24,7 @@ fn main() {
gstgif::plugin_register_static().expect("Failed to register gif plugin"); gstgif::plugin_register_static().expect("Failed to register gif plugin");
let pipeline = gst::parse_launch(ENCODE_PIPELINE).unwrap(); let pipeline = gst::parse_launch(ENCODE_PIPELINE).unwrap();
let bus = pipeline.get_bus().unwrap(); let bus = pipeline.bus().unwrap();
pipeline pipeline
.set_state(gst::State::Playing) .set_state(gst::State::Playing)
@ -38,9 +38,9 @@ fn main() {
MessageView::Error(err) => { MessageView::Error(err) => {
println!( println!(
"Error from {:?}: {} ({:?})", "Error from {:?}: {} ({:?})",
err.get_src().map(|s| s.get_path_string()), err.src().map(|s| s.path_string()),
err.get_error(), err.error(),
err.get_debug() err.debug()
); );
break; break;
} }

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

@ -161,7 +161,7 @@ impl ObjectImpl for GifEnc {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"repeat" => { "repeat" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
settings.repeat = value.get_some().expect("type checked upstream"); settings.repeat = value.get_some().expect("type checked upstream");
@ -171,7 +171,7 @@ impl ObjectImpl for GifEnc {
} }
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"repeat" => { "repeat" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.repeat.to_value() settings.repeat.to_value()
@ -260,7 +260,7 @@ impl VideoEncoderImpl for GifEnc {
self.flush_encoder(element) self.flush_encoder(element)
.map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?; .map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?;
let video_info = state.get_info(); let video_info = state.info();
gst_debug!(CAT, obj: element, "Setting format {:?}", video_info); gst_debug!(CAT, obj: element, "Setting format {:?}", video_info);
{ {
@ -296,12 +296,10 @@ impl VideoEncoderImpl for GifEnc {
CAT, CAT,
obj: element, obj: element,
"Sending frame {}", "Sending frame {}",
frame.get_system_frame_number() frame.system_frame_number()
); );
let input_buffer = frame let input_buffer = frame.input_buffer().expect("frame without input buffer");
.get_input_buffer()
.expect("frame without input buffer");
{ {
let in_frame = gst_video::VideoFrameRef::from_buffer_ref_readable( let in_frame = gst_video::VideoFrameRef::from_buffer_ref_readable(
@ -323,12 +321,12 @@ impl VideoEncoderImpl for GifEnc {
// Calculate delay to new frame by calculating the difference between the current actual // Calculate delay to new frame by calculating the difference between the current actual
// presentation timestamp of the last frame within the gif, and the pts of the new frame. // presentation timestamp of the last frame within the gif, and the pts of the new frame.
// This results in variable frame delays in the gif - but an overall constant fps. // This results in variable frame delays in the gif - but an overall constant fps.
state.last_actual_pts = in_frame.buffer().get_pts(); state.last_actual_pts = in_frame.buffer().pts();
if state.gif_pts.is_none() { if state.gif_pts.is_none() {
// First frame: use pts of first input frame as origin // First frame: use pts of first input frame as origin
state.gif_pts = Some(in_frame.buffer().get_pts()); state.gif_pts = Some(in_frame.buffer().pts());
} }
let frame_delay = in_frame.buffer().get_pts() - state.gif_pts.unwrap(); let frame_delay = in_frame.buffer().pts() - state.gif_pts.unwrap();
if frame_delay.is_none() { if frame_delay.is_none() {
gst::element_error!( gst::element_error!(
element, element,

2
video/gif/tests/gifenc.rs
View file

@ -63,6 +63,6 @@ fn test_encode(video_info: &gst_video::VideoInfo) {
// last frame is the GIF trailer // last frame is the GIF trailer
let buffer = h.pull().unwrap(); let buffer = h.pull().unwrap();
// Currently, every frame should be a full frame // Currently, every frame should be a full frame
assert!(!buffer.get_flags().contains(gst::BufferFlags::DELTA_UNIT)) assert!(!buffer.flags().contains(gst::BufferFlags::DELTA_UNIT))
} }
} }

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

@ -153,7 +153,7 @@ impl ObjectImpl for HsvDetector {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"hue-ref" => { "hue-ref" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let hue_ref = value.get_some().expect("type checked upstream"); let hue_ref = value.get_some().expect("type checked upstream");
@ -233,7 +233,7 @@ impl ObjectImpl for HsvDetector {
// Called whenever a value of a property is read. It can be called // Called whenever a value of a property is read. It can be called
// at any time from any thread. // at any time from any thread.
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"hue-ref" => { "hue-ref" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.hue_ref.to_value() settings.hue_ref.to_value()

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

@ -139,7 +139,7 @@ impl ObjectImpl for HsvFilter {
value: &glib::Value, value: &glib::Value,
pspec: &glib::ParamSpec, pspec: &glib::ParamSpec,
) { ) {
match pspec.get_name() { match pspec.name() {
"hue-shift" => { "hue-shift" => {
let mut settings = self.settings.lock().unwrap(); let mut settings = self.settings.lock().unwrap();
let hue_shift = value.get_some().expect("type checked upstream"); let hue_shift = value.get_some().expect("type checked upstream");
@ -207,7 +207,7 @@ impl ObjectImpl for HsvFilter {
// Called whenever a value of a property is read. It can be called // Called whenever a value of a property is read. It can be called
// at any time from any thread. // at any time from any thread.
fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value { fn get_property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
match pspec.get_name() { match pspec.name() {
"hue-shift" => { "hue-shift" => {
let settings = self.settings.lock().unwrap(); let settings = self.settings.lock().unwrap();
settings.hue_shift.to_value() settings.hue_shift.to_value()

Some files were not shown because too many files have changed in this diff Show more