mirrors/gst-plugins-rs
mirrors/gst-plugins-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git synced 2025-06-07 16:08:55 +00:00
Code Issues Projects Releases Wiki Activity

Fixes/simplifications for GStreamer API changes

Browse source
This commit is contained in:
Sebastian Dröge 2017-12-09 19:41:54 +02:00
parent 63380e023a
commit c6800e8a26
5 changed files with 82 additions and 145 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
gst-plugin-simple/src/demuxer.rs
View file

@ -205,8 +205,7 @@ impl Demuxer {
); );
pad.push_event(gst::Event::new_caps(&caps).build()); pad.push_event(gst::Event::new_caps(&caps).build());
let mut segment = gst::Segment::default(); let segment = gst::FormattedSegment::<gst::ClockTime>::default();
segment.init(gst::Format::Time);
pad.push_event(gst::Event::new_segment(&segment).build()); pad.push_event(gst::Event::new_segment(&segment).build());
self.flow_combiner.lock().unwrap().add_pad(&pad); self.flow_combiner.lock().unwrap().add_pad(&pad);
@ -351,9 +350,8 @@ impl Demuxer {
if active { if active {
let upstream_size = demuxer let upstream_size = demuxer
.sinkpad .sinkpad
.peer_query_duration(gst::Format::Bytes) .peer_query_duration::<gst::format::Bytes>()
.and_then(|d| d.try_to_bytes()) .and_then(|v| v.0);
.and_then(|d| d);
if !demuxer.start(&element, upstream_size, mode == gst::PadMode::Pull) { if !demuxer.start(&element, upstream_size, mode == gst::PadMode::Pull) {
return false; return false;

11
gst-plugin-simple/src/source.rs
View file

@ -277,15 +277,16 @@ impl BaseSrcImpl<BaseSrc> for Source {
fn do_seek(&self, src: &BaseSrc, segment: &mut gst::Segment) -> bool { fn do_seek(&self, src: &BaseSrc, segment: &mut gst::Segment) -> bool {
let source_impl = &mut self.imp.lock().unwrap(); let source_impl = &mut self.imp.lock().unwrap();
if segment.get_format() != gst::Format::Bytes { let segment = match segment.downcast_ref::<gst::format::Bytes>() {
return false; None => return false,
} Some(segment) => segment,
};
let start = match segment.get_start().try_to_bytes().unwrap() { let start = match segment.get_start().0 {
None => return false, None => return false,
Some(start) => start, Some(start) => start,
}; };
let stop = segment.get_stop().try_to_bytes().unwrap(); let stop = segment.get_stop().0;
gst_debug!(self.cat, obj: src, "Seeking to {:?}-{:?}", start, stop); gst_debug!(self.cat, obj: src, "Seeking to {:?}-{:?}", start, stop);

18
gst-plugin-togglerecord/examples/gtk_recording.rs
View file

@ -225,25 +225,13 @@ fn create_ui(app: &gtk::Application) {
let video_sink = &video_sink_clone; let video_sink = &video_sink_clone;
let togglerecord = &togglerecord_clone; let togglerecord = &togglerecord_clone;
let position = if let Some(gst::FormatValue::Time(position)) = let position = video_sink.query_position::<gst::ClockTime>().unwrap_or(0.into());
video_sink.query_position(gst::Format::Time)
{
position
} else {
0.into()
};
position_label.set_text(&format!("Position: {:.0}", position)); position_label.set_text(&format!("Position: {:.0}", position));
let recording_duration = if let Some(gst::FormatValue::Time(recording_duration)) = let recording_duration = togglerecord
togglerecord
.get_static_pad("src") .get_static_pad("src")
.unwrap() .unwrap()
.query_position(gst::Format::Time) .query_position::<gst::ClockTime>().unwrap_or(0.into());
{
recording_duration
} else {
0.into()
};
recorded_duration_label.set_text(&format!("Recorded: {:.0}", recording_duration)); recorded_duration_label.set_text(&format!("Recorded: {:.0}", recording_duration));
glib::Continue(true) glib::Continue(true)

125
gst-plugin-togglerecord/src/togglerecord.rs
View file

@ -88,8 +88,8 @@ impl Stream {
} }
struct StreamState { struct StreamState {
in_segment: gst::Segment, in_segment: gst::FormattedSegment<gst::ClockTime>,
out_segment: gst::Segment, out_segment: gst::FormattedSegment<gst::ClockTime>,
segment_seqnum: gst::Seqnum, segment_seqnum: gst::Seqnum,
current_running_time: gst::ClockTime, current_running_time: gst::ClockTime,
eos: bool, eos: bool,
@ -101,8 +101,8 @@ struct StreamState {
impl Default for StreamState { impl Default for StreamState {
fn default() -> Self { fn default() -> Self {
Self { Self {
in_segment: gst::Segment::new(), in_segment: gst::FormattedSegment::new(),
out_segment: gst::Segment::new(), out_segment: gst::FormattedSegment::new(),
segment_seqnum: gst::util_seqnum_next(), segment_seqnum: gst::util_seqnum_next(),
current_running_time: gst::CLOCK_TIME_NONE, current_running_time: gst::CLOCK_TIME_NONE,
eos: false, eos: false,
@ -343,30 +343,14 @@ impl ToggleRecord {
dts_or_pts dts_or_pts
}; };
dts_or_pts = cmp::max( dts_or_pts = cmp::max(state.in_segment.get_start(), dts_or_pts);
state.in_segment.get_start().try_to_time().unwrap(), dts_or_pts_end = cmp::max(state.in_segment.get_start(), dts_or_pts_end);
dts_or_pts, if state.in_segment.get_stop().is_some() {
); dts_or_pts = cmp::min(state.in_segment.get_stop(), dts_or_pts);
dts_or_pts_end = cmp::max( dts_or_pts_end = cmp::min(state.in_segment.get_stop(), dts_or_pts_end);
state.in_segment.get_start().try_to_time().unwrap(),
dts_or_pts_end,
);
if state.in_segment.get_stop().try_to_time().unwrap().is_some() {
dts_or_pts = cmp::min(
state.in_segment.get_stop().try_to_time().unwrap(),
dts_or_pts,
);
dts_or_pts_end = cmp::min(
state.in_segment.get_stop().try_to_time().unwrap(),
dts_or_pts_end,
);
} }
let mut current_running_time = state let mut current_running_time = state.in_segment.to_running_time(dts_or_pts);
.in_segment
.to_running_time(dts_or_pts)
.try_to_time()
.unwrap();
current_running_time = cmp::max(current_running_time, state.current_running_time); current_running_time = cmp::max(current_running_time, state.current_running_time);
state.current_running_time = current_running_time; state.current_running_time = current_running_time;
@ -376,11 +360,7 @@ impl ToggleRecord {
// get the wrong state // get the wrong state
self.main_stream_cond.notify_all(); self.main_stream_cond.notify_all();
let current_running_time_end = state let current_running_time_end = state.in_segment.to_running_time(dts_or_pts_end);
.in_segment
.to_running_time(dts_or_pts_end)
.try_to_time()
.unwrap();
gst_log!( gst_log!(
self.cat, self.cat,
@ -552,40 +532,32 @@ impl ToggleRecord {
pts pts
}; };
pts = cmp::max(state.in_segment.get_start().try_to_time().unwrap(), pts); pts = cmp::max(state.in_segment.get_start(), pts);
if state.in_segment.get_stop().try_to_time().unwrap().is_some() if state.in_segment.get_stop().is_some() && pts >= state.in_segment.get_stop() {
&& pts >= state.in_segment.get_stop().try_to_time().unwrap()
{
state.current_running_time = state state.current_running_time = state
.in_segment .in_segment
.to_running_time(state.in_segment.get_stop()) .to_running_time(state.in_segment.get_stop());
.try_to_time()
.unwrap();
state.eos = true; state.eos = true;
gst_debug!( gst_debug!(
self.cat, self.cat,
obj: pad, obj: pad,
"After segment end {} >= {}, EOS", "After segment end {} >= {}, EOS",
pts, pts,
state.in_segment.get_stop().try_to_time().unwrap() state.in_segment.get_stop()
); );
return HandleResult::Eos; return HandleResult::Eos;
} }
pts_end = cmp::max(state.in_segment.get_start().try_to_time().unwrap(), pts_end); pts_end = cmp::max(state.in_segment.get_start(), pts_end);
if state.in_segment.get_stop().try_to_time().unwrap().is_some() { if state.in_segment.get_stop().is_some() {
pts_end = cmp::min(state.in_segment.get_stop().try_to_time().unwrap(), pts_end); pts_end = cmp::min(state.in_segment.get_stop(), pts_end);
} }
let mut current_running_time = state.in_segment.to_running_time(pts).try_to_time().unwrap(); let mut current_running_time = state.in_segment.to_running_time(pts);
current_running_time = cmp::max(current_running_time, state.current_running_time); current_running_time = cmp::max(current_running_time, state.current_running_time);
state.current_running_time = current_running_time; state.current_running_time = current_running_time;
let current_running_time_end = state let current_running_time_end = state.in_segment.to_running_time(pts_end);
.in_segment
.to_running_time(pts_end)
.try_to_time()
.unwrap();
gst_log!( gst_log!(
self.cat, self.cat,
obj: pad, obj: pad,
@ -762,18 +734,6 @@ impl ToggleRecord {
{ {
let state = stream.state.lock().unwrap(); let state = stream.state.lock().unwrap();
if state.in_segment.get_format() != gst::Format::Time {
gst_element_error!(
element,
gst::StreamError::Format,
[
"Only Time segments supported, got {:?}",
state.in_segment.get_format()
]
);
return gst::FlowReturn::Error;
}
if state.eos { if state.eos {
return gst::FlowReturn::Eos; return gst::FlowReturn::Eos;
} }
@ -856,10 +816,8 @@ impl ToggleRecord {
// recording_duration // recording_duration
state.out_segment = state.in_segment.clone(); state.out_segment = state.in_segment.clone();
let offset: u64 = rec_state.running_time_offset.into(); let offset = rec_state.running_time_offset.unwrap_or(0);
let res = state let res = state.out_segment.offset_running_time(-(offset as i64));
.out_segment
.offset_running_time(gst::Format::Time, -(offset as i64));
assert!(res); assert!(res);
events.push( events.push(
gst::Event::new_segment(&state.out_segment) gst::Event::new_segment(&state.out_segment)
@ -881,11 +839,7 @@ impl ToggleRecord {
events.append(&mut state.pending_events); events.append(&mut state.pending_events);
let out_running_time = state let out_running_time = state.out_segment.to_running_time(buffer.get_pts());
.out_segment
.to_running_time(buffer.get_pts())
.try_to_time()
.unwrap();
// Unlock before pushing // Unlock before pushing
drop(state); drop(state);
@ -950,18 +904,21 @@ impl ToggleRecord {
EventView::Segment(e) => { EventView::Segment(e) => {
let mut state = stream.state.lock().unwrap(); let mut state = stream.state.lock().unwrap();
let segment = e.get_segment(); let segment = match e.get_segment().downcast::<gst::ClockTime>() {
if segment.get_format() != gst::Format::Time { Err(segment) => {
gst_element_error!( gst_element_error!(
element, element,
gst::StreamError::Format, gst::StreamError::Format,
[ [
"Only Time segments supported, got {:?}", "Only Time segments supported, got {:?}",
segment.get_format() segment.get_format()
] ]
); );
return false; return false;
} }
Ok(segment) => segment,
};
if (segment.get_rate() - 1.0).abs() > f64::EPSILON { if (segment.get_rate() - 1.0).abs() > f64::EPSILON {
gst_element_error!( gst_element_error!(
element, element,
@ -974,7 +931,7 @@ impl ToggleRecord {
return false; return false;
} }
state.in_segment = e.get_segment(); state.in_segment = segment;
state.segment_seqnum = event.get_seqnum(); state.segment_seqnum = event.get_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;
@ -1165,8 +1122,8 @@ impl ToggleRecord {
let format = q.get_format(); let format = q.get_format();
q.set( q.set(
false, false,
gst::FormatValue::new(format, -1), gst::GenericFormattedValue::new(format, -1),
gst::FormatValue::new(format, -1), gst::GenericFormattedValue::new(format, -1),
); );
gst_log!(self.cat, obj: pad, "Returning {:?}", q.get_mut_query()); gst_log!(self.cat, obj: pad, "Returning {:?}", q.get_mut_query());

65
gst-plugin-togglerecord/tests/tests.rs
View file

@ -132,8 +132,7 @@ fn setup_sender_receiver(
while let Ok(send_data) = receiver_input.recv() { while let Ok(send_data) = receiver_input.recv() {
if first { if first {
assert!(sinkpad.send_event(gst::Event::new_stream_start("test").build())); assert!(sinkpad.send_event(gst::Event::new_stream_start("test").build()));
let mut segment = gst::Segment::new(); let segment = gst::FormattedSegment::<gst::ClockTime>::new();
segment.init(gst::Format::Time);
assert!(sinkpad.send_event(gst::Event::new_segment(&segment).build())); assert!(sinkpad.send_event(gst::Event::new_segment(&segment).build()));
let mut tags = gst::TagList::new(); let mut tags = gst::TagList::new();
@ -195,7 +194,7 @@ fn setup_sender_receiver(
fn recv_buffers( fn recv_buffers(
receiver_output: &mpsc::Receiver<Either<gst::Buffer, gst::Event>>, receiver_output: &mpsc::Receiver<Either<gst::Buffer, gst::Event>>,
segment: &mut gst::Segment, segment: &mut gst::FormattedSegment<gst::ClockTime>,
wait_buffers: usize, wait_buffers: usize,
) -> Vec<(gst::ClockTime, gst::ClockTime)> { ) -> Vec<(gst::ClockTime, gst::ClockTime)> {
let mut res = Vec::new(); let mut res = Vec::new();
@ -204,10 +203,7 @@ fn recv_buffers(
match val { match val {
Left(buffer) => { Left(buffer) => {
res.push(( res.push((
segment segment.to_running_time(buffer.get_pts()),
.to_running_time(buffer.get_pts())
.try_to_time()
.unwrap(),
buffer.get_pts(), buffer.get_pts(),
)); ));
n_buffers += 1; n_buffers += 1;
@ -222,10 +218,7 @@ fn recv_buffers(
EventView::Gap(ref e) => { EventView::Gap(ref e) => {
let (ts, _) = e.get(); let (ts, _) = e.get();
res.push(( res.push((segment.to_running_time(ts), ts.into()));
segment.to_running_time(ts).try_to_time().unwrap(),
ts.into(),
));
n_buffers += 1; n_buffers += 1;
if wait_buffers > 0 && n_buffers == wait_buffers { if wait_buffers > 0 && n_buffers == wait_buffers {
return res; return res;
@ -235,7 +228,7 @@ fn recv_buffers(
return res; return res;
} }
EventView::Segment(ref e) => { EventView::Segment(ref e) => {
*segment = e.get_segment(); *segment = e.get_segment().downcast().unwrap();
} }
_ => (), _ => (),
} }
@ -288,7 +281,7 @@ fn test_one_stream_open() {
sender_input.send(SendData::Buffers(10)).unwrap(); sender_input.send(SendData::Buffers(10)).unwrap();
drop(sender_input); drop(sender_input);
let mut segment = gst::Segment::new(); let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers = recv_buffers(&receiver_output, &mut segment, 0); let buffers = recv_buffers(&receiver_output, &mut segment, 0);
assert_eq!(buffers.len(), 10); assert_eq!(buffers.len(), 10);
for (index, &(running_time, pts)) in buffers.iter().enumerate() { for (index, &(running_time, pts)) in buffers.iter().enumerate() {
@ -323,7 +316,7 @@ fn test_one_stream_gaps_open() {
sender_input.send(SendData::Gaps(5)).unwrap(); sender_input.send(SendData::Gaps(5)).unwrap();
drop(sender_input); drop(sender_input);
let mut segment = gst::Segment::new(); let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers = recv_buffers(&receiver_output, &mut segment, 0); let buffers = recv_buffers(&receiver_output, &mut segment, 0);
assert_eq!(buffers.len(), 10); assert_eq!(buffers.len(), 10);
for (index, &(running_time, pts)) in buffers.iter().enumerate() { for (index, &(running_time, pts)) in buffers.iter().enumerate() {
@ -359,7 +352,7 @@ fn test_one_stream_close_open() {
sender_input.send(SendData::Buffers(10)).unwrap(); sender_input.send(SendData::Buffers(10)).unwrap();
drop(sender_input); drop(sender_input);
let mut segment = gst::Segment::new(); let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers = recv_buffers(&receiver_output, &mut segment, 0); let buffers = recv_buffers(&receiver_output, &mut segment, 0);
assert_eq!(buffers.len(), 10); assert_eq!(buffers.len(), 10);
for (index, &(running_time, pts)) in buffers.iter().enumerate() { for (index, &(running_time, pts)) in buffers.iter().enumerate() {
@ -396,7 +389,7 @@ fn test_one_stream_open_close() {
sender_input.send(SendData::Buffers(10)).unwrap(); sender_input.send(SendData::Buffers(10)).unwrap();
drop(sender_input); drop(sender_input);
let mut segment = gst::Segment::new(); let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers = recv_buffers(&receiver_output, &mut segment, 0); let buffers = recv_buffers(&receiver_output, &mut segment, 0);
assert_eq!(buffers.len(), 10); assert_eq!(buffers.len(), 10);
for (index, &(running_time, pts)) in buffers.iter().enumerate() { for (index, &(running_time, pts)) in buffers.iter().enumerate() {
@ -436,7 +429,7 @@ fn test_one_stream_open_close_open() {
sender_input.send(SendData::Buffers(10)).unwrap(); sender_input.send(SendData::Buffers(10)).unwrap();
drop(sender_input); drop(sender_input);
let mut segment = gst::Segment::new(); let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers = recv_buffers(&receiver_output, &mut segment, 0); let buffers = recv_buffers(&receiver_output, &mut segment, 0);
assert_eq!(buffers.len(), 20); assert_eq!(buffers.len(), 20);
for (index, &(running_time, pts)) in buffers.iter().enumerate() { for (index, &(running_time, pts)) in buffers.iter().enumerate() {
@ -485,7 +478,7 @@ fn test_two_stream_open() {
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -495,7 +488,7 @@ fn test_two_stream_open() {
assert_eq!(buffers_1.len(), 10); assert_eq!(buffers_1.len(), 10);
// Last buffer should be dropped from second stream // Last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -539,7 +532,7 @@ fn test_two_stream_open_shift() {
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -549,7 +542,7 @@ fn test_two_stream_open_shift() {
assert_eq!(buffers_1.len(), 10); assert_eq!(buffers_1.len(), 10);
// Last buffer should be dropped from second stream // Last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -594,7 +587,7 @@ fn test_two_stream_open_shift_main() {
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
// PTS 5 maps to running time 0 now // PTS 5 maps to running time 0 now
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -604,7 +597,7 @@ fn test_two_stream_open_shift_main() {
assert_eq!(buffers_1.len(), 10); assert_eq!(buffers_1.len(), 10);
// First and last buffer should be dropped from second stream // First and last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -664,7 +657,7 @@ fn test_two_stream_open_close() {
receiver_input_done_1.recv().unwrap(); receiver_input_done_1.recv().unwrap();
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -674,7 +667,7 @@ fn test_two_stream_open_close() {
assert_eq!(buffers_1.len(), 10); assert_eq!(buffers_1.len(), 10);
// Last buffer should be dropped from second stream // Last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -734,7 +727,7 @@ fn test_two_stream_close_open() {
receiver_input_done_1.recv().unwrap(); receiver_input_done_1.recv().unwrap();
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -744,7 +737,7 @@ fn test_two_stream_close_open() {
assert_eq!(buffers_1.len(), 10); assert_eq!(buffers_1.len(), 10);
// Last buffer should be dropped from second stream // Last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -817,7 +810,7 @@ fn test_two_stream_open_close_open() {
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let pts_off = if index >= 10 { let pts_off = if index >= 10 {
@ -833,7 +826,7 @@ fn test_two_stream_open_close_open() {
assert_eq!(buffers_1.len(), 20); assert_eq!(buffers_1.len(), 20);
// Last buffer should be dropped from second stream // Last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let pts_off = if index >= 10 { let pts_off = if index >= 10 {
@ -918,7 +911,7 @@ fn test_two_stream_open_close_open_gaps() {
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let pts_off = if index >= 10 { let pts_off = if index >= 10 {
@ -934,7 +927,7 @@ fn test_two_stream_open_close_open_gaps() {
assert_eq!(buffers_1.len(), 20); assert_eq!(buffers_1.len(), 20);
// Last buffer should be dropped from second stream // Last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let pts_off = if index >= 10 { let pts_off = if index >= 10 {
@ -1020,7 +1013,7 @@ fn test_two_stream_close_open_close_delta() {
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -1030,7 +1023,7 @@ fn test_two_stream_close_open_close_delta() {
assert_eq!(buffers_1.len(), 10); assert_eq!(buffers_1.len(), 10);
// Last buffer should be dropped from second stream // Last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let index = index as u64; let index = index as u64;
@ -1117,7 +1110,7 @@ fn test_three_stream_open_close_open() {
receiver_input_done_2.recv().unwrap(); receiver_input_done_2.recv().unwrap();
receiver_input_done_3.recv().unwrap(); receiver_input_done_3.recv().unwrap();
let mut segment_1 = gst::Segment::new(); let mut segment_1 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0); let buffers_1 = recv_buffers(&receiver_output_1, &mut segment_1, 0);
for (index, &(running_time, pts)) in buffers_1.iter().enumerate() { for (index, &(running_time, pts)) in buffers_1.iter().enumerate() {
let pts_off = if index >= 10 { let pts_off = if index >= 10 {
@ -1133,7 +1126,7 @@ fn test_three_stream_open_close_open() {
assert_eq!(buffers_1.len(), 20); assert_eq!(buffers_1.len(), 20);
// Last buffer should be dropped from second stream // Last buffer should be dropped from second stream
let mut segment_2 = gst::Segment::new(); let mut segment_2 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0); let buffers_2 = recv_buffers(&receiver_output_2, &mut segment_2, 0);
for (index, &(running_time, pts)) in buffers_2.iter().enumerate() { for (index, &(running_time, pts)) in buffers_2.iter().enumerate() {
let pts_off = if index >= 10 { let pts_off = if index >= 10 {
@ -1148,7 +1141,7 @@ fn test_three_stream_open_close_open() {
} }
assert_eq!(buffers_2.len(), 20); assert_eq!(buffers_2.len(), 20);
let mut segment_3 = gst::Segment::new(); let mut segment_3 = gst::FormattedSegment::<gst::ClockTime>::new();
let buffers_3 = recv_buffers(&receiver_output_3, &mut segment_3, 0); let buffers_3 = recv_buffers(&receiver_output_3, &mut segment_3, 0);
for (index, &(running_time, pts)) in buffers_3.iter().enumerate() { for (index, &(running_time, pts)) in buffers_3.iter().enumerate() {
let pts_off = if index >= 10 { let pts_off = if index >= 10 {