From 0e11ac87d3fccaaacefbcc27a4165b344503fa04 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Laignel?= Date: Tue, 13 Aug 2019 00:45:36 +0200 Subject: [PATCH] Update for new `{Value, StructureRef}::get` signature See https://github.com/gtk-rs/glib/pull/513 and https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/merge_requests/310 --- gst-plugin-audiofx/src/audioecho.rs | 8 ++--- gst-plugin-closedcaption/src/mcc_enc.rs | 29 ++++++++++------ gst-plugin-closedcaption/src/scc_enc.rs | 12 ++++--- gst-plugin-file/src/filesink.rs | 5 +-- gst-plugin-file/src/filesrc.rs | 5 +-- gst-plugin-rav1e/src/rav1enc.rs | 21 +++++++----- gst-plugin-reqwest/src/reqwesthttpsrc.rs | 31 +++++++++++------ gst-plugin-s3/src/s3sink.rs | 14 +++++--- gst-plugin-s3/src/s3src.rs | 18 +++++++--- gst-plugin-sodium/src/decrypter.rs | 4 +-- gst-plugin-sodium/src/encrypter.rs | 6 ++-- gst-plugin-threadshare/src/appsrc.rs | 28 +++++++++++----- gst-plugin-threadshare/src/proxy.rs | 33 ++++++++++++++----- gst-plugin-threadshare/src/queue.rs | 23 +++++++++---- gst-plugin-threadshare/src/tcpclientsrc.rs | 15 +++++---- gst-plugin-threadshare/src/udpsrc.rs | 20 ++++++----- gst-plugin-threadshare/tests/appsrc.rs | 4 +-- gst-plugin-threadshare/tests/proxy.rs | 1 + gst-plugin-threadshare/tests/queue.rs | 1 + gst-plugin-threadshare/tests/tcpclientsrc.rs | 1 + .../examples/gtk_recording.rs | 6 ++-- gst-plugin-togglerecord/src/togglerecord.rs | 2 +- gst-plugin-tutorial/src/progressbin.rs | 4 ++- gst-plugin-tutorial/src/rgb2gray.rs | 4 +-- gst-plugin-tutorial/src/sinesrc.rs | 10 +++--- 25 files changed, 199 insertions(+), 106 deletions(-) diff --git a/gst-plugin-audiofx/src/audioecho.rs b/gst-plugin-audiofx/src/audioecho.rs index 7f930981e..a33ede023 100644 --- a/gst-plugin-audiofx/src/audioecho.rs +++ b/gst-plugin-audiofx/src/audioecho.rs @@ -205,20 +205,20 @@ impl ObjectImpl for AudioEcho { subclass::Property("max-delay", ..) => { let mut settings = self.settings.lock().unwrap(); if self.state.lock().unwrap().is_none() { - settings.max_delay = value.get().unwrap(); + settings.max_delay = value.get_some().expect("type checked upstream"); } } subclass::Property("delay", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.delay = value.get().unwrap(); + settings.delay = value.get_some().expect("type checked upstream"); } subclass::Property("intensity", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.intensity = value.get().unwrap(); + settings.intensity = value.get_some().expect("type checked upstream"); } subclass::Property("feedback", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.feedback = value.get().unwrap(); + settings.feedback = value.get_some().expect("type checked upstream"); } _ => unimplemented!(), } diff --git a/gst-plugin-closedcaption/src/mcc_enc.rs b/gst-plugin-closedcaption/src/mcc_enc.rs index 27dcc144d..b7c3f9e33 100644 --- a/gst-plugin-closedcaption/src/mcc_enc.rs +++ b/gst-plugin-closedcaption/src/mcc_enc.rs @@ -21,6 +21,7 @@ use glib::subclass; use glib::subclass::prelude::*; use gst; use gst::prelude::*; +use gst::structure; use gst::subclass::prelude::*; use gst_video; @@ -139,11 +140,17 @@ impl MccEnc { .sinkpad .get_current_caps() .ok_or(gst::FlowError::NotNegotiated)?; - let framerate = caps + let framerate = match caps .get_structure(0) .unwrap() - .get::("framerate") - .ok_or(gst::FlowError::NotNegotiated)?; + .get_some::("framerate") + { + Ok(framerate) => framerate, + Err(structure::GetError::FieldNotFound { .. }) => { + return Err(gst::FlowError::NotNegotiated); + } + err => panic!("MccEnc::generate_headers caps: {:?}", err), + }; if framerate == gst::Fraction::new(60000, 1001) { buffer.extend_from_slice(PREAMBLE_V2); @@ -412,11 +419,13 @@ impl MccEnc { EventView::Caps(ev) => { let caps = ev.get_caps(); let s = caps.get_structure(0).unwrap(); - let framerate = if let Some(framerate) = s.get::("framerate") { - framerate - } else { - gst_error!(self.cat, obj: pad, "Caps without framerate"); - return false; + let framerate = match s.get_some::("framerate") { + Ok(framerate) => framerate, + Err(structure::GetError::FieldNotFound { .. }) => { + gst_error!(self.cat, obj: pad, "Caps without framerate"); + return false; + } + err => panic!("MccEnc::sink_event caps: {:?}", err), }; let mut state = self.state.lock().unwrap(); @@ -573,11 +582,11 @@ impl ObjectImpl for MccEnc { match *prop { subclass::Property("uuid", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.uuid = value.get(); + settings.uuid = value.get().expect("type checked upstream"); } subclass::Property("creation-date", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.creation_date = value.get(); + settings.creation_date = value.get().expect("type checked upstream"); } _ => unimplemented!(), } diff --git a/gst-plugin-closedcaption/src/scc_enc.rs b/gst-plugin-closedcaption/src/scc_enc.rs index 6ef34fc1f..0d5bf98eb 100644 --- a/gst-plugin-closedcaption/src/scc_enc.rs +++ b/gst-plugin-closedcaption/src/scc_enc.rs @@ -22,6 +22,7 @@ use glib::subclass; use glib::subclass::prelude::*; use gst; use gst::prelude::*; +use gst::structure; use gst::subclass::prelude::*; use gst_video::{self, ValidVideoTimeCode}; @@ -288,10 +289,13 @@ impl SccEnc { EventView::Caps(ev) => { let caps = ev.get_caps(); let s = caps.get_structure(0).unwrap(); - let framerate = s.get::("framerate"); - if framerate.is_none() { - gst_error!(CAT, obj: pad, "Caps without framerate"); - return false; + let framerate = match s.get_some::("framerate") { + Ok(framerate) => Some(framerate), + Err(structure::GetError::FieldNotFound { .. }) => { + gst_error!(CAT, obj: pad, "Caps without framerate"); + return false; + } + err => panic!("SccEnc::sink_event caps: {:?}", err), }; let mut state = self.state.lock().unwrap(); diff --git a/gst-plugin-file/src/filesink.rs b/gst-plugin-file/src/filesink.rs index c95a67fc3..c535356e9 100644 --- a/gst-plugin-file/src/filesink.rs +++ b/gst-plugin-file/src/filesink.rs @@ -166,9 +166,10 @@ impl ObjectImpl for FileSink { let element = obj.downcast_ref::().unwrap(); let res = match value.get::() { - Some(location) => FileLocation::try_from_path_str(location) + Ok(Some(location)) => FileLocation::try_from_path_str(location) .and_then(|file_location| self.set_location(&element, Some(file_location))), - None => self.set_location(&element, None), + Ok(None) => self.set_location(&element, None), + Err(_) => unreachable!("type checked upstream"), }; if let Err(err) = res { diff --git a/gst-plugin-file/src/filesrc.rs b/gst-plugin-file/src/filesrc.rs index 012821b4c..4684678cc 100644 --- a/gst-plugin-file/src/filesrc.rs +++ b/gst-plugin-file/src/filesrc.rs @@ -180,9 +180,10 @@ impl ObjectImpl for FileSrc { let element = obj.downcast_ref::().unwrap(); let res = match value.get::() { - Some(location) => FileLocation::try_from_path_str(location) + Ok(Some(location)) => FileLocation::try_from_path_str(location) .and_then(|file_location| self.set_location(&element, Some(file_location))), - None => self.set_location(&element, None), + Ok(None) => self.set_location(&element, None), + Err(_) => unreachable!("type checked upstream"), }; if let Err(err) = res { diff --git a/gst-plugin-rav1e/src/rav1enc.rs b/gst-plugin-rav1e/src/rav1enc.rs index d68b30853..234dee049 100644 --- a/gst-plugin-rav1e/src/rav1enc.rs +++ b/gst-plugin-rav1e/src/rav1enc.rs @@ -345,39 +345,42 @@ impl ObjectImpl for Rav1Enc { match *prop { subclass::Property("speed-preset", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.speed_preset = value.get().unwrap(); + settings.speed_preset = value.get_some().expect("type checked upstream"); } subclass::Property("low-latency", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.low_latency = value.get().unwrap(); + settings.low_latency = value.get_some().expect("type checked upstream"); } subclass::Property("min-key-frame-interval", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.min_key_frame_interval = value.get().unwrap(); + settings.min_key_frame_interval = value.get_some().expect("type checked upstream"); } subclass::Property("max-key-frame-interval", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.max_key_frame_interval = value.get().unwrap(); + settings.max_key_frame_interval = value.get_some().expect("type checked upstream"); } subclass::Property("bitrate", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.bitrate = value.get().unwrap(); + settings.bitrate = value.get_some().expect("type checked upstream"); } subclass::Property("quantizer", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.quantizer = value.get::().unwrap() as usize; + settings.quantizer = + value.get_some::().expect("type checked upstream") as usize; } subclass::Property("tile-cols-log2", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.tile_cols_log2 = value.get::().unwrap() as usize; + settings.tile_cols_log2 = + value.get_some::().expect("type checked upstream") as usize; } subclass::Property("tile-rows-log2", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.tile_rows_log2 = value.get::().unwrap() as usize; + settings.tile_rows_log2 = + value.get_some::().expect("type checked upstream") as usize; } subclass::Property("threads", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.threads = value.get::().unwrap() as usize; + settings.threads = value.get_some::().expect("type checked upstream") as usize; } _ => unimplemented!(), } diff --git a/gst-plugin-reqwest/src/reqwesthttpsrc.rs b/gst-plugin-reqwest/src/reqwesthttpsrc.rs index b98de48f2..bae94eba9 100644 --- a/gst-plugin-reqwest/src/reqwesthttpsrc.rs +++ b/gst-plugin-reqwest/src/reqwesthttpsrc.rs @@ -137,7 +137,11 @@ pub struct ReqwestHttpSrc { } impl ReqwestHttpSrc { - fn set_location(&self, _element: &gst_base::BaseSrc, uri: &str) -> Result<(), glib::Error> { + fn set_location( + &self, + _element: &gst_base::BaseSrc, + uri: Option<&str>, + ) -> Result<(), glib::Error> { let state = self.state.lock().unwrap(); if let State::Started { .. } = *state { return Err(glib::Error::new( @@ -148,6 +152,12 @@ impl ReqwestHttpSrc { let mut settings = self.settings.lock().unwrap(); + if uri.is_none() { + settings.location = DEFAULT_LOCATION; + return Ok(()); + } + + let uri = uri.unwrap(); let uri = Url::parse(uri).map_err(|err| { glib::Error::new( gst::URIError::BadUri, @@ -336,10 +346,8 @@ impl ObjectImpl for ReqwestHttpSrc { subclass::Property("location", ..) => { let element = obj.downcast_ref::().unwrap(); - let location = value.get::<&str>().unwrap(); - let res = self.set_location(element, location); - - if let Err(err) = res { + let location = value.get::<&str>().expect("type checked upstream"); + if let Err(err) = self.set_location(element, location) { gst_error!( self.cat, obj: element, @@ -350,22 +358,25 @@ impl ObjectImpl for ReqwestHttpSrc { } subclass::Property("user-agent", ..) => { let mut settings = self.settings.lock().unwrap(); - let user_agent = value.get().unwrap(); + let user_agent = value + .get() + .expect("type checked upstream") + .unwrap_or_else(|| DEFAULT_USER_AGENT.into()); settings.user_agent = user_agent; } subclass::Property("is-live", ..) => { let element = obj.downcast_ref::().unwrap(); - let is_live = value.get().unwrap(); + let is_live = value.get_some().expect("type checked upstream"); element.set_live(is_live); } subclass::Property("user-id", ..) => { let mut settings = self.settings.lock().unwrap(); - let user_id = value.get(); + let user_id = value.get().expect("type checked upstream"); settings.user_id = user_id; } subclass::Property("user-pw", ..) => { let mut settings = self.settings.lock().unwrap(); - let user_pw = value.get(); + let user_pw = value.get().expect("type checked upstream"); settings.user_pw = user_pw; } _ => unimplemented!(), @@ -613,7 +624,7 @@ impl URIHandlerImpl for ReqwestHttpSrc { fn set_uri(&self, element: &gst::URIHandler, uri: &str) -> Result<(), glib::Error> { let element = element.dynamic_cast_ref::().unwrap(); - self.set_location(&element, uri) + self.set_location(&element, Some(uri)) } fn get_uri_type() -> gst::URIType { diff --git a/gst-plugin-s3/src/s3sink.rs b/gst-plugin-s3/src/s3sink.rs index b173d8ccc..77d3a2a63 100644 --- a/gst-plugin-s3/src/s3sink.rs +++ b/gst-plugin-s3/src/s3sink.rs @@ -432,13 +432,19 @@ impl ObjectImpl for S3Sink { match *prop { subclass::Property("bucket", ..) => { - settings.bucket = value.get::(); + settings.bucket = value.get::().expect("type checked upstream"); } subclass::Property("key", ..) => { - settings.key = value.get::(); + settings.key = value.get::().expect("type checked upstream"); } subclass::Property("region", ..) => { - let region = Region::from_str(&value.get::().unwrap()).unwrap(); + let region = Region::from_str( + &value + .get::() + .expect("type checked upstream") + .expect("set_property(\"region\"): no value provided"), + ) + .unwrap(); if settings.region != region { let mut client = self.client.lock().unwrap(); std::mem::replace(&mut *client, S3Client::new(region.clone())); @@ -446,7 +452,7 @@ impl ObjectImpl for S3Sink { } } subclass::Property("part-size", ..) => { - settings.buffer_size = value.get::().unwrap(); + settings.buffer_size = value.get_some::().expect("type checked upstream"); } _ => unimplemented!(), } diff --git a/gst-plugin-s3/src/s3src.rs b/gst-plugin-s3/src/s3src.rs index 305cc39f2..d0ca98d97 100644 --- a/gst-plugin-s3/src/s3src.rs +++ b/gst-plugin-s3/src/s3src.rs @@ -69,7 +69,11 @@ impl S3Src { Ok(S3Client::new(url.region.clone())) } - fn set_uri(self: &S3Src, _: &gst_base::BaseSrc, url_str: &str) -> Result<(), glib::Error> { + fn set_uri( + self: &S3Src, + _: &gst_base::BaseSrc, + url_str: Option<&str>, + ) -> Result<(), glib::Error> { let state = self.state.lock().unwrap(); if let StreamingState::Started { .. } = *state { @@ -81,7 +85,13 @@ impl S3Src { let mut url = self.url.lock().unwrap(); - match parse_s3_url(&url_str) { + if url_str.is_none() { + *url = None; + return Ok(()); + } + + let url_str = url_str.unwrap(); + match parse_s3_url(url_str) { Ok(s3url) => { *url = Some(s3url); Ok(()) @@ -271,7 +281,7 @@ impl ObjectImpl for S3Src { match *prop { subclass::Property("uri", ..) => { - let _ = self.set_uri(basesrc, value.get().unwrap()); + let _ = self.set_uri(basesrc, value.get().expect("type checked upstream")); } _ => unimplemented!(), } @@ -314,7 +324,7 @@ impl URIHandlerImpl for S3Src { fn set_uri(&self, element: &gst::URIHandler, uri: &str) -> Result<(), glib::Error> { let basesrc = element.dynamic_cast_ref::().unwrap(); - self.set_uri(basesrc, uri) + self.set_uri(basesrc, Some(uri)) } fn get_uri_type() -> gst::URIType { diff --git a/gst-plugin-sodium/src/decrypter.rs b/gst-plugin-sodium/src/decrypter.rs index 20d8ae6c8..3859d723c 100644 --- a/gst-plugin-sodium/src/decrypter.rs +++ b/gst-plugin-sodium/src/decrypter.rs @@ -635,12 +635,12 @@ impl ObjectImpl for Decrypter { match *prop { subclass::Property("sender-key", ..) => { let mut props = self.props.lock().unwrap(); - props.sender_key = value.get(); + props.sender_key = value.get().expect("type checked upstream"); } subclass::Property("receiver-key", ..) => { let mut props = self.props.lock().unwrap(); - props.receiver_key = value.get(); + props.receiver_key = value.get().expect("type checked upstream"); } _ => unimplemented!(), diff --git a/gst-plugin-sodium/src/encrypter.rs b/gst-plugin-sodium/src/encrypter.rs index 495ac3fc4..60a6e01e8 100644 --- a/gst-plugin-sodium/src/encrypter.rs +++ b/gst-plugin-sodium/src/encrypter.rs @@ -488,17 +488,17 @@ impl ObjectImpl for Encrypter { match *prop { subclass::Property("sender-key", ..) => { let mut props = self.props.lock().unwrap(); - props.sender_key = value.get(); + props.sender_key = value.get().expect("type checked upstream"); } subclass::Property("receiver-key", ..) => { let mut props = self.props.lock().unwrap(); - props.receiver_key = value.get(); + props.receiver_key = value.get().expect("type checked upstream"); } subclass::Property("block-size", ..) => { let mut props = self.props.lock().unwrap(); - props.block_size = value.get().unwrap(); + props.block_size = value.get_some().expect("type checked upstream"); } _ => unimplemented!(), diff --git a/gst-plugin-threadshare/src/appsrc.rs b/gst-plugin-threadshare/src/appsrc.rs index f431919a3..883259e3e 100644 --- a/gst-plugin-threadshare/src/appsrc.rs +++ b/gst-plugin-threadshare/src/appsrc.rs @@ -519,8 +519,14 @@ impl ObjectSubclass for AppSrc { &[gst::Buffer::static_type()], bool::static_type(), |_, args| { - let element = args[0].get::().unwrap(); - let buffer = args[1].get::().unwrap(); + let element = args[0] + .get::() + .expect("signal arg") + .expect("missing signal arg"); + let buffer = args[1] + .get::() + .expect("signal arg") + .expect("missing signal arg"); let appsrc = Self::from_instance(&element); Some(appsrc.push_buffer(&element, buffer).to_value()) @@ -533,7 +539,10 @@ impl ObjectSubclass for AppSrc { &[], bool::static_type(), |_, args| { - let element = args[0].get::().unwrap(); + let element = args[0] + .get::() + .expect("signal arg") + .expect("missing signal arg"); let appsrc = Self::from_instance(&element); Some(appsrc.end_of_stream(&element).to_value()) }, @@ -581,23 +590,26 @@ impl ObjectImpl for AppSrc { match *prop { subclass::Property("context", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context = value.get().unwrap_or_else(|| "".into()); + settings.context = value + .get() + .expect("type checked upstream") + .unwrap_or_else(|| "".into()); } subclass::Property("context-wait", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context_wait = value.get().unwrap(); + settings.context_wait = value.get_some().expect("type checked upstream"); } subclass::Property("caps", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.caps = value.get(); + settings.caps = value.get().expect("type checked upstream"); } subclass::Property("max-buffers", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.max_buffers = value.get().unwrap(); + settings.max_buffers = value.get_some().expect("type checked upstream"); } subclass::Property("do-timestamp", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.do_timestamp = value.get().unwrap(); + settings.do_timestamp = value.get_some().expect("type checked upstream"); } _ => unimplemented!(), } diff --git a/gst-plugin-threadshare/src/proxy.rs b/gst-plugin-threadshare/src/proxy.rs index 98f35636a..ba1933d7c 100644 --- a/gst-plugin-threadshare/src/proxy.rs +++ b/gst-plugin-threadshare/src/proxy.rs @@ -529,8 +529,14 @@ impl ProxySink { let s = e.get_structure().unwrap(); if s.get_name() == "ts-io-context" { let mut state = self.state.lock().unwrap(); - let io_context = s.get::<&IOContext>("io-context").unwrap(); - let pending_future_id = s.get::<&PendingFutureId>("pending-future-id").unwrap(); + let io_context = s + .get::<&IOContext>("io-context") + .expect("signal arg") + .expect("missing signal arg"); + let pending_future_id = s + .get::<&PendingFutureId>("pending-future-id") + .expect("signal arg") + .expect("missing signal arg"); gst_debug!( self.cat, @@ -711,7 +717,10 @@ impl ObjectImpl for ProxySink { match *prop { subclass::Property("proxy-context", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.proxy_context = value.get().unwrap_or_else(|| "".into()); + settings.proxy_context = value + .get() + .expect("type checked upstream") + .unwrap_or_else(|| "".into()); } _ => unimplemented!(), } @@ -1239,27 +1248,33 @@ impl ObjectImpl for ProxySrc { match *prop { subclass::Property("max-size-buffers", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.max_size_buffers = value.get().unwrap(); + settings.max_size_buffers = value.get_some().expect("type checked upstream"); } subclass::Property("max-size-bytes", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.max_size_bytes = value.get().unwrap(); + settings.max_size_bytes = value.get_some().expect("type checked upstream"); } subclass::Property("max-size-time", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.max_size_time = value.get().unwrap(); + settings.max_size_time = value.get_some().expect("type checked upstream"); } subclass::Property("context", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context = value.get().unwrap_or_else(|| "".into()); + settings.context = value + .get() + .expect("type checked upstream") + .unwrap_or_else(|| "".into()); } subclass::Property("context-wait", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context_wait = value.get().unwrap(); + settings.context_wait = value.get_some().expect("type checked upstream"); } subclass::Property("proxy-context", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.proxy_context = value.get().unwrap_or_else(|| "".into()); + settings.proxy_context = value + .get() + .expect("type checked upstream") + .unwrap_or_else(|| "".into()); } _ => unimplemented!(), } diff --git a/gst-plugin-threadshare/src/queue.rs b/gst-plugin-threadshare/src/queue.rs index 25987baa8..6ac28a6d0 100644 --- a/gst-plugin-threadshare/src/queue.rs +++ b/gst-plugin-threadshare/src/queue.rs @@ -432,8 +432,14 @@ impl Queue { let s = e.get_structure().unwrap(); if s.get_name() == "ts-io-context" { let mut state = self.state.lock().unwrap(); - let io_context = s.get::<&IOContext>("io-context").unwrap(); - let pending_future_id = s.get::<&PendingFutureId>("pending-future-id").unwrap(); + let io_context = s + .get::<&IOContext>("io-context") + .expect("signal arg") + .expect("missing signal arg"); + let pending_future_id = s + .get::<&PendingFutureId>("pending-future-id") + .expect("signal arg") + .expect("missing signal arg"); gst_debug!( self.cat, @@ -918,23 +924,26 @@ impl ObjectImpl for Queue { match *prop { subclass::Property("max-size-buffers", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.max_size_buffers = value.get().unwrap(); + settings.max_size_buffers = value.get_some().expect("type checked upstream"); } subclass::Property("max-size-bytes", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.max_size_bytes = value.get().unwrap(); + settings.max_size_bytes = value.get_some().expect("type checked upstream"); } subclass::Property("max-size-time", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.max_size_time = value.get().unwrap(); + settings.max_size_time = value.get_some().expect("type checked upstream"); } subclass::Property("context", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context = value.get().unwrap_or_else(|| "".into()); + settings.context = value + .get() + .expect("type checked upstream") + .unwrap_or_else(|| "".into()); } subclass::Property("context-wait", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context_wait = value.get().unwrap(); + settings.context_wait = value.get_some().expect("type checked upstream"); } _ => unimplemented!(), } diff --git a/gst-plugin-threadshare/src/tcpclientsrc.rs b/gst-plugin-threadshare/src/tcpclientsrc.rs index be0bd7cdb..99a64abd2 100644 --- a/gst-plugin-threadshare/src/tcpclientsrc.rs +++ b/gst-plugin-threadshare/src/tcpclientsrc.rs @@ -640,27 +640,30 @@ impl ObjectImpl for TcpClientSrc { match *prop { subclass::Property("address", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.address = value.get(); + settings.address = value.get().expect("type checked upstream"); } subclass::Property("port", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.port = value.get().unwrap(); + settings.port = value.get_some().expect("type checked upstream"); } subclass::Property("caps", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.caps = value.get(); + settings.caps = value.get().expect("type checked upstream"); } subclass::Property("chunk-size", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.chunk_size = value.get().unwrap(); + settings.chunk_size = value.get_some().expect("type checked upstream"); } subclass::Property("context", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context = value.get().unwrap_or_else(|| "".into()); + settings.context = value + .get() + .expect("type checked upstream") + .unwrap_or_else(|| "".into()); } subclass::Property("context-wait", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context_wait = value.get().unwrap(); + settings.context_wait = value.get_some().expect("type checked upstream"); } _ => unimplemented!(), } diff --git a/gst-plugin-threadshare/src/udpsrc.rs b/gst-plugin-threadshare/src/udpsrc.rs index 8cb2a80fa..b83d5cd9c 100644 --- a/gst-plugin-threadshare/src/udpsrc.rs +++ b/gst-plugin-threadshare/src/udpsrc.rs @@ -979,28 +979,29 @@ impl ObjectImpl for UdpSrc { match *prop { subclass::Property("address", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.address = value.get(); + settings.address = value.get().expect("type checked upstream"); } subclass::Property("port", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.port = value.get().unwrap(); + settings.port = value.get_some().expect("type checked upstream"); } subclass::Property("reuse", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.reuse = value.get().unwrap(); + settings.reuse = value.get_some().expect("type checked upstream"); } subclass::Property("caps", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.caps = value.get(); + settings.caps = value.get().expect("type checked upstream"); } subclass::Property("mtu", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.mtu = value.get().unwrap(); + settings.mtu = value.get_some().expect("type checked upstream"); } subclass::Property("socket", ..) => { let mut settings = self.settings.lock().unwrap(); settings.socket = value .get::() + .expect("type checked upstream") .map(|socket| GioSocketWrapper::new(&socket)); } subclass::Property("used-socket", ..) => { @@ -1008,15 +1009,18 @@ impl ObjectImpl for UdpSrc { } subclass::Property("context", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context = value.get().unwrap_or_else(|| "".into()); + settings.context = value + .get() + .expect("type checked upstream") + .unwrap_or_else(|| "".into()); } subclass::Property("context-wait", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.context_wait = value.get().unwrap(); + settings.context_wait = value.get_some().expect("type checked upstream"); } subclass::Property("retrieve-sender-address", ..) => { let mut settings = self.settings.lock().unwrap(); - settings.retrieve_sender_address = value.get().unwrap(); + settings.retrieve_sender_address = value.get_some().expect("type checked upstream"); } _ => unimplemented!(), } diff --git a/gst-plugin-threadshare/tests/appsrc.rs b/gst-plugin-threadshare/tests/appsrc.rs index 8c4d23334..fd17eba56 100644 --- a/gst-plugin-threadshare/tests/appsrc.rs +++ b/gst-plugin-threadshare/tests/appsrc.rs @@ -56,7 +56,7 @@ fn test_push() { .emit("push-buffer", &[&gst::Buffer::new()]) .unwrap() .unwrap() - .get::() + .get_some::() .unwrap()); } @@ -64,7 +64,7 @@ fn test_push() { .emit("end-of-stream", &[]) .unwrap() .unwrap() - .get::() + .get_some::() .unwrap()); } diff --git a/gst-plugin-threadshare/tests/proxy.rs b/gst-plugin-threadshare/tests/proxy.rs index e0b713462..d20bb3073 100644 --- a/gst-plugin-threadshare/tests/proxy.rs +++ b/gst-plugin-threadshare/tests/proxy.rs @@ -69,6 +69,7 @@ fn test_push() { .unwrap() .unwrap() .get::() + .unwrap() .unwrap(); samples_clone.lock().unwrap().push(sample); diff --git a/gst-plugin-threadshare/tests/queue.rs b/gst-plugin-threadshare/tests/queue.rs index 276c4ed17..33c211f9d 100644 --- a/gst-plugin-threadshare/tests/queue.rs +++ b/gst-plugin-threadshare/tests/queue.rs @@ -64,6 +64,7 @@ fn test_push() { .unwrap() .unwrap() .get::() + .unwrap() .unwrap(); samples_clone.lock().unwrap().push(sample); diff --git a/gst-plugin-threadshare/tests/tcpclientsrc.rs b/gst-plugin-threadshare/tests/tcpclientsrc.rs index 0a509c55d..972f90063 100644 --- a/gst-plugin-threadshare/tests/tcpclientsrc.rs +++ b/gst-plugin-threadshare/tests/tcpclientsrc.rs @@ -85,6 +85,7 @@ fn test_push() { .unwrap() .unwrap() .get::() + .unwrap() .unwrap(); let mut samples = samples_clone.lock().unwrap(); diff --git a/gst-plugin-togglerecord/examples/gtk_recording.rs b/gst-plugin-togglerecord/examples/gtk_recording.rs index 2f1ef403b..ff87f512e 100644 --- a/gst-plugin-togglerecord/examples/gtk_recording.rs +++ b/gst-plugin-togglerecord/examples/gtk_recording.rs @@ -62,11 +62,11 @@ fn create_pipeline() -> ( glsinkbin.set_property("sink", >kglsink).unwrap(); let widget = gtkglsink.get_property("widget").unwrap(); - (glsinkbin, widget.get::().unwrap()) + (glsinkbin, widget.get::().unwrap().unwrap()) } else { let sink = gst::ElementFactory::make("gtksink", None).unwrap(); let widget = sink.get_property("widget").unwrap(); - (sink, widget.get::().unwrap()) + (sink, widget.get::().unwrap().unwrap()) }; let video_enc = gst::ElementFactory::make("x264enc", None).unwrap(); @@ -268,7 +268,7 @@ fn create_ui(app: >k::Application) { let recording = !togglerecord .get_property("record") .unwrap() - .get::() + .get_some::() .unwrap(); togglerecord.set_property("record", &recording).unwrap(); diff --git a/gst-plugin-togglerecord/src/togglerecord.rs b/gst-plugin-togglerecord/src/togglerecord.rs index 9f7b4dc2c..d4cc0109e 100644 --- a/gst-plugin-togglerecord/src/togglerecord.rs +++ b/gst-plugin-togglerecord/src/togglerecord.rs @@ -1581,7 +1581,7 @@ impl ObjectImpl for ToggleRecord { match *prop { subclass::Property("record", ..) => { let mut settings = self.settings.lock(); - let record = value.get().unwrap(); + let record = value.get_some().expect("type checked upstream"); gst_debug!( self.cat, obj: element, diff --git a/gst-plugin-tutorial/src/progressbin.rs b/gst-plugin-tutorial/src/progressbin.rs index 4d4da97fe..344059a4c 100644 --- a/gst-plugin-tutorial/src/progressbin.rs +++ b/gst-plugin-tutorial/src/progressbin.rs @@ -164,7 +164,9 @@ impl BinImpl for ProgressBin { .unwrap_or(false) => { let s = msg.get_structure().unwrap(); - let percent = s.get::("percent-double").unwrap(); + let percent = s + .get_some::("percent-double") + .expect("ProgressBin::handle_message"); println!("progress: {:5.1}%", percent); } diff --git a/gst-plugin-tutorial/src/rgb2gray.rs b/gst-plugin-tutorial/src/rgb2gray.rs index ef2edc8ce..831822600 100644 --- a/gst-plugin-tutorial/src/rgb2gray.rs +++ b/gst-plugin-tutorial/src/rgb2gray.rs @@ -249,7 +249,7 @@ impl ObjectImpl for Rgb2Gray { match *prop { subclass::Property("invert", ..) => { let mut settings = self.settings.lock().unwrap(); - let invert = value.get().unwrap(); + let invert = value.get_some().expect("type checked upstream"); gst_info!( self.cat, obj: element, @@ -261,7 +261,7 @@ impl ObjectImpl for Rgb2Gray { } subclass::Property("shift", ..) => { let mut settings = self.settings.lock().unwrap(); - let shift = value.get().unwrap(); + let shift = value.get_some().expect("type checked upstream"); gst_info!( self.cat, obj: element, diff --git a/gst-plugin-tutorial/src/sinesrc.rs b/gst-plugin-tutorial/src/sinesrc.rs index a8856709e..589bac960 100644 --- a/gst-plugin-tutorial/src/sinesrc.rs +++ b/gst-plugin-tutorial/src/sinesrc.rs @@ -304,7 +304,7 @@ impl ObjectImpl for SineSrc { match *prop { subclass::Property("samples-per-buffer", ..) => { let mut settings = self.settings.lock().unwrap(); - let samples_per_buffer = value.get().unwrap(); + let samples_per_buffer = value.get_some().expect("type checked upstream"); gst_info!( self.cat, obj: basesrc, @@ -320,7 +320,7 @@ impl ObjectImpl for SineSrc { } subclass::Property("freq", ..) => { let mut settings = self.settings.lock().unwrap(); - let freq = value.get().unwrap(); + let freq = value.get_some().expect("type checked upstream"); gst_info!( self.cat, obj: basesrc, @@ -332,7 +332,7 @@ impl ObjectImpl for SineSrc { } subclass::Property("volume", ..) => { let mut settings = self.settings.lock().unwrap(); - let volume = value.get().unwrap(); + let volume = value.get_some().expect("type checked upstream"); gst_info!( self.cat, obj: basesrc, @@ -344,7 +344,7 @@ impl ObjectImpl for SineSrc { } subclass::Property("mute", ..) => { let mut settings = self.settings.lock().unwrap(); - let mute = value.get().unwrap(); + let mute = value.get_some().expect("type checked upstream"); gst_info!( self.cat, obj: basesrc, @@ -356,7 +356,7 @@ impl ObjectImpl for SineSrc { } subclass::Property("is-live", ..) => { let mut settings = self.settings.lock().unwrap(); - let is_live = value.get().unwrap(); + let is_live = value.get_some().expect("type checked upstream"); gst_info!( self.cat, obj: basesrc,