event,message,query: update instantiation

See https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/532

audio/audiofx/src/audioloudnorm.rs

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

audio/claxon/tests/claxondec.rs

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

audio/csound/tests/csound_filter.rs

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

audio/lewton/tests/lewtondec.rs

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

generic/sodium/src/decrypter.rs

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

generic/sodium/src/encrypter.rs

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

generic/sodium/tests/decrypter.rs

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

generic/sodium/tests/encrypter.rs

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

generic/threadshare/src/appsrc.rs

@@ -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(gst::event::Caps::new(&caps)).await;
-                pad.push_event(caps_evt).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(gst::event::Eos::new()).await;
-                    pad.push_event(eos).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(StreamItem::Event(gst::event::Eos::new())) {
-        match sender.try_send(eos) {
             Ok(_) => true,
             Err(err) => {
                 gst_error!(CAT, obj: element, "Failed to queue EOS: {}", err);

generic/threadshare/src/inputselector.rs

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

generic/threadshare/src/jitterbuffer/jitterbuffer.rs

@@ -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(gst::event::Eos::new()).await;
-                            let _ = jb.src_pad.push_event(event).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();

generic/threadshare/src/proxy.rs

@@ -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),
                 _ => (),

generic/threadshare/src/queue.rs

@@ -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(gst::event::Eos::new()).await;
-                    pad.push_event(eos).await;
                 }
                 Err(err) => {
                     gst_error!(CAT, obj: &self.element, "Got error {}", err);

generic/threadshare/src/tcpclientsrc.rs

@@ -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(gst::event::Caps::new(&caps)).await;
-                pad.push_event(caps_evt).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(gst::event::Eos::new()).await;
-            pad.push_event(event).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(gst::event::Eos::new()).await;
-                    pad.push_event(eos).await;
                 }
                 Err(err) => {
                     gst_error!(CAT, obj: &self.element, "Got error {}", err);

generic/threadshare/src/udpsink.rs

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

generic/threadshare/src/udpsrc.rs

@@ -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(gst::event::Caps::new(&caps)).await;
-                pad.push_event(caps_evt).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(gst::event::Eos::new()).await;
-                    pad.push_event(eos).await;
                 }
                 Err(err) => {
                     gst_error!(CAT, obj: &self.element, "Got error {}", err);

generic/threadshare/tests/appsrc.rs

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

generic/threadshare/tests/pad.rs

@@ -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(
+        .try_push(Item::Event(gst::event::Segment::new(
-            gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
+            &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::FlushStart::new());
-    src_element.send_event(gst::Event::new_flush_stop(true).build());
+    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(
+        .try_push(Item::Event(gst::event::Segment::new(
-            gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
+            &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(
+        .try_push(Item::Event(gst::event::Segment::new(
-            gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
+            &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(
+        .try_push(Item::Event(gst::event::Segment::new(
-            gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
+            &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(
+        .try_push(Item::Event(gst::event::Segment::new(
-            gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
+            &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(
+        .try_push(Item::Event(gst::event::Segment::new(
-            gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
+            &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(
+        .try_push(Item::Event(gst::event::Segment::new(
-            gst::Event::new_segment(&gst::FormattedSegment::<gst::format::Time>::new()).build(),
+            &gst::FormattedSegment::<gst::format::Time>::new(),
-        ))
+        )))
         .unwrap();
 
     match futures::executor::block_on(receiver.next()).unwrap() {

net/reqwest/src/reqwesthttpsrc.rs

@@ -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)
+                &gst::message::NeedContext::builder(REQWEST_CLIENT_CONTEXT)
-                    .src(Some(src))
+                    .src(src)
                     .build(),
             );
         }
@@ -325,11 +325,7 @@ impl ReqwestHttpSrc {
             s.set("client", &client);
         }
         src.set_context(&context);
-        let _ = src.post_message(
+        let _ = src.post_message(&gst::message::HaveContext::builder(context).src(src).build());
-            &gst::Message::new_have_context(context)
-                .src(Some(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 {

net/rusoto/src/aws_transcribe_parse.rs

@@ -274,12 +274,13 @@ 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)
+                let gap_event =
+                    gst::event::Gap::builder(last_position, buf.get_pts() - last_position)
                         .seqnum(seqnum)
                         .build();
                 gst_debug!(
@@ -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),
         }

tutorial/src/sinesrc.rs

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

utils/fallbackswitch/src/fallbacksrc.rs

@@ -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)
+                &gst::message::StreamsSelected::builder(&collection)
-                    .src(Some(element))
+                    .src(element)
                     .build(),
             );
 

utils/togglerecord/examples/gtk_recording.rs

@@ -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());
+        video_pad.send_event(gst::event::Eos::new());
-        audio_pad.send_event(gst::Event::new_eos().build());
+        audio_pad.send_event(gst::event::Eos::new());
     });
 
     let app_weak = app.downgrade();

utils/togglerecord/src/togglerecord.rs

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

utils/togglerecord/tests/tests.rs

@@ -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)
+                            gst::event::Gap::new(offset + i * 20 * gst::MSECOND, 20 * gst::MSECOND);
-                                .build();
                         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(());
     });
 

video/cdg/src/cdgparse.rs

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

video/closedcaption/src/cea608overlay.rs

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

video/closedcaption/src/cea608tott.rs

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

video/closedcaption/src/mcc_enc.rs

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

video/closedcaption/src/mcc_parse.rs

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

video/closedcaption/src/scc_enc.rs

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

video/closedcaption/src/scc_parse.rs

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

video/closedcaption/src/tttocea608.rs

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

video/closedcaption/tests/mcc_enc.rs

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

video/closedcaption/tests/mcc_parse.rs

@@ -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(
+    h.push_upstream_event(gst::event::Seek::new(
-        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(),
-    );
 
     loop {
         let mut done = false;

video/closedcaption/tests/scc_enc.rs

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

video/closedcaption/tests/scc_parse.rs

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

video/closedcaption/tests/tttocea608.rs

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

video/flavors/src/flvdemux.rs

@@ -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::StreamStart::new(&full_stream_id));
-        srcpad.push_event(gst::Event::new_caps(&caps).build());
+        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);
 

video/gif/tests/gifenc.rs

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

video/rav1e/tests/rav1enc.rs

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

video/rspng/tests/pngenc.rs

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