Update everything for element factory builder API changes

And set properties as part of object construction wherever it makes
sense.

5 files changed, 80 insertions, 53 deletions

diff --git a/video/cdg/tests/cdgdec.rs b/video/cdg/tests/cdgdec.rs
index 750ab359..b5e07118 100644
--- a/video/cdg/tests/cdgdec.rs
+++ b/video/cdg/tests/cdgdec.rs
@@ -37,8 +37,10 @@ fn test_cdgdec() {
     };
 
     // Ensure we are in push mode so 'blocksize' prop is used
-    let filesrc = gst::ElementFactory::make("pushfilesrc", None).unwrap();
-    filesrc.set_property("location", input_path.to_str().unwrap());
+    let filesrc = gst::ElementFactory::make("pushfilesrc")
+        .property("location", input_path.to_str().unwrap())
+        .build()
+        .unwrap();
     {
         let child_proxy = filesrc.dynamic_cast_ref::<gst::ChildProxy>().unwrap();
         child_proxy.set_child_property("real-filesrc::num-buffers", 1);
@@ -46,9 +48,9 @@ fn test_cdgdec() {
         child_proxy.set_child_property("real-filesrc::blocksize", blocksize);
     }
 
-    let parse = gst::ElementFactory::make("cdgparse", None).unwrap();
-    let dec = gst::ElementFactory::make("cdgdec", None).unwrap();
-    let sink = gst::ElementFactory::make("appsink", None).unwrap();
+    let parse = gst::ElementFactory::make("cdgparse").build().unwrap();
+    let dec = gst::ElementFactory::make("cdgdec").build().unwrap();
+    let sink = gst::ElementFactory::make("appsink").build().unwrap();
 
     pipeline
         .add_many(&[&filesrc, &parse, &dec, &sink])
diff --git a/video/closedcaption/src/transcriberbin/imp.rs b/video/closedcaption/src/transcriberbin/imp.rs
index 251cc278..5e2636ac 100644
--- a/video/closedcaption/src/transcriberbin/imp.rs
+++ b/video/closedcaption/src/transcriberbin/imp.rs
@@ -88,12 +88,14 @@ impl TranscriberBin {
     fn construct_transcription_bin(&self, state: &mut State) -> Result<(), Error> {
         gst::debug!(CAT, imp: self, "Building transcription bin");
 
-        let aqueue_transcription = gst::ElementFactory::make("queue", Some("transqueue"))?;
-        aqueue_transcription.set_property("max-size-buffers", 0u32);
-        aqueue_transcription.set_property("max-size-bytes", 0u32);
-        aqueue_transcription.set_property("max-size-time", 5_000_000_000u64);
-        aqueue_transcription.set_property_from_str("leaky", "downstream");
-        let ccconverter = gst::ElementFactory::make("ccconverter", None)?;
+        let aqueue_transcription = gst::ElementFactory::make("queue")
+            .name("transqueue")
+            .property("max-size-buffers", 0u32)
+            .property("max-size-bytes", 0u32)
+            .property("max-size-time", 5_000_000_000u64)
+            .property_from_str("leaky", "downstream")
+            .build()?;
+        let ccconverter = gst::ElementFactory::make("ccconverter").build()?;
 
         state.transcription_bin.add_many(&[
             &aqueue_transcription,
@@ -150,9 +152,9 @@ impl TranscriberBin {
     }
 
     fn construct_internal_bin(&self, state: &mut State) -> Result<(), Error> {
-        let aclocksync = gst::ElementFactory::make("clocksync", None)?;
+        let aclocksync = gst::ElementFactory::make("clocksync").build()?;
 
-        let vclocksync = gst::ElementFactory::make("clocksync", None)?;
+        let vclocksync = gst::ElementFactory::make("clocksync").build()?;
 
         state.internal_bin.add_many(&[
             &aclocksync,
@@ -442,22 +444,31 @@ impl TranscriberBin {
     fn build_state(&self) -> Result<State, Error> {
         let internal_bin = gst::Bin::new(Some("internal"));
         let transcription_bin = gst::Bin::new(Some("transcription-bin"));
-        let audio_tee = gst::ElementFactory::make("tee", None)?;
-        let cccombiner = gst::ElementFactory::make("cccombiner", Some("cccombiner"))?;
-        let textwrap = gst::ElementFactory::make("textwrap", Some("textwrap"))?;
-        let tttocea608 = gst::ElementFactory::make("tttocea608", Some("tttocea608"))?;
-        let transcriber_aconv = gst::ElementFactory::make("audioconvert", None)?;
-        let transcriber = gst::ElementFactory::make("awstranscriber", Some("transcriber"))?;
-        let transcriber_queue = gst::ElementFactory::make("queue", None)?;
-        let audio_queue_passthrough = gst::ElementFactory::make("queue", None)?;
-        let video_queue = gst::ElementFactory::make("queue", None)?;
-        let cccapsfilter = gst::ElementFactory::make("capsfilter", None)?;
-        let transcription_valve = gst::ElementFactory::make("valve", None)?;
-
-        // Protect passthrough enable (and resulting dynamic reconfigure)
-        // from non-streaming thread
-        audio_tee.set_property("allow-not-linked", true);
-        transcription_valve.set_property_from_str("drop-mode", "transform-to-gap");
+        let audio_tee = gst::ElementFactory::make("tee")
+            // Protect passthrough enable (and resulting dynamic reconfigure)
+            // from non-streaming thread
+            .property("allow-not-linked", true)
+            .build()?;
+        let cccombiner = gst::ElementFactory::make("cccombiner")
+            .name("cccombiner")
+            .build()?;
+        let textwrap = gst::ElementFactory::make("textwrap")
+            .name("textwrap")
+            .build()?;
+        let tttocea608 = gst::ElementFactory::make("tttocea608")
+            .name("tttocea608")
+            .build()?;
+        let transcriber_aconv = gst::ElementFactory::make("audioconvert").build()?;
+        let transcriber = gst::ElementFactory::make("awstranscriber")
+            .name("transcriber")
+            .build()?;
+        let transcriber_queue = gst::ElementFactory::make("queue").build()?;
+        let audio_queue_passthrough = gst::ElementFactory::make("queue").build()?;
+        let video_queue = gst::ElementFactory::make("queue").build()?;
+        let cccapsfilter = gst::ElementFactory::make("capsfilter").build()?;
+        let transcription_valve = gst::ElementFactory::make("valve")
+            .property_from_str("drop-mode", "transform-to-gap")
+            .build()?;
 
         Ok(State {
             framerate: None,
diff --git a/video/gtk4/examples/gtksink.rs b/video/gtk4/examples/gtksink.rs
index 530b1812..0899d480 100644
--- a/video/gtk4/examples/gtksink.rs
+++ b/video/gtk4/examples/gtksink.rs
@@ -7,12 +7,16 @@ use std::cell::RefCell;
 
 fn create_ui(app: &gtk::Application) {
     let pipeline = gst::Pipeline::new(None);
-    let src = gst::ElementFactory::make("videotestsrc", None).unwrap();
+    let src = gst::ElementFactory::make("videotestsrc").build().unwrap();
 
-    let overlay = gst::ElementFactory::make("clockoverlay", None).unwrap();
-    overlay.set_property("font-desc", "Monospace 42");
+    let overlay = gst::ElementFactory::make("clockoverlay")
+        .property("font-desc", "Monospace 42")
+        .build()
+        .unwrap();
 
-    let sink = gst::ElementFactory::make("gtk4paintablesink", None).unwrap();
+    let sink = gst::ElementFactory::make("gtk4paintablesink")
+        .build()
+        .unwrap();
     let paintable = sink.property::<gdk::Paintable>("paintable");
 
     pipeline.add_many(&[&src, &overlay, &sink]).unwrap();
diff --git a/video/videofx/tests/colordetect.rs b/video/videofx/tests/colordetect.rs
index ccba6a0e..6b355ea4 100644
--- a/video/videofx/tests/colordetect.rs
+++ b/video/videofx/tests/colordetect.rs
@@ -23,12 +23,14 @@ fn test_red_color() {
     init();
     let pipeline = gst::Pipeline::new(None);
 
-    let src = gst::ElementFactory::make("videotestsrc", None).unwrap();
-    src.set_property_from_str("pattern", "red");
-    src.set_property("num-buffers", &2i32);
+    let src = gst::ElementFactory::make("videotestsrc")
+        .property_from_str("pattern", "red")
+        .property("num-buffers", &2i32)
+        .build()
+        .unwrap();
 
-    let filter = gst::ElementFactory::make("colordetect", None).unwrap();
-    let sink = gst::ElementFactory::make("fakevideosink", None).unwrap();
+    let filter = gst::ElementFactory::make("colordetect").build().unwrap();
+    let sink = gst::ElementFactory::make("fakevideosink").build().unwrap();
 
     pipeline
         .add_many(&[&src, &filter, &sink])
diff --git a/video/videofx/tests/videocompare.rs b/video/videofx/tests/videocompare.rs
index 251697c1..cc1ab724 100644
--- a/video/videofx/tests/videocompare.rs
+++ b/video/videofx/tests/videocompare.rs
@@ -26,18 +26,26 @@ fn setup_pipeline(
     max_distance_threshold: f64,
     hash_algo: HashAlgorithm,
 ) {
-    let videocompare = gst::ElementFactory::make("videocompare", None).unwrap();
-    videocompare.set_property("max-dist-threshold", max_distance_threshold);
-    videocompare.set_property("hash-algo", hash_algo);
+    let videocompare = gst::ElementFactory::make("videocompare")
+        .property("max-dist-threshold", max_distance_threshold)
+        .property("hash-algo", hash_algo)
+        .build()
+        .unwrap();
 
-    let reference_src = gst::ElementFactory::make("videotestsrc", Some("reference_src")).unwrap();
-    reference_src.set_property_from_str("pattern", pattern_a);
-    reference_src.set_property("num-buffers", 1i32);
+    let reference_src = gst::ElementFactory::make("videotestsrc")
+        .name("reference_src")
+        .property_from_str("pattern", pattern_a)
+        .property("num-buffers", 1i32)
+        .build()
+        .unwrap();
 
-    let secondary_src = gst::ElementFactory::make("videotestsrc", Some("secondary_src")).unwrap();
-    reference_src.set_property_from_str("pattern", pattern_b);
+    let secondary_src = gst::ElementFactory::make("videotestsrc")
+        .name("secondary_src")
+        .property_from_str("pattern", pattern_b)
+        .build()
+        .unwrap();
 
-    let sink = gst::ElementFactory::make("fakesink", None).unwrap();
+    let sink = gst::ElementFactory::make("fakesink").build().unwrap();
 
     pipeline
         .add_many(&[&reference_src, &secondary_src, &videocompare, &sink])
@@ -50,9 +58,7 @@ fn setup_pipeline(
 fn test_can_find_similar_frames() {
     init();
 
-    // TODO: for some reason only in the tests, the distance is higher
-    //       than when running via gst-launch tool for the same pipeline. What is happening?
-    let max_distance = 32_f64;
+    let max_distance = 0.0f64;
 
     let pipeline = gst::Pipeline::new(None);
     setup_pipeline(
@@ -101,7 +107,7 @@ fn test_do_not_send_message_when_image_not_found() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    setup_pipeline(&pipeline, "black", "red", 0f64, HashAlgorithm::Blockhash);
+    setup_pipeline(&pipeline, "snow", "red", 0f64, HashAlgorithm::Blockhash);
 
     pipeline.set_state(gst::State::Playing).unwrap();
 
@@ -127,7 +133,9 @@ fn test_do_not_send_message_when_image_not_found() {
 
     pipeline.set_state(gst::State::Null).unwrap();
 
-    assert!(detection.is_none());
+    if let Some(detection) = detection {
+        panic!("Got unexpected detection message {:?}", detection);
+    }
 }
 
 #[cfg(feature = "dssim")]
@@ -135,7 +143,7 @@ fn test_do_not_send_message_when_image_not_found() {
 fn test_use_dssim_to_find_similar_frames() {
     init();
 
-    let max_distance = 1_f64;
+    let max_distance = 0.0f64;
 
     let pipeline = gst::Pipeline::new(None);
     setup_pipeline(&pipeline, "red", "red", max_distance, HashAlgorithm::Dssim);