Fix various compiler warnings

9 files changed, 38 insertions, 43 deletions

diff --git a/gst-plugin-threadshare/src/appsrc.rs b/gst-plugin-threadshare/src/appsrc.rs
index 759651594..769d37a78 100644
--- a/gst-plugin-threadshare/src/appsrc.rs
+++ b/gst-plugin-threadshare/src/appsrc.rs
@@ -608,23 +608,23 @@ impl ObjectImpl for AppSrc {
 
         match *prop {
             subclass::Property("context", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context.to_value())
             }
             subclass::Property("context-wait", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context_wait.to_value())
             }
             subclass::Property("caps", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.caps.to_value())
             }
             subclass::Property("max-buffers", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.max_buffers.to_value())
             }
             subclass::Property("do-timestamp", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.do_timestamp.to_value())
             }
             _ => unimplemented!(),
diff --git a/gst-plugin-threadshare/src/lib.rs b/gst-plugin-threadshare/src/lib.rs
index 7e632f4ba..cf9fe17c2 100644
--- a/gst-plugin-threadshare/src/lib.rs
+++ b/gst-plugin-threadshare/src/lib.rs
@@ -89,7 +89,6 @@ pub fn set_element_flags<T: glib::IsA<gst::Object> + glib::IsA<gst::Element>>(
 ) {
     unsafe {
         use glib::translate::ToGlib;
-        use gst_ffi;
 
         let ptr: *mut gst_ffi::GstObject = element.as_ptr() as *mut _;
         let _guard = MutexGuard::lock(&(*ptr).lock);
diff --git a/gst-plugin-threadshare/src/proxy.rs b/gst-plugin-threadshare/src/proxy.rs
index 54110479b..55a194c09 100644
--- a/gst-plugin-threadshare/src/proxy.rs
+++ b/gst-plugin-threadshare/src/proxy.rs
@@ -174,7 +174,7 @@ impl SharedQueue {
         if let Some(context) = contexts.get(name) {
             if let Some(context) = context.upgrade() {
                 {
-                    let mut inner = context.lock().unwrap();
+                    let inner = context.lock().unwrap();
                     if (inner.have_sink && as_sink) || (inner.have_src && !as_sink) {
                         return None;
                     }
@@ -722,7 +722,7 @@ impl ObjectImpl for ProxySink {
 
         match *prop {
             subclass::Property("proxy-context", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.proxy_context.to_value())
             }
             _ => unimplemented!(),
@@ -1270,27 +1270,27 @@ impl ObjectImpl for ProxySrc {
 
         match *prop {
             subclass::Property("max-size-buffers", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.max_size_buffers.to_value())
             }
             subclass::Property("max-size-bytes", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.max_size_bytes.to_value())
             }
             subclass::Property("max-size-time", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.max_size_time.to_value())
             }
             subclass::Property("context", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context.to_value())
             }
             subclass::Property("context-wait", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context_wait.to_value())
             }
             subclass::Property("proxy-context", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.proxy_context.to_value())
             }
             _ => unimplemented!(),
diff --git a/gst-plugin-threadshare/src/queue.rs b/gst-plugin-threadshare/src/queue.rs
index 8c3e64aa4..7d2b32dde 100644
--- a/gst-plugin-threadshare/src/queue.rs
+++ b/gst-plugin-threadshare/src/queue.rs
@@ -890,23 +890,23 @@ impl ObjectImpl for Queue {
 
         match *prop {
             subclass::Property("max-size-buffers", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.max_size_buffers.to_value())
             }
             subclass::Property("max-size-bytes", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.max_size_bytes.to_value())
             }
             subclass::Property("max-size-time", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.max_size_time.to_value())
             }
             subclass::Property("context", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context.to_value())
             }
             subclass::Property("context-wait", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context_wait.to_value())
             }
             _ => unimplemented!(),
