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

event,message,query: update instantiation

Browse source 
See https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/532
This commit is contained in:
François Laignel 2020-06-25 00:33:57 +02:00
parent fe274ac6e7
commit e40267e95d
42 changed files with 161 additions and 172 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
audio/audiofx/src/audioloudnorm.rs
View file

@ -1718,7 +1718,7 @@ impl AudioLoudNorm {
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Latency(ref mut q) => {
let mut peer_query = gst::Query::new_latency();
let mut peer_query = gst::query::Latency::new();
if self.sinkpad.peer_query(&mut peer_query) {
let (live, min_latency, max_latency) = peer_query.get_result();
q.set(

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

@ -96,7 +96,7 @@ fn do_test(data: &'static [u8], packet_sizes: &[usize], decoded_samples: &[usize
h.push(buffer).unwrap();
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
for samples in decoded_samples {
if *samples == 0 {

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

@ -170,7 +170,7 @@ fn csound_filter_eos() {
num_buffers += 1;
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
// pull the buffer produced after the EOS event
let buffer = h.pull().unwrap();
@ -242,7 +242,7 @@ fn csound_filter_underflow() {
assert!(h.push(buffer).is_ok());
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
// From here we check our output data
let mut num_buffers = 0;
@ -324,7 +324,7 @@ fn csound_filter_caps_negotiation() {
h.play();
assert!(h.push(gst::Buffer::with_size(2048).unwrap()).is_ok());
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
let buffer = h.pull().unwrap();
@ -403,7 +403,7 @@ fn csound_filter_caps_negotiation_fail() {
let buffer = gst::Buffer::with_size(2048).unwrap();
assert!(h.push(buffer).is_err());
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
// The harness sinkpad end up not having defined caps
// so, the get_current_caps should be None

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

@ -80,7 +80,7 @@ fn run_test(inline_headers: bool) {
h.push(buffer).unwrap();
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
for samples in &decoded_samples {
if *samples == 0 {

4
generic/sodium/src/decrypter.rs
View file

@ -302,7 +302,7 @@ impl Decrypter {
match query.view_mut() {
QueryView::Scheduling(mut q) => {
let mut peer_query = gst::Query::new_scheduling();
let mut peer_query = gst::query::Scheduling::new();
let res = self.sinkpad.peer_query(&mut peer_query);
if !res {
return res;
@ -324,7 +324,7 @@ impl Decrypter {
}
/* First let's query the bytes duration upstream */
let mut peer_query = gst::query::Query::new_duration(gst::Format::Bytes);
let mut peer_query = gst::query::Duration::new(gst::Format::Bytes);
if !self.sinkpad.peer_query(&mut peer_query) {
gst_error!(CAT, "Failed to query upstream duration");

4
generic/sodium/src/encrypter.rs
View file

@ -260,7 +260,7 @@ impl Encrypter {
EventView::Caps(_) => {
// We send our own caps downstream
let caps = gst::Caps::builder("application/x-sodium-encrypted").build();
self.srcpad.push_event(gst::Event::new_caps(&caps).build())
self.srcpad.push_event(gst::event::Caps::new(&caps))
}
EventView::Eos(_) => {
let mut state_mutex = self.state.lock().unwrap();
@ -341,7 +341,7 @@ impl Encrypter {
}
/* First let's query the bytes duration upstream */
let mut peer_query = gst::query::Query::new_duration(gst::Format::Bytes);
let mut peer_query = gst::query::Duration::new(gst::Format::Bytes);
if !self.sinkpad.peer_query(&mut peer_query) {
gst_error!(CAT, "Failed to query upstream duration");

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

@ -198,7 +198,7 @@ fn test_pull_range() {
.expect("Unable to set the pipeline to the `Playing` state");
// Test that the decryptor is seekable
let mut q = gst::query::Query::new_seeking(gst::Format::Bytes);
let mut q = gst::query::Seeking::new(gst::Format::Bytes);
srcpad.query(&mut q);
// get the seeking capabilities

2
generic/sodium/tests/encrypter.rs
View file

@ -91,7 +91,7 @@ fn encrypt_file() {
let buf = gst::Buffer::from_mut_slice(Vec::from(&input[..]));
assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok));
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
println!("Pulling buffer...");
while let Ok(buf) = h.pull() {

13
generic/threadshare/src/appsrc.rs
View file

@ -182,14 +182,13 @@ impl AppSrcPadHandler {
gst_debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
let stream_id = format!("{:08x}{:08x}", rand::random::<u32>(), rand::random::<u32>());
let stream_start_evt = gst::Event::new_stream_start(&stream_id)
let stream_start_evt = gst::event::StreamStart::builder(&stream_id)
.group_id(gst::GroupId::next())
.build();
pad.push_event(stream_start_evt).await;
if let Some(ref caps) = state.caps {
let caps_evt = gst::Event::new_caps(&caps).build();
pad.push_event(caps_evt).await;
pad.push_event(gst::event::Caps::new(&caps)).await;
*self.0.configured_caps.lock().unwrap() = Some(caps.clone());
}
@ -198,7 +197,7 @@ impl AppSrcPadHandler {
if state.need_segment {
let segment_evt =
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build();
gst::event::Segment::new(&gst::FormattedSegment::<gst::format::Time>::new());
pad.push_event(segment_evt).await;
state.need_segment = false;
@ -374,8 +373,7 @@ impl TaskImpl for AppSrcTask {
}
Err(gst::FlowError::Eos) => {
gst_debug!(CAT, obj: &self.element, "EOS");
let eos = gst::Event::new_eos().build();
pad.push_event(eos).await;
pad.push_event(gst::event::Eos::new()).await;
}
Err(gst::FlowError::Flushing) => {
gst_debug!(CAT, obj: &self.element, "Flushing");
@ -478,8 +476,7 @@ impl AppSrc {
None => return false,
};
let eos = StreamItem::Event(gst::Event::new_eos().build());
match sender.try_send(eos) {
match sender.try_send(StreamItem::Event(gst::event::Eos::new())) {
Ok(_) => true,
Err(err) => {
gst_error!(CAT, obj: element, "Failed to queue EOS: {}", err);

10
generic/threadshare/src/inputselector.rs
View file

@ -334,7 +334,7 @@ impl PadSrcHandler for InputSelectorPadSrcHandler {
};
for pad in pads {
let mut peer_query = gst::query::Query::new_latency();
let mut peer_query = gst::query::Latency::new();
ret = pad.peer_query(&mut peer_query);
@ -518,12 +518,12 @@ impl ObjectImpl for InputSelector {
if let Some(old_pad) = old_pad {
if Some(&old_pad) != pad.as_ref() {
let _ = old_pad.push_event(gst::Event::new_reconfigure().build());
let _ = old_pad.push_event(gst::event::Reconfigure::new());
}
}
if let Some(pad) = pad {
let _ = pad.push_event(gst::Event::new_reconfigure().build());
let _ = pad.push_event(gst::event::Reconfigure::new());
}
}
_ => unimplemented!(),
@ -614,7 +614,7 @@ impl ElementImpl for InputSelector {
drop(pads);
drop(state);
let _ = element.post_message(&gst::Message::new_latency().src(Some(element)).build());
let _ = element.post_message(&gst::message::Latency::builder().src(element).build());
Some(ret)
}
@ -626,7 +626,7 @@ impl ElementImpl for InputSelector {
element.remove_pad(pad).unwrap();
drop(pads);
let _ = element.post_message(&gst::Message::new_latency().src(Some(element)).build());
let _ = element.post_message(&gst::message::Latency::builder().src(element).build());
}
fn provide_clock(&self, _element: &gst::Element) -> Option<gst::Clock> {

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

@ -812,7 +812,7 @@ impl SrcHandler {
],
);
events.push(gst::Event::new_custom_downstream(s).build());
events.push(gst::event::CustomDownstream::new(s));
}
lost_seqnum = lost_seqnum.wrapping_add(n_packets as u16);
@ -837,7 +837,7 @@ impl SrcHandler {
],
);
events.push(gst::Event::new_custom_downstream(s).build());
events.push(gst::event::CustomDownstream::new(s));
}
state.stats.num_lost += 1;
@ -1036,7 +1036,7 @@ impl PadSrcHandler for SrcHandler {
match query.view_mut() {
QueryView::Latency(ref mut q) => {
let mut peer_query = gst::query::Query::new_latency();
let mut peer_query = gst::query::Latency::new();
let ret = jb.sink_pad.gst_pad().peer_query(&mut peer_query);
@ -1302,8 +1302,7 @@ impl TaskImpl for JitterBufferTask {
match err {
gst::FlowError::Eos => {
gst_debug!(CAT, obj: &self.element, "Pushing EOS event");
let event = gst::Event::new_eos().build();
let _ = jb.src_pad.push_event(event).await;
let _ = jb.src_pad.push_event(gst::event::Eos::new()).await;
}
gst::FlowError::Flushing => gst_debug!(CAT, obj: &self.element, "Flushing"),
err => gst_error!(CAT, obj: &self.element, "Error {}", err),
@ -1513,7 +1512,7 @@ impl ObjectImpl for JitterBuffer {
let element = obj.downcast_ref::<gst::Element>().unwrap();
let _ =
element.post_message(&gst::Message::new_latency().src(Some(element)).build());
element.post_message(&gst::message::Latency::builder().src(element).build());
}
subclass::Property("do-lost", ..) => {
let mut settings = self.settings.lock().unwrap();

2
generic/threadshare/src/proxy.rs
View file

@ -389,7 +389,7 @@ impl PadSinkHandler for ProxySinkPadHandler {
match event.view() {
EventView::Eos(..) => {
let _ =
element.post_message(&gst::Message::new_eos().src(Some(&element)).build());
element.post_message(&gst::message::Eos::builder().src(&element).build());
}
EventView::FlushStop(..) => proxysink.start(&element),
_ => (),

5
generic/threadshare/src/queue.rs
View file

@ -350,7 +350,7 @@ impl PadSrcHandler for QueuePadSrcHandler {
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
if let QueryView::Scheduling(ref mut q) = query.view_mut() {
let mut new_query = gst::Query::new_scheduling();
let mut new_query = gst::query::Scheduling::new();
let res = queue.sink_pad.gst_pad().peer_query(&mut new_query);
if !res {
return res;
@ -439,8 +439,7 @@ impl TaskImpl for QueueTask {
Err(gst::FlowError::Eos) => {
gst_debug!(CAT, obj: &self.element, "EOS");
*queue.last_res.lock().unwrap() = Err(gst::FlowError::Eos);
let eos = gst::Event::new_eos().build();
pad.push_event(eos).await;
pad.push_event(gst::event::Eos::new()).await;
}
Err(err) => {
gst_error!(CAT, obj: &self.element, "Got error {}", err);

13
generic/threadshare/src/tcpclientsrc.rs
View file

@ -207,14 +207,13 @@ impl TcpClientSrcPadHandler {
gst_debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
let stream_id = format!("{:08x}{:08x}", rand::random::<u32>(), rand::random::<u32>());
let stream_start_evt = gst::Event::new_stream_start(&stream_id)
let stream_start_evt = gst::event::StreamStart::builder(&stream_id)
.group_id(gst::GroupId::next())
.build();
pad.push_event(stream_start_evt).await;
if let Some(ref caps) = state.caps {
let caps_evt = gst::Event::new_caps(&caps).build();
pad.push_event(caps_evt).await;
pad.push_event(gst::event::Caps::new(&caps)).await;
*self.0.configured_caps.lock().unwrap() = Some(caps.clone());
}
@ -223,7 +222,7 @@ impl TcpClientSrcPadHandler {
if state.need_segment {
let segment_evt =
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build();
gst::event::Segment::new(&gst::FormattedSegment::<gst::format::Time>::new());
pad.push_event(segment_evt).await;
state.need_segment = false;
@ -241,8 +240,7 @@ impl TcpClientSrcPadHandler {
self.push_prelude(pad, element).await;
if buffer.get_size() == 0 {
let event = gst::Event::new_eos().build();
pad.push_event(event).await;
pad.push_event(gst::event::Eos::new()).await;
return Ok(gst::FlowSuccess::Ok);
}
@ -459,8 +457,7 @@ impl TaskImpl for TcpClientSrcTask {
}
Err(gst::FlowError::Eos) => {
gst_debug!(CAT, obj: &self.element, "EOS");
let eos = gst::Event::new_eos().build();
pad.push_event(eos).await;
pad.push_event(gst::event::Eos::new()).await;
}
Err(err) => {
gst_error!(CAT, obj: &self.element, "Got error {}", err);

2
generic/threadshare/src/udpsink.rs
View file

@ -754,7 +754,7 @@ impl UdpSinkPadHandler {
async fn handle_event(&self, element: &gst::Element, event: gst::Event) {
match event.view() {
EventView::Eos(_) => {
let _ = element.post_message(&gst::Message::new_eos().src(Some(element)).build());
let _ = element.post_message(&gst::message::Eos::builder().src(element).build());
}
EventView::Segment(e) => {
self.0.write().unwrap().segment = Some(e.get_segment().clone());

10
generic/threadshare/src/udpsrc.rs
View file

@ -260,14 +260,13 @@ impl UdpSrcPadHandler {
gst_debug!(CAT, obj: pad.gst_pad(), "Pushing initial events");
let stream_id = format!("{:08x}{:08x}", rand::random::<u32>(), rand::random::<u32>());
let stream_start_evt = gst::Event::new_stream_start(&stream_id)
let stream_start_evt = gst::event::StreamStart::builder(&stream_id)
.group_id(gst::GroupId::next())
.build();
pad.push_event(stream_start_evt).await;
if let Some(ref caps) = state.caps {
let caps_evt = gst::Event::new_caps(&caps).build();
pad.push_event(caps_evt).await;
pad.push_event(gst::event::Caps::new(&caps)).await;
*self.0.configured_caps.lock().unwrap() = Some(caps.clone());
}
@ -276,7 +275,7 @@ impl UdpSrcPadHandler {
if state.need_segment {
let segment_evt =
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build();
gst::event::Segment::new(&gst::FormattedSegment::<gst::format::Time>::new());
pad.push_event(segment_evt).await;
state.need_segment = false;
@ -478,8 +477,7 @@ impl TaskImpl for UdpSrcTask {
Err(gst::FlowError::Flushing) => gst_debug!(CAT, obj: &self.element, "Flushing"),
Err(gst::FlowError::Eos) => {
gst_debug!(CAT, obj: &self.element, "EOS");
let eos = gst::Event::new_eos().build();
pad.push_event(eos).await;
pad.push_event(gst::event::Eos::new()).await;
}
Err(err) => {
gst_error!(CAT, obj: &self.element, "Got error {}", err);

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

@ -193,7 +193,7 @@ fn flush_regular() {
let _ = h.pull().unwrap();
// FlushStart
assert!(h.push_upstream_event(gst::Event::new_flush_start().build()));
assert!(h.push_upstream_event(gst::event::FlushStart::new()));
// Can't push buffer while flushing
assert!(!appsrc
@ -206,7 +206,7 @@ fn flush_regular() {
assert!(h.try_pull().is_none());
// FlushStop
assert!(h.push_upstream_event(gst::Event::new_flush_stop(true).build()));
assert!(h.push_upstream_event(gst::event::FlushStop::new(true)));
// No buffer available due to flush
assert!(h.try_pull().is_none());
@ -258,7 +258,7 @@ fn pause_flush() {
.unwrap();
// FlushStart
assert!(h.push_upstream_event(gst::Event::new_flush_start().build()));
assert!(h.push_upstream_event(gst::event::FlushStart::new()));
// Can't push buffers while flushing
assert!(!appsrc
@ -271,7 +271,7 @@ fn pause_flush() {
assert!(h.try_pull().is_none());
// FlushStop
assert!(h.push_upstream_event(gst::Event::new_flush_stop(true).build()));
assert!(h.push_upstream_event(gst::event::FlushStop::new(true)));
appsrc
.change_state(gst::StateChange::PausedToPlaying)

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

@ -586,7 +586,7 @@ impl ElementSinkTest {
gst_debug!(SINK_CAT, obj: element, "Pushing FlushStart");
self.sink_pad
.gst_pad()
.push_event(gst::Event::new_flush_start().build());
.push_event(gst::event::FlushStart::new());
gst_debug!(SINK_CAT, obj: element, "FlushStart pushed");
}
@ -594,7 +594,7 @@ impl ElementSinkTest {
gst_debug!(SINK_CAT, obj: element, "Pushing FlushStop");
self.sink_pad
.gst_pad()
.push_event(gst::Event::new_flush_stop(true).build());
.push_event(gst::event::FlushStop::new(true));
gst_debug!(SINK_CAT, obj: element, "FlushStop pushed");
}
}
@ -762,7 +762,7 @@ fn nominal_scenario(
// Initial events
elem_src_test
.try_push(Item::Event(
gst::Event::new_stream_start(scenario_name)
gst::event::StreamStart::builder(scenario_name)
.group_id(gst::GroupId::next())
.build(),
))
@ -777,9 +777,9 @@ fn nominal_scenario(
}
elem_src_test
.try_push(Item::Event(
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
))
.try_push(Item::Event(gst::event::Segment::new(
&gst::FormattedSegment::<gst::format::Time>::new(),
)))
.unwrap();
match futures::executor::block_on(receiver.next()).unwrap() {
@ -838,8 +838,8 @@ fn nominal_scenario(
}
// Flush
src_element.send_event(gst::Event::new_flush_start().build());
src_element.send_event(gst::Event::new_flush_stop(true).build());
src_element.send_event(gst::event::FlushStart::new());
src_element.send_event(gst::event::FlushStop::new(true));
match futures::executor::block_on(receiver.next()).unwrap() {
Item::Event(event) => match event.view() {
@ -850,9 +850,9 @@ fn nominal_scenario(
}
elem_src_test
.try_push(Item::Event(
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
))
.try_push(Item::Event(gst::event::Segment::new(
&gst::FormattedSegment::<gst::format::Time>::new(),
)))
.unwrap();
match futures::executor::block_on(receiver.next()).unwrap() {
@ -878,7 +878,7 @@ fn nominal_scenario(
// EOS
elem_src_test
.try_push(Item::Event(gst::Event::new_eos().build()))
.try_push(Item::Event(gst::event::Eos::new()))
.unwrap();
match futures::executor::block_on(receiver.next()).unwrap() {
@ -894,7 +894,7 @@ fn nominal_scenario(
// Receiver was dropped when stopping => can't send anymore
elem_src_test
.try_push(Item::Event(
gst::Event::new_stream_start(&format!("{}_past_stop", scenario_name))
gst::event::StreamStart::builder(&format!("{}_past_stop", scenario_name))
.group_id(gst::GroupId::next())
.build(),
))
@ -986,7 +986,7 @@ fn start_pause_start() {
// Initial events
elem_src_test
.try_push(Item::Event(
gst::Event::new_stream_start(scenario_name)
gst::event::StreamStart::builder(scenario_name)
.group_id(gst::GroupId::next())
.build(),
))
@ -1001,9 +1001,9 @@ fn start_pause_start() {
}
elem_src_test
.try_push(Item::Event(
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
))
.try_push(Item::Event(gst::event::Segment::new(
&gst::FormattedSegment::<gst::format::Time>::new(),
)))
.unwrap();
match futures::executor::block_on(receiver.next()).unwrap() {
@ -1064,7 +1064,7 @@ fn start_stop_start() {
// Initial events
elem_src_test
.try_push(Item::Event(
gst::Event::new_stream_start(&format!("{}-after_stop", scenario_name))
gst::event::StreamStart::builder(&format!("{}-after_stop", scenario_name))
.group_id(gst::GroupId::next())
.build(),
))
@ -1079,9 +1079,9 @@ fn start_stop_start() {
}
elem_src_test
.try_push(Item::Event(
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
))
.try_push(Item::Event(gst::event::Segment::new(
&gst::FormattedSegment::<gst::format::Time>::new(),
)))
.unwrap();
match futures::executor::block_on(receiver.next()).unwrap() {
@ -1104,7 +1104,7 @@ fn start_stop_start() {
// Initial events again
elem_src_test
.try_push(Item::Event(
gst::Event::new_stream_start(scenario_name)
gst::event::StreamStart::builder(scenario_name)
.group_id(gst::GroupId::next())
.build(),
))
@ -1134,9 +1134,9 @@ fn start_stop_start() {
}
elem_src_test
.try_push(Item::Event(
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
))
.try_push(Item::Event(gst::event::Segment::new(
&gst::FormattedSegment::<gst::format::Time>::new(),
)))
.unwrap();
match futures::executor::block_on(receiver.next()).unwrap() {
@ -1177,7 +1177,7 @@ fn start_flush() {
// Initial events
elem_src_test
.try_push(Item::Event(
gst::Event::new_stream_start(&format!("{}-after_stop", scenario_name))
gst::event::StreamStart::builder(&format!("{}-after_stop", scenario_name))
.group_id(gst::GroupId::next())
.build(),
))
@ -1192,9 +1192,9 @@ fn start_flush() {
}
elem_src_test
.try_push(Item::Event(
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
))
.try_push(Item::Event(gst::event::Segment::new(
&gst::FormattedSegment::<gst::format::Time>::new(),
)))
.unwrap();
match futures::executor::block_on(receiver.next()).unwrap() {
@ -1221,9 +1221,9 @@ fn start_flush() {
elem_sink_test.push_flush_stop(&sink_element);
elem_src_test
.try_push(Item::Event(
gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
))
.try_push(Item::Event(gst::event::Segment::new(
&gst::FormattedSegment::<gst::format::Time>::new(),
)))
.unwrap();
match futures::executor::block_on(receiver.next()).unwrap() {

14
net/reqwest/src/reqwesthttpsrc.rs
View file

@ -276,15 +276,15 @@ impl ReqwestHttpSrc {
}
let srcpad = src.get_static_pad("src").unwrap();
let mut q = gst::Query::new_context(REQWEST_CLIENT_CONTEXT);
let mut q = gst::query::Context::new(REQWEST_CLIENT_CONTEXT);
if srcpad.peer_query(&mut q) {
if let Some(context) = q.get_context_owned() {
src.set_context(&context);
}
} else {
let _ = src.post_message(
&gst::Message::new_need_context(REQWEST_CLIENT_CONTEXT)
.src(Some(src))
&gst::message::NeedContext::builder(REQWEST_CLIENT_CONTEXT)
.src(src)
.build(),
);
}
@ -325,11 +325,7 @@ impl ReqwestHttpSrc {
s.set("client", &client);
}
src.set_context(&context);
let _ = src.post_message(
&gst::Message::new_have_context(context)
.src(Some(src))
.build(),
);
let _ = src.post_message(&gst::message::HaveContext::builder(context).src(src).build());
*client_guard = Some(client.clone());
@ -1000,7 +996,7 @@ impl PushSrcImpl for ReqwestHttpSrc {
if let Some(tags) = tags {
gst_debug!(CAT, obj: src, "Sending iradio tags {:?}", tags);
let pad = src.get_static_pad("src").unwrap();
pad.push_event(gst::Event::new_tag(tags).build());
pad.push_event(gst::event::Tag::new(tags));
}
let future = async {

17
net/rusoto/src/aws_transcribe_parse.rs
View file

@ -274,14 +274,15 @@ impl Transcriber {
return self
.srcpad
.push_event(gst::Event::new_eos().seqnum(seqnum).build());
.push_event(gst::event::Eos::builder().seqnum(seqnum).build());
}
for mut buf in items.drain(..) {
if buf.get_pts() > last_position {
let gap_event = gst::Event::new_gap(last_position, buf.get_pts() - last_position)
.seqnum(seqnum)
.build();
let gap_event =
gst::event::Gap::builder(last_position, buf.get_pts() - last_position)
.seqnum(seqnum)
.build();
gst_debug!(
CAT,
"Pushing gap: {} -> {}",
@ -313,7 +314,7 @@ impl Transcriber {
if now - last_position > latency {
let duration = now - last_position - latency;
let gap_event = gst::Event::new_gap(last_position, duration)
let gap_event = gst::event::Gap::builder(last_position, duration)
.seqnum(seqnum)
.build();
gst_debug!(
@ -634,7 +635,7 @@ impl Transcriber {
match query.view_mut() {
QueryView::Latency(ref mut q) => {
let mut peer_query = gst::query::Query::new_latency();
let mut peer_query = gst::query::Latency::new();
let ret = self.sinkpad.peer_query(&mut peer_query);
@ -744,7 +745,7 @@ impl Transcriber {
state.in_segment = segment;
state.seqnum = e.get_seqnum();
gst::Event::new_segment(&state.out_segment)
gst::event::Segment::builder(&state.out_segment)
.seqnum(state.seqnum)
.build()
};
@ -762,7 +763,7 @@ impl Transcriber {
.build();
let seqnum = self.state.lock().unwrap().seqnum;
self.srcpad
.push_event(gst::Event::new_caps(&caps).seqnum(seqnum).build())
.push_event(gst::event::Caps::builder(&caps).seqnum(seqnum).build())
}
_ => pad.event_default(Some(element), event),
}

4
tutorial/src/sinesrc.rs
View file

@ -316,7 +316,7 @@ impl ObjectImpl for SineSrc {
drop(settings);
let _ =
basesrc.post_message(&gst::Message::new_latency().src(Some(basesrc)).build());
basesrc.post_message(&gst::message::Latency::builder().src(basesrc).build());
}
subclass::Property("freq", ..) => {
let mut settings = self.settings.lock().unwrap();
@ -483,7 +483,7 @@ impl BaseSrcImpl for SineSrc {
drop(state);
let _ = element.post_message(&gst::Message::new_latency().src(Some(element)).build());
let _ = element.post_message(&gst::message::Latency::builder().src(element).build());
Ok(())
}

6
utils/fallbackswitch/src/fallbacksrc.rs
View file

@ -1899,7 +1899,7 @@ impl FallbackSrc {
for pad in element.get_src_pads() {
element.call_async(move |_element| {
pad.push_event(gst::Event::new_eos().build());
pad.push_event(gst::event::Eos::new());
});
}
});
@ -2286,8 +2286,8 @@ mod custom_source {
element.no_more_pads();
let _ = element.post_message(
&gst::Message::new_streams_selected(&collection)
.src(Some(element))
&gst::message::StreamsSelected::builder(&collection)
.src(element)
.build(),
);

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

@ -285,8 +285,8 @@ fn create_ui(app: &gtk::Application) {
record_button.set_sensitive(false);
button.set_sensitive(false);
video_pad.send_event(gst::Event::new_eos().build());
audio_pad.send_event(gst::Event::new_eos().build());
video_pad.send_event(gst::event::Eos::new());
audio_pad.send_event(gst::event::Eos::new());
});
let app_weak = app.downgrade();

10
utils/togglerecord/src/togglerecord.rs
View file

@ -1013,7 +1013,7 @@ impl ToggleRecord {
}
HandleResult::Eos => {
stream.srcpad.push_event(
gst::Event::new_eos()
gst::event::Eos::builder()
.seqnum(stream.state.lock().segment_seqnum)
.build(),
);
@ -1050,7 +1050,7 @@ impl ToggleRecord {
.offset_running_time(-(offset as i64))
.expect("Adjusting record duration");
events.push(
gst::Event::new_segment(&state.out_segment)
gst::event::Segment::builder(&state.out_segment)
.seqnum(state.segment_seqnum)
.build(),
);
@ -1195,7 +1195,7 @@ impl ToggleRecord {
forward = match handle_result {
Ok(HandleResult::Pass((new_pts, new_duration))) if new_pts.is_some() => {
if new_pts != pts || new_duration != duration {
event = gst::Event::new_gap(new_pts, new_duration).build();
event = gst::event::Gap::new(new_pts, new_duration);
}
true
}
@ -1248,7 +1248,7 @@ impl ToggleRecord {
// the input segment
if state.segment_pending {
events.push(
gst::Event::new_segment(&state.in_segment)
gst::event::Segment::builder(&state.in_segment)
.seqnum(state.segment_seqnum)
.build(),
);
@ -1350,7 +1350,7 @@ impl ToggleRecord {
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Scheduling(ref mut q) => {
let mut new_query = gst::Query::new_scheduling();
let mut new_query = gst::query::Scheduling::new();
let res = stream.sinkpad.peer_query(&mut new_query);
if !res {
return res;

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

@ -114,7 +114,7 @@ fn setup_sender_receiver(
let mut first = true;
while let Ok(send_data) = receiver_input.recv() {
if first {
assert!(sinkpad.send_event(gst::Event::new_stream_start("test").build()));
assert!(sinkpad.send_event(gst::event::StreamStart::new("test")));
let caps = if main_stream {
gst::Caps::builder("video/x-raw")
.field("format", &"ARGB")
@ -130,16 +130,16 @@ fn setup_sender_receiver(
.field("channels", &1i32)
.build()
};
assert!(sinkpad.send_event(gst::Event::new_caps(&caps).build()));
assert!(sinkpad.send_event(gst::event::Caps::new(&caps)));
let segment = gst::FormattedSegment::<gst::ClockTime>::new();
assert!(sinkpad.send_event(gst::Event::new_segment(&segment).build()));
assert!(sinkpad.send_event(gst::event::Segment::new(&segment)));
let mut tags = gst::TagList::new();
tags.get_mut()
.unwrap()
.add::<gst::tags::Title>(&"some title", gst::TagMergeMode::Append);
assert!(sinkpad.send_event(gst::Event::new_tag(tags).build()));
assert!(sinkpad.send_event(gst::event::Tag::new(tags)));
first = false;
}
@ -185,8 +185,7 @@ fn setup_sender_receiver(
SendData::Gaps(n) => {
for _ in 0..n {
let event =
gst::Event::new_gap(offset + i * 20 * gst::MSECOND, 20 * gst::MSECOND)
.build();
gst::event::Gap::new(offset + i * 20 * gst::MSECOND, 20 * gst::MSECOND);
let _ = sinkpad.send_event(event);
i += 1;
}
@ -196,7 +195,7 @@ fn setup_sender_receiver(
let _ = sender_input_done.send(());
}
let _ = sinkpad.send_event(gst::Event::new_eos().build());
let _ = sinkpad.send_event(gst::event::Eos::new());
let _ = sender_input_done.send(());
});

4
video/cdg/src/cdgparse.rs
View file

@ -114,7 +114,7 @@ impl BaseParseImpl for CdgParse {
element.set_min_frame_size(CDG_PACKET_SIZE as u32);
/* Set duration */
let mut query = gst::Query::new_duration(gst::Format::Bytes);
let mut query = gst::query::Duration::new(gst::Format::Bytes);
let pad = element.get_src_pad();
if pad.query(&mut query) {
let size = query.get_result();
@ -143,7 +143,7 @@ impl BaseParseImpl for CdgParse {
],
);
pad.push_event(gst::Event::new_caps(&src_caps).build());
pad.push_event(gst::event::Caps::new(&src_caps));
}
// Scan for CDG instruction

2
video/closedcaption/src/cea608overlay.rs
View file

@ -284,7 +284,7 @@ impl Cea608Overlay {
self.recalculate_layout(element, state)?;
if !self.srcpad.push_event(gst::Event::new_caps(&caps).build()) {
if !self.srcpad.push_event(gst::event::Caps::new(&caps)) {
Err(gst::FlowError::NotNegotiated)
} else {
Ok(gst::FlowSuccess::Ok)

2
video/closedcaption/src/cea608tott.rs
View file

@ -318,7 +318,7 @@ impl Cea608ToTt {
unreachable!();
};
let new_event = gst::Event::new_caps(&new_caps).build();
let new_event = gst::event::Caps::new(&new_caps);
return self.srcpad.push_event(new_event);
}

2
video/closedcaption/src/mcc_enc.rs
View file

@ -420,7 +420,7 @@ impl MccEnc {
},
)
.build();
self.srcpad.push_event(gst::Event::new_caps(&caps).build())
self.srcpad.push_event(gst::event::Caps::new(&caps))
}
_ => pad.event_default(Some(element), event),
}

26
video/closedcaption/src/mcc_parse.rs
View file

@ -288,7 +288,7 @@ impl State {
let mut events = Vec::new();
if self.need_flush_stop {
let mut b = gst::Event::new_flush_stop(true);
let mut b = gst::event::FlushStop::builder(true);
if let Some(seek_seqnum) = self.seek_seqnum {
b = b.seqnum(seek_seqnum);
@ -300,7 +300,7 @@ impl State {
if let Some(pull) = &mut self.pull {
if pull.need_stream_start {
events.push(gst::Event::new_stream_start(&pull.stream_id).build());
events.push(gst::event::StreamStart::new(&pull.stream_id));
pull.need_stream_start = false;
}
}
@ -320,13 +320,13 @@ impl State {
.build(),
};
events.push(gst::Event::new_caps(&caps).build());
events.push(gst::event::Caps::new(&caps));
gst_info!(CAT, obj: element, "Caps changed to {:?}", &caps);
}
}
if self.need_segment {
let mut b = gst::Event::new_segment(&self.segment);
let mut b = gst::event::Segment::builder(&self.segment);
if let Some(seek_seqnum) = self.seek_seqnum {
b = b.seqnum(seek_seqnum);
@ -590,7 +590,7 @@ impl MccParse {
element: &gst::Element,
) -> Result<(), gst::LoggableError> {
let mode = {
let mut query = gst::Query::new_scheduling();
let mut query = gst::query::Scheduling::new();
let mut state = self.state.lock().unwrap();
state.pull = None;
@ -664,7 +664,7 @@ impl MccParse {
gst_debug!(CAT, obj: element, "Scanning duration");
/* First let's query the bytes duration upstream */
let mut q = gst::query::Query::new_duration(gst::Format::Bytes);
let mut q = gst::query::Duration::new(gst::Format::Bytes);
if !self.sinkpad.peer_query(&mut q) {
return Err(gst_loggable_error!(
@ -758,7 +758,7 @@ impl MccParse {
match parse_timecode_rate(state.timecode_rate) {
Ok((framerate, _)) => {
let mut events = state.create_events(element, None, framerate);
let mut eos_event = gst::Event::new_eos();
let mut eos_event = gst::event::Eos::builder();
if let Some(seek_seqnum) = state.seek_seqnum {
eos_event = eos_event.seqnum(seek_seqnum);
@ -1006,12 +1006,16 @@ impl MccParse {
let seek_seqnum = event.get_seqnum();
state.seek_seqnum = Some(seek_seqnum);
let event = gst::Event::new_flush_start().seqnum(seek_seqnum).build();
let event = gst::event::FlushStart::builder()
.seqnum(seek_seqnum)
.build();
gst_debug!(CAT, obj: element, "Sending event {:?} upstream", event);
self.sinkpad.push_event(event);
let event = gst::Event::new_flush_start().seqnum(seek_seqnum).build();
let event = gst::event::FlushStart::builder()
.seqnum(seek_seqnum)
.build();
gst_debug!(CAT, obj: element, "Pushing event {:?}", event);
self.srcpad.push_event(event);
@ -1020,7 +1024,9 @@ impl MccParse {
state = self.flush(state);
let event = gst::Event::new_flush_stop(true).seqnum(seek_seqnum).build();
let event = gst::event::FlushStop::builder(true)
.seqnum(seek_seqnum)
.build();
/* Drop our state while we push a serialized event upstream */
drop(state);

2
video/closedcaption/src/scc_enc.rs
View file

@ -269,7 +269,7 @@ impl SccEnc {
// We send our own caps downstream
let caps = gst::Caps::builder("application/x-scc").build();
self.srcpad.push_event(gst::Event::new_caps(&caps).build())
self.srcpad.push_event(gst::event::Caps::new(&caps))
}
EventView::Eos(_) => {
let mut state = self.state.lock().unwrap();

4
video/closedcaption/src/scc_parse.rs
View file

@ -260,13 +260,13 @@ impl SccParse {
.field("format", &"raw")
.field("framerate", &framerate)
.build();
events.push(gst::Event::new_caps(&caps).build());
events.push(gst::event::Caps::new(&caps));
state.framerate = Some(framerate);
}
if state.need_segment {
let segment = gst::FormattedSegment::<gst::format::Time>::new();
events.push(gst::Event::new_segment(&segment).build());
events.push(gst::event::Segment::new(&segment));
state.need_segment = false;
}

6
video/closedcaption/src/tttocea608.rs
View file

@ -296,7 +296,7 @@ impl TtToCea608 {
.mul_div_round(fps_d, fps_n)
.unwrap();
let event = gst::Event::new_gap(start, end - start).build();
let event = gst::event::Gap::new(start, end - start);
drop(state);
@ -635,7 +635,7 @@ impl TtToCea608 {
match query.view_mut() {
QueryView::Latency(ref mut q) => {
let mut peer_query = gst::query::Query::new_latency();
let mut peer_query = gst::query::Latency::new();
let ret = self.sinkpad.peer_query(&mut peer_query);
@ -702,7 +702,7 @@ impl TtToCea608 {
gst_debug!(CAT, obj: pad, "Pushing caps {}", caps);
let new_event = gst::Event::new_caps(&downstream_caps).build();
let new_event = gst::event::Caps::new(&downstream_caps);
drop(state);

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

@ -127,7 +127,7 @@ Time Code Rate=30DF\r\n\
};
assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok));
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
let buf = h.pull().expect("Couldn't pull buffer");
let timecode = buf

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

@ -92,7 +92,7 @@ fn test_parse() {
data = &data[l..];
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
while let Some(buf) = h.try_pull() {
output_len += buf.get_size();
checksum = checksum.wrapping_add(
@ -173,17 +173,14 @@ fn test_pull() {
}
/* Now seek and check that we receive buffers with appropriate PTS */
h.push_upstream_event(
gst::Event::new_seek(
1.0,
gst::SeekFlags::FLUSH,
gst::SeekType::Set,
gst::GenericFormattedValue::Time(gst::SECOND),
gst::SeekType::Set,
gst::GenericFormattedValue::Time(2 * gst::SECOND),
)
.build(),
);
h.push_upstream_event(gst::event::Seek::new(
1.0,
gst::SeekFlags::FLUSH,
gst::SeekType::Set,
gst::GenericFormattedValue::Time(gst::SECOND),
gst::SeekType::Set,
gst::GenericFormattedValue::Time(2 * gst::SECOND),
));
loop {
let mut done = false;

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

@ -60,7 +60,7 @@ fn test_encode_single_packet() {
};
assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok));
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
let buf = h.pull().expect("Couldn't pull buffer");
@ -158,7 +158,7 @@ fn test_encode_multiple_packets() {
buffers.iter().for_each(|buf| {
assert_eq!(h.push(buf.clone()), Ok(gst::FlowSuccess::Ok));
});
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
// Pull 1
let buf = h.pull().expect("Couldn't pull buffer");

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

@ -79,7 +79,7 @@ fn test_parse() {
data = &data[l..];
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
while let Some(buf) = h.try_pull() {
output_len += buf.get_size();
checksum = checksum.wrapping_add(

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

@ -105,7 +105,7 @@ fn test_one_timed_buffer_and_eos() {
assert_eq!(h.buffers_in_queue(), 0);
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
/* Check that we do receive an erase_display */
assert_eq!(h.buffers_in_queue(), 2);
@ -222,7 +222,7 @@ fn test_erase_display_memory_gaps() {
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
/* Let's first push a gap that doesn't leave room for our two control codes */
let gap_event = gst::Event::new_gap(2 * gst::SECOND, 2_533_333_333.into()).build();
let gap_event = gst::event::Gap::new(2 * gst::SECOND, 2_533_333_333.into());
assert_eq!(h.push_event(gap_event), true);
let mut erase_display_buffers = 0;
@ -237,7 +237,7 @@ fn test_erase_display_memory_gaps() {
assert_eq!(erase_display_buffers, 0);
let gap_event = gst::Event::new_gap(4_533_333_333.into(), 1.into()).build();
let gap_event = gst::event::Gap::new(4_533_333_333.into(), 1.into());
assert_eq!(h.push_event(gap_event), true);
while h.buffers_in_queue() > 0 {
@ -353,7 +353,7 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
assert_eq!(h.buffers_in_queue(), 0);
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
let expected_gaps: [(gst::ClockTime, gst::ClockTime); 2] = [
(0.into(), 1_000_000_000.into()),

10
video/flavors/src/flvdemux.rs
View file

@ -293,7 +293,7 @@ impl FlvDemux {
_element: &gst::Element,
) -> Result<(), gst::LoggableError> {
let mode = {
let mut query = gst::Query::new_scheduling();
let mut query = gst::query::Scheduling::new();
if !pad.peer_query(&mut query) {
return Err(gst_loggable_error!(CAT, "Scheduling query failed on peer"));
}
@ -598,7 +598,7 @@ impl FlvDemux {
}
};
pad.push_event(gst::Event::new_caps(&caps).build());
pad.push_event(gst::event::Caps::new(&caps));
}
Event::Buffer(stream, buffer) => {
let pad = match stream {
@ -658,12 +658,12 @@ impl FlvDemux {
let full_stream_id = srcpad.create_stream_id(element, Some(name)).unwrap();
// FIXME group id
srcpad.push_event(gst::Event::new_stream_start(&full_stream_id).build());
srcpad.push_event(gst::Event::new_caps(&caps).build());
srcpad.push_event(gst::event::StreamStart::new(&full_stream_id));
srcpad.push_event(gst::event::Caps::new(&caps));
// FIXME proper segment handling
let segment = gst::FormattedSegment::<gst::ClockTime>::default();
srcpad.push_event(gst::Event::new_segment(&segment).build());
srcpad.push_event(gst::event::Segment::new(&segment));
self.flow_combiner.lock().unwrap().add_pad(&srcpad);

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

@ -64,7 +64,7 @@ fn test_encode(video_info: &gst_video::VideoInfo) {
};
h.push(buffer.clone()).unwrap();
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
for _ in 0..6 {
// last frame is the GIF trailer

2
video/rav1e/tests/rav1enc.rs
View file

@ -181,7 +181,7 @@ fn test_encode(video_info: &gst_video::VideoInfo) {
for _ in 0..5 {
h.push(buffer.clone()).unwrap();
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
for i in 0..5 {
let buffer = h.pull().unwrap();

2
video/rspng/tests/pngenc.rs
View file

@ -81,7 +81,7 @@ fn test_png_encode(video_info: &gst_video::VideoInfo) {
};
h.push(buffer.clone()).unwrap();
}
h.push_event(gst::Event::new_eos().build());
h.push_event(gst::event::Eos::new());
(0..5).for_each(|_| {
let buffer = h.pull().unwrap();