update gstreamer to 0.23

Cargo.toml

@@ -8,11 +8,11 @@ description = "NewTek NDI Plugin"
 edition = "2018"
 
 [dependencies]
-glib = "0.15"
-gst = { package = "gstreamer", version = "0.18", features = ["v1_12"] }
-gst-base = { package = "gstreamer-base", version = "0.18" }
-gst-audio = { package = "gstreamer-audio", version = "0.18" }
-gst-video = { package = "gstreamer-video", version = "0.18", features = ["v1_12"] }
+glib = "0.20"
+gst = { package = "gstreamer", version = "0.23" }
+gst-base = { package = "gstreamer-base", version = "0.23" }
+gst-audio = { package = "gstreamer-audio", version = "0.23" }
+gst-video = { package = "gstreamer-video", version = "0.23" }
 byte-slice-cast = "1"
 once_cell = "1.0"
 byteorder = "1.0"
@@ -23,7 +23,7 @@ gst-plugin-version-helper = "0.7"
 [features]
 default = ["interlaced-fields", "reference-timestamps", "sink"]
 interlaced-fields = ["gst/v1_16", "gst-video/v1_16"]
-reference-timestamps = ["gst/v1_14"]
+reference-timestamps = []
 sink = ["gst/v1_18", "gst-base/v1_18"]
 advanced-sdk = []
 

src/device_provider/imp.rs

@@ -1,6 +1,6 @@
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{gst_error, gst_log, gst_trace};
+use gst::{error, log, trace};
 
 use once_cell::sync::OnceCell;
 
@@ -60,7 +60,7 @@ impl DeviceProviderImpl for DeviceProvider {
         Some(&*METADATA)
     }
 