diff --git a/gst-plugin-threadshare/src/socket.rs b/gst-plugin-threadshare/src/socket.rs
index eea59921b..4acf5df3b 100644
--- a/gst-plugin-threadshare/src/socket.rs
+++ b/gst-plugin-threadshare/src/socket.rs
@@ -250,7 +250,7 @@ impl<T: SocketRead + 'static> Stream for SocketStream<T> {
 
         gst_debug!(SOCKET_CAT, obj: &inner.element, "Trying to read data");
         let (len, saddr, time) = {
-            let mut buffer = match self.1 {
+            let buffer = match self.1 {
                 Some(ref mut buffer) => buffer,
                 None => match inner.buffer_pool.acquire_buffer(None) {
                     Ok(buffer) => {
diff --git a/gst-plugin-threadshare/src/tcpclientsrc.rs b/gst-plugin-threadshare/src/tcpclientsrc.rs
index 353699cd6..8c9ce721b 100644
--- a/gst-plugin-threadshare/src/tcpclientsrc.rs
+++ b/gst-plugin-threadshare/src/tcpclientsrc.rs
@@ -675,27 +675,27 @@ impl ObjectImpl for TcpClientSrc {
 
         match *prop {
             subclass::Property("address", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.address.to_value())
             }
             subclass::Property("port", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.port.to_value())
             }
             subclass::Property("caps", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.caps.to_value())
             }
             subclass::Property("chunk-size", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.chunk_size.to_value())
             }
             subclass::Property("context", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context.to_value())
             }
             subclass::Property("context-wait", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context_wait.to_value())
             }
             _ => unimplemented!(),
diff --git a/gst-plugin-threadshare/src/udpsrc.rs b/gst-plugin-threadshare/src/udpsrc.rs
index 381f4f8d3..46cf3ade7 100644
--- a/gst-plugin-threadshare/src/udpsrc.rs
+++ b/gst-plugin-threadshare/src/udpsrc.rs
@@ -97,8 +97,6 @@ impl GioSocketWrapper {
 
     #[cfg(unix)]
     fn get<T: FromRawFd>(&self) -> T {
-        use libc;
-
         unsafe { FromRawFd::from_raw_fd(libc::dup(gio_ffi::g_socket_get_fd(self.socket))) }
     }
 
@@ -699,8 +697,6 @@ impl UdpSrc {
             // Store the socket as used-socket in the settings
             #[cfg(unix)]
             unsafe {
-                use libc;
-
                 let fd = libc::dup(socket.as_raw_fd());
 
                 // This is unsafe because it allows us to share the fd between the socket and the
@@ -1034,27 +1030,27 @@ impl ObjectImpl for UdpSrc {
 
         match *prop {
             subclass::Property("address", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.address.to_value())
             }
             subclass::Property("port", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.port.to_value())
             }
             subclass::Property("reuse", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.reuse.to_value())
             }
             subclass::Property("caps", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.caps.to_value())
             }
             subclass::Property("mtu", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.mtu.to_value())
             }
             subclass::Property("socket", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings
                     .socket
                     .as_ref()
@@ -1062,7 +1058,7 @@ impl ObjectImpl for UdpSrc {
                     .to_value())
             }
             subclass::Property("used-socket", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings
                     .used_socket
                     .as_ref()
@@ -1070,15 +1066,15 @@ impl ObjectImpl for UdpSrc {
                     .to_value())
             }
             subclass::Property("context", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context.to_value())
             }
             subclass::Property("context-wait", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.context_wait.to_value())
             }
             subclass::Property("retrieve-sender-address", ..) => {
-                let mut settings = self.settings.lock().unwrap();
+                let settings = self.settings.lock().unwrap();
                 Ok(settings.retrieve_sender_address.to_value())
             }
             _ => unimplemented!(),
diff --git a/gst-plugin-togglerecord/examples/gtk_recording.rs b/gst-plugin-togglerecord/examples/gtk_recording.rs
index 06c2e93fc..2b00c8838 100644
--- a/gst-plugin-togglerecord/examples/gtk_recording.rs
+++ b/gst-plugin-togglerecord/examples/gtk_recording.rs
@@ -334,7 +334,7 @@ fn create_ui(app: &gtk::Application) {
     app.connect_shutdown(move |_| {
         pipeline.set_state(gst::State::Null).unwrap();
 
-        bus.remove_watch();
+        bus.remove_watch().unwrap();
 
         if let Some(timeout_id) = timeout_id.borrow_mut().take() {
             glib::source_remove(timeout_id);
diff --git a/gst-plugin-togglerecord/src/togglerecord.rs b/gst-plugin-togglerecord/src/togglerecord.rs
index 95b338d6a..b05321ade 100644
--- a/gst-plugin-togglerecord/src/togglerecord.rs
+++ b/gst-plugin-togglerecord/src/togglerecord.rs
@@ -350,8 +350,8 @@ impl ToggleRecord {
 
                 let mut rec_state = self.state.lock();
                 rec_state.recording_state = RecordingState::Stopped;
-                rec_state.recording_duration +=
-                    rec_state.last_recording_stop - rec_state.last_recording_start;
+                let advance_by = rec_state.last_recording_stop - rec_state.last_recording_start;
+                rec_state.recording_duration += advance_by;
                 rec_state.last_recording_start = gst::CLOCK_TIME_NONE;
                 rec_state.last_recording_stop = gst::CLOCK_TIME_NONE;