Run everything through rustfmt

gst-plugin-audiofx/src/audioecho.rs

@@ -163,7 +163,8 @@ impl AudioEcho {
     ) {
         let delay_frames = (settings.delay as usize)
             * (state.info.channels() as usize)
-            * (state.info.rate() as usize) / (gst::SECOND_VAL as usize);
+            * (state.info.rate() as usize)
+            / (gst::SECOND_VAL as usize);
 
         for (i, (o, e)) in data.iter_mut().zip(state.buffer.iter(delay_frames)) {
             let inp = (*i).to_f64().unwrap();

gst-plugin-flv/src/flvdemux.rs

@@ -619,7 +619,8 @@ impl FlvDemux {
             }
         }
 
-        if !streaming_state.got_all_streams && streaming_state.audio != None
+        if !streaming_state.got_all_streams
+            && streaming_state.audio != None
             && (streaming_state.expect_video && streaming_state.video != None
                 || !streaming_state.expect_video)
         {
@@ -795,7 +796,8 @@ impl FlvDemux {
             }
         }
 
-        if !streaming_state.got_all_streams && streaming_state.video != None
+        if !streaming_state.got_all_streams
+            && streaming_state.video != None
             && (streaming_state.expect_audio && streaming_state.audio != None
                 || !streaming_state.expect_audio)
         {

gst-plugin-simple/src/demuxer.rs

@@ -231,12 +231,16 @@ impl Demuxer {
 
         let event = gst::Event::new_eos().build();
         match index {
-            Some(index) => if let Some(pad) = srcpads.get(&index) {
+            Some(index) => {
-                pad.push_event(event);
+                if let Some(pad) = srcpads.get(&index) {
-            },
+                    pad.push_event(event);
-            None => for (_, pad) in srcpads.iter().by_ref() {
+                }
-                pad.push_event(event.clone());
+            }
-            },
+            None => {
+                for (_, pad) in srcpads.iter().by_ref() {
+                    pad.push_event(event.clone());
+                }
+            }
         };
     }
 
@@ -416,9 +420,11 @@ impl Demuxer {
                 HandleBufferResult::StreamChanged(stream) => {
                     demuxer.stream_format_changed(element, stream.index, stream.caps);
                 }
-                HandleBufferResult::StreamsChanged(streams) => for stream in streams {
+                HandleBufferResult::StreamsChanged(streams) => {
-                    demuxer.stream_format_changed(element, stream.index, stream.caps);
+                    for stream in streams {
-                },
+                        demuxer.stream_format_changed(element, stream.index, stream.caps);
+                    }
+                }
                 HandleBufferResult::BufferForStream(index, buffer) => {
                     let flow_ret = demuxer.stream_push_buffer(element, index, buffer);
 

gst-plugin-simple/src/sink.rs

@@ -124,7 +124,8 @@ impl Sink {
                 Err(err) => Err(UriError::new(
                     gst::URIError::BadUri,
                     format!("Failed to parse URI '{}': {}", uri_str, err),
-                ).into()),
+                )
+                .into()),
             }
         } else {
             Ok(())

gst-plugin-simple/src/source.rs

@@ -143,7 +143,8 @@ impl Source {
                 Err(err) => Err(UriError::new(
                     gst::URIError::BadUri,
                     format!("Failed to parse URI '{}': {}", uri_str, err),
-                ).into()),
+                )
+                .into()),
             }
         } else {
             Ok(())

gst-plugin-togglerecord/examples/gtk_recording.rs

@@ -139,7 +139,8 @@ fn create_pipeline() -> (
         &video_queue1,
         &video_convert1,
         &video_sink,
-    ]).unwrap();
+    ])
+    .unwrap();
 
     gst::Element::link_many(&[
         &video_tee,
@@ -147,7 +148,8 @@ fn create_pipeline() -> (
         &video_convert2,
         &video_enc,
         &video_parse,
-    ]).unwrap();
+    ])
+    .unwrap();
 
     video_parse.link_pads("src", &togglerecord, "sink").unwrap();
     togglerecord.link_pads("src", &mux_queue1, "sink").unwrap();
@@ -159,7 +161,8 @@ fn create_pipeline() -> (
         &audio_queue1,
         &audio_convert1,
         &audio_sink,
-    ]).unwrap();
+    ])
+    .unwrap();
 
     gst::Element::link_many(&[
         &audio_tee,
@@ -167,7 +170,8 @@ fn create_pipeline() -> (
         &audio_convert2,
         &audio_enc,
         &audio_parse,
-    ]).unwrap();
+    ])
+    .unwrap();
 
     audio_parse
         .link_pads("src", &togglerecord, "sink_0")

gst-plugin-togglerecord/src/togglerecord.rs

@@ -585,7 +585,8 @@ impl ToggleRecord {
 
         while (main_state.current_running_time == gst::CLOCK_TIME_NONE
             || main_state.current_running_time < current_running_time)
-            && !main_state.eos && !stream.state.lock().unwrap().flushing
+            && !main_state.eos
+            && !stream.state.lock().unwrap().flushing
         {
             gst_log!(
                 self.cat,
@@ -1138,36 +1139,40 @@ impl ToggleRecord {
                 return true;
             }
             // Position and duration is always the current recording position
-            QueryView::Position(ref mut q) => if q.get_format() == gst::Format::Time {
+            QueryView::Position(ref mut q) => {
-                let state = stream.state.lock().unwrap();
+                if q.get_format() == gst::Format::Time {
-                let rec_state = self.state.lock().unwrap();
+                    let state = stream.state.lock().unwrap();
-                let mut recording_duration = rec_state.recording_duration;
+                    let rec_state = self.state.lock().unwrap();
-                if rec_state.recording_state == RecordingState::Recording
+                    let mut recording_duration = rec_state.recording_duration;
-                    || rec_state.recording_state == RecordingState::Stopping
+                    if rec_state.recording_state == RecordingState::Recording
-                {
+                        || rec_state.recording_state == RecordingState::Stopping
-                    recording_duration +=
+                    {
-                        state.current_running_time - rec_state.last_recording_start;
+                        recording_duration +=
+                            state.current_running_time - rec_state.last_recording_start;
+                    }
+                    q.set(recording_duration);
+                    return true;
+                } else {
+                    return false;
                 }
-                q.set(recording_duration);
+            }
-                return true;
+            QueryView::Duration(ref mut q) => {
-            } else {
+                if q.get_format() == gst::Format::Time {
-                return false;
+                    let state = stream.state.lock().unwrap();
-            },
+                    let rec_state = self.state.lock().unwrap();
-            QueryView::Duration(ref mut q) => if q.get_format() == gst::Format::Time {
+                    let mut recording_duration = rec_state.recording_duration;
-                let state = stream.state.lock().unwrap();
+                    if rec_state.recording_state == RecordingState::Recording
-                let rec_state = self.state.lock().unwrap();
+                        || rec_state.recording_state == RecordingState::Stopping
-                let mut recording_duration = rec_state.recording_duration;
+                    {
-                if rec_state.recording_state == RecordingState::Recording
+                        recording_duration +=
-                    || rec_state.recording_state == RecordingState::Stopping
+                            state.current_running_time - rec_state.last_recording_start;
-                {
+                    }
-                    recording_duration +=
+                    q.set(recording_duration);
-                        state.current_running_time - rec_state.last_recording_start;
+                    return true;
+                } else {
+                    return false;
                 }
-                q.set(recording_duration);
+            }
-                return true;
-            } else {
-                return false;
-            },
             _ => (),
         };
 

gst-plugin-togglerecord/tests/tests.rs

@@ -148,37 +148,43 @@ fn setup_sender_receiver(
                 SendData::Eos => {
                     break;
                 }
-                SendData::Buffers(n) => for _ in 0..n {
+                SendData::Buffers(n) => {
-                    let mut buffer = gst::Buffer::new();
+                    for _ in 0..n {
-                    buffer
+                        let mut buffer = gst::Buffer::new();
-                        .get_mut()
+                        buffer
-                        .unwrap()
+                            .get_mut()
-                        .set_pts(offset + i * 20 * gst::MSECOND);
+                            .unwrap()
-                    buffer.get_mut().unwrap().set_duration(20 * gst::MSECOND);
+                            .set_pts(offset + i * 20 * gst::MSECOND);
-                    let _ = sinkpad.chain(buffer);
+                        buffer.get_mut().unwrap().set_duration(20 * gst::MSECOND);
-                    i += 1;
+                        let _ = sinkpad.chain(buffer);
-                },
+                        i += 1;
-                SendData::BuffersDelta(n) => for _ in 0..n {
+                    }
-                    let mut buffer = gst::Buffer::new();
+                }
-                    buffer
+                SendData::BuffersDelta(n) => {
-                        .get_mut()
+                    for _ in 0..n {
-                        .unwrap()
+                        let mut buffer = gst::Buffer::new();
-                        .set_pts(offset + i * 20 * gst::MSECOND);
+                        buffer
-                    buffer.get_mut().unwrap().set_duration(20 * gst::MSECOND);
+                            .get_mut()
-                    buffer
+                            .unwrap()
-                        .get_mut()
+                            .set_pts(offset + i * 20 * gst::MSECOND);
-                        .unwrap()
+                        buffer.get_mut().unwrap().set_duration(20 * gst::MSECOND);
-                        .set_flags(gst::BufferFlags::DELTA_UNIT);
+                        buffer
-                    let _ = sinkpad.chain(buffer);
+                            .get_mut()
-                    i += 1;
+                            .unwrap()
-                },
+                            .set_flags(gst::BufferFlags::DELTA_UNIT);
-                SendData::Gaps(n) => for _ in 0..n {
+                        let _ = sinkpad.chain(buffer);
-                    let event =
+                        i += 1;
-                        gst::Event::new_gap(offset + i * 20 * gst::MSECOND, 20 * gst::MSECOND)
+                    }
-                            .build();
+                }
-                    let _ = sinkpad.send_event(event);
+                SendData::Gaps(n) => {
-                    i += 1;
+                    for _ in 0..n {
-                },
+                        let event =
+                            gst::Event::new_gap(offset + i * 20 * gst::MSECOND, 20 * gst::MSECOND)
+                                .build();
+                        let _ = sinkpad.send_event(event);
+                        i += 1;
+                    }
+                }
             }
 
             let _ = sender_input_done.send(());

gst-plugin/src/aggregator.rs

@@ -540,7 +540,8 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), gst::FlowReturn::Error, {
         imp.flush(&wrap)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_clip<T: AggregatorBase>(
@@ -583,7 +584,8 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), gst::FlowReturn::Error, {
         imp.finish_buffer(&wrap, from_glib_full(buffer))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_sink_event<T: AggregatorBase>(
@@ -606,7 +608,8 @@ where
             &from_glib_borrow(aggregator_pad),
             from_glib_full(event),
         )
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_sink_query<T: AggregatorBase>(
@@ -629,7 +632,8 @@ where
             &from_glib_borrow(aggregator_pad),
             gst::QueryRef::from_mut_ptr(query),
         )
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_src_event<T: AggregatorBase>(
@@ -647,7 +651,8 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), false, {
         imp.src_event(&wrap, from_glib_full(event))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_src_query<T: AggregatorBase>(
@@ -665,7 +670,8 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), false, {
         imp.src_query(&wrap, gst::QueryRef::from_mut_ptr(query))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_src_activate<T: AggregatorBase>(
@@ -684,7 +690,8 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), false, {
         imp.src_activate(&wrap, from_glib(mode), from_glib(active))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_aggregate<T: AggregatorBase>(
@@ -702,7 +709,8 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), gst::FlowReturn::Error, {
         imp.aggregate(&wrap, from_glib(timeout))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_start<T: AggregatorBase>(
@@ -749,7 +757,8 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), gst::CLOCK_TIME_NONE, {
         imp.get_next_time(&wrap)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_create_new_pad<T: AggregatorBase>(
@@ -790,7 +799,8 @@ where
                 Some(gst::CapsRef::from_ptr(caps))
             },
         )
-    }).to_glib_full()
+    })
+    .to_glib_full()
 }
 
 unsafe extern "C" fn aggregator_update_src_caps<T: AggregatorBase>(
@@ -817,7 +827,8 @@ where
             }
             Err(err) => err,
         }
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn aggregator_fixate_src_caps<T: AggregatorBase>(
@@ -835,7 +846,8 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), gst::Caps::new_empty(), {
         imp.fixate_src_caps(&wrap, from_glib_full(caps))
-    }).into_ptr()
+    })
+    .into_ptr()
 }
 
 unsafe extern "C" fn aggregator_negotiated_src_caps<T: AggregatorBase>(
@@ -853,5 +865,6 @@ where
 
     panic_to_error!(&wrap, &aggregator.panicked(), false, {
         imp.negotiated_src_caps(&wrap, gst::CapsRef::from_ptr(caps))
-    }).to_glib()
+    })
+    .to_glib()
 }

gst-plugin/src/aggregator_pad.rs

@@ -11,8 +11,8 @@ use std::ptr;
 
 use glib_ffi;
 use gobject_ffi;
-use gst_ffi;
 use gst_base_ffi;
+use gst_ffi;
 
 use glib;
 use glib::translate::*;
@@ -32,14 +32,21 @@ pub trait AggregatorPadImpl<T: AggregatorPadBase>:
         aggregator_pad.parent_flush(aggregator)
     }
 
-    fn skip_buffer(&self, aggregator_pad: &T, aggregator: &gst_base::Aggregator, buffer: &gst::BufferRef) -> bool {
+    fn skip_buffer(
+        &self,
+        aggregator_pad: &T,
+        aggregator: &gst_base::Aggregator,
+        buffer: &gst::BufferRef,
+    ) -> bool {
         aggregator_pad.parent_skip_buffer(aggregator, buffer)
     }
 }
 
 any_impl!(AggregatorPadBase, AggregatorPadImpl);
 
-pub unsafe trait AggregatorPadBase: IsA<gst_base::AggregatorPad> + IsA<gst::Pad> + ObjectType {
+pub unsafe trait AggregatorPadBase:
+    IsA<gst_base::AggregatorPad> + IsA<gst::Pad> + ObjectType
+{
     fn parent_flush(&self, aggregator: &gst_base::Aggregator) -> gst::FlowReturn {
         unsafe {
             let klass = self.get_class();
@@ -52,14 +59,24 @@ pub unsafe trait AggregatorPadBase: IsA<gst_base::AggregatorPad> + IsA<gst::Pad>
         }
     }
 
-    fn parent_skip_buffer(&self, aggregator: &gst_base::Aggregator, buffer: &gst::BufferRef) -> bool {
+    fn parent_skip_buffer(
+        &self,
+        aggregator: &gst_base::Aggregator,
+        buffer: &gst::BufferRef,
+    ) -> bool {
         unsafe {
             let klass = self.get_class();
             let parent_klass =
                 (*klass).get_parent_class() as *const gst_base_ffi::GstAggregatorPadClass;
             (*parent_klass)
                 .skip_buffer
-                .map(|f| from_glib(f(self.to_glib_none().0, aggregator.to_glib_none().0, buffer.as_mut_ptr())))
+                .map(|f| {
+                    from_glib(f(
+                        self.to_glib_none().0,
+                        aggregator.to_glib_none().0,
+                        buffer.as_mut_ptr(),
+                    ))
+                })
                 .unwrap_or(false)
         }
     }
@@ -163,5 +180,10 @@ where
     let wrap: T = from_glib_borrow(ptr as *mut T::InstanceStructType);
     let imp = aggregator_pad.get_impl();
 
-    imp.skip_buffer(&wrap, &from_glib_borrow(aggregator), gst::BufferRef::from_ptr(buffer)).to_glib()
+    imp.skip_buffer(
+        &wrap,
+        &from_glib_borrow(aggregator),
+        gst::BufferRef::from_ptr(buffer),
+    )
+    .to_glib()
 }

gst-plugin/src/base_sink.rs

@@ -350,7 +350,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), gst::FlowReturn::Error, {
         imp.render(&wrap, buffer)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_sink_prepare<T: BaseSinkBase>(
@@ -369,7 +370,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), gst::FlowReturn::Error, {
         imp.prepare(&wrap, buffer)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_sink_render_list<T: BaseSinkBase>(
@@ -388,7 +390,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), gst::FlowReturn::Error, {
         imp.render_list(&wrap, list)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_sink_prepare_list<T: BaseSinkBase>(
@@ -407,7 +410,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), gst::FlowReturn::Error, {
         imp.prepare_list(&wrap, list)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_sink_query<T: BaseSinkBase>(
@@ -426,7 +430,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         BaseSinkImpl::query(imp, &wrap, query)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_sink_event<T: BaseSinkBase>(
@@ -444,7 +449,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.event(&wrap, from_glib_full(event_ptr))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_sink_get_caps<T: BaseSinkBase>(
@@ -467,8 +473,9 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), None, {
         imp.get_caps(&wrap, filter)
-    }).map(|caps| caps.into_ptr())
+    })
-        .unwrap_or(ptr::null_mut())
+    .map(|caps| caps.into_ptr())
+    .unwrap_or(ptr::null_mut())
 }
 
 unsafe extern "C" fn base_sink_set_caps<T: BaseSinkBase>(
@@ -487,7 +494,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.set_caps(&wrap, caps)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_sink_fixate<T: BaseSinkBase>(
@@ -506,7 +514,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), gst::Caps::new_empty(), {
         imp.fixate(&wrap, caps)
-    }).into_ptr()
+    })
+    .into_ptr()
 }
 
 unsafe extern "C" fn base_sink_unlock<T: BaseSinkBase>(
@@ -538,5 +547,6 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.unlock_stop(&wrap)
-    }).to_glib()
+    })
+    .to_glib()
 }

gst-plugin/src/base_src.rs

@@ -420,7 +420,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.is_seekable(&wrap)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_src_get_size<T: BaseSrcBase>(
@@ -444,7 +445,8 @@ where
             }
             None => false,
         }
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_src_fill<T: BaseSrcBase>(
@@ -465,7 +467,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), gst::FlowReturn::Error, {
         imp.fill(&wrap, offset, length, buffer)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_src_create<T: BaseSrcBase>(
@@ -494,7 +497,8 @@ where
             }
             Err(err) => err,
         }
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_src_do_seek<T: BaseSrcBase>(
@@ -512,7 +516,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.do_seek(&wrap, &mut from_glib_borrow(segment))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_src_query<T: BaseSrcBase>(
@@ -531,7 +536,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         BaseSrcImpl::query(imp, &wrap, query)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_src_event<T: BaseSrcBase>(
@@ -549,7 +555,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.event(&wrap, &from_glib_borrow(event_ptr))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_src_get_caps<T: BaseSrcBase>(
@@ -572,8 +579,9 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), None, {
         imp.get_caps(&wrap, filter)
-    }).map(|caps| caps.into_ptr())
+    })
-        .unwrap_or(ptr::null_mut())
+    .map(|caps| caps.into_ptr())
+    .unwrap_or(ptr::null_mut())
 }
 
 unsafe extern "C" fn base_src_negotiate<T: BaseSrcBase>(
@@ -607,7 +615,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.set_caps(&wrap, caps)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_src_fixate<T: BaseSrcBase>(
@@ -626,7 +635,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), gst::Caps::new_empty(), {
         imp.fixate(&wrap, caps)
-    }).into_ptr()
+    })
+    .into_ptr()
 }
 
 unsafe extern "C" fn base_src_unlock<T: BaseSrcBase>(
@@ -658,5 +668,6 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.unlock_stop(&wrap)
-    }).to_glib()
+    })
+    .to_glib()
 }

gst-plugin/src/base_transform.rs

@@ -328,7 +328,8 @@ unsafe impl<T: IsA<gst::Element> + IsA<gst_base::BaseTransform> + ObjectType> Ba
     for T
 where
     T::InstanceStructType: PanicPoison,
-{}
+{
+}
 pub type BaseTransformClass = ClassStruct<BaseTransform>;
 
 // FIXME: Boilerplate
@@ -494,7 +495,8 @@ where
             &from_glib_borrow(caps),
             filter.as_ref(),
         )
-    }).into_ptr()
+    })
+    .into_ptr()
 }
 
 unsafe extern "C" fn base_transform_fixate_caps<T: BaseTransformBase>(
@@ -519,7 +521,8 @@ where
             &from_glib_borrow(caps),
             from_glib_full(othercaps),
         )
-    }).into_ptr()
+    })
+    .into_ptr()
 }
 
 unsafe extern "C" fn base_transform_set_caps<T: BaseTransformBase>(
@@ -538,7 +541,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.set_caps(&wrap, &from_glib_borrow(incaps), &from_glib_borrow(outcaps))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_transform_accept_caps<T: BaseTransformBase>(
@@ -557,7 +561,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.accept_caps(&wrap, from_glib(direction), &from_glib_borrow(caps))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_transform_query<T: BaseTransformBase>(
@@ -581,7 +586,8 @@ where
             from_glib(direction),
             gst::QueryRef::from_mut_ptr(query),
         )
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_transform_transform_size<T: BaseTransformBase>(
@@ -615,7 +621,8 @@ where
             }
             None => false,
         }
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_transform_get_unit_size<T: BaseTransformBase>(
@@ -640,7 +647,8 @@ where
             }
             None => false,
         }
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_transform_sink_event<T: BaseTransformBase>(
@@ -658,7 +666,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.sink_event(&wrap, from_glib_full(event))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_transform_src_event<T: BaseTransformBase>(
@@ -676,7 +685,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.src_event(&wrap, from_glib_full(event))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_transform_transform<T: BaseTransformBase>(
@@ -699,7 +709,8 @@ where
             &from_glib_borrow(inbuf),
             gst::BufferRef::from_mut_ptr(outbuf),
         )
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn base_transform_transform_ip<T: BaseTransformBase>(
@@ -724,5 +735,6 @@ where
         } else {
             imp.transform_ip(&wrap, gst::BufferRef::from_mut_ptr(buf))
         }
-    }).to_glib()
+    })
+    .to_glib()
 }

gst-plugin/src/bin.rs

@@ -173,7 +173,8 @@ where
 
     panic_to_error!(&wrap, &bin.panicked(), false, {
         imp.add_element(&wrap, &from_glib_borrow(element))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn bin_remove_element<T: BinBase>(
@@ -191,7 +192,8 @@ where
 
     panic_to_error!(&wrap, &bin.panicked(), false, {
         imp.remove_element(&wrap, &from_glib_borrow(element))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn bin_handle_message<T: BinBase>(

gst-plugin/src/child_proxy.rs

@@ -70,7 +70,8 @@ unsafe extern "C" fn child_proxy_get_child_by_name<T: ObjectType>(
     imp.get_child_by_name(
         &from_glib_borrow(child_proxy),
         String::from_glib_none(name).as_str(),
-    ).to_glib_full()
+    )
+    .to_glib_full()
 }
 
 unsafe extern "C" fn child_proxy_get_child_by_index<T: ObjectType>(

gst-plugin/src/element.rs

@@ -199,7 +199,8 @@ glib_wrapper! {
 
 unsafe impl<T: IsA<gst::Element> + ObjectType> ElementBase for T where
     Self::InstanceStructType: PanicPoison
-{}
+{
+}
 
 pub type ElementClass = ClassStruct<Element>;
 
@@ -297,7 +298,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), fallback, {
         imp.change_state(&wrap, transition)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn element_request_new_pad<T: ElementBase>(
@@ -371,7 +373,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.send_event(&wrap, from_glib_full(event))
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn element_query<T: ElementBase>(
@@ -390,7 +393,8 @@ where
 
     panic_to_error!(&wrap, &element.panicked(), false, {
         imp.query(&wrap, query)
-    }).to_glib()
+    })
+    .to_glib()
 }
 
 unsafe extern "C" fn element_set_context<T: ElementBase>(

gst-plugin/src/pipeline.rs

@@ -62,7 +62,8 @@ glib_wrapper! {
 
 unsafe impl<T: IsA<gst::Element> + IsA<gst::Bin> + IsA<gst::Pipeline> + ObjectType> PipelineBase
     for T
-{}
+{
+}
 pub type PipelineClass = ClassStruct<Pipeline>;
 
 // FIXME: Boilerplate