-    fn probe(&self, _device_provider: &Self::Type) -> Vec<gst::Device> {
+    fn probe(&self) -> Vec<gst::Device> {
         self.current_devices
             .lock()
             .unwrap()
@@ -69,10 +69,11 @@ impl DeviceProviderImpl for DeviceProvider {
             .collect()
     }
 
-    fn start(&self, device_provider: &Self::Type) -> Result<(), gst::LoggableError> {
+    fn start(&self) -> Result<(), gst::LoggableError> {
+        let device_provider = self.obj();
         let mut thread_guard = self.thread.lock().unwrap();
         if thread_guard.is_some() {
-            gst_log!(CAT, obj: device_provider, "Device provider already started");
+            log!(CAT, obj = device_provider, "Device provider already started");
             return Ok(());
         }
 
@@ -86,17 +87,17 @@ impl DeviceProviderImpl for DeviceProvider {
                 Some(device_provider) => device_provider,
             };
 
-            let imp = DeviceProvider::from_instance(&device_provider);
+            let imp = DeviceProvider::from_obj(&device_provider);
             {
                 let mut find_guard = imp.find.lock().unwrap();
                 if find_guard.is_some() {
-                    gst_log!(CAT, obj: &device_provider, "Already started");
+                    log!(CAT, obj = &device_provider, "Already started");
                     return;
                 }
 
                 let find = match ndi::FindInstance::builder().build() {
                     None => {
-                        gst_error!(CAT, obj: &device_provider, "Failed to create Find instance");
+                        error!(CAT, obj = &device_provider, "Failed to create Find instance");
                         return;
                     }
                     Some(find) => find,
@@ -110,7 +111,7 @@ impl DeviceProviderImpl for DeviceProvider {
                     Some(device_provider) => device_provider,
                 };
 
-                let imp = DeviceProvider::from_instance(&device_provider);
+                let imp = DeviceProvider::from_obj(&device_provider);
                 if !imp.is_running.load(atomic::Ordering::SeqCst) {
                     break;
                 }
@@ -123,7 +124,7 @@ impl DeviceProviderImpl for DeviceProvider {
         Ok(())
     }
 
-    fn stop(&self, _device_provider: &Self::Type) {
+    fn stop(&self) {
         if let Some(_thread) = self.thread.lock().unwrap().take() {
             self.is_running.store(false, atomic::Ordering::SeqCst);
             // Don't actually join because that might take a while
@@ -140,7 +141,7 @@ impl DeviceProvider {
         };
 
         if !find.wait_for_sources(if first { 1000 } else { 5000 }) {
-            gst_trace!(CAT, obj: device_provider, "No new sources found");
+            trace!(CAT, obj = device_provider, "No new sources found");
             return;
         }
 
@@ -153,13 +154,13 @@ impl DeviceProvider {
 
         // First check for each device we previously knew if it's still available
         for old_device in &*current_devices_guard {
-            let old_device_imp = Device::from_instance(old_device);
+            let old_device_imp = Device::from_obj(old_device);
             let old_source = old_device_imp.source.get().unwrap();
 
             if !sources.contains(&*old_source) {
-                gst_log!(
+                log!(
                     CAT,
-                    obj: device_provider,
+                    obj = device_provider,
                     "Source {:?} disappeared",
                     old_source
                 );
@@ -184,7 +185,7 @@ impl DeviceProvider {
 
         // Now go through all new devices and announce them
         for source in sources {
-            gst_log!(CAT, obj: device_provider, "Source {:?} appeared", source);
+            log!(CAT, obj = device_provider, "Source {:?} appeared", source);
             let device = super::Device::new(&source);
             device_provider.device_add(&device);
             current_devices_guard.push(device);
@@ -217,21 +218,16 @@ impl GstObjectImpl for Device {}
 impl DeviceImpl for Device {
     fn create_element(
         &self,
-        _device: &Self::Type,
         name: Option<&str>,
     ) -> Result<gst::Element, gst::LoggableError> {
         let source_info = self.source.get().unwrap();
-        let element = glib::Object::with_type(
-            crate::ndisrc::NdiSrc::static_type(),
-            &[
-                ("name", &name),
-                ("ndi-name", &source_info.ndi_name()),
-                ("url-address", &source_info.url_address()),
-            ],
-        )
-        .unwrap()
-        .dynamic_cast::<gst::Element>()
-        .unwrap();
+        let element = glib::Object::builder_with_type(crate::ndisrc::NdiSrc::static_type())
+            .property("name", &name)
+            .property("ndi-name", &source_info.ndi_name())
+            .property("url-address", &source_info.url_address())
+            .build()
+            .dynamic_cast::<gst::Element>()
+            .unwrap();
 
         Ok(element)
     }
@@ -253,14 +249,13 @@ impl super::Device {
             .field("url-address", &source.url_address())
             .build();
 
-        let device = glib::Object::new::<super::Device>(&[
-            ("caps", &caps),
-            ("display-name", &display_name),
-            ("device-class", &device_class),
-            ("properties", &extra_properties),
-        ])
-        .unwrap();
-        let device_impl = Device::from_instance(&device);
+        let device = glib::Object::builder::<super::Device>()
+            .property("caps", &caps)
+            .property("display-name", &display_name)
+            .property("device-class", &device_class)
+            .property("properties", &extra_properties)
+            .build();
+        let device_impl = Device::from_obj(&device);
 
         device_impl.source.set(source.to_owned()).unwrap();
 

src/device_provider/mod.rs

@@ -20,7 +20,7 @@ pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
     gst::DeviceProvider::register(
         Some(plugin),
         "ndideviceprovider",
-        gst::Rank::Primary,
+        gst::Rank::PRIMARY,
         DeviceProvider::static_type(),
     )
 }

src/lib.rs

@@ -141,10 +141,10 @@ static DEFAULT_RECEIVER_NDI_NAME: Lazy<String> = Lazy::new(|| {
 
 #[cfg(feature = "reference-timestamps")]
 static TIMECODE_CAPS: Lazy<gst::Caps> =
-    Lazy::new(|| gst::Caps::new_simple("timestamp/x-ndi-timecode", &[]));
+    Lazy::new(|| gst::Caps::new_empty_simple("timestamp/x-ndi-timecode"));
 #[cfg(feature = "reference-timestamps")]
 static TIMESTAMP_CAPS: Lazy<gst::Caps> =
-    Lazy::new(|| gst::Caps::new_simple("timestamp/x-ndi-timestamp", &[]));
+    Lazy::new(|| gst::Caps::new_empty_simple("timestamp/x-ndi-timestamp"));
 
 gst::plugin_define!(
     ndi,

src/ndi.rs

@@ -5,6 +5,7 @@ use std::mem;
 use std::ptr;
 
 use byte_slice_cast::*;
+use gst_video::VideoFrameExt as _;
 
 pub fn initialize() -> bool {
     unsafe { NDIlib_initialize() }

src/ndisink/imp.rs

@@ -1,7 +1,7 @@
 use glib::subclass::prelude::*;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{gst_debug, gst_error, gst_info, gst_trace};
+use gst::{debug, error, info, trace};
 use gst_base::prelude::*;
 use gst_base::subclass::prelude::*;
 
@@ -64,21 +64,20 @@ impl ObjectSubclass for NdiSink {
 impl ObjectImpl for NdiSink {
     fn properties() -> &'static [glib::ParamSpec] {
         static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
-            vec![glib::ParamSpecString::new(
-                "ndi-name",
-                "NDI Name",
-                "NDI Name to use",
-                Some(DEFAULT_SENDER_NDI_NAME.as_ref()),
-                glib::ParamFlags::READWRITE,
-            )]
+            vec![glib::ParamSpecString::builder("ndi-name")
+                .nick("NDI Name")
+                .blurb("NDI Name to use")
+                .default_value(Some(DEFAULT_SENDER_NDI_NAME.as_ref()))
+                .flags(glib::ParamFlags::READWRITE)
+                .build()
+            ]
         });
 
         PROPERTIES.as_ref()
     }
 
     fn set_property(
         &self,
-        _obj: &Self::Type,
         _id: usize,
         value: &glib::Value,
         pspec: &glib::ParamSpec,
@@ -94,7 +93,7 @@ impl ObjectImpl for NdiSink {
         };
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "ndi-name" => {
                 let settings = self.settings.lock().unwrap();
@@ -176,7 +175,8 @@ impl ElementImpl for NdiSink {
 }
 
 impl BaseSinkImpl for NdiSink {
-    fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn start(&self) -> Result<(), gst::ErrorMessage> {
+        let element = self.obj();
         let mut state_storage = self.state.lock().unwrap();
         let settings = self.settings.lock().unwrap();
 
@@ -195,30 +195,30 @@ impl BaseSinkImpl for NdiSink {
             audio_info: None,
         };
         *state_storage = Some(state);
-        gst_info!(CAT, obj: element, "Started");
+        info!(CAT, obj = element, "Started");
 
         Ok(())
     }
 
-    fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         let mut state_storage = self.state.lock().unwrap();
 
         *state_storage = None;
-        gst_info!(CAT, obj: element, "Stopped");
+        info!(CAT, obj = self.obj(), "Stopped");
 
         Ok(())
     }
 
-    fn unlock(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn unlock(&self) -> Result<(), gst::ErrorMessage> {
         Ok(())
     }
 
-    fn unlock_stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn unlock_stop(&self) -> Result<(), gst::ErrorMessage> {
         Ok(())
     }
 
-    fn set_caps(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
-        gst_debug!(CAT, obj: element, "Setting caps {}", caps);
+    fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
+        debug!(CAT, obj = self.obj(), "Setting caps {}", caps);
 
         let mut state_storage = self.state.lock().unwrap();
         let state = match &mut *state_storage {
@@ -246,9 +246,9 @@ impl BaseSinkImpl for NdiSink {
 
     fn render(
         &self,
-        element: &Self::Type,
         buffer: &gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
+        let element = self.obj();
         let mut state_storage = self.state.lock().unwrap();
         let state = match &mut *state_storage {
             None => return Err(gst::FlowError::Error),
@@ -260,13 +260,13 @@ impl BaseSinkImpl for NdiSink {
                 for (buffer, info, timecode) in audio_meta.buffers() {
                     let frame = crate::ndi::AudioFrame::try_from_buffer(info, buffer, *timecode)
                         .map_err(|_| {
-                            gst_error!(CAT, obj: element, "Unsupported audio frame");
+                            error!(CAT, obj = element, "Unsupported audio frame");
                             gst::FlowError::NotNegotiated
                         })?;
 
-                    gst_trace!(
+                    trace!(
                         CAT,
-                        obj: element,
+                        obj = element,
                         "Sending audio buffer {:?} with timecode {} and format {:?}",
                         buffer,
                         if *timecode < 0 {
@@ -297,19 +297,19 @@ impl BaseSinkImpl for NdiSink {
 
                 let frame = gst_video::VideoFrameRef::from_buffer_ref_readable(buffer, info)
                     .map_err(|_| {
-                        gst_error!(CAT, obj: element, "Failed to map buffer");
+                        error!(CAT, obj = element, "Failed to map buffer");
                         gst::FlowError::Error
                     })?;
 
                 let frame = crate::ndi::VideoFrame::try_from_video_frame(&frame, timecode)
                     .map_err(|_| {
-                        gst_error!(CAT, obj: element, "Unsupported video frame");
+                        error!(CAT, obj = element, "Unsupported video frame");
                         gst::FlowError::NotNegotiated
                     })?;
 
-                gst_trace!(
+                trace!(
                     CAT,
-                    obj: element,
+                    obj = element,
                     "Sending video buffer {:?} with timecode {} and format {:?}",
                     buffer,
                     if timecode < 0 {
@@ -337,13 +337,13 @@ impl BaseSinkImpl for NdiSink {
 
             let frame =
                 crate::ndi::AudioFrame::try_from_buffer(info, buffer, timecode).map_err(|_| {
-                    gst_error!(CAT, obj: element, "Unsupported audio frame");
+                    error!(CAT, obj = element, "Unsupported audio frame");
                     gst::FlowError::NotNegotiated
                 })?;
 
-            gst_trace!(
+            trace!(
                 CAT,
-                obj: element,
+                obj = element,
                 "Sending audio buffer {:?} with timecode {} and format {:?}",
                 buffer,
                 if timecode < 0 {

src/ndisink/mod.rs

@@ -13,7 +13,7 @@ pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
     gst::Element::register(
         Some(plugin),
         "ndisink",
-        gst::Rank::None,
+        gst::Rank::NONE,
         NdiSink::static_type(),
     )
 